Пример #1
0
    private void DrawDebugImg(KinectManager manager, int leftIdx, int rightIdx)
    {
        byte[] colorData = new byte[3 * manager.DepthData.Length];
        float  depthLimt = 1000 * manager.JointData[Kinect.JointType.SpineBase].Position.Z;

        for (int i = 0; i < manager.DepthData.Length; i++)
        {
            if (manager.DepthData[i] < depthLimt)
            {
                colorData[3 * i] = (byte)(255 * (manager.DepthData[i] / depthLimt));
            }
        }

        System.Action <int> colorRed = (idx) =>
        {
            colorData[3 * idx + 1] = 255;
        };
        colorRed(leftIdx);
        colorRed(rightIdx);

        //debugTexture.LoadRawTextureData(colorData);

        Kinect.DepthSpacePoint leftHand  = manager.Mapper.MapCameraPointToDepthSpace(manager.JointData[Kinect.JointType.HandLeft].Position);
        Kinect.DepthSpacePoint rightHand = manager.Mapper.MapCameraPointToDepthSpace(manager.JointData[Kinect.JointType.HandRight].Position);

        DrawLine(debugTexture, leftIdx % manager.DepthFrameDesc.Width, (int)leftIdx / manager.DepthFrameDesc.Width,
                 (int)leftHand.X, (int)leftHand.Y, Color.green);
        DrawLine(debugTexture, rightIdx % manager.DepthFrameDesc.Width, (int)rightIdx / manager.DepthFrameDesc.Width,
                 (int)rightHand.X, (int)rightHand.Y, Color.green);
        //debugTexture.Apply();
        //debugPlane.GetComponent<Renderer>().material.mainTexture = debugTexture;
    }
Пример #2
0
    private float getDistanceWithDepthSpacePoint(Kinect.DepthSpacePoint p, Kinect.DepthSpacePoint q, ushort[] depthData)
    {
        Kinect.CameraSpacePoint P = _Mapper.MapDepthPointToCameraSpace(p, depthData[Pos2Idx((int)p.X, (int)p.Y)]);
        Kinect.CameraSpacePoint Q = _Mapper.MapDepthPointToCameraSpace(q, depthData[Pos2Idx((int)q.X, (int)q.Y)]);

        return(Mathf.Sqrt((P.X - Q.X) * (P.X - Q.X) + (P.Y - Q.Y) * (P.Y - Q.Y) + (P.Z - Q.Z) * (P.Z - Q.Z)));
    }
Пример #3
0
    /// <summary>
    /// Maps the depth point to color coords.
    /// </summary>
    /// <returns>The depth point to color coords.</returns>
    /// <param name="depthPos">Depth position.</param>
    /// <param name="depthVal">Depth value.</param>
    public Vector2 MapDepthPointToColorCoords(Vector2 depthPos, ushort depthVal)
    {
        Vector2 vPoint = Vector2.zero;
        Kinect.CoordinateMapper coordMapper = m_MultiSourceManager.GetCoordinateMapper();

        if (coordMapper != null && depthPos != Vector2.zero)
        {
            Kinect.DepthSpacePoint depthPoint = new Kinect.DepthSpacePoint();
            depthPoint.X = depthPos.x;
            depthPoint.Y = depthPos.y;

            Kinect.DepthSpacePoint[] depthPoints = new Kinect.DepthSpacePoint[1];
            depthPoints [0] = depthPoint;

            ushort[] depthVals = new ushort[1];
            depthVals [0] = depthVal;

            Kinect.ColorSpacePoint[] colPoints = new Kinect.ColorSpacePoint[1];
            coordMapper.MapDepthPointsToColorSpace(depthPoints, depthVals, colPoints);

            Kinect.ColorSpacePoint colPoint = colPoints [0];
            vPoint.x = colPoint.X;
            vPoint.y = colPoint.Y;
        }

        return vPoint;
    }
Пример #4
0
    int getStickEnd(ushort[] depthData, Kinect.CameraSpacePoint handCameraPoint, Kinect.DepthSpacePoint handDepthPoint)
    {
        //depthData = (ushort[])depthData.Clone();
        //cutDepthData(depthData, (int)handDepthPoint.Y + 100, (int)(handCameraPoint.Z * 1000));

        return(DFS(depthData, (int)handDepthPoint.X, (int)handDepthPoint.Y));
    }
    void drawLineBetweenJoints(ref Color[] mapPixels, Windows.Kinect.Body body, Windows.Kinect.JointType jointA, Windows.Kinect.JointType jointB)
    {
        depthSpacePoint_1 = _Sensor.CoordinateMapper.MapCameraPointToDepthSpace(body.Joints[jointA].Position);
        depthSpacePoint_2 = _Sensor.CoordinateMapper.MapCameraPointToDepthSpace(body.Joints[jointB].Position);

        DrawLine.DrawSimpleLine(ref mapPixels,
                                (int)depthSpacePoint_1.X / _DownsampleSize, (int)depthSpacePoint_1.Y / _DownsampleSize,
                                (int)depthSpacePoint_2.X / _DownsampleSize, (int)depthSpacePoint_2.Y / _DownsampleSize,
                                imageWidth / _DownsampleSize, imageHeight / _DownsampleSize,
                                Color.white);
    }
Пример #6
0
        // Token: 0x060029C7 RID: 10695 RVA: 0x000D4E9C File Offset: 0x000D329C
        public DepthSpacePoint MapCameraPointToDepthSpace(CameraSpacePoint cameraPoint)
        {
            if (this._pNative == IntPtr.Zero)
            {
                throw new ObjectDisposedException("CoordinateMapper");
            }
            IntPtr intPtr = CoordinateMapper.Windows_Kinect_CoordinateMapper_MapCameraPointToDepthSpace(this._pNative, cameraPoint);

            ExceptionHelper.CheckLastError();
            DepthSpacePoint result = (DepthSpacePoint)Marshal.PtrToStructure(intPtr, typeof(DepthSpacePoint));

            Marshal.FreeHGlobal(intPtr);
            return(result);
        }
Пример #7
0
        // Token: 0x060029CD RID: 10701 RVA: 0x000D4FB4 File Offset: 0x000D33B4
        public ColorSpacePoint MapDepthPointToColorSpace(DepthSpacePoint depthPoint, ushort depth)
        {
            if (this._pNative == IntPtr.Zero)
            {
                throw new ObjectDisposedException("CoordinateMapper");
            }
            IntPtr intPtr = CoordinateMapper.Windows_Kinect_CoordinateMapper_MapDepthPointToColorSpace(this._pNative, depthPoint, depth);

            ExceptionHelper.CheckLastError();
            ColorSpacePoint result = (ColorSpacePoint)Marshal.PtrToStructure(intPtr, typeof(ColorSpacePoint));

            Marshal.FreeHGlobal(intPtr);
            return(result);
        }
        public ColorSpacePoint MapDepthPointToColorSpace(DepthSpacePoint depthPoint,
                                                         ushort depth)
        {
            if (_pNative == RootSystem.IntPtr.Zero)
            {
                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
            }

            var objectPointer = Windows_Kinect_CoordinateMapper_MapDepthPointToColorSpace(_pNative, depthPoint, depth);

            ExceptionHelper.CheckLastError();
            var obj = (ColorSpacePoint)Marshal.PtrToStructure(
                objectPointer, typeof(ColorSpacePoint));

            Marshal.FreeHGlobal(objectPointer);
            return(obj);
        }
Пример #9
0
    bool[] getStickIndex(ushort[] depthData)
    {
        bool[] stickIndex = new bool[depthData.Length];
        for (int i = 0; i < depthData.Length; i++)
        {
            stickIndex[i] = false;
        }

        Kinect.CameraSpacePoint leftHandCameraPoint  = joints[Kinect.JointType.HandLeft].Position;
        Kinect.DepthSpacePoint  leftHandDepthPoint   = mapper.MapCameraPointToDepthSpace(leftHandCameraPoint);
        Kinect.CameraSpacePoint rightHandCameraPoint = joints[Kinect.JointType.HandRight].Position;
        Kinect.DepthSpacePoint  rightHandDepthPoint  = mapper.MapCameraPointToDepthSpace(rightHandCameraPoint);

        depthData = (ushort[])depthData.Clone();
        cutDepthData(depthData, (int)Mathf.Min(leftHandDepthPoint.Y, rightHandDepthPoint.Y) + 300, (int)(Mathf.Max(leftHandCameraPoint.Z, rightHandCameraPoint.Z) * 1000));

        //  left hand
        int  leftStickEndInd = getStickEnd(depthData, leftHandCameraPoint, leftHandDepthPoint);
        bool useCache        = leftStickEndInd == 0;

        if (useCache)
        {
            return(null);
        }
        int rightStickEndInd = getStickEnd(depthData, rightHandCameraPoint, rightHandDepthPoint);

        useCache |= rightStickEndInd == 0;
        if (useCache)
        {
            return(null);
        }

        depthDataCache = (ushort[])depthData.Clone();

        addStickIndex(stickIndex, depthData, leftHandDepthPoint, leftStickEndInd);

        //  right hand
        addStickIndex(stickIndex, depthData, rightHandDepthPoint, rightStickEndInd);

        stickIndexCache = (bool[])stickIndex.Clone();


        return(stickIndex);
    }
Пример #10
0
    void ZigTrackedUserCenter(KinectOneLabelMap labelmap)
    {
        if (m_engageuser == null || m_engageuser.engagedTrackedUser == null)
        {
            trackedUserIndex = 255;
            return;
        }
        ZigTrackedUser _engagedUser = m_engageuser.engagedTrackedUser;

        Kinect.CameraSpacePoint positionPoint = new Kinect.CameraSpacePoint();
        positionPoint.X = _engagedUser.Position.x;
        positionPoint.Y = _engagedUser.Position.y;
        positionPoint.Z = _engagedUser.Position.z;
        Kinect.DepthSpacePoint depthSpacePoint = _mapper.MapCameraPointToDepthSpace(positionPoint);
        short[] labelData = labelmap.data;
        int     index     = (int)(depthSpacePoint.Y * depthInfo.xres + depthSpacePoint.X);

        trackedUserIndex = (index >= 0 && index < labelData.Length) ? labelData[index] : (short)255;
    }
Пример #11
0
    void addStickIndex(bool[] stickIndex, ushort[] depthData, Kinect.DepthSpacePoint hand, int stickEndInd)
    {
        int handX     = (int)hand.X;
        int handY     = (int)hand.Y;
        int stickEndX = stickEndInd % depthFrameInfo.Width;
        int stickEndY = stickEndInd / depthFrameInfo.Width;

        float slope     = (float)(handY - stickEndY) / (float)(handX - stickEndX);
        int   direction = stickEndX > handX ? 1 : -1;

        for (int x = handX; x != stickEndX; x += direction)
        {
            int y = (int)(handY + (x - handX) * slope);
            if (pos2ind(x, y) < depthData.Length)
            {
                stickIndex[pos2ind(x, y)] = true;
            }
        }
    }
Пример #12
0
 public bool Equals(DepthSpacePoint obj)
 {
     return X.Equals(obj.X) && Y.Equals(obj.Y);
 }
    // 3次元座標の取得
    void calcColorPointToWorld(ushort[] depthData, int colorWidth, int colorHeight, int[] srcPointx, int[] srcPointy, int[] proPointx, int[] proPointy, int srcLen, 
                        ref List<double> dstPoint2dx, ref List<double> dstPoint2dy, ref List<double> dstPoint3dx, ref List<double> dstPoint3dy, ref List<double> dstPoint3dz, ref int dstLen)
    {
        var frameDesc = KinectSensor.GetDefault().DepthFrameSource.FrameDescription;

        // depthをcolorに合わせる
        DepthSpacePoint[] depthSpace = new DepthSpacePoint[colorWidth * colorHeight];
        mapper.MapColorFrameToDepthSpace(depthData, depthSpace);

        // depthをcameraに合わせる
        CameraSpacePoint[] cameraSpace = new CameraSpacePoint[depthData.Length];
        mapper.MapDepthFrameToCameraSpace(depthData, cameraSpace);

        dstPoint2dx.Clear();
        dstPoint2dy.Clear();
        dstPoint3dx.Clear();
        dstPoint3dy.Clear();
        dstPoint3dz.Clear();

        dstLen = 0;

        for (int i = 0; i < srcLen; ++i)
        {
            int src_index = srcPointy[i] * multiSourceManagerScript.ColorWidth + srcPointx[i];
            int dst_x = (int)(depthSpace[src_index].X);
            int dst_y = (int)(depthSpace[src_index].Y);
            int dst_index = dst_y * frameDesc.Width + dst_x;

            if( ((0<=dst_x) && (dst_x < frameDesc.Width)) && ((0<=dst_y) && (dst_y<frameDesc.Height)) )
            {
                if( (0.5f<=cameraSpace[dst_index].Z) && (cameraSpace[dst_index].Z<=8.0f) )
                {
                    dstPoint2dx.Add((double)(proPointx[i]));
                    dstPoint2dy.Add((double)(proPointy[i]));
                    dstPoint3dx.Add(-cameraSpace[dst_index].X);
                    dstPoint3dy.Add(cameraSpace[dst_index].Y);
                    dstPoint3dz.Add(cameraSpace[dst_index].Z);

                    dstLen++;
                }
            }
        }
    }
Пример #14
0
    public void FindTip(KinectManager manager,
                        out Kinect.CameraSpacePoint leftTipCameraPoint, out Kinect.CameraSpacePoint rightTipCameraPoint,
                        out bool leftStatus, out bool rightStatus)
    {
        Kinect.CameraSpacePoint leftHandCameraPoint  = manager.JointData[Kinect.JointType.HandLeft].Position;
        Kinect.DepthSpacePoint  leftHandDepthPoint   = manager.Mapper.MapCameraPointToDepthSpace(leftHandCameraPoint);
        Kinect.CameraSpacePoint rightHandCameraPoint = manager.JointData[Kinect.JointType.HandRight].Position;
        Kinect.DepthSpacePoint  rightHandDepthPoint  = manager.Mapper.MapCameraPointToDepthSpace(rightHandCameraPoint);
        byte[] colorData = new byte[3 * manager.DepthData.Length];

        ushort[] tempDepthData = new ushort[manager.DepthData.Length];
        tempDepthData = (ushort[])manager.DepthData.Clone();


        for (int i = 0; i < tempDepthData.Length; i++)
        {
            if (tempDepthData[i] > (tempDepthData[Pos2Idx((int)leftHandDepthPoint.X, (int)leftHandDepthPoint.Y)] + 30))
            {
                tempDepthData[i] = 0;
            }
        }

        int leftStickEndIdx = GetStickEnd(tempDepthData, leftHandCameraPoint, leftHandDepthPoint, ref colorData);

        if (leftStickEndIdx == 0)
        {
            leftTipCameraPoint = _LeftTipCache;
            if (_LeftCacheElapsedFrame >= 10)
            {
                leftStatus = false;
            }
            else
            {
                leftStatus = true;
                _LeftCacheElapsedFrame++;
            }
        }
        else
        {
            Kinect.DepthSpacePoint leftTipDepthPoint = new Kinect.DepthSpacePoint();
            leftTipDepthPoint.X = leftStickEndIdx % _Width;
            leftTipDepthPoint.Y = leftStickEndIdx / _Width;
            leftTipCameraPoint  = manager.Mapper.MapDepthPointToCameraSpace(leftTipDepthPoint, manager.DepthData[leftStickEndIdx]);

            _LeftTipCache          = leftTipCameraPoint;
            _LeftCacheElapsedFrame = 0;

            leftStatus = true;
        }

        tempDepthData = (ushort[])manager.DepthData.Clone();

        for (int i = 0; i < tempDepthData.Length; i++)
        {
            if (tempDepthData[i] > (tempDepthData[Pos2Idx((int)rightHandDepthPoint.X, (int)rightHandDepthPoint.Y)] + 30))
            {
                tempDepthData[i] = 0;
            }
        }

        //int rightStickEndIdx = GetStickEnd(manager.DepthData, rightHandCameraPoint, rightHandDepthPoint);
        int rightStickEndIdx = GetStickEnd(tempDepthData, rightHandCameraPoint, rightHandDepthPoint, ref colorData);

        if (rightStickEndIdx == 0)
        {
            rightTipCameraPoint = _RightTipCache;
            if (_RightCacheElapsedFrame >= 10)
            {
                rightStatus = false;
            }
            else
            {
                rightStatus = true;
                _RightCacheElapsedFrame++;
            }
        }
        else
        {
            Kinect.DepthSpacePoint rightTipDepthPoint = new Kinect.DepthSpacePoint();
            rightTipDepthPoint.X = rightStickEndIdx % _Width;
            rightTipDepthPoint.Y = rightStickEndIdx / _Width;
            rightTipCameraPoint  = manager.Mapper.MapDepthPointToCameraSpace(rightTipDepthPoint, manager.DepthData[rightStickEndIdx]);


            _RightTipCache          = rightTipCameraPoint;
            _RightCacheElapsedFrame = 0;

            rightStatus = true;
        }


        ushort[] depthData = manager.DepthData;
        //DrawDebugImg(manager, leftStickEndIdx, rightStickEndIdx);
    }
    // 1点の3次元座標の取得
    void calcColorPointToWorld(ushort[] depthData, int colorWidth, int colorHeight, List<int> srcPoint, ref List<double> dstPoint)
    {
        var frameDesc = KinectSensor.GetDefault().DepthFrameSource.FrameDescription;

        // depthをcolorに合わせる
        DepthSpacePoint[] depthSpace = new DepthSpacePoint[colorWidth * colorHeight];
        mapper.MapColorFrameToDepthSpace(depthData, depthSpace);

        // depthをcameraに合わせる
        CameraSpacePoint[] cameraSpace = new CameraSpacePoint[depthData.Length];
        mapper.MapDepthFrameToCameraSpace(depthData, cameraSpace);

        dstPoint.Clear();

        int src_index = srcPoint[1] * multiSourceManagerScript.ColorWidth + srcPoint[0];
        int dst_x = (int)(depthSpace[src_index].X);
        int dst_y = (int)(depthSpace[src_index].Y);
        int dst_index = dst_y * frameDesc.Width + dst_x;

        if (((0 <= dst_x) && (dst_x < frameDesc.Width)) && ((0 <= dst_y) && (dst_y < frameDesc.Height)))
        {
            if ((0.5f <= cameraSpace[dst_index].Z) && (cameraSpace[dst_index].Z <= 8.0f))
            {
                dstPoint.Add(-cameraSpace[dst_index].X);
                dstPoint.Add(cameraSpace[dst_index].Y);
                dstPoint.Add(cameraSpace[dst_index].Z);
            }
        }
    }
Пример #16
0
    private void DFS_helper(ref DFS_Datas datas, int start)
    {
        datas.visited.Add(start);

        ushort curDep = datas.depthData[start];

        if (curDep == 0)
        {
            return;
        }

        int x = start % _Width;
        int y = start / _Width;

        Kinect.DepthSpacePoint curDSP = new Kinect.DepthSpacePoint();
        curDSP.X = x;
        curDSP.Y = y;
        Kinect.DepthSpacePoint handDSP = new Kinect.DepthSpacePoint();
        handDSP.X = datas.handIndX;
        handDSP.Y = datas.handIndY;
        float len = getDistanceWithDepthSpacePoint(curDSP, handDSP, datas.depthData);

        if (len > 0.15)
        {
            float    slope        = (float)(datas.handIndY - y) / (x - datas.handIndX);
            float    angle        = Mathf.Atan(slope);
            float    distance     = 30;
            int      dx           = (int)(distance * Mathf.Cos(angle));
            int      dy           = (int)(distance * Mathf.Sin(angle));
            int      outThreshold = 400;
            ushort[] depthData    = datas.depthData;
            System.Func <int, int, bool> isBadNeighbor = (X, Y) =>
            {
                return(validateDepthPosition(X, Y) && Mathf.Abs(depthData[Pos2Idx(X, Y)] - curDep) <= outThreshold);
            };
            if (isBadNeighbor(x + dx, y + dy) || isBadNeighbor(x - dx, y - dy))
            {
                return;
            }
        }

        if (len > datas.max)
        {
            datas.max  = len;
            datas.maxX = x;
            datas.maxY = y;
        }

        int walk = 1;

        //int inThreshold = len < 800 ? 1500 : 300;
        //System.Func<int, int, bool> depthCondition = (X, Y) => { return Mathf.Abs(depthData[Pos2Idx(X, Y)] - curDep) < inThreshold; };
        System.Func <int, int, bool> depthCondition = (X, Y) => { return(true); };

        int newX = x + walk, newY = y;

        if (validateDepthPosition(newX, newY) && depthCondition(newX, newY) && !datas.visited.Contains(Pos2Idx(newX, newY)))
        {
            DFS_helper(ref datas, Pos2Idx(newX, newY));
        }

        newX = x - walk;
        if (validateDepthPosition(newX, newY) && depthCondition(newX, newY) && !datas.visited.Contains(Pos2Idx(newX, newY)))
        {
            DFS_helper(ref datas, Pos2Idx(newX, newY));
        }

        newX = x;
        newY = y + walk;
        if (validateDepthPosition(newX, newY) && depthCondition(newX, newY) && !datas.visited.Contains(Pos2Idx(newX, newY)))
        {
            DFS_helper(ref datas, Pos2Idx(newX, newY));
        }

        newY = y - walk;
        if (validateDepthPosition(newX, newY) && depthCondition(newX, newY) && !datas.visited.Contains(Pos2Idx(newX, newY)))
        {
            DFS_helper(ref datas, Pos2Idx(newX, newY));
        }
    }
Пример #17
0
 private int GetStickEnd(ushort[] depthData, Kinect.CameraSpacePoint handCameraPoint, Kinect.DepthSpacePoint handDepthPoint, ref byte[] colorData)
 {
     return(DFS(depthData, (int)handDepthPoint.X, (int)handDepthPoint.Y, ref colorData));
 }
 private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_MapDepthPointToCameraSpace(
     RootSystem.IntPtr pNative, DepthSpacePoint depthPoint, ushort depth);
Пример #19
0
    /// <summary>
    /// Maps the space point to depth coords.
    /// </summary>
    /// <returns>The space point to depth coords.</returns>
    /// <param name="spacePos">Space position.</param>
    private Vector2 MapSpacePointToDepthCoords(Vector3 spacePos)
    {
        Vector2 vPoint = Vector2.zero;

        Kinect.CoordinateMapper coordMapper = m_MultiSourceManager.GetCoordinateMapper();

        if (coordMapper != null)
        {
            Kinect.CameraSpacePoint camPoint = new Kinect.CameraSpacePoint();
            camPoint.X = spacePos.x;
            camPoint.Y = spacePos.y;
            camPoint.Z = spacePos.z;

            Kinect.CameraSpacePoint[] camPoints = new Kinect.CameraSpacePoint[1];
            camPoints [0] = camPoint;

            Kinect.DepthSpacePoint[] depthPoints = new Kinect.DepthSpacePoint[1];
            coordMapper.MapCameraPointsToDepthSpace(camPoints, depthPoints);

            Kinect.DepthSpacePoint depthPoint = depthPoints [0];

            if (depthPoint.X >= 0 && depthPoint.X < cDepthImageWidth &&
                depthPoint.Y >= 0 && depthPoint.Y < cDepthImageHeight)
            {
                vPoint.x = depthPoint.X;
                vPoint.y = depthPoint.Y;
            }
        }

        return vPoint;
    }
    public Vector3 MapDepthPointToSpaceCoords(KinectInterop.SensorData sensorData, Vector2 depthPos, ushort depthVal)
    {
        Vector3 vPoint = Vector3.zero;

        if(coordMapper != null && depthPos != Vector2.zero)
        {
            DepthSpacePoint depthPoint = new DepthSpacePoint();
            depthPoint.X = depthPos.x;
            depthPoint.Y = depthPos.y;

            DepthSpacePoint[] depthPoints = new DepthSpacePoint[1];
            depthPoints[0] = depthPoint;

            ushort[] depthVals = new ushort[1];
            depthVals[0] = depthVal;

            CameraSpacePoint[] camPoints = new CameraSpacePoint[1];
            coordMapper.MapDepthPointsToCameraSpace(depthPoints, depthVals, camPoints);

            CameraSpacePoint camPoint = camPoints[0];
            vPoint.x = camPoint.X;
            vPoint.y = camPoint.Y;
            vPoint.z = camPoint.Z;
        }

        return vPoint;
    }
Пример #21
0
 public bool Equals(DepthSpacePoint obj)
 {
     return(X.Equals(obj.X) && Y.Equals(obj.Y));
 }
Пример #22
0
 // Token: 0x06002C82 RID: 11394 RVA: 0x000DDB3C File Offset: 0x000DBF3C
 public bool Equals(DepthSpacePoint obj)
 {
     return(this.X.Equals(obj.X) && this.Y.Equals(obj.Y));
 }
    public Vector2 MapDepthPointToColorCoords(KinectInterop.SensorData sensorData, Vector2 depthPos, ushort depthVal)
    {
        Vector2 vPoint = Vector2.zero;

        if(coordMapper != null && depthPos != Vector2.zero)
        {
            DepthSpacePoint depthPoint = new DepthSpacePoint();
            depthPoint.X = depthPos.x;
            depthPoint.Y = depthPos.y;

            DepthSpacePoint[] depthPoints = new DepthSpacePoint[1];
            depthPoints[0] = depthPoint;

            ushort[] depthVals = new ushort[1];
            depthVals[0] = depthVal;

            ColorSpacePoint[] colPoints = new ColorSpacePoint[1];
            coordMapper.MapDepthPointsToColorSpace(depthPoints, depthVals, colPoints);

            ColorSpacePoint colPoint = colPoints[0];
            vPoint.x = colPoint.X;
            vPoint.y = colPoint.Y;
        }

        return vPoint;
    }
Пример #24
0
 private static extern IntPtr Windows_Kinect_CoordinateMapper_MapDepthPointToColorSpace(IntPtr pNative, DepthSpacePoint depthPoint, ushort depth);
    public Vector2 MapSpacePointToDepthCoords(KinectInterop.SensorData sensorData, Vector3 spacePos)
    {
        Vector2 vPoint = Vector2.zero;

        if(coordMapper != null)
        {
            CameraSpacePoint camPoint = new CameraSpacePoint();
            camPoint.X = spacePos.x;
            camPoint.Y = spacePos.y;
            camPoint.Z = spacePos.z;

            CameraSpacePoint[] camPoints = new CameraSpacePoint[1];
            camPoints[0] = camPoint;

            DepthSpacePoint[] depthPoints = new DepthSpacePoint[1];
            coordMapper.MapCameraPointsToDepthSpace(camPoints, depthPoints);

            DepthSpacePoint depthPoint = depthPoints[0];

            if(depthPoint.X >= 0 && depthPoint.X < sensorData.depthImageWidth &&
               depthPoint.Y >= 0 && depthPoint.Y < sensorData.depthImageHeight)
            {
                vPoint.x = depthPoint.X;
                vPoint.y = depthPoint.Y;
            }
        }

        return vPoint;
    }
Пример #26
0
    //    // Polls for new color histogram frame data
    //    public static bool PollUserHistogramFrame(ref UserHistogramBuffer userHistImage, bool bUseColorData)
    //    {
    //        bool bNewFrame = false;
    //
    //        IntPtr imagePtr = IntPtr.Zero;
    //        Int64 liFrameTime = 0;
    //    
    //        int hr = GetUserHistogramFrameData(ref imagePtr, ref liFrameTime, bUseColorData);
    //        
    //        if(hr == 0)
    //        {
    //            userHistImage = (UserHistogramBuffer)Marshal.PtrToStructure(imagePtr, typeof(UserHistogramBuffer));
    //            bNewFrame = true;
    //        }
    //        
    //        return bNewFrame;
    //    }
    // returns depth frame coordinates for the given 3d Kinect-space point
    public static Vector2 GetKinectPointDepthCoords(SensorData sensorData, Vector3 kinectPos)
    {
        Vector2 vPoint = Vector2.zero;

        //		int dx = 0, dy = 0;

        //		int hr = GetKinectPointDepthCoords(kinectPos.x, kinectPos.y, kinectPos.z, out dx, out dy);
        //
        //		if(hr == 0)
        //		{
        //			return new Vector2(dx, dy);
        //		}

        if(sensorData.coordMapper != null)
        {
            CameraSpacePoint camPoint = new CameraSpacePoint();
            camPoint.X = kinectPos.x;
            camPoint.Y = kinectPos.y;
            camPoint.Z = kinectPos.z;

            CameraSpacePoint[] camPoints = new CameraSpacePoint[1];
            camPoints[0] = camPoint;

            DepthSpacePoint[] depthPoints = new DepthSpacePoint[1];
            sensorData.coordMapper.MapCameraPointsToDepthSpace(camPoints, depthPoints);

            DepthSpacePoint depthPoint = depthPoints[0];

            if(depthPoint.X >= 0 && depthPoint.X < sensorData.depthImageWidth &&
               depthPoint.Y >= 0 && depthPoint.Y < sensorData.depthImageHeight)
            {
                vPoint.x = depthPoint.X;
                vPoint.y = depthPoint.Y;
            }
        }

        return vPoint;
    }