Beispiel #1
0
    void Awake()
    {
        int hr = 0;

        try
        {
            hr = KinectWrapper.NuiInitialize(KinectWrapper.NuiInitializeFlags.UsesSkeleton |
                                             KinectWrapper.NuiInitializeFlags.UsesDepthAndPlayerIndex |
                                             (ComputeColorMap ? KinectWrapper.NuiInitializeFlags.UsesColor : 0));
            if (hr != 0)
            {
                throw new Exception("NuiInitialize Failed");
            }

            hr = KinectWrapper.NuiSkeletonTrackingEnable(IntPtr.Zero,
                                                         8);              // 0, 12,8
            if (hr != 0)
            {
                throw new Exception("Cannot initialize Skeleton Data");
            }

            depthStreamHandle = IntPtr.Zero;
            if (ComputeUserMap)
            {
                hr = KinectWrapper.NuiImageStreamOpen
                         (KinectWrapper.NuiImageType.DepthAndPlayerIndex,

                         KinectWrapper.Constants.DepthImageResolution, 0, 2, IntPtr.Zero, ref
                         depthStreamHandle);
                if (hr != 0)
                {
                    throw new Exception("Cannot open depth stream");
                }
            }

            colorStreamHandle = IntPtr.Zero;
            if (ComputeColorMap)
            {
                hr = KinectWrapper.NuiImageStreamOpen
                         (KinectWrapper.NuiImageType.Color,

                         KinectWrapper.Constants.ColorImageResolution, 0, 2, IntPtr.Zero, ref
                         colorStreamHandle);
                if (hr != 0)
                {
                    throw new Exception("Cannot open color stream");
                }
            }

            // set kinect elevation angle
            KinectWrapper.NuiCameraElevationSetAngle(SensorAngle);

            // init skeleton structures
            skeletonFrame = new KinectWrapper.NuiSkeletonFrame()
            {
                SkeletonData = new KinectWrapper.NuiSkeletonData
                               [KinectWrapper.Constants.NuiSkeletonCount]
            };

            // values used to pass to smoothing function
            smoothParameters = new
                               KinectWrapper.NuiTransformSmoothParameters();

            switch (smoothing)
            {
            case Smoothing.Default:
                smoothParameters.fSmoothing          = 0.5f;
                smoothParameters.fCorrection         = 0.5f;
                smoothParameters.fPrediction         = 0.5f;
                smoothParameters.fJitterRadius       = 0.05f;
                smoothParameters.fMaxDeviationRadius = 0.04f;
                break;

            case Smoothing.Medium:
                smoothParameters.fSmoothing          = 0.5f;
                smoothParameters.fCorrection         = 0.1f;
                smoothParameters.fPrediction         = 0.5f;
                smoothParameters.fJitterRadius       = 0.1f;
                smoothParameters.fMaxDeviationRadius = 0.1f;
                break;

            case Smoothing.Aggressive:
                smoothParameters.fSmoothing          = 0.7f;
                smoothParameters.fCorrection         = 0.3f;
                smoothParameters.fPrediction         = 1.0f;
                smoothParameters.fJitterRadius       = 1.0f;
                smoothParameters.fMaxDeviationRadius = 1.0f;
                break;
            }

            // create arrays for joint positions and joint orientations
            int skeletonJointsCount = (int)
                                      KinectWrapper.NuiSkeletonPositionIndex.Count;

            playerJointsTracked = new bool[skeletonJointsCount];
            playerPrevTracked   = new bool[skeletonJointsCount];

            playerJointsPos = new Vector3[skeletonJointsCount];


            //create the transform matrix that converts from kinect-space to world-space
            Quaternion quatTiltAngle = new Quaternion();
            quatTiltAngle.eulerAngles = new Vector3(-SensorAngle, 0.0f, 0.0f);

            //float heightAboveHips = SensorHeight - 1.0f;

            // transform matrix - kinect to world
            //kinectToWorld.SetTRS(new Vector3(0.0f, heightAboveHips, 0.0f), quatTiltAngle, Vector3.one);
            kinectToWorld.SetTRS(new Vector3(0.0f, SensorHeight, 0.0f), quatTiltAngle, Vector3.one);
            flipMatrix       = Matrix4x4.identity;
            flipMatrix[2, 2] = -1;

            instance = this;
        }
        catch (DllNotFoundException e)
        {
            string message = "Please check the Kinect SDK installation.";
            Debug.LogError(message);
            Debug.LogError(e.ToString());
            return;
        }
        catch (Exception e)
        {
            string message = e.Message + " - " +
                             KinectWrapper.GetNuiErrorString(hr);
            Debug.LogError(message);
            Debug.LogError(e.ToString());
            return;
        }

        if (ComputeUserMap)
        {
            // Initialize depth & label map related stuff
            usersMapSize = KinectWrapper.GetDepthWidth() *
                           KinectWrapper.GetDepthHeight();
            usersLblTex = new Texture2D(KinectWrapper.GetDepthWidth(),
                                        KinectWrapper.GetDepthHeight());
            usersMapColors = new Color32[usersMapSize];
            usersPrevState = new ushort[usersMapSize];

            usersDepthMap     = new ushort[usersMapSize];
            usersHistogramMap = new float[8192];
        }

        if (ComputeColorMap)
        {
            // Initialize color map related stuff
            usersClrTex = new Texture2D(KinectWrapper.GetColorWidth(),
                                        KinectWrapper.GetColorHeight());

            colorImage = new Color32[KinectWrapper.GetColorWidth() *
                                     KinectWrapper.GetColorHeight()];
            usersColorMap = new byte[colorImage.Length << 2];
        }


        // Initialize user list to contain ALL users.
        allUsers = new List <uint>();

        KinectInitialized = true;
    }
Beispiel #2
0
    //----------------------------------- end of public functions --------------------------------------//

    void Start()
    {
        //CalibrationText = GameObject.Find("CalibrationText");
        int hr = 0;

        try
        {
            hr = KinectWrapper.NuiInitialize(KinectWrapper.NuiInitializeFlags.UsesSkeleton |
                                             KinectWrapper.NuiInitializeFlags.UsesDepthAndPlayerIndex |
                                             (ComputeColorMap ? KinectWrapper.NuiInitializeFlags.UsesColor : 0));
            if (hr != 0)
            {
                throw new Exception("NuiInitialize Failed");
            }

            hr = KinectWrapper.NuiSkeletonTrackingEnable(IntPtr.Zero, 8);              // 0, 12,8
            if (hr != 0)
            {
                throw new Exception("Cannot initialize Skeleton Data");
            }

            _depthStreamHandle = IntPtr.Zero;
            if (ComputeUserMap)
            {
                hr = KinectWrapper.NuiImageStreamOpen(KinectWrapper.NuiImageType.DepthAndPlayerIndex,
                                                      KinectWrapper.Constants.DepthImageResolution, 0, 2, IntPtr.Zero, ref _depthStreamHandle);
                if (hr != 0)
                {
                    throw new Exception("Cannot open depth stream");
                }
            }

            _colorStreamHandle = IntPtr.Zero;
            if (ComputeColorMap)
            {
                hr = KinectWrapper.NuiImageStreamOpen(KinectWrapper.NuiImageType.Color,
                                                      KinectWrapper.Constants.ColorImageResolution, 0, 2, IntPtr.Zero, ref _colorStreamHandle);
                if (hr != 0)
                {
                    throw new Exception("Cannot open color stream");
                }
            }

            // set kinect elevation angle
            KinectWrapper.NuiCameraElevationSetAngle(SensorAngle);

            // init skeleton structures
            _skeletonFrame = new KinectWrapper.NuiSkeletonFrame()
            {
                SkeletonData = new KinectWrapper.NuiSkeletonData[KinectWrapper.Constants.NuiSkeletonCount]
            };

            // values used to pass to smoothing function
            _smoothParameters = new KinectWrapper.NuiTransformSmoothParameters();

            switch (smoothing)
            {
            case Smoothing.Default:
                _smoothParameters.fSmoothing          = 0.5f;
                _smoothParameters.fCorrection         = 0.5f;
                _smoothParameters.fPrediction         = 0.5f;
                _smoothParameters.fJitterRadius       = 0.05f;
                _smoothParameters.fMaxDeviationRadius = 0.04f;
                break;

            case Smoothing.Medium:
                _smoothParameters.fSmoothing          = 0.5f;
                _smoothParameters.fCorrection         = 0.1f;
                _smoothParameters.fPrediction         = 0.5f;
                _smoothParameters.fJitterRadius       = 0.1f;
                _smoothParameters.fMaxDeviationRadius = 0.1f;
                break;

            case Smoothing.Aggressive:
                _smoothParameters.fSmoothing          = 0.7f;
                _smoothParameters.fCorrection         = 0.3f;
                _smoothParameters.fPrediction         = 1.0f;
                _smoothParameters.fJitterRadius       = 1.0f;
                _smoothParameters.fMaxDeviationRadius = 1.0f;
                break;
            }

            // create arrays for joint positions and joint orientations
            int skeletonJointsCount = (int)KinectWrapper.NuiSkeletonPositionIndex.Count;

            _player1JointsTracked = new bool[skeletonJointsCount];
            _player2JointsTracked = new bool[skeletonJointsCount];
            _player1PrevTracked   = new bool[skeletonJointsCount];
            _player2PrevTracked   = new bool[skeletonJointsCount];

            _player1JointsPos = new Vector3[skeletonJointsCount];
            _player2JointsPos = new Vector3[skeletonJointsCount];

            _player1JointsOri = new Matrix4x4[skeletonJointsCount];
            _player2JointsOri = new Matrix4x4[skeletonJointsCount];

            //create the transform matrix that converts from kinect-space to world-space
            Quaternion quatTiltAngle = new Quaternion();
            quatTiltAngle.eulerAngles = new Vector3(-SensorAngle, 0.0f, 0.0f);

            // transform matrix - kinect to world
            _kinectToWorld.SetTRS(new Vector3(0.0f, SensorHeight, 0.0f), quatTiltAngle, Vector3.one);
            _flipMatrix       = Matrix4x4.identity;
            _flipMatrix[2, 2] = -1;

            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        catch (DllNotFoundException e)
        {
            string message = "Please check the Kinect SDK installation.";
            Debug.LogError(message);
            Debug.LogError(e.ToString());

            return;
        }
        catch (Exception e)
        {
            string message = e.Message + " - " + KinectWrapper.GetNuiErrorString(hr);
            Debug.LogError(message);
            Debug.LogError(e.ToString());

            return;
        }

        // get the main camera rectangle
        Rect cameraRect = Camera.main.pixelRect;

        if (ComputeUserMap)
        {
            var displayMapsWidthPercent  = DisplayMapsWidthPercent / 100f;
            var displayMapsHeightPercent = displayMapsWidthPercent * KinectWrapper.GetDepthHeight() / KinectWrapper.GetDepthWidth();

            var displayWidth  = cameraRect.width * displayMapsWidthPercent;
            var displayHeight = cameraRect.width * displayMapsHeightPercent;

            // Initialize depth & label map related stuff
            _usersMapSize   = KinectWrapper.GetDepthWidth() * KinectWrapper.GetDepthHeight();
            _usersLblTex    = new Texture2D(KinectWrapper.GetDepthWidth(), KinectWrapper.GetDepthHeight());
            _usersMapColors = new Color32[_usersMapSize];
            _usersPrevState = new ushort[_usersMapSize];
            _usersMapRect   = new Rect(cameraRect.width - displayWidth, cameraRect.height, displayWidth, -displayHeight);

            _usersDepthMap     = new ushort[_usersMapSize];
            _usersHistogramMap = new float[8192];
        }

        if (ComputeColorMap)
        {
            var displayMapsWidthPercent  = DisplayMapsWidthPercent / 100f;
            var displayMapsHeightPercent = displayMapsWidthPercent * KinectWrapper.GetColorHeight() / KinectWrapper.GetColorWidth();

            var displayWidth  = cameraRect.width * displayMapsWidthPercent;
            var displayHeight = cameraRect.width * displayMapsHeightPercent;

            // Initialize color map related stuff
            _usersClrTex  = new Texture2D(KinectWrapper.GetColorWidth(), KinectWrapper.GetColorHeight());
            _usersClrRect = new Rect(cameraRect.width - displayWidth, cameraRect.height, displayWidth, -displayHeight);

            _colorImage    = new Color32[KinectWrapper.GetColorWidth() * KinectWrapper.GetColorHeight()];
            _usersColorMap = new byte[_colorImage.Length << 2];
        }


        // Initialize user list to contain ALL users.
        _allUsers = new List <uint>();

        Debug.Log("Waiting for users.");

        _kinectInitialized = true;
    }