투명디스플레이 연구사업

using UnityEngine;

//using Windows.Kinect;

using System.Collections;

using System.Collections.Generic;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

using System;

using System.IO;

using System.Text;

#if !UNITY_WSA

using ICSharpCode.SharpZipLib.Zip;

#endif

//using OpenCvSharp;

using UnityEngine.SceneManagement;

/// <summary>

/// KinectInterop is a class containing utility and interop functions, that call the proper sensor interface.

/// </summary>

public class KinectInterop

{

	// order of depth sensor interfaces

//	public static Type[] SensorInterfaceOrder = new Type[] { 

//		typeof(Kinect2Interface), typeof(Kinect1Interface), typeof(OpenNI2Interface)

//	};

	public static DepthSensorInterface[] SensorInterfaceOrder = new DepthSensorInterface[] { 

#if UNITY_WSA_10_0 && NETFX_CORE

		new Kinect2UwpInterface()

#else

		new Kinect2Interface(), new Kinect1Interface()/**, new OpenNI2Interface()*/

#endif

	};

	// graphics shader level

	private static int graphicsShaderLevel = 0;

	/// <summary>

	/// Constants used by this class and other K2-components

	/// </summary>

	public static class Constants

	{

		public const int MaxBodyCount = 6;

		public const int MaxJointCount = 25;

		public const float MinTimeBetweenSameGestures = 0.0f;

		public const float PoseCompleteDuration = 1.0f;

		public const float ClickMaxDistance = 0.05f;

		public const float ClickStayDuration = 2.0f;

	}

	// Types of depth sensor platforms

	public enum DepthSensorPlatform : int

	{

		None = 0,

		KinectSDKv1 = 1,

		KinectSDKv2 = 2,

		OpenNIv2 = 3,

		RealSense = 4,

		KinectUWPv2 = 5,

		DummyK1 = 101,

		DummyK2 = 102

	}

	// Data structures for interfacing C# with the native wrappers

    [Flags]

    public enum FrameSource : uint

    {

		TypeNone = 0x0,

        TypeColor = 0x1,

        TypeInfrared = 0x2,

        TypeDepth = 0x8,

        TypeBodyIndex = 0x10,

        TypeBody = 0x20,

        TypeAudio = 0x40

    }

    public enum JointType : int

    {

		SpineBase = 0,

		SpineMid = 1,

        Neck = 2,

        Head = 3,

        ShoulderLeft = 4,

        ElbowLeft = 5,

        WristLeft = 6,

        HandLeft = 7,

        ShoulderRight = 8,

        ElbowRight = 9,

        WristRight = 10,

        HandRight = 11,

        HipLeft = 12,

        KneeLeft = 13,

        AnkleLeft = 14,

        FootLeft = 15,

        HipRight = 16,

        KneeRight = 17,

        AnkleRight = 18,

        FootRight = 19,

        SpineShoulder = 20,

        HandTipLeft = 21,

        ThumbLeft = 22,

        HandTipRight = 23,

        ThumbRight = 24

		//Count = 25

    }

    public static readonly Vector3[] JointBaseDir =

    {

        Vector3.zero,

        Vector3.up,

        Vector3.up,

        Vector3.up,

        Vector3.left,

        Vector3.left,

        Vector3.left,

        Vector3.left,

        Vector3.right,

        Vector3.right,

        Vector3.right,

        Vector3.right,

        Vector3.down,

        Vector3.down,

        Vector3.down,

        Vector3.forward,

        Vector3.down,

        Vector3.down,

        Vector3.down,

        Vector3.forward,

        Vector3.up,

        Vector3.left,

        Vector3.forward,

        Vector3.right,

        Vector3.forward

    };

    public enum TrackingState

    {

        NotTracked = 0,

        Inferred = 1,

        Tracked = 2

    }

	public enum HandState

    {

        Unknown = 0,

        NotTracked = 1,

        Open = 2,

        Closed = 3,

        Lasso = 4

    }

	public enum TrackingConfidence

    {

        Low = 0,

        High = 1

    }

//    [Flags]

//    public enum ClippedEdges

//    {

//        None = 0,

//        Right = 1,

//        Left = 2,

//        Top = 4,

//        Bottom = 8

//    }

	public enum FaceShapeAnimations : int

	{

		JawOpen                                  =0,

		LipPucker                                =1,

		JawSlideRight                            =2,

		LipStretcherRight                        =3,

		LipStretcherLeft                         =4,

		LipCornerPullerLeft                      =5,

		LipCornerPullerRight                     =6,

		LipCornerDepressorLeft                   =7,

		LipCornerDepressorRight                  =8,

		LeftcheekPuff                            =9,

		RightcheekPuff                           =10,

		LefteyeClosed                            =11,

		RighteyeClosed                           =12,

		RighteyebrowLowerer                      =13,

		LefteyebrowLowerer                       =14,

		LowerlipDepressorLeft                    =15,

		LowerlipDepressorRight                   =16,

	}

	public enum FaceShapeDeformations : int

	{

		PCA01                                    =0,

		PCA02                                    =1,

		PCA03                                    =2,

		PCA04                                    =3,

		PCA05                                    =4,

		PCA06                                    =5,

		PCA07                                    =6,

		PCA08                                    =7,

		PCA09                                    =8,

		PCA10                                    =9,

		Chin03                                   =10,

		Forehead00                               =11,

		Cheeks02                                 =12,

		Cheeks01                                 =13,

		MouthBag01                               =14,

		MouthBag02                               =15,

		Eyes02                                   =16,

		MouthBag03                               =17,

		Forehead04                               =18,

		Nose00                                   =19,

		Nose01                                   =20,

		Nose02                                   =21,

		MouthBag06                               =22,

		MouthBag05                               =23,

		Cheeks00                                 =24,

		Mask03                                   =25,

		Eyes03                                   =26,

		Nose03                                   =27,

		Eyes08                                   =28,

		MouthBag07                               =29,

		Eyes00                                   =30,

		Nose04                                   =31,

		Mask04                                   =32,

		Chin04                                   =33,

		Forehead05                               =34,

		Eyes06                                   =35,

		Eyes11                                   =36,

		Nose05                                   =37,

		Mouth07                                  =38,

		Cheeks08                                 =39,

		Eyes09                                   =40,

		Mask10                                   =41,

		Mouth09                                  =42,

		Nose07                                   =43,

		Nose08                                   =44,

		Cheeks07                                 =45,

		Mask07                                   =46,

		MouthBag09                               =47,

		Nose06                                   =48,

		Chin02                                   =49,

		Eyes07                                   =50,

		Cheeks10                                 =51,

		Rim20                                    =52,

		Mask22                                   =53,

		MouthBag15                               =54,

		Chin01                                   =55,

		Cheeks04                                 =56,

		Eyes17                                   =57,

		Cheeks13                                 =58,

		Mouth02                                  =59,

		MouthBag12                               =60,

		Mask19                                   =61,

		Mask20                                   =62,

		Forehead06                               =63,

		Mouth13                                  =64,

		Mask25                                   =65,

		Chin05                                   =66,

		Cheeks20                                 =67,

		Nose09                                   =68,

		Nose10                                   =69,

		MouthBag27                               =70,

		Mouth11                                  =71,

		Cheeks14                                 =72,

		Eyes16                                   =73,

		Mask29                                   =74,

		Nose15                                   =75,

		Cheeks11                                 =76,

		Mouth16                                  =77,

		Eyes19                                   =78,

		Mouth17                                  =79,

		MouthBag36                               =80,

		Mouth15                                  =81,

		Cheeks25                                 =82,

		Cheeks16                                 =83,

		Cheeks18                                 =84,

		Rim07                                    =85,

		Nose13                                   =86,

		Mouth18                                  =87,

		Cheeks19                                 =88,

		Rim21                                    =89,

		Mouth22                                  =90,

		Nose18                                   =91,

		Nose16                                   =92,

		Rim22                                    =93,

	}

	/// <summary>

	/// Container for the sensor data, including color, depth, ir and body frames.

	/// </summary>

	public class SensorData

	{

		public DepthSensorInterface sensorInterface;

		public DepthSensorPlatform sensorIntPlatform;

		public int bodyCount;

		public int jointCount;

		public float depthCameraOffset;

		public float depthCameraFOV;

		public float colorCameraFOV;

		public float faceOverlayOffset;

		public int colorImageWidth;

		public int colorImageHeight;

		public byte[] colorImage;

		public long lastColorFrameTime = 0;

		public int depthImageWidth;

		public int depthImageHeight;

		public ushort[] depthImage;

		public long lastDepthFrameTime = 0;

		public ushort[] infraredImage;

		public long lastInfraredFrameTime = 0;

		public byte[] bodyIndexImage;

		public long lastBodyIndexFrameTime = 0;

		public byte selectedBodyIndex = 255;

		public bool hintHeightAngle = false;

		public Quaternion sensorRotDetected = Quaternion.identity;

		public float sensorHgtDetected = 0f;

		public RenderTexture bodyIndexTexture;

		public Material bodyIndexMaterial;

		public ComputeBuffer bodyIndexBuffer;

		public float[] bodyIndexBufferData = null;

		public bool bodyIndexBufferReady = false;

		public object bodyIndexBufferLock = new object();

		public RenderTexture depthImageTexture;

		public Material depthImageMaterial;

		public ComputeBuffer depthImageBuffer;

		public ComputeBuffer depthHistBuffer;

		public float[] depthImageBufferData = null;

		public int[] depthHistBufferData = null;

		public float[] equalHistBufferData = null;

		public int depthHistTotalPoints = 0;

		public int firstUserIndex = -1;

		public bool depthImageBufferReady = false;

		public object depthImageBufferLock = new object();

		public bool depthCoordsBufferReady = false;

		public object depthCoordsBufferLock = new object();

		public bool newDepthImage = false;

		public Texture2D colorImageTexture;

		public bool colorImageBufferReady = false;

		public object colorImageBufferLock = new object();

		public bool newColorImage = false;

		public RenderTexture depth2ColorTexture;

		public Material depth2ColorMaterial;

		public ComputeBuffer depth2ColorBuffer;

		public Vector2[] depth2ColorCoords;

		public Vector3[] depth2SpaceCoords;

		public bool spaceCoordsBufferReady = false;

		public object spaceCoordsBufferLock = new object();

        public bool backgroundRemovalInited = false;

        public bool backgroundRemovalHiRes = false;

		public bool invertAlphaColorMask = false;

		public RenderTexture color2DepthTexture;

		public Material color2DepthMaterial;

		public ComputeBuffer color2DepthBuffer;

		public Vector2[] color2DepthCoords;

		public RenderTexture alphaBodyTexture;

		public Material alphaBodyMaterial;

		public Material erodeBodyMaterial, dilateBodyMaterial, blurBodyMaterial;

		public int erodeIterations;

		public int dilateIterations;

		public RenderTexture colorBackgroundTexture;

		public Material colorBackgroundMaterial;

		public bool newInfraredImage = false;

		public bool bodyFrameReady = false;

		public object bodyFrameLock = new object();

		public bool newBodyFrame = false;

		public bool isPlayModeEnabled;

		public string playModeData;

		public string playModeHandData;

	}

	/// <summary>

	/// Parameters used for smoothing of the body-joint positions between frames.

	/// </summary>

	public struct SmoothParameters

	{

		public float smoothing;

		public float correction;

		public float prediction;

		public float jitterRadius;

		public float maxDeviationRadius;

	}

	/// <summary>

	/// Container for the body-joint data.

	/// </summary>

	public struct JointData

    {

		// parameters filled in by the sensor interface

		//public JointType jointType;

    	public TrackingState trackingState;

    	public Vector3 kinectPos;

    	public Vector3 position;

		public Quaternion orientation;  // deprecated

		public Vector3 posPrev;

		public Vector3 posRel;

		public Vector3 posVel;

		// KM calculated parameters

		public Vector3 direction;

		public Quaternion normalRotation;

		public Quaternion mirroredRotation;

		// Constraint parameters

		public float lastAngle;

    }

	/// <summary>

	/// Container for the body data.

	/// </summary>

	public struct BodyData

    {

		// parameters filled in by the sensor interface

        public Int64 liTrackingID;

        public Vector3 position;

		public Quaternion orientation;  // deprecated

		public JointData[] joint;

		// KM calculated parameters

		public Quaternion normalRotation;

		public Quaternion mirroredRotation;

		public Vector3 hipsDirection;

		public Vector3 shouldersDirection;

		public float bodyTurnAngle;

		//public float bodyFullAngle;

		public bool isTurnedAround;

		public float turnAroundFactor;

		public Quaternion leftHandOrientation;

		public Quaternion rightHandOrientation;

		public Quaternion headOrientation;

//		public Vector3 leftArmDirection;

//		public Vector3 leftThumbForward;

//		public Vector3 leftThumbDirection;

//		//public float leftThumbAngle;

//

//		public Vector3 rightArmDirection;

//		public Vector3 rightThumbForward;

//		public Vector3 rightThumbDirection;

//		//public float rightThumbAngle;

		//public Vector3 leftLegDirection;

		//public Vector3 leftFootDirection;

		//public Vector3 rightLegDirection;

		//public Vector3 rightFootDirection;

		public HandState leftHandState;

		public TrackingConfidence leftHandConfidence;

		public HandState rightHandState;

		public TrackingConfidence rightHandConfidence;

        public uint dwClippedEdges;

        public short bIsTracked;

		public short bIsRestricted;

    }

	/// <summary>

	/// Container for the body frame data.

	/// </summary>

    public struct BodyFrameData

    {

        public Int64 liRelativeTime, liPreviousTime;

        [MarshalAsAttribute(UnmanagedType.ByValArray, SizeConst = 6, ArraySubType = UnmanagedType.Struct)]

        public BodyData[] bodyData;

        //public UnityEngine.Vector4 floorClipPlane;

		public bool bTurnAnalisys;

		public BodyFrameData(int bodyCount, int jointCount)

		{

			liRelativeTime = liPreviousTime = 0;

			//floorClipPlane = UnityEngine.Vector4.zero;

			bTurnAnalisys = false;

			bodyData = new BodyData[bodyCount];

			for(int i = 0; i < bodyCount; i++)

			{

				bodyData[i].joint = new JointData[jointCount];

				bodyData[i].leftHandOrientation = Quaternion.identity;

				bodyData[i].rightHandOrientation = Quaternion.identity;

				bodyData[i].headOrientation = Quaternion.identity;

			}

		}

    }

	// initializes the available sensor interfaces

	public static List<DepthSensorInterface> InitSensorInterfaces(bool bOnceRestarted, ref bool bNeedRestart)

	{

		List<DepthSensorInterface> listInterfaces = new List<DepthSensorInterface>();

		//var typeInterface = typeof(DepthSensorInterface);

		for(int pass = 0; pass <= 1; pass++)

		{

			bool bCopyLibs = (pass != 0);

			//foreach(Type type in SensorInterfaceOrder)

			for(int i = 0; i < SensorInterfaceOrder.Length; i++)

			{

				DepthSensorInterface sensorInt = SensorInterfaceOrder[i];

				//if(typeInterface.IsAssignableFrom(type) && type != typeInterface)

				if(sensorInt != null)

				{

					//DepthSensorInterface sensorInt = null;

					try 

					{

						//sensorInt = (DepthSensorInterface)Activator.CreateInstance(type);

						bool bIntNeedRestart = false;

						if(sensorInt.InitSensorInterface(bCopyLibs, ref bIntNeedRestart))

						{

							bNeedRestart |= bIntNeedRestart;

						}

						else

						{

							sensorInt.FreeSensorInterface(bCopyLibs);

							sensorInt = null;

							continue;

						}

						if(!bNeedRestart && !sensorInt.IsSensorAvailable())

						{

							sensorInt.FreeSensorInterface(false);

							sensorInt = null;

						}

					}

					catch (Exception /**ex*/) 

					{

						//Debug.Log(ex);

						if(sensorInt != null)

						{

							try 

							{

								sensorInt.FreeSensorInterface(bCopyLibs);

							}

							catch (Exception) 

							{

								// do nothing

							}

							finally

							{

								sensorInt = null;

							}

						}

					}

					if(sensorInt != null)

					{

						listInterfaces.Add(sensorInt);

					}

				}

			}

			if(listInterfaces.Count > 0)

			{

				// we found working interface(s), don't go any further

				break;

			}

			if(bOnceRestarted)

			{

				// we have restarted once, don't do it again

				break;

			}

		}

		return listInterfaces;

	}

	// opens the default sensor and needed readers

	public static SensorData OpenDefaultSensor(List<DepthSensorInterface> listInterfaces, FrameSource dwFlags, float sensorAngle, bool bUseMultiSource,  

		KinectManager.UserMapType userMapType, BackgroundRemovalManager brManager)

	{

		SensorData sensorData = null;

		if(listInterfaces == null)

			return sensorData;

		foreach(DepthSensorInterface sensorInt in listInterfaces)

		{

			try 

			{

				if(sensorData == null)

				{

					sensorData = sensorInt.OpenDefaultSensor(dwFlags, sensorAngle, bUseMultiSource);

					if(sensorData != null)

					{

						sensorData.sensorInterface = sensorInt;

						sensorData.sensorIntPlatform = sensorInt.GetSensorPlatform();

						Debug.Log("Interface used: " + sensorInt.GetType().Name);

						Debug.Log("Shader level: " + SystemInfo.graphicsShaderLevel);

						if(sensorData.bodyIndexImage != null && IsDirectX11Available())

						{

							Shader bodyIndexShader = Shader.Find("Kinect/BodyShader");

							if(bodyIndexShader != null)

							{

                                if(sensorData.bodyIndexTexture == null || sensorData.bodyIndexTexture.width != sensorData.depthImageWidth || sensorData.bodyIndexTexture.height != sensorData.depthImageHeight)

                                {

                                    sensorData.bodyIndexTexture = new RenderTexture(sensorData.depthImageWidth, sensorData.depthImageHeight, 0);

                                    sensorData.bodyIndexTexture.wrapMode = TextureWrapMode.Clamp;

                                    sensorData.bodyIndexTexture.filterMode = FilterMode.Point;

                                    //Debug.Log(sensorData.bodyIndexTexture.format);

                                }

                                sensorData.bodyIndexMaterial = new Material(bodyIndexShader);

								sensorData.bodyIndexMaterial.SetFloat("_TexResX", (float)sensorData.depthImageWidth);

								sensorData.bodyIndexMaterial.SetFloat("_TexResY", (float)sensorData.depthImageHeight);

								sensorData.bodyIndexBuffer = new ComputeBuffer(sensorData.bodyIndexImage.Length, sizeof(float));

								sensorData.bodyIndexMaterial.SetBuffer("_BodyIndexBuffer", sensorData.bodyIndexBuffer);

							}

						}

						if(sensorData.depthImage != null && IsDirectX11Available() &&

						    userMapType == KinectManager.UserMapType.UserTexture)

						{

							Shader depthImageShader = Shader.Find("Kinect/DepthShader");

							if(depthImageShader != null)

							{

                                if (sensorData.depthImageTexture == null || sensorData.depthImageTexture.width != sensorData.depthImageWidth || sensorData.depthImageTexture.height != sensorData.depthImageHeight)

                                {

                                    sensorData.depthImageTexture = new RenderTexture(sensorData.depthImageWidth, sensorData.depthImageHeight, 0);

                                    sensorData.depthImageTexture.wrapMode = TextureWrapMode.Clamp;

                                    sensorData.depthImageTexture.filterMode = FilterMode.Point;

                                }

                                sensorData.depthImageMaterial = new Material(depthImageShader);

								sensorData.depthImageMaterial.SetTexture("_MainTex", sensorData.bodyIndexTexture);

								sensorData.depthImageMaterial.SetFloat("_TexResX", (float)sensorData.depthImageWidth);

								sensorData.depthImageMaterial.SetFloat("_TexResY", (float)sensorData.depthImageHeight);

								sensorData.depthImageBuffer = new ComputeBuffer(sensorData.depthImage.Length, sizeof(float));

								sensorData.depthImageMaterial.SetBuffer("_DepthBuffer", sensorData.depthImageBuffer);

								sensorData.depthHistBuffer = new ComputeBuffer(5001, sizeof(float));

								sensorData.depthImageMaterial.SetBuffer("_HistBuffer", sensorData.depthHistBuffer);

								// use body index buffer to overcome the linear color correction

								sensorData.depthImageMaterial.SetBuffer("_BodyIndexBuffer", sensorData.bodyIndexBuffer);

							}

						}

						if(sensorData.colorImage != null)

						{

                            if (sensorData.colorImageTexture == null || sensorData.colorImageTexture.width != sensorData.colorImageWidth || sensorData.colorImageTexture.height != sensorData.colorImageHeight)

                            {

                                sensorData.colorImageTexture = new Texture2D(sensorData.colorImageWidth, sensorData.colorImageHeight, TextureFormat.RGBA32, false);

                            }

                        }

						// check if background removal requires cut-out image

						bool bBrRequiresCutOut = brManager && (!brManager.colorCameraResolution || !sensorInt.IsBRHiResSupported());

						if(sensorData.bodyIndexImage != null && sensorData.colorImage != null && IsDirectX11Available() &&

						   (userMapType == KinectManager.UserMapType.CutOutTexture || bBrRequiresCutOut))

						{

							Shader depth2ColorShader = Shader.Find("Kinect/Depth2ColorShader");

							if(depth2ColorShader != null)

							{

                                if (sensorData.depth2ColorTexture == null || sensorData.depth2ColorTexture.width != sensorData.depthImageWidth || sensorData.depth2ColorTexture.height != sensorData.depthImageHeight)

                                {

                                    sensorData.depth2ColorTexture = new RenderTexture(sensorData.depthImageWidth, sensorData.depthImageHeight, 0);

                                    sensorData.depth2ColorTexture.wrapMode = TextureWrapMode.Clamp;

                                    sensorData.depth2ColorTexture.filterMode = FilterMode.Point;

                                }

                                sensorData.depth2ColorMaterial = new Material(depth2ColorShader);

								sensorData.depth2ColorMaterial.SetFloat("_ColorResX", (float)sensorData.colorImageWidth);

								sensorData.depth2ColorMaterial.SetFloat("_ColorResY", (float)sensorData.colorImageHeight);

								sensorData.depth2ColorMaterial.SetFloat("_DepthResX", (float)sensorData.depthImageWidth);

								sensorData.depth2ColorMaterial.SetFloat("_DepthResY", (float)sensorData.depthImageHeight);

								sensorData.depth2ColorBuffer = new ComputeBuffer(sensorData.depthImage.Length, sizeof(float) * 2);

								sensorData.depth2ColorMaterial.SetBuffer("_ColorCoords", sensorData.depth2ColorBuffer);

								sensorData.depth2ColorCoords = new Vector2[sensorData.depthImage.Length];

							}

						}

//						if(sensorData.bodyIndexImage != null && sensorData.colorImage != null && IsDirectX11Available() &&

//						   (userMapType == KinectManager.UserMapType.CutOutTexture || bBrRequiresCutOut))

//						{

//							sensorData.depth2ColorCoords = new Vector2[sensorData.depthImage.Length];

//						}

					}

				}

				else

				{

					sensorInt.FreeSensorInterface(false);

				}

			}

			catch (Exception ex) 

			{

				Debug.LogError("Initialization of the sensor failed.");

				Debug.LogError(ex.ToString());

				try 

				{

					sensorInt.FreeSensorInterface(false);

				} 

				catch (Exception) 

				{

					// do nothing

				}

			}

		}

		return sensorData;

	}

	// closes opened readers and closes the sensor

	public static void CloseSensor(SensorData sensorData)

	{

		FinishBackgroundRemoval(sensorData);

		//FinishColorBackground(sensorData);

		if(sensorData != null && sensorData.sensorInterface != null)

		{

			sensorData.sensorInterface.CloseSensor(sensorData);

		}

		if(sensorData.bodyIndexBuffer != null)

		{

			sensorData.bodyIndexBuffer.Release();

			sensorData.bodyIndexBuffer = null;

		}

		if(sensorData.depthImageBuffer != null)

		{

			sensorData.depthImageBuffer.Release();

			sensorData.depthImageBuffer = null;

		}

		if(sensorData.depthHistBuffer != null)

		{

			sensorData.depthHistBuffer.Release();

			sensorData.depthHistBuffer = null;

		}

		if(sensorData.depth2ColorBuffer != null)

		{

			sensorData.depth2ColorBuffer.Release();

			sensorData.depth2ColorBuffer = null;

		}

        //if (sensorData.depth2ColorTexture != null)

        //{

        //    sensorData.depth2ColorTexture.Release();

        //    sensorData.depth2ColorTexture = null;

        //}

        //sensorData.depth2ColorMaterial = null;

        //sensorData.depth2ColorCoords = null;

    }

    // invoked periodically to update sensor data, if needed

    public static bool UpdateSensorData(SensorData sensorData)

	{

		bool bResult = false;

		if(sensorData.sensorInterface != null)

		{

			bResult = sensorData.sensorInterface.UpdateSensorData(sensorData);

		}

		return bResult;

	}

	// returns the mirror joint of the given joint

	public static JointType GetMirrorJoint(JointType joint)

	{

		switch(joint)

		{

			case JointType.ShoulderLeft:

				return JointType.ShoulderRight;

	        case JointType.ElbowLeft:

				return JointType.ElbowRight;

	        case JointType.WristLeft:

				return JointType.WristRight;

	        case JointType.HandLeft:

				return JointType.HandRight;

	        case JointType.ShoulderRight:

				return JointType.ShoulderLeft;

	        case JointType.ElbowRight:

				return JointType.ElbowLeft;

	        case JointType.WristRight:

				return JointType.WristLeft;

	        case JointType.HandRight:

				return JointType.HandLeft;

	        case JointType.HipLeft:

				return JointType.HipRight;

	        case JointType.KneeLeft:

				return JointType.KneeRight;

	        case JointType.AnkleLeft:

				return JointType.AnkleRight;

	        case JointType.FootLeft:

				return JointType.FootRight;

	        case JointType.HipRight:

				return JointType.HipLeft;

	        case JointType.KneeRight:

				return JointType.KneeLeft;

	        case JointType.AnkleRight:

				return JointType.AnkleLeft;

	        case JointType.FootRight:

				return JointType.FootLeft;

	        case JointType.HandTipLeft:

				return JointType.HandTipRight;

	        case JointType.ThumbLeft:

				return JointType.ThumbRight;

	        case JointType.HandTipRight:

				return JointType.HandTipLeft;

	        case JointType.ThumbRight:

				return JointType.ThumbLeft;

		}

		return joint;

	}

	// gets new multi source frame

	public static bool GetMultiSourceFrame(SensorData sensorData)

	{

		bool bResult = false;

		if(sensorData.sensorInterface != null)

		{

			bResult = sensorData.sensorInterface.GetMultiSourceFrame(sensorData);

		}

		return bResult;

	}

	// frees last multi source frame

	public static void FreeMultiSourceFrame(SensorData sensorData)

	{

		if(sensorData.sensorInterface != null)

		{

			sensorData.sensorInterface.FreeMultiSourceFrame(sensorData);

		}

	}

	// gets matrix values as csv line

	public static string GetMatrixAsCsv(ref Matrix4x4 mat, char delimiter)

	{

		// create the output string

		StringBuilder sbBuf = new StringBuilder();

		//const char delimiter = ',';

		sbBuf.Append("km").Append(delimiter);

		for(int i = 0; i < 4; i++)

		{

			Vector4 vRow = mat.GetRow(i);

			sbBuf.AppendFormat("{0:F3}", vRow.x).Append(delimiter);

			sbBuf.AppendFormat("{0:F3}", vRow.y).Append(delimiter);

			sbBuf.AppendFormat("{0:F3}", vRow.z).Append(delimiter);

			sbBuf.AppendFormat("{0:F3}", vRow.w).Append(delimiter);

		}

		// remove the last delimiter

		if(sbBuf.Length > 0 && sbBuf[sbBuf.Length - 1] == delimiter)

		{

			sbBuf.Remove(sbBuf.Length - 1, 1);

		}

		return sbBuf.ToString();

	}

	// sets matrix values from a csv line

	public static bool SetMatrixFromCsv(string sCsvLine, ref Matrix4x4 mat)

	{

		if(sCsvLine.Length == 0)

			return false;

		// split the csv line in parts

		char[] delimiters = { ',' };

		string[] alCsvParts = sCsvLine.Split(delimiters);

		if(alCsvParts.Length < 17)

			return false;

		if(alCsvParts[0] != "km")

			return false;

		int iIndex = 1;

		for(int i = 0; i < 4; i++)

		{

			float x = 0f, y = 0f, z = 0f, w = 0f;

			float.TryParse(alCsvParts[iIndex], out x);

			float.TryParse(alCsvParts[iIndex + 1], out y);

			float.TryParse(alCsvParts[iIndex + 2], out z);

			float.TryParse(alCsvParts[iIndex + 3], out w);

			iIndex += 4;

			Vector4 vRow = new Vector4(x, y, z, w);

			mat.SetRow(i, vRow);

		}

		return true;

	}

	// converts current hand data to a single csv line. returns empty string if there is no new data

	public static string GetHandsDataAsCsv(SensorData sensorData, ref BodyFrameData bodyFrame, ref long liRelTime, char delimiter)

	{

		// check for invalid sensor data and if the frame is still the same

		if(sensorData == null)

			return string.Empty;

//		if(bodyFrame.liRelativeTime == liRelTime)

//			return string.Empty;

		// create the output string

		StringBuilder sbBuf = new StringBuilder();

		//const char delimiter = ',';

		sbBuf.Append("kh").Append(delimiter);

		sbBuf.Append(bodyFrame.liRelativeTime).Append(delimiter);

		sbBuf.Append(sensorData.bodyCount).Append(delimiter);

		// add information for all bodies

		for(int i = 0; i < sensorData.bodyCount; i++)

		{

			sbBuf.Append(bodyFrame.bodyData[i].bIsTracked).Append(delimiter);

			if(bodyFrame.bodyData[i].bIsTracked != 0)

			{

				// add information for the tracked body - body-id and hand states

				sbBuf.Append(bodyFrame.bodyData[i].liTrackingID).Append(delimiter);

				sbBuf.AppendFormat("{0}", (int)bodyFrame.bodyData[i].leftHandState).Append(delimiter);

				sbBuf.AppendFormat("{0}", (int)bodyFrame.bodyData[i].leftHandConfidence).Append(delimiter);

				sbBuf.AppendFormat("{0}", (int)bodyFrame.bodyData[i].rightHandState).Append(delimiter);

				sbBuf.AppendFormat("{0}", (int)bodyFrame.bodyData[i].rightHandConfidence).Append(delimiter);

			}

		}

		// remove the last delimiter

		if(sbBuf.Length > 0 && sbBuf[sbBuf.Length - 1] == delimiter)

		{

			sbBuf.Remove(sbBuf.Length - 1, 1);

		}

		return sbBuf.ToString();

	}

	// sets current hand data from the given csv line. returns true on success, false otherwise

	public static bool SetHandsDataFromCsv(string sCsvLine, SensorData sensorData, ref BodyFrameData bodyFrame)

	{

		// check for invalid sensor data and for same frame time

		if(sensorData == null)

			return false;

		if(sCsvLine.Length == 0)

			return false;

		// split the csv line in parts

		char[] delimiters = { ',' };

		string[] alCsvParts = sCsvLine.Split(delimiters);

		if(alCsvParts.Length < 3)

			return false;

		// check the id & body count

		int bodyCount = 0;

		int.TryParse(alCsvParts[2], out bodyCount);

		long liRelTime = 0;

		long.TryParse(alCsvParts[1], out liRelTime);

		if(alCsvParts[0] != "kh" || bodyCount == 0 || liRelTime == 0)

			return false;

		// check rel time

		if(bodyFrame.liRelativeTime > liRelTime)

			return false;

		int iIndex = 3;

		for(int i = 0; i < bodyCount; i++)

		{

			if(alCsvParts.Length < (iIndex + 1))

				return false;

			// update the tracked-flag and body id

			short bIsTracked = 0;

			long liTrackingID = 0;

			short.TryParse(alCsvParts[iIndex], out bIsTracked);

			iIndex++;

			if(bIsTracked != 0 && alCsvParts.Length >= (iIndex + 5))

			{

				long.TryParse(alCsvParts[iIndex], out liTrackingID);

				iIndex++;

				int lhState = 0, lhConf = 0, rhState = 0, rhConf = 0;

				int.TryParse(alCsvParts[iIndex++], out lhState);

				int.TryParse(alCsvParts[iIndex++], out lhConf);

				int.TryParse(alCsvParts[iIndex++], out rhState);

				int.TryParse(alCsvParts[iIndex++], out rhConf);

				if(i < sensorData.bodyCount && bodyFrame.bodyData[i].bIsTracked != 0 && 

					bodyFrame.bodyData[i].liTrackingID == liTrackingID)

				{

					bodyFrame.bodyData[i].leftHandState = (HandState)lhState;

					bodyFrame.bodyData[i].leftHandConfidence = (TrackingConfidence)lhConf;

					bodyFrame.bodyData[i].rightHandState = (HandState)rhState;

					bodyFrame.bodyData[i].rightHandConfidence = (TrackingConfidence)rhConf;

				}

			}

		}

		return true;

	}

	// converts current body frame to a single csv line. returns empty string if there is no new data

	public static string GetBodyFrameAsCsv(SensorData sensorData, ref BodyFrameData bodyFrame, ref long liRelTime, ref float fUnityTime, char delimiter)

	{

		// check for invalid sensor data and if the frame is still the same

		if(sensorData == null)

			return string.Empty;

		if(bodyFrame.liRelativeTime == liRelTime)

			return string.Empty;

		// create the output string

		StringBuilder sbBuf = new StringBuilder();

		//const char delimiter = ',';

		sbBuf.Append("kb").Append(delimiter);

		sbBuf.Append(bodyFrame.liRelativeTime).Append(delimiter);

		liRelTime = bodyFrame.liRelativeTime;

		fUnityTime = Time.time;

		sbBuf.Append(sensorData.bodyCount).Append(delimiter);

		sbBuf.Append(sensorData.jointCount).Append(delimiter);

		// add information for all bodies

		for(int i = 0; i < sensorData.bodyCount; i++)

		{

			sbBuf.Append(bodyFrame.bodyData[i].bIsTracked).Append(delimiter);

			if(bodyFrame.bodyData[i].bIsTracked != 0)

			{

				// add information for the tracked body - body-id and joints

				sbBuf.Append(bodyFrame.bodyData[i].liTrackingID).Append(delimiter);

				for(int j = 0; j < sensorData.jointCount; j++)

				{

					KinectInterop.JointData jointData = bodyFrame.bodyData[i].joint[j];

					sbBuf.Append((int)jointData.trackingState).Append(delimiter);

					if(jointData.trackingState != TrackingState.NotTracked)

					{

						sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.x).Append(delimiter);

						sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.y).Append(delimiter);

						sbBuf.AppendFormat("{0:F3}", jointData.kinectPos.z).Append(delimiter);

					}

				}

			}

		}

		// remove the last delimiter

		if(sbBuf.Length > 0 && sbBuf[sbBuf.Length - 1] == delimiter)

		{

			sbBuf.Remove(sbBuf.Length - 1, 1);

		}

		return sbBuf.ToString();

	}

	// sets current body frame from the given csv line. returns true on success, false otherwise

	public static bool SetBodyFrameFromCsv(string sCsvLine, SensorData sensorData, ref BodyFrameData bodyFrame, ref Matrix4x4 kinectToWorld)

	{

		// check for invalid sensor data and for same frame time

		if(sensorData == null)

			return false;

		if(sCsvLine.Length == 0)

			return false;

		// split the csv line in parts

		char[] delimiters = { ',' };

		string[] alCsvParts = sCsvLine.Split(delimiters);

		if(alCsvParts.Length < 4)

			return false;

		//// wait for buffer release

		//while(sensorData.bodyFrameReady)

		//{

		//	Sleep(1);

		//}

		// check the id, body count & joint count

		int bodyCount = 0, jointCount = 0;

		int.TryParse(alCsvParts[2], out bodyCount);

		int.TryParse(alCsvParts[3], out jointCount);

		long liRelTime = 0;

		long.TryParse(alCsvParts[1], out liRelTime);

		if(alCsvParts[0] != "kb" || bodyCount == 0 || jointCount == 0 || liRelTime == 0)

			return false;

		//		if(bodyCount != sensorData.bodyCount || jointCount != sensorData.jointCount)

		//			return false;

		if (bodyCount != sensorData.bodyCount) 

		{

			// set the other bodies as not tracked

			for (int i = bodyCount; i < sensorData.bodyCount; i++) 

			{

				bodyFrame.bodyData[i].bIsTracked = 0;

			}

		}

		// update body frame data

		bodyFrame.liPreviousTime = bodyFrame.liRelativeTime;

		bodyFrame.liRelativeTime = liRelTime;

		int iIndex = 4;

		for(int i = 0; i < bodyCount; i++)

		{

			if(alCsvParts.Length < (iIndex + 1))

				return false;

			// update the tracked-flag and body id

			short bIsTracked = 0;

			long liTrackingID = 0;

			short.TryParse(alCsvParts[iIndex], out bIsTracked);

			iIndex++;

			if(bIsTracked != 0 && alCsvParts.Length >= (iIndex + 1))

			{

				long.TryParse(alCsvParts[iIndex], out liTrackingID);

				iIndex++;

				if(liTrackingID == 0)

				{

					bIsTracked = 0;

				}

			}

			bodyFrame.bodyData[i].bIsTracked = bIsTracked;

			bodyFrame.bodyData[i].liTrackingID = liTrackingID;

			if(bIsTracked != 0)

			{

				if (jointCount != sensorData.jointCount) 

				{

					// set the other joints as not tracked

					for (int j = jointCount; j < sensorData.jointCount; j++) 

					{

						bodyFrame.bodyData [i].joint [j].trackingState = TrackingState.NotTracked;

					}

				}

				// update joints' data

				for(int j = 0; j < jointCount; j++)

				{

					KinectInterop.JointData jointData = bodyFrame.bodyData[i].joint[j];

					int iTrackingState = 0;

					if(alCsvParts.Length >= (iIndex + 1))

					{

						int.TryParse(alCsvParts[iIndex], out iTrackingState);

						iIndex++;

						jointData.trackingState = (KinectInterop.TrackingState)iTrackingState;

						if(iTrackingState != (int)TrackingState.NotTracked && alCsvParts.Length >= (iIndex + 3))

						{

							float x = 0f, y = 0f, z = 0f;

							float.TryParse(alCsvParts[iIndex], out x);

							float.TryParse(alCsvParts[iIndex + 1], out y);

							float.TryParse(alCsvParts[iIndex + 2], out z);

							iIndex += 3;

							jointData.kinectPos = new Vector3(x, y, z);

						}

						else

						{

							jointData.kinectPos = Vector3.zero;

						}

						jointData.position = kinectToWorld.MultiplyPoint3x4(jointData.kinectPos);

						jointData.orientation = Quaternion.identity;

						if(j == 0)

						{

							// set body position

							bodyFrame.bodyData[i].position = jointData.position;

							bodyFrame.bodyData[i].orientation = jointData.orientation;

						}

					}

					bodyFrame.bodyData[i].joint[j] = jointData;

				}

			}

		}

		// calculate bone directions

		CalcBodyFrameBoneDirs(sensorData, ref bodyFrame);

		// frame is ready

		lock(sensorData.bodyFrameLock)

		{

			sensorData.bodyFrameReady = true;

		}

		return true;

	}

	// Polls for new skeleton data

	public static bool PollBodyFrame(SensorData sensorData, ref BodyFrameData bodyFrame, ref Matrix4x4 kinectToWorld, bool bIgnoreJointZ)

	{

		bool bNewFrame = false;

		if(sensorData.sensorInterface != null)

		{

			//// wait for buffer release

			//while(sensorData.bodyFrameReady)

			//{

			//	Sleep(1);

			//}

			bNewFrame = sensorData.sensorInterface.PollBodyFrame(sensorData, ref bodyFrame, ref kinectToWorld, bIgnoreJointZ);

			if(bNewFrame)

			{

				if(bodyFrame.bTurnAnalisys && bodyFrame.liPreviousTime > 0)

				{

					CalcBodyFrameJointVels(sensorData, ref bodyFrame);

				}

				CalcBodyFrameBoneDirs(sensorData, ref bodyFrame);

				// frame is ready

				lock(sensorData.bodyFrameLock)

				{

					sensorData.bodyFrameReady = true;

				}

			}

		}

		return bNewFrame;

	}

	// calculates joint velocities in a body frame

	private static void CalcBodyFrameJointVels(SensorData sensorData, ref BodyFrameData bodyFrame)

	{

		// calculate the inter-frame time

		float frameTime = (float)(bodyFrame.liRelativeTime - bodyFrame.liPreviousTime) / 100000000000f;

		for(int i = 0; i < sensorData.bodyCount; i++)

		{

			if(bodyFrame.bodyData[i].bIsTracked != 0)

			{

				for(int j = 0; j < sensorData.jointCount; j++)

				{

					KinectInterop.JointData jointData = bodyFrame.bodyData[i].joint[j];

					int p = (int)sensorData.sensorInterface.GetParentJoint((KinectInterop.JointType)j);

					Vector3 parentPos = bodyFrame.bodyData[i].joint[p].position;

					jointData.posRel = jointData.position - parentPos;

					jointData.posVel = frameTime > 0f ? (jointData.position - jointData.posPrev) / frameTime : Vector3.zero;

					jointData.posPrev = jointData.position;

					bodyFrame.bodyData[i].joint[j] = jointData;

				}

			}

		}

	}

	// Calculates all valid bone directions in a body frame

	private static void CalcBodyFrameBoneDirs(SensorData sensorData, ref BodyFrameData bodyFrame)

	{

		for(int i = 0; i < sensorData.bodyCount; i++)

		{

			if(bodyFrame.bodyData[i].bIsTracked != 0)

			{

				for(int j = 0; j < sensorData.jointCount; j++)

				{

					if(j == 0)

					{

						bodyFrame.bodyData[i].joint[j].direction = Vector3.zero;

					}

					else

					{

						int jParent = (int)sensorData.sensorInterface.GetParentJoint((KinectInterop.JointType)j);

						if(bodyFrame.bodyData[i].joint[j].trackingState != TrackingState.NotTracked && 

						   bodyFrame.bodyData[i].joint[jParent].trackingState != TrackingState.NotTracked)

						{

							bodyFrame.bodyData[i].joint[j].direction = 

								bodyFrame.bodyData[i].joint[j].position - bodyFrame.bodyData[i].joint[jParent].position;

						}

					}

				}

			}

		}

	}

	// Recalculates bone directions for the given body

	public static void RecalcBoneDirs(SensorData sensorData, ref BodyData bodyData)

	{

		for(int j = 0; j < bodyData.joint.Length; j++)

		{

			if(j == 0)

			{

				bodyData.joint[j].direction = Vector3.zero;

			}

			else

			{

				int jParent = (int)sensorData.sensorInterface.GetParentJoint((KinectInterop.JointType)j);

				if(bodyData.joint[j].trackingState != TrackingState.NotTracked && 

				   bodyData.joint[jParent].trackingState != TrackingState.NotTracked)

				{

					bodyData.joint[j].direction = bodyData.joint[j].position - bodyData.joint[jParent].position;

				}

			}

		}

	}

	// Polls for new color frame data

	public static bool PollColorFrame(SensorData sensorData)

	{

		bool bNewFrame = false;

		if(sensorData.sensorInterface != null && !sensorData.isPlayModeEnabled)

		{

			//// wait for buffer release

			//while(sensorData.colorImageBufferReady)

			//{

			//	Sleep(1);

			//}

			bNewFrame = sensorData.sensorInterface.PollColorFrame(sensorData);

			if(bNewFrame)

			{

				// buffer is ready

				lock(sensorData.colorImageBufferLock)

				{

					sensorData.colorImageBufferReady = true;

				}

			}

		}

		return bNewFrame;

	}

	// Renders color texture

	public static void RenderColorTexture(SensorData sensorData)

	{

		if(sensorData.colorImageBufferReady && sensorData.colorImageTexture)

		{

			sensorData.colorImageTexture.LoadRawTextureData(sensorData.colorImage);

			sensorData.colorImageTexture.Apply();

			// buffer is released

			lock(sensorData.colorImageBufferLock)

			{

				sensorData.colorImageBufferReady = false;

			}

		}

	}

	// Polls for new depth frame data

	public static bool PollDepthFrame(SensorData sensorData, KinectManager.UserMapType userMapType,

	                                  bool bLimitedUsers, ICollection<int> alTrackedIndexes)

	{

		bool bNewFrame = false;

		if(sensorData.sensorInterface != null && !sensorData.isPlayModeEnabled)

		{

			//// wait for buffer releases

			//while(sensorData.bodyIndexBufferReady || sensorData.depthImageBufferReady)

			//{

			//	Sleep(1);

			//}

			bNewFrame = sensorData.sensorInterface.PollDepthFrame(sensorData);

			if(bNewFrame)

			{

				if(userMapType != KinectManager.UserMapType.RawUserDepth && sensorData.bodyIndexBuffer != null)

				{

					byte btSelBI = sensorData.selectedBodyIndex;

					int iBodyIndexLength = sensorData.bodyIndexImage.Length;

					// convert the body indices to string

					string sTrackedIndices = string.Empty;

					if (bLimitedUsers) 

					{

						foreach(int bodyIndex in alTrackedIndexes)

						{

							sTrackedIndices += (char)(0x30 + bodyIndex);

						}

						//Debug.Log ("Tracked indices: " + sTrackedIndices);

					}

					// create body index texture

					if(sensorData.bodyIndexBufferData == null)

					{

						sensorData.bodyIndexBufferData = new float[iBodyIndexLength];

					}

					for (int i = 0; i < iBodyIndexLength; i++)

					{

						byte btBufBI = sensorData.bodyIndexImage[i];

						bool bUserTracked = btSelBI != 255 ? btSelBI == btBufBI : 

								//(bLimitedUsers ? alTrackedIndexes.Contains((int)btBufBI) : btBufBI != 255);

								(bLimitedUsers ? sTrackedIndices.IndexOf((char)(0x30 + btBufBI)) >= 0 : btBufBI != 255);

						if(bUserTracked)

						{

							sensorData.bodyIndexBufferData[i] = (float)btBufBI;

						}

						else

						{

							sensorData.bodyIndexBufferData[i] = 255f;

						}

					}

					// buffer is ready

					lock(sensorData.bodyIndexBufferLock)

					{

						sensorData.bodyIndexBufferReady = true;

					}

				}

				if(sensorData.depthImageBuffer != null && sensorData.depthHistBuffer != null &&

				   userMapType == KinectManager.UserMapType.UserTexture)

				{

					// create depth texture

					if(sensorData.depthImageBufferData == null)

					{

						sensorData.depthImageBufferData = new float[sensorData.depthImage.Length];

						sensorData.depthHistBufferData = new int[5001];

						sensorData.equalHistBufferData = new float[sensorData.depthHistBufferData.Length];

					}

					Array.Clear(sensorData.depthHistBufferData, 0, sensorData.depthHistBufferData.Length);

					Array.Clear(sensorData.equalHistBufferData, 0, sensorData.equalHistBufferData.Length);

					sensorData.depthHistTotalPoints = 0;

					for (int i = 0; i < sensorData.depthImage.Length; i++)

					{

						int depth = sensorData.depthImage[i] < 5000 ? (int)sensorData.depthImage[i] : 5000;

						sensorData.depthImageBufferData[i] = (float)depth;

						if(sensorData.bodyIndexImage[i] != 255)

						{

							sensorData.depthHistBufferData[depth]++;

							sensorData.depthHistTotalPoints++;

						}

					}

					sensorData.equalHistBufferData[0] = (float)sensorData.depthHistBufferData[0];

					for(int i = 1; i < sensorData.depthHistBufferData.Length; i++)

					{

						sensorData.equalHistBufferData[i] = sensorData.equalHistBufferData[i - 1] + (float)sensorData.depthHistBufferData[i];

					}

					// buffer is ready

					lock(sensorData.depthImageBufferLock)

					{

						sensorData.depthImageBufferReady = true;

					}

				}

				if(sensorData.color2DepthCoords != null)

				{

					//// wait for buffer release

					//while(sensorData.depthCoordsBufferReady)

					//{

					//	Sleep(1);

					//}

					if(!MapColorFrameToDepthCoords(sensorData, ref sensorData.color2DepthCoords))

					{

						sensorData.color2DepthCoords = null;

					}

					// buffer is ready

					lock(sensorData.depthCoordsBufferLock)

					{

						sensorData.depthCoordsBufferReady = (sensorData.color2DepthCoords != null);

					}

				}

				else if(sensorData.depth2ColorCoords != null && (userMapType == KinectManager.UserMapType.CutOutTexture || 

					    (sensorData.sensorInterface.IsBackgroundRemovalActive() && 

						 sensorData.sensorInterface.GetSensorPlatform() != KinectInterop.DepthSensorPlatform.KinectSDKv1)))

				{

					//// wait for buffer release

					//while(sensorData.depthCoordsBufferReady)

					//{

					//	Sleep(1);

					//}

					if(!MapDepthFrameToColorCoords(sensorData, ref sensorData.depth2ColorCoords))

					{

						sensorData.depth2ColorCoords = null;

					}

					// buffer is ready

					lock(sensorData.depthCoordsBufferLock)

					{

						sensorData.depthCoordsBufferReady = (sensorData.depth2ColorCoords != null);

					}

				}

				if(sensorData.depth2SpaceCoords != null)

				{

					//// wait for buffer release

					//while(sensorData.spaceCoordsBufferReady)