// Initialize the filter with a set of TransformSmoothParameters.
public void Init(KinectInterop.SmoothParameters smoothParameters)
{
this.smoothParameters = smoothParameters;
this.Reset();
this.init = true;
}
/// <summary>
/// Invoked if a gesture is cancelled.
/// </summary>
/// <returns>true</returns>
/// <c>false</c>
/// <param name="userId">User ID</param>
/// <param name="userIndex">User index</param>
/// <param name="gesture">Gesture type</param>
/// <param name="joint">Joint type</param>
public bool GestureCancelled(long userId, int userIndex, KinectGestures.Gestures gesture,
KinectInterop.JointType joint)
{
// the gestures are allowed for the primary user only
KinectManager manager = KinectManager.Instance;
if (!manager || (userId != manager.GetPrimaryUserID()))
return false;
if (progressDisplayed)
{
progressDisplayed = false;
/*if (gestureInfo != null)
{
gestureInfo.GetComponent<GUIText>().text = String.Empty;
}*/
}
return true;
}
public Vector2 MapSpacePointToDepthCoords(KinectInterop.SensorData sensorData, Vector3 spacePos)
{
float fDepthX, fDepthY, fDepthZ;
NuiTransformSkeletonToDepthImage(spacePos, out fDepthX, out fDepthY, out fDepthZ);
fDepthX = Mathf.RoundToInt(fDepthX * sensorData.depthImageWidth);
fDepthY = Mathf.RoundToInt(fDepthY * sensorData.depthImageHeight);
fDepthZ = Mathf.RoundToInt(fDepthZ);
Vector3 point = new Vector3(fDepthX, fDepthY, fDepthZ);
return point;
}
public Vector2 MapDepthPointToColorCoords(KinectInterop.SensorData sensorData, Vector2 depthPos, ushort depthVal)
{
int cx, cy;
NuiImageGetColorPixelCoordinatesFromDepthPixelAtResolution(
Constants.ColorImageResolution,
Constants.DepthImageResolution,
ref pcViewArea,
(int)depthPos.x, (int)depthPos.y, (ushort)(depthVal << 3),
out cx, out cy);
return new Vector2(cx, cy);
}
public bool MapColorFrameToDepthCoords(KinectInterop.SensorData sensorData, ref Vector2[] vDepthCoords)
{
return false;
}
public bool InitBackgroundRemoval(KinectInterop.SensorData sensorData, bool isHiResPrefered)
{
int hr = InitBackgroundRemovalNative();
if (hr < 0)
{
Debug.LogError(string.Format("Error initializing BackgroundRemoval: hr=0x{0:X}", hr));
}
bBackgroundRemovalInited = (hr >= 0);
return bBackgroundRemovalInited;
}
// returns the next joint in the hierarchy, as to the given joint
public KinectInterop.JointType GetNextJoint(KinectInterop.JointType joint)
{
switch (joint)
{
case KinectInterop.JointType.SpineBase:
return KinectInterop.JointType.SpineMid;
case KinectInterop.JointType.SpineMid:
return KinectInterop.JointType.Neck;
case KinectInterop.JointType.Neck:
return KinectInterop.JointType.Head;
case KinectInterop.JointType.ShoulderLeft:
return KinectInterop.JointType.ElbowLeft;
case KinectInterop.JointType.ElbowLeft:
return KinectInterop.JointType.WristLeft;
case KinectInterop.JointType.WristLeft:
return KinectInterop.JointType.HandLeft;
case KinectInterop.JointType.ShoulderRight:
return KinectInterop.JointType.ElbowRight;
case KinectInterop.JointType.ElbowRight:
return KinectInterop.JointType.WristRight;
case KinectInterop.JointType.WristRight:
return KinectInterop.JointType.HandRight;
case KinectInterop.JointType.HipLeft:
return KinectInterop.JointType.KneeLeft;
case KinectInterop.JointType.KneeLeft:
return KinectInterop.JointType.AnkleLeft;
case KinectInterop.JointType.AnkleLeft:
return KinectInterop.JointType.FootLeft;
case KinectInterop.JointType.HipRight:
return KinectInterop.JointType.KneeRight;
case KinectInterop.JointType.KneeRight:
return KinectInterop.JointType.AnkleRight;
case KinectInterop.JointType.AnkleRight:
return KinectInterop.JointType.FootRight;
}
return joint; // in case of end joint - Head, HandLeft, HandRight, FootLeft, FootRight
}
// returns the index of the given joint in joint's array or -1 if joint is not applicable
public int GetJointIndex(KinectInterop.JointType joint)
{
switch (joint)
{
case KinectInterop.JointType.SpineBase:
return (int)NuiSkeletonPositionIndex.HipCenter;
case KinectInterop.JointType.SpineMid:
return (int)NuiSkeletonPositionIndex.Spine;
case KinectInterop.JointType.SpineShoulder:
case KinectInterop.JointType.Neck:
return (int)NuiSkeletonPositionIndex.ShoulderCenter;
case KinectInterop.JointType.Head:
return (int)NuiSkeletonPositionIndex.Head;
case KinectInterop.JointType.ShoulderLeft:
return (int)NuiSkeletonPositionIndex.ShoulderLeft;
case KinectInterop.JointType.ElbowLeft:
return (int)NuiSkeletonPositionIndex.ElbowLeft;
case KinectInterop.JointType.WristLeft:
return (int)NuiSkeletonPositionIndex.WristLeft;
case KinectInterop.JointType.HandLeft:
return (int)NuiSkeletonPositionIndex.HandLeft;
case KinectInterop.JointType.ShoulderRight:
return (int)NuiSkeletonPositionIndex.ShoulderRight;
case KinectInterop.JointType.ElbowRight:
return (int)NuiSkeletonPositionIndex.ElbowRight;
case KinectInterop.JointType.WristRight:
return (int)NuiSkeletonPositionIndex.WristRight;
case KinectInterop.JointType.HandRight:
return (int)NuiSkeletonPositionIndex.HandRight;
case KinectInterop.JointType.HipLeft:
return (int)NuiSkeletonPositionIndex.HipLeft;
case KinectInterop.JointType.KneeLeft:
return (int)NuiSkeletonPositionIndex.KneeLeft;
case KinectInterop.JointType.AnkleLeft:
return (int)NuiSkeletonPositionIndex.AnkleLeft;
case KinectInterop.JointType.FootLeft:
return (int)NuiSkeletonPositionIndex.FootLeft;
case KinectInterop.JointType.HipRight:
return (int)NuiSkeletonPositionIndex.HipRight;
case KinectInterop.JointType.KneeRight:
return (int)NuiSkeletonPositionIndex.KneeRight;
case KinectInterop.JointType.AnkleRight:
return (int)NuiSkeletonPositionIndex.AnkleRight;
case KinectInterop.JointType.FootRight:
return (int)NuiSkeletonPositionIndex.FootRight;
}
return -1;
}
public bool PollInfraredFrame(KinectInterop.SensorData sensorData)
{
uint infraredBufLen = (uint)(sensorData.infraredImage.Length * sizeof(ushort));
var pInfraredData = GCHandle.Alloc(sensorData.infraredImage, GCHandleType.Pinned);
bool newInfrared = GetInfraredFrameData(pInfraredData.AddrOfPinnedObject(), ref infraredBufLen, true);
pInfraredData.Free();
return newInfrared;
}
public bool PollForegroundFrame(KinectInterop.SensorData sensorData, bool isHiResPrefered, Color32 defaultColor, bool bLimitedUsers, ICollection<int> alTrackedIndexes, ref byte[] foregroundImage)
{
uint frameLen = (uint)foregroundImage.Length;
var pFrameData = GCHandle.Alloc(foregroundImage, GCHandleType.Pinned);
bool newFrame = GetBackgroundRemovalFrameDataNative(pFrameData.AddrOfPinnedObject(), ref frameLen, true);
pFrameData.Free();
return newFrame;
}
public bool PollDepthFrame(KinectInterop.SensorData sensorData)
{
uint depthBufLen = (uint)(sensorData.depthImage.Length * sizeof(ushort));
var pDepthData = GCHandle.Alloc(sensorData.depthImage, GCHandleType.Pinned);
bool newDepth = GetDepthFrameData(pDepthData.AddrOfPinnedObject(), ref depthBufLen, true);
pDepthData.Free();
if (newDepth)
{
uint depthLen = (uint)sensorData.depthImage.Length;
for (int i = 0; i < depthLen; i++)
{
if ((sensorData.depthImage[i] & 7) != 0)
sensorData.bodyIndexImage[i] = (byte)((sensorData.depthImage[i] & 7) - 1);
else
sensorData.bodyIndexImage[i] = 255;
sensorData.depthImage[i] = (ushort)(sensorData.depthImage[i] >> 3);
}
}
return newDepth;
}
public bool PollColorFrame(KinectInterop.SensorData sensorData)
{
uint videoBufLen = (uint)sensorData.colorImage.Length;
var pColorData = GCHandle.Alloc(sensorData.colorImage, GCHandleType.Pinned);
bool newColor = GetColorFrameData(pColorData.AddrOfPinnedObject(), ref videoBufLen, true);
pColorData.Free();
if (newColor)
{
for (int i = 0; i < videoBufLen; i += 4)
{
byte btTmp = sensorData.colorImage[i];
sensorData.colorImage[i] = sensorData.colorImage[i + 2];
sensorData.colorImage[i + 2] = btTmp;
sensorData.colorImage[i + 3] = 255;
}
}
return newColor;
}
public bool PollBodyFrame(KinectInterop.SensorData sensorData, ref KinectInterop.BodyFrameData bodyFrame, ref Matrix4x4 kinectToWorld)
{
// get next body frame
int hr = NuiSkeletonGetNextFrame(0, ref skeletonFrame);
bool newSkeleton = (hr == 0);
if (newSkeleton)
{
bodyFrame.liPreviousTime = bodyFrame.liRelativeTime;
bodyFrame.liRelativeTime = skeletonFrame.liTimeStamp;
hr = NuiTransformSmooth(ref skeletonFrame, ref smoothParameters);
if (hr < 0)
{
Debug.LogError("Skeleton Data Smoothing failed");
}
for (uint i = 0; i < sensorData.bodyCount; i++)
{
NuiSkeletonData body = skeletonFrame.SkeletonData[i];
bodyFrame.bodyData[i].bIsTracked = (short)(body.eTrackingState == NuiSkeletonTrackingState.SkeletonTracked ? 1 : 0);
if (body.eTrackingState == NuiSkeletonTrackingState.SkeletonTracked)
{
// transfer body and joints data
bodyFrame.bodyData[i].liTrackingID = (long)body.dwTrackingID;
for (int j = 0; j < sensorData.jointCount; j++)
{
KinectInterop.JointData jointData = bodyFrame.bodyData[i].joint[j];
//jointData.jointType = (KinectInterop.JointType)j;
jointData.trackingState = (KinectInterop.TrackingState)body.eSkeletonPositionTrackingState[j];
if (jointData.trackingState != KinectInterop.TrackingState.NotTracked)
{
jointData.kinectPos = body.SkeletonPositions[j];
jointData.position = kinectToWorld.MultiplyPoint3x4(jointData.kinectPos);
}
jointData.orientation = Quaternion.identity;
// Windows.Kinect.Vector4 vQ = body.JointOrientations[jointData.jointType].Orientation;
// jointData.orientation = new Quaternion(vQ.X, vQ.Y, vQ.Z, vQ.W);
if (j == 0)
{
bodyFrame.bodyData[i].position = jointData.position;
bodyFrame.bodyData[i].orientation = jointData.orientation;
}
bodyFrame.bodyData[i].joint[j] = jointData;
}
// tranfer hand states
uint intCount = GetInteractorsCount();
string sDebug = string.Empty;
for (uint intIndex = 0; intIndex < intCount; intIndex++)
{
uint skeletonId = GetSkeletonTrackingID(intIndex);
if (skeletonId == body.dwTrackingID)
{
uint leftHandState = GetLeftHandState(intIndex);
InteractionHandEventType leftHandEvent = GetLeftHandEvent(intIndex);
uint rightHandState = GetRightHandState(intIndex);
InteractionHandEventType rightHandEvent = GetRightHandEvent(intIndex);
// sDebug += string.Format("{0}-L:{1},{2};R:{3},{4} ", skeletonId,
// (int)leftHandState, (int)leftHandEvent,
// (int)rightHandState, (int)rightHandEvent);
GetHandStateAndConf(skeletonId, false, leftHandState, leftHandEvent,
ref lastLeftHandEvent,
ref bodyFrame.bodyData[i].leftHandState,
ref bodyFrame.bodyData[i].leftHandConfidence);
GetHandStateAndConf(skeletonId, true, rightHandState, rightHandEvent,
ref lastRightHandEvent,
ref bodyFrame.bodyData[i].rightHandState,
ref bodyFrame.bodyData[i].rightHandConfidence);
}
}
if (intCount > 0 && sDebug.Length > 0)
{
Debug.Log(sDebug);
}
}
}
if (sensorData.hintHeightAngle)
{
// get the floor plane
Vector4 vFloorPlane = skeletonFrame.vFloorClipPlane;
Vector3 floorPlane = new Vector3(vFloorPlane.x, vFloorPlane.y, vFloorPlane.z);
sensorData.sensorRotDetected = Quaternion.FromToRotation(floorPlane, Vector3.up);
sensorData.sensorHgtDetected = vFloorPlane.w;
}
}
return newSkeleton;
}
public bool IsBodyTurned(ref KinectInterop.BodyData bodyData)
{
//face = On: Face (357.0/1.0)
//face = Off
//| Head_px <= -0.02
//| | Neck_dx <= 0.08: Face (46.0/1.0)
//| | Neck_dx > 0.08: Back (3.0)
//| Head_px > -0.02
//| | SpineShoulder_px <= -0.02: Face (4.0)
//| | SpineShoulder_px > -0.02: Back (64.0/1.0)
bool bBodyTurned = false;
if (bFaceTrackingInited)
{
bool bFaceOn = IsFaceTracked(bodyData.liTrackingID);
if (bFaceOn)
{
bBodyTurned = false;
}
else
{
// face = Off
if (bodyData.joint[(int)KinectInterop.JointType.Head].posRel.x <= -0.02f)
{
bBodyTurned = (bodyData.joint[(int)KinectInterop.JointType.Neck].posDrv.x > 0.08f);
}
else
{
// Head_px > -0.02
bBodyTurned = (bodyData.joint[(int)KinectInterop.JointType.SpineShoulder].posRel.x > -0.02f);
}
}
}
return bBodyTurned;
}
public bool InitBackgroundRemoval(KinectInterop.SensorData sensorData, bool isHiResPrefered)
{
return KinectInterop.InitBackgroundRemoval(sensorData, isHiResPrefered);
}
public int GetForegroundFrameLength(KinectInterop.SensorData sensorData, bool isHiResPrefered)
{
return GetBackgroundRemovalFrameLengthNative();
}
public Rect GetForegroundFrameRect(KinectInterop.SensorData sensorData, bool isHiResPrefered)
{
return new Rect(0f, 0f, sensorData.depthImageWidth, sensorData.depthImageHeight);
}
public bool UpdateBackgroundRemoval(KinectInterop.SensorData sensorData, bool isHiResPrefered, Color32 defaultColor)
{
int hr = UpdateBackgroundRemovalNative();
return (hr >= 0);
}
public bool GetMultiSourceFrame(KinectInterop.SensorData sensorData)
{
return false;
}
public bool UpdateSensorData(KinectInterop.SensorData sensorData)
{
int hr = UpdateKinectSensor();
return (hr == 0);
}
// // returns the joint at given index
// public KinectInterop.JointType GetJointAtIndex(int index)
// {
// switch(index)
// {
// case (int)NuiSkeletonPositionIndex.HipCenter:
// return KinectInterop.JointType.SpineBase;
// case (int)NuiSkeletonPositionIndex.Spine:
// return KinectInterop.JointType.SpineMid;
// case (int)NuiSkeletonPositionIndex.ShoulderCenter:
// return KinectInterop.JointType.Neck;
// case (int)NuiSkeletonPositionIndex.Head:
// return KinectInterop.JointType.Head;
//
// case (int)NuiSkeletonPositionIndex.ShoulderLeft:
// return KinectInterop.JointType.ShoulderLeft;
// case (int)NuiSkeletonPositionIndex.ElbowLeft:
// return KinectInterop.JointType.ElbowLeft;
// case (int)NuiSkeletonPositionIndex.WristLeft:
// return KinectInterop.JointType.WristLeft;
// case (int)NuiSkeletonPositionIndex.HandLeft:
// return KinectInterop.JointType.HandLeft;
//
// case (int)NuiSkeletonPositionIndex.ShoulderRight:
// return KinectInterop.JointType.ShoulderRight;
// case (int)NuiSkeletonPositionIndex.ElbowRight:
// return KinectInterop.JointType.ElbowRight;
// case (int)NuiSkeletonPositionIndex.WristRight:
// return KinectInterop.JointType.WristRight;
// case (int)NuiSkeletonPositionIndex.HandRight:
// return KinectInterop.JointType.HandRight;
//
// case (int)NuiSkeletonPositionIndex.HipLeft:
// return KinectInterop.JointType.HipLeft;
// case (int)NuiSkeletonPositionIndex.KneeLeft:
// return KinectInterop.JointType.KneeLeft;
// case (int)NuiSkeletonPositionIndex.AnkleLeft:
// return KinectInterop.JointType.AnkleLeft;
// case (int)NuiSkeletonPositionIndex.FootLeft:
// return KinectInterop.JointType.FootLeft;
//
// case (int)NuiSkeletonPositionIndex.HipRight:
// return KinectInterop.JointType.HipRight;
// case (int)NuiSkeletonPositionIndex.KneeRight:
// return KinectInterop.JointType.KneeRight;
// case (int)NuiSkeletonPositionIndex.AnkleRight:
// return KinectInterop.JointType.AnkleRight;
// case (int)NuiSkeletonPositionIndex.FootRight:
// return KinectInterop.JointType.FootRight;
// }
//
// return (KinectInterop.JointType)(-1);
// }
// returns the parent joint of the given joint
public KinectInterop.JointType GetParentJoint(KinectInterop.JointType joint)
{
switch (joint)
{
case KinectInterop.JointType.SpineBase:
return KinectInterop.JointType.SpineBase;
case KinectInterop.JointType.ShoulderLeft:
case KinectInterop.JointType.ShoulderRight:
return KinectInterop.JointType.Neck;
case KinectInterop.JointType.HipLeft:
case KinectInterop.JointType.HipRight:
return KinectInterop.JointType.SpineBase;
}
return (KinectInterop.JointType)((int)joint - 1);
}
private void GetHandStateAndConf(uint skeletonId, bool isRightHand, uint handState, InteractionHandEventType handEvent,
ref Dictionary<uint, InteractionHandEventType> lastHandEvent,
ref KinectInterop.HandState refHandState,
ref KinectInterop.TrackingConfidence refHandConf)
{
bool bHandPrimary = (handState & (uint)NuiHandpointerState.Active) != 0;
refHandConf = bHandPrimary ? KinectInterop.TrackingConfidence.High : KinectInterop.TrackingConfidence.Low;
if (!lastHandEvent.ContainsKey(skeletonId))
{
lastHandEvent[skeletonId] = InteractionHandEventType.Release;
}
if (handEvent == InteractionHandEventType.Grip ||
handEvent == InteractionHandEventType.Release)
{
if (lastHandEvent[skeletonId] != handEvent)
{
//Debug.Log(string.Format("{0} - {1}, event: {2}", skeletonId, !isRightHand ? "left" : "right", handEvent));
lastHandEvent[skeletonId] = handEvent;
}
}
if (bHandPrimary)
{
switch (lastHandEvent[skeletonId])
{
case InteractionHandEventType.Grip:
refHandState = KinectInterop.HandState.Closed;
break;
case InteractionHandEventType.Release:
refHandState = KinectInterop.HandState.Open;
break;
}
}
else
{
// if(lastHandEvent[skeletonId] != InteractionHandEventType.Release)
// {
// Debug.Log(string.Format("{0} - old: {1}, NONE: {2}", skeletonId, lastHandEvent[skeletonId], InteractionHandEventType.Release));
// lastHandEvent[skeletonId] = InteractionHandEventType.Release;
// }
refHandState = KinectInterop.HandState.NotTracked;
}
}
public bool IsBodyTurned(ref KinectInterop.BodyData bodyData)
{
return false;
}
public void CloseSensor(KinectInterop.SensorData sensorData)
{
FinishKinectInteraction();
ShutdownKinectSensor();
}
public bool MapDepthFrameToColorCoords(KinectInterop.SensorData sensorData, ref Vector2[] vColorCoords)
{
// uncomment this block of code, if you need the user cut-out image (lowers the FPS a lot)
// if(sensorData.depthImage != null && sensorData.colorImage != null)
// {
// int i = 0, cx = 0, cy = 0;
//
// for(int y = 0; y < sensorData.depthImageHeight; y++)
// {
// for(int x = 0; x < sensorData.depthImageWidth; x++)
// {
// ushort dv = sensorData.depthImage[i];
//
// NuiImageGetColorPixelCoordinatesFromDepthPixelAtResolution(
// Constants.ColorImageResolution,
// Constants.DepthImageResolution,
// ref pcViewArea,
// x, y, (ushort)(dv << 3),
// out cx, out cy);
//
// vColorCoords[i] = new Vector2(cx, cy);
// i++;
// }
// }
//
// return true;
// }
return false;
}
public void FinishBackgroundRemoval(KinectInterop.SensorData sensorData)
{
FinishBackgroundRemovalNative();
bBackgroundRemovalInited = false;
}
public Vector3 MapDepthPointToSpaceCoords(KinectInterop.SensorData sensorData, Vector2 depthPos, ushort depthVal)
{
float fDepthX = depthPos.x / sensorData.depthImageWidth;
float fDepthY = depthPos.y / sensorData.depthImageHeight;
Vector3 point = NuiTransformDepthImageToSkeleton(fDepthX, fDepthY, depthVal);
return point;
}
public void FixJointOrientations(KinectInterop.SensorData sensorData, ref KinectInterop.BodyData bodyData)
{
// fix the hips-to-spine tilt (it is about 40 degrees to the back)
int hipsIndex = (int)KinectInterop.JointType.SpineBase;
Quaternion quat = bodyData.joint[hipsIndex].normalRotation;
quat *= Quaternion.Euler(40f, 0f, 0f);
bodyData.joint[hipsIndex].normalRotation = quat;
Vector3 mirroredAngles = quat.eulerAngles;
mirroredAngles.y = -mirroredAngles.y;
mirroredAngles.z = -mirroredAngles.z;
bodyData.joint[hipsIndex].mirroredRotation = Quaternion.Euler(mirroredAngles);
bodyData.normalRotation = bodyData.joint[hipsIndex].normalRotation;
bodyData.mirroredRotation = bodyData.joint[hipsIndex].mirroredRotation;
}
public KinectInterop.SensorData OpenDefaultSensor(KinectInterop.FrameSource dwFlags, float sensorAngle, bool bUseMultiSource)
{
sourceFlags = dwFlags;
NuiInitializeFlags nuiFlags = // NuiInitializeFlags.UsesNone;
NuiInitializeFlags.UsesSkeleton | NuiInitializeFlags.UsesDepthAndPlayerIndex;
if ((dwFlags & KinectInterop.FrameSource.TypeBody) != 0)
{
nuiFlags |= NuiInitializeFlags.UsesSkeleton;
}
if ((dwFlags & KinectInterop.FrameSource.TypeColor) != 0)
{
nuiFlags |= NuiInitializeFlags.UsesColor;
}
if ((dwFlags & KinectInterop.FrameSource.TypeDepth) != 0)
{
nuiFlags |= NuiInitializeFlags.UsesDepthAndPlayerIndex;
}
if ((dwFlags & KinectInterop.FrameSource.TypeBodyIndex) != 0)
{
nuiFlags |= NuiInitializeFlags.UsesDepthAndPlayerIndex;
}
if ((dwFlags & KinectInterop.FrameSource.TypeInfrared) != 0)
{
nuiFlags |= (NuiInitializeFlags.UsesColor | (NuiInitializeFlags)0x8000);
}
if ((dwFlags & KinectInterop.FrameSource.TypeAudio) != 0)
{
nuiFlags |= NuiInitializeFlags.UsesAudio;
}
FacetrackingManager[] faceManagers = GameObject.FindObjectsOfType(typeof(FacetrackingManager)) as FacetrackingManager[];
if (faceManagers != null && faceManagers.Length > 0)
{
for (int i = 0; i < faceManagers.Length; i++)
{
if (faceManagers[i].enabled)
{
//Debug.Log("Found FacetrackingManager => UsesColor");
nuiFlags |= NuiInitializeFlags.UsesColor;
break;
}
}
}
SpeechManager[] speechManagers = GameObject.FindObjectsOfType(typeof(SpeechManager)) as SpeechManager[];
if (speechManagers != null && speechManagers.Length > 0)
{
for (int i = 0; i < speechManagers.Length; i++)
{
if (speechManagers[i].enabled)
{
//Debug.Log("Found SpeechManager => UsesAudio");
nuiFlags |= NuiInitializeFlags.UsesAudio;
break;
}
}
}
int hr = InitKinectSensor(nuiFlags, true, (int)Constants.ColorImageResolution, (int)Constants.DepthImageResolution, Constants.IsNearMode);
if (hr == 0)
{
// set sensor angle
SetKinectElevationAngle((int)sensorAngle);
// initialize Kinect interaction
hr = InitKinectInteraction();
if (hr != 0)
{
Debug.LogError(string.Format("Error initializing KinectInteraction: hr=0x{0:X}", hr));
}
KinectInterop.SensorData sensorData = new KinectInterop.SensorData();
sensorData.bodyCount = Constants.NuiSkeletonCount;
sensorData.jointCount = Constants.JointCount;
sensorData.depthCameraFOV = 46.6f;
sensorData.colorCameraFOV = 48.6f;
sensorData.depthCameraOffset = 0.01f;
sensorData.faceOverlayOffset = 0.01f;
NuiImageResolutionToSize(Constants.ColorImageResolution, out sensorData.colorImageWidth, out sensorData.colorImageHeight);
// sensorData.colorImageWidth = Constants.ColorImageWidth;
// sensorData.colorImageHeight = Constants.ColorImageHeight;
if ((dwFlags & KinectInterop.FrameSource.TypeColor) != 0)
{
//colorStreamHandle = GetColorStreamHandle();
sensorData.colorImage = new byte[sensorData.colorImageWidth * sensorData.colorImageHeight * 4];
}
NuiImageResolutionToSize(Constants.DepthImageResolution, out sensorData.depthImageWidth, out sensorData.depthImageHeight);
// sensorData.depthImageWidth = Constants.DepthImageWidth;
// sensorData.depthImageHeight = Constants.DepthImageHeight;
if ((dwFlags & KinectInterop.FrameSource.TypeDepth) != 0)
{
//depthStreamHandle = GetDepthStreamHandle();
sensorData.depthImage = new ushort[sensorData.depthImageWidth * sensorData.depthImageHeight];
}
if ((dwFlags & KinectInterop.FrameSource.TypeBodyIndex) != 0)
{
sensorData.bodyIndexImage = new byte[sensorData.depthImageWidth * sensorData.depthImageHeight];
}
if ((dwFlags & KinectInterop.FrameSource.TypeInfrared) != 0)
{
sensorData.infraredImage = new ushort[sensorData.colorImageWidth * sensorData.colorImageHeight];
}
if ((dwFlags & KinectInterop.FrameSource.TypeBody) != 0)
{
skeletonFrame = new NuiSkeletonFrame()
{
SkeletonData = new NuiSkeletonData[Constants.NuiSkeletonCount]
};
// default values used to pass to smoothing function
smoothParameters = new NuiTransformSmoothParameters();
smoothParameters.fSmoothing = 0.5f;
smoothParameters.fCorrection = 0.5f;
smoothParameters.fPrediction = 0.5f;
smoothParameters.fJitterRadius = 0.05f;
smoothParameters.fMaxDeviationRadius = 0.04f;
}
return sensorData;
}
else
{
Debug.LogError("InitKinectSensor failed: " + GetNuiErrorString(hr));
}
return null;
}
public void FreeMultiSourceFrame(KinectInterop.SensorData sensorData)
{
}
