public KinectV2SettingsControl(int kinectNumber, ref KinectBase.MasterSettings settings, KinectBase.IKinectCore kinect)
{
if (settings != null)
{
if (settings.kinectOptionsList[kinectNumber].version == KinectBase.KinectVersion.KinectV2)
{
masterSettings = settings;
dynamic tempSettings = settings.kinectOptionsList[kinectNumber];
kinectSettings = (KinectV2Settings)tempSettings;
kinectID = kinectNumber;
kinectCore = (KinectCoreV2)kinect;
uniqueKinectID = kinect.uniqueKinectID;
InitializeComponent();
this.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
this.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
}
else
{
throw new ArgumentException("The provided KinectID is not for a Kinect v2 sensor.");
}
}
else
{
throw new NotSupportedException("Method arguments are invalid!");
}
}
public KinectCoreV2(ref KinectBase.MasterSettings settings, bool isGUILaunched, int kinectNumber)
{
masterSettings = settings;
dynamic temp = masterSettings.kinectOptionsList[kinectNumber];
masterKinectSettings = (KinectV2Settings)temp;
//TODO: Update this to open a specific Kinect v2, if the SDK is ever updated to support multiple on one machine
kinect = KinectSensor.GetDefault();
kinectID = kinectNumber;
uint tempC = kinect.ColorFrameSource.FrameDescription.LengthInPixels;
uint tempD = kinect.DepthFrameSource.FrameDescription.LengthInPixels;
uint tempI = kinect.InfraredFrameSource.FrameDescription.LengthInPixels;
colorImagePool = new KinectBase.ObjectPool<byte[]>(() => new byte[tempC * 4]);
depthImagePool = new KinectBase.ObjectPool<byte[]>(() => new byte[tempD * 4]);
irImagePool = new KinectBase.ObjectPool<byte[]>(() => new byte[tempI * sizeof(UInt16)]);
if (isGUILaunched)
{
isGUI = true;
LaunchKinect();
}
else
{
launchKinectDelegate kinectDelegate = LaunchKinect;
IAsyncResult result = kinectDelegate.BeginInvoke(null, null);
kinectDelegate.EndInvoke(result); //Even though this is blocking, the events should be on a different thread now.
}
}
//TODO: Subscribe this to the skeletonChanged event and update the GUI with a preview of the skeleton positions
public NetworkKinectSettingsControl(int kinectNumber, ref KinectBase.MasterSettings settings, KinectBase.IKinectCore kinect)
{
if (settings != null)
{
if (settings.kinectOptionsList[kinectNumber].version == KinectBase.KinectVersion.NetworkKinect)
{
masterSettings = settings;
dynamic tempSettings = settings.kinectOptionsList[kinectNumber];
kinectSettings = (NetworkKinectSettings)tempSettings;
kinectID = kinectNumber;
kinectCore = (NetworkKinectCore)kinect;
uniqueKinectID = kinect.uniqueKinectID;
InitializeComponent();
this.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
this.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
//Set the binding on the joint mapping data grid
jointMappingDataGrid.ItemsSource = kinectSettings.jointMappings;
jointMappingDataGrid.Items.Refresh();
}
else
{
throw new ArgumentException("The provided KinectID is not for a network Kinect sensor.");
}
}
else
{
throw new ArgumentNullException("settings");
}
}
//Why is the kinectNumber nullable if it is requried later?
public KinectCoreV1(ref KinectBase.MasterSettings settings, bool isGUILaunched, int? kinectNumber = null)
{
if (kinectNumber != null)
{
masterSettings = settings;
dynamic tempSettings = masterSettings.kinectOptionsList[(int)kinectNumber]; //We have to use dynamic because the type of the Kinect settings in the master list isn't defined until runtime
masterKinectSettings = (KinectV1Settings)tempSettings;
//Initialize the object pools
colorImagePool = new KinectBase.ObjectPool<byte[]>(() => new byte[640 * 480 * 4]);
depthImagePool = new KinectBase.ObjectPool<byte[]>(() => new byte[640 * 480 * 4]);
//Note: the kinectNumber could be greater than the number of Kinect v1s if there are other types of sensors in use
//Therefore, we have to find the correct Kinect, if it exists using this loop
int globalIndex = -1;
for (int i = 0; i < KinectSensor.KinectSensors.Count; i++)
{
if (KinectSensor.KinectSensors[i].DeviceConnectionId == masterSettings.kinectOptionsList[(int)kinectNumber].uniqueKinectID)
{
globalIndex = i;
break;
}
}
if (globalIndex >= 0)
{
kinect = KinectSensor.KinectSensors[globalIndex];
kinectID = (int)kinectNumber;
}
else
{
throw new System.IndexOutOfRangeException("Specified Kinect sensor does not exist");
}
if (isGUILaunched)
{
isGUI = true;
LaunchKinect();
}
else
{
launchKinectDelegate kinectDelegate = LaunchKinect;
IAsyncResult result = kinectDelegate.BeginInvoke(null, null);
kinectDelegate.EndInvoke(result); //Even though this is blocking, the events should be on a different thread now.
}
}
else
{
//TODO: Open the default Kinect?
throw new NullReferenceException("To create a KinectCore object, the KinectNumber must be valid.");
}
}
public KinectV1SettingsControl(int kinectNumber, ref KinectBase.MasterSettings settings, KinectBase.IKinectCore kinect)
{
if (settings != null)
{
if (settings.kinectOptionsList[kinectNumber].version == KinectBase.KinectVersion.KinectV1)
{
masterSettings = settings;
dynamic tempSettings = settings.kinectOptionsList[kinectNumber];
kinectSettings = (KinectV1Settings)tempSettings;
kinectID = kinectNumber;
kinectCore = (KinectCoreV1)kinect;
kinectCore.AccelerationChanged += kinectCore_AccelerationChanged;
uniqueKinectID = kinect.uniqueKinectID;
InitializeComponent();
this.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
this.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
//This moved to the wrapper
//Grid.SetColumn(this, 2);
//this.Visibility = System.Windows.Visibility.Collapsed;
if (kinectCore.isXbox360Kinect != null && (bool)kinectCore.isXbox360Kinect)
{
DisableK4WOnlyOptions();
}
}
else
{
throw new ArgumentException("The provided KinectID is not for a Kinect v1 sensor.");
}
}
else
{
throw new ArgumentNullException("settings");
}
}
protected virtual void OnColorFrameReceived(KinectBase.ColorFrameEventArgs e)
{
if (ColorFrameReceived != null)
{
ColorFrameReceived(this, e);
}
//Put the object back in the image pool
if (e.isIR)
{
irImagePool.PutObject(e.image);
}
else
{
colorImagePool.PutObject(e.image);
}
}
protected virtual void OnDepthFrameReceived(KinectBase.DepthFrameEventArgs e)
{
if (DepthFrameReceived != null)
{
DepthFrameReceived(this, e);
}
//Put the image array back in the image pool
depthImagePool.PutObject(e.image);
}
protected virtual void OnAccelerationChanged(KinectBase.AccelerationEventArgs e)
{
if (AccelerationChanged != null)
{
AccelerationChanged(this, e);
}
}
protected virtual void OnAudioPositionChanged(KinectBase.AudioPositionEventArgs e)
{
if (AudioPositionChanged != null)
{
AudioPositionChanged(this, e);
}
}
protected virtual void OnDepthFrameReceived(KinectBase.DepthFrameEventArgs e)
{
if (DepthFrameReceived != null)
{
DepthFrameReceived(this, e);
}
}
public KinectBase.KinectSkeleton TransformSkeleton(KinectBase.KinectSkeleton skeleton)
{
KinectBase.KinectSkeleton transformedSkeleton = new KinectBase.KinectSkeleton();
transformedSkeleton.leftHandClosed = skeleton.leftHandClosed;
transformedSkeleton.rightHandClosed = skeleton.rightHandClosed;
transformedSkeleton.TrackingId = skeleton.TrackingId;
transformedSkeleton.SkeletonTrackingState = skeleton.SkeletonTrackingState;
//transformedSkeleton.utcSampleTime = skeleton.utcSampleTime;
transformedSkeleton.sourceKinectID = skeleton.sourceKinectID;
transformedSkeleton.Position = skeletonTransformation.Transform(skeleton.Position);
//Transform the joints
for (int i = 0; i < skeleton.skeleton.Count; i++)
{
transformedSkeleton.skeleton[i] = TransformJoint(skeleton.skeleton[i]);
}
return transformedSkeleton;
}
void kinectCore_AccelerationChanged(object sender, KinectBase.AccelerationEventArgs e)
{
//Don't bother calling the disptacher (which is kind of expensive) if the control is hidden
if (IsInitialized && Visibility == System.Windows.Visibility.Visible)
{
this.Dispatcher.BeginInvoke((Action)(() =>
{
if (e.acceleration.HasValue)
{
AccelXTextBlock.Text = e.acceleration.Value.X.ToString("F2");
AccelYTextBlock.Text = e.acceleration.Value.Y.ToString("F2");
AccelZTextBlock.Text = e.acceleration.Value.Z.ToString("F2");
}
else
{
AccelXTextBlock.Text = "N/A";
AccelYTextBlock.Text = "N/A";
AccelZTextBlock.Text = "N/A";
}
if (e.elevationAngle.HasValue)
{
AngleTextBlock.Text = e.elevationAngle.Value.ToString();
}
else
{
AngleTextBlock.Text = "N/A";
}
}), null);
}
}
public Point MapJointToDepth(KinectBase.Joint joint, bool undoTransform)
{
Point mappedPoint = new Point(0, 0);
Point3D transformedPosition = joint.Position;
if (undoTransform)
{
Matrix3D inverseTransform = skeletonTransformation;
inverseTransform.Invert();
transformedPosition = inverseTransform.Transform(transformedPosition);
}
SkeletonPoint skelPoint = new SkeletonPoint();
skelPoint.X = (float)transformedPosition.X;
skelPoint.Y = (float)transformedPosition.Y;
skelPoint.Z = (float)transformedPosition.Z;
DepthImagePoint point = kinect.CoordinateMapper.MapSkeletonPointToDepthPoint(skelPoint, kinect.DepthStream.Format);
mappedPoint.X = point.X;
mappedPoint.Y = point.Y;
return mappedPoint;
}
internal void ChangeColorResolution(KinectBase.ColorImageFormat newResolution)
{
kinect.ColorStream.Disable();
if (newResolution != KinectBase.ColorImageFormat.Undefined)
{
kinect.ColorStream.Enable(convertColorImageFormat(newResolution));
//Get the size, in bytes, of the new image array and reset the image pool
int size = 0;
if (newResolution == KinectBase.ColorImageFormat.InfraredResolution640x480Fps30)
{
size = 640 * 480 * 2;
}
else if (newResolution == KinectBase.ColorImageFormat.RawBayerResolution1280x960Fps12 || newResolution == KinectBase.ColorImageFormat.RgbResolution1280x960Fps12)
{
size = 1280 * 960 * 4;
}
else
{
size = 640 * 480 * 4;
}
colorImagePool.ResetPool(() => new byte[size]);
isColorStreamOn = true;
}
else
{
isColorStreamOn = false;
}
}
public void UpdateGUI(KinectBase.MasterSettings newSettings)
{
if (kinectID.HasValue)
{
masterSettings = newSettings;
dynamic tempSettings = newSettings.kinectOptionsList[kinectID.Value];
kinectSettings = (KinectV2Settings)tempSettings;
//Update the color options
useColorRadioButton.IsChecked = kinectSettings.useColorPreview;
useIRRadionButton.IsChecked = kinectSettings.useIRPreview;
//Update the depth options
ScaleDepthCheckBox.IsChecked = kinectSettings.scaleDepthToReliableRange;
ColorizeDepthCheckBox.IsChecked = kinectSettings.colorizeDepth;
//Update skeleton options
UseSkeletonCheckBox.IsChecked = kinectSettings.mergeSkeletons;
UseRawSkeletonCheckBox.IsChecked = kinectSettings.sendRawSkeletons;
XFormRawSkeletonCheckBox.IsChecked = kinectSettings.transformRawSkeletons;
//Update audio settings
SendSoundAngleCheckBox.IsChecked = kinectSettings.sendAudioAngle;
audioServerTextBox.Text = kinectSettings.audioAngleServerName;
audioChannelTextBox.Text = kinectSettings.audioAngleChannel.ToString();
audioBeamSkeletonNumberTextBox.Text = kinectSettings.audioBeamTrackSkeletonNumber.ToString();
switch (kinectSettings.audioTrackMode)
{
//Note: the enabled/disabled controls don't need to be set manually here because the selected index changed event will still be hit
case KinectBase.AudioTrackingMode.Feedback:
{
audioBeamModeComboBox.SelectedIndex = 1;
break;
}
case KinectBase.AudioTrackingMode.MergedSkeletonX:
{
audioBeamModeComboBox.SelectedIndex = 2;
break;
}
case KinectBase.AudioTrackingMode.LocalSkeletonX:
{
audioBeamModeComboBox.SelectedIndex = 3;
break;
}
default:
{
audioBeamModeComboBox.SelectedIndex = 0;
break;
}
}
//Update the position options
xPosTextBox.Text = kinectSettings.kinectPosition.X.ToString();
yPosTextBox.Text = kinectSettings.kinectPosition.Y.ToString();
zPosTextBox.Text = kinectSettings.kinectPosition.Z.ToString();
yawPosTextBox.Text = kinectSettings.kinectYaw.ToString();
pitchPosTextBox.Text = kinectSettings.kinectPitch.ToString();
rollPosTextBox.Text = kinectSettings.kinectRoll.ToString();
}
}
internal void ChangeDepthResolution(KinectBase.DepthImageFormat newResolution)
{
kinect.DepthStream.Disable();
if (newResolution != KinectBase.DepthImageFormat.Undefined)
{
kinect.DepthStream.Enable(convertDepthImageFormat(newResolution));
//Get the size, in bytes, of the new image array and reset the image pool
int size = 0;
if (newResolution == KinectBase.DepthImageFormat.Resolution640x480Fps30)
{
size = 640 * 480 * 4;
}
else if (newResolution == KinectBase.DepthImageFormat.Resolution320x240Fps30)
{
size = 320 * 240 * 4;
}
else
{
size = 80 * 60 * 4;
}
depthImagePool.ResetPool(() => new byte[size]);
isDepthStreamOn = true;
}
else
{
isDepthStreamOn = false;
}
}
private DepthImageFormat convertDepthImageFormat(KinectBase.DepthImageFormat format)
{
//The depth formats are all numbered the same for the Kienct v1, so we can do a straight cast
return (DepthImageFormat)format;
}
private ColorImageFormat convertColorImageFormat(KinectBase.ColorImageFormat format)
{
//The color formats are all numbered the same for the Kienct v1, so we can do a straight cast
return (ColorImageFormat)format;
}
protected virtual void OnLogMessageGenerated(KinectBase.LogMessageEventArgs e)
{
if (LogMessageGenerated != null)
{
LogMessageGenerated(this, e);
}
}
public void UpdateGUI(KinectBase.MasterSettings settings)
{
if (kinectID.HasValue)
{
masterSettings = settings;
dynamic tempSettings = masterSettings.kinectOptionsList[kinectID.Value];
kinectSettings = (NetworkKinectSettings)tempSettings;
//Shutdown the server, if it is running
bool wasRunning = false;
if (kinectCore.isKinectRunning)
{
kinectCore.ShutdownSensor();
wasRunning = true;
}
//Update the skeleton server and joint mappings
serverNameTextBox.Text = kinectSettings.serverName;
jointMappingDataGrid.ItemsSource = kinectSettings.jointMappings;
jointMappingDataGrid.Items.Refresh();
//Update the physical position
xPosTextBox.Text = kinectSettings.kinectPosition.X.ToString();
yPosTextBox.Text = kinectSettings.kinectPosition.Y.ToString();
zPosTextBox.Text = kinectSettings.kinectPosition.Z.ToString();
yawTextBox.Text = kinectSettings.kinectYaw.ToString();
pitchTextBox.Text = kinectSettings.kinectPitch.ToString();
rollTextBox.Text = kinectSettings.kinectRoll.ToString();
//Update the hand grab data
lhServerTextBox.Text = kinectSettings.lhServerName;
lhChannelTextBox.Text = kinectSettings.lhChannel.ToString();
rhServerTextBox.Text = kinectSettings.rhServerName;
rhChannelTextBox.Text = kinectSettings.rhChannel.ToString();
//Restart the server if it was running to begin with
if (wasRunning)
{
kinectCore.StartNetworkKinect();
}
}
}
//Methods to fire the events
protected virtual void OnSkeletonChanged(KinectBase.SkeletonEventArgs e)
{
if (SkeletonChanged != null)
{
SkeletonChanged(this, e);
}
}
public KinectBase.Joint TransformJoint(KinectBase.Joint joint)
{
KinectBase.Joint transformedJoint = new KinectBase.Joint();
transformedJoint.Confidence = joint.Confidence;
transformedJoint.JointType = joint.JointType;
transformedJoint.TrackingState = joint.TrackingState;
transformedJoint.Orientation = skeletonRotQuaternion * joint.Orientation;
transformedJoint.Position = skeletonTransformation.Transform(joint.Position);
transformedJoint.utcTime = joint.utcTime;
return transformedJoint;
}
internal static void SaveSettings(string fileName, KinectBase.MasterSettings settings)
{
//Create a serializable version of the settings (basically, move the Kinect options from the Master settings to a type specific array)
List<KinectV1Wrapper.Settings> kinect1Settings = new List<KinectV1Wrapper.Settings>();
List<KinectV2Wrapper.Settings> kinect2Settings = new List<KinectV2Wrapper.Settings>();
List<NetworkKinectWrapper.Settings> networkSettings = new List<NetworkKinectWrapper.Settings>();
for (int i = 0; i < settings.kinectOptionsList.Count; i++)
{
if (settings.kinectOptionsList[i].version == KinectVersion.KinectV1)
{
kinect1Settings.Add((KinectV1Wrapper.Settings)settings.kinectOptionsList[i]);
}
else if (settings.kinectOptionsList[i].version == KinectVersion.KinectV2)
{
kinect2Settings.Add((KinectV2Wrapper.Settings)settings.kinectOptionsList[i]);
}
else if (settings.kinectOptionsList[i].version == KinectVersion.NetworkKinect)
{
networkSettings.Add((NetworkKinectWrapper.Settings)settings.kinectOptionsList[i]);
}
}
SerializableSettings serialSettings = new SerializableSettings();
serialSettings.masterSettings = settings;
serialSettings.kinectV1Settings = kinect1Settings.ToArray();
serialSettings.kinectV2Settings = kinect2Settings.ToArray();
serialSettings.networkKinectSettings = networkSettings.ToArray();
//Do the actual serialization
XmlSerializer serializer = new XmlSerializer(typeof(SerializableSettings));
using (FileStream file = new FileStream(fileName, FileMode.Create))
{
serializer.Serialize(file, serialSettings);
file.Close();
file.Dispose();
}
}
protected virtual void OnColorFrameReceived(KinectBase.ColorFrameEventArgs e)
{
if (ColorFrameReceived != null)
{
ColorFrameReceived(this, e);
}
}
public void UpdateGUI(KinectBase.MasterSettings newSettings)
{
if (kinectID.HasValue)
{
masterSettings = newSettings;
dynamic tempSettings = masterSettings.kinectOptionsList[kinectID.Value];
kinectSettings = (KinectV1Settings)tempSettings;
//Update the color options
switch (kinectSettings.colorImageMode)
{
case KinectBase.ColorImageFormat.RgbResolution640x480Fps30:
{
colorResComboBox.SelectedIndex = 0;
break;
}
case KinectBase.ColorImageFormat.RgbResolution1280x960Fps12:
{
colorResComboBox.SelectedIndex = 1;
break;
}
case KinectBase.ColorImageFormat.InfraredResolution640x480Fps30:
{
colorResComboBox.SelectedIndex = 2;
break;
}
default:
{
//If we don't know how to handle a mode, lets just shut it off
colorResComboBox.SelectedIndex = 3;
break;
}
}
//Update the skeleton settings
UseSkeletonCheckBox.IsChecked = kinectSettings.mergeSkeletons;
UseRawSkeletonCheckBox.IsChecked = kinectSettings.sendRawSkeletons;
XFormRawSkeletonCheckBox.IsChecked = kinectSettings.transformRawSkeletons;
SeatedModeCheckBox.IsChecked = kinectSettings.rawSkeletonSettings.isSeatedMode;
//Update the depth settings
irOnCheckBox.IsChecked = kinectSettings.irON;
nearModeCheckBox.IsChecked = kinectSettings.isNearMode;
switch (kinectSettings.depthImageMode)
{
case KinectBase.DepthImageFormat.Resolution320x240Fps30:
{
depthResComboBox.SelectedIndex = 1;
break;
}
case KinectBase.DepthImageFormat.Resolution80x60Fps30:
{
depthResComboBox.SelectedIndex = 2;
break;
}
default:
{
depthResComboBox.SelectedIndex = 0;
break;
}
}
//Update the audio settings
SendSoundAngleCheckBox.IsChecked = kinectSettings.sendAudioAngle;
audioServerTextBox.Text = kinectSettings.audioAngleServerName;
audioChannelTextBox.Text = kinectSettings.audioAngleChannel.ToString();
audioBeamSkeletonNumberTextBox.Text = kinectSettings.audioBeamTrackSkeletonNumber.ToString();
switch (kinectSettings.audioTrackMode)
{
//Note: the enabled/disabled controls don't need to be set manually here because the selected index changed event will still be hit
case KinectBase.AudioTrackingMode.Feedback:
{
audioBeamModeComboBox.SelectedIndex = 1;
break;
}
case KinectBase.AudioTrackingMode.MergedSkeletonX:
{
audioBeamModeComboBox.SelectedIndex = 2;
break;
}
case KinectBase.AudioTrackingMode.LocalSkeletonX:
{
audioBeamModeComboBox.SelectedIndex = 3;
break;
}
default:
{
audioBeamModeComboBox.SelectedIndex = 0;
break;
}
}
//Update the acceleration options
SendAccelCheckBox.IsChecked = kinectSettings.sendAcceleration;
accelServerTextBox.Text = kinectSettings.accelerationServerName;
accelXChannelTextBox.Text = kinectSettings.accelXChannel.ToString();
accelYChannelTextBox.Text = kinectSettings.accelYChannel.ToString();
accelZChannelTextBox.Text = kinectSettings.accelZChannel.ToString();
//Update the position options
xPosTextBox.Text = kinectSettings.kinectPosition.X.ToString();
yPosTextBox.Text = kinectSettings.kinectPosition.Y.ToString();
zPosTextBox.Text = kinectSettings.kinectPosition.Z.ToString();
yawPosTextBox.Text = kinectSettings.kinectYaw.ToString();
}
}
public Point MapJointToDepth(KinectBase.Joint joint, bool undoTransform)
{
//TODO: Update this so it takes a joint array instead of a single joint (this is supposed to be more efficient for the Kinect 2)
Point mappedPoint = new Point(0, 0);
Point3D transformedPosition = joint.Position;
if (undoTransform)
{
Matrix3D inverseTransform = skeletonTransformation;
inverseTransform.Invert();
transformedPosition = inverseTransform.Transform(transformedPosition);
}
//Setup the Kinect v2 objects to do the transformation
CameraSpacePoint[] skelPoints = new CameraSpacePoint[1];
skelPoints[0] = new CameraSpacePoint();
skelPoints[0].X = (float)transformedPosition.X;
skelPoints[0].Y = (float)transformedPosition.Y;
skelPoints[0].Z = (float)transformedPosition.Z;
DepthSpacePoint[] points = new DepthSpacePoint[1];
kinect.CoordinateMapper.MapCameraPointsToDepthSpace(skelPoints, points);
//Convert back to the base object type
mappedPoint.X = points[0].X;
mappedPoint.Y = points[0].Y;
return mappedPoint;
}
