Kinect尝鲜（3）——轮询模型

最新推荐文章于 2023-04-10 17:41:38 发布
最新推荐文章于 2023-04-10 17:41:38 发布
阅读量225 收藏
点赞数
文章标签： c#
原文链接：https://segmentfault.com/a/1190000008655329
版权

  在《Kinect尝鲜（1）》中提到了Kinect程序的两种模型——事件模型和轮询模型。其中事件模型是通过C#的事件与委托的编程方式，在Kinect采集完成一帧的数据后触发某事件，通过该事件委托的方法完成相关的数据处理。而轮询模型则是将控制权还给应用程序，由应用程序向Kinect主动去“要”数据。事件模型的开发难度教低，同时限制也比较大；而轮询模型则更高效，更适合多线程应用程序。

事件模型

private void StartKinect()
{
    if (KinectSensor.KinectSensors.Count <= 0)
    {
        MessageBox.Show("No Kinect device foound!");
        return;
    }
    _kinect = KinectSensor.KinectSensors[0];

    _kinect.ColorStream.Enabl(ColorImageFormat.RgbResolution640x480Fps30);
    _kinect.DepthStream.Enabl(DepthImageFormat.Resolution640x480Fps30);
    _kinect.SkeletonStream.Enable();

    _kinect.ColorFrameReady += newEventHandler<ColorImageFrameReadyEventArgs(KinectColorFrameReady);
    _kinect.DepthFrameReady += newEventHandler<DepthImageFrameReadyEventArgs(KinectDepthFrameReady);
    _kinect.SkeletonFrameReady += newEventHandler<SkeletonFrameReadyEventArgs(KinectSkeletonFrameReady);
    _kinect.Start();
}

  上面代码是一个典型的事件模型，ColorFrameReady、DepthFrameReady和SkeletonFrameReady是Kinect封装好的三种事件，可以在其被触发的时候执行委托方法KinectColorFrameReady、KinectDepthFrameReady和KinectSkeletonFrameReady，这三个方法都是自定义的。以KinectColorFrameReady为例：

private void KinectColorFrameReady(object sender,ColorImageFrameReadyEventArgs e)
{
    using (ColorImageFrame colorImageFrame = e.OpenColorImageFrame())
    {
        if (colorImageFrame == null)
            return;
        byte[] pixels = new byte[colorImageFrame.PixelDataLength];
        colorImageFrame.CopyPixelDataTo(pixels);
        int stride = colorImageFrame.Width * 4;
        colorImage.Source = BitmapSource.Create(colorImageFrame.Width, colorImageFrame.Height, 96, 96, PixelFormats.Bgr32, null, pixels, stride);
    }
}

  每次Kinect已经采集到一帧的彩色图像数据后会触发ColorFrameReady事件，该事件委托执行KinectColorFrameReady方法，在该方法中将彩色视频流绘制到colorImage控件上。

轮询模型

  在轮询模型中，既然主动权被交还给应用程序，那么我希望将Kinect数据收集与处理与应用程序逻辑分隔开，于是将Kinect有关的方法封装到KinectX类中，其中CustomKinectException是自定义的异常。

public KinectX()
{
    if (KinectSensor.KinectSensors.Count <= 0)
    {
        throw new CustomKinectException("No Kinect Found");
    }
    _kinect = KinectSensor.KinectSensors[0];
    _kinect.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
    _kinect.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
    _kinect.SkeletonStream.Enable();
}

public void Start(/*args*/)
{
    /*......*/
    _kinect.Start();
}

  在应用程序中启动Kinect后，可以将Kinect相关的内容放到另一个线程中执行。

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    kinectX = new KinectX();
    try
    {
        kinectX.Start(KinectX.StartModel.StreamAll);
    }
    catch (CustomKinectException exc)
    {
        textBlock.Text = exc.ToString();
    }
    renderThread = new Thread(new ThreadStart(RenderImage));
    renderThread.Start();
}

private void RenderImage()
{
    while (isWindowsClosing == false) 
    {
        kinectX.GetColorStream();
        kinectX.GetDepthStream();
        if (kinectX.ColorImageAvailable == false)
            continue;
        if (kinectX.DepthImageAvailable == false)
            continue;
        colorImage.Dispatcher.Invoke(
            delegate
            {
                colorImage.Source = BitmapSource.Create(kinectX.colorImageFrameWidth, kinectX.colorImageFrameHeight, 96, 96, PixelFormats.Bgr32, null, kinectX.GetColorPixelsData, kinectX.colorStride);
            });
        depthImage.Dispatcher.Invoke(
            delegate
            {
                depthImage.Source = BitmapSource.Create(kinectX.depthImageFrameWidth, kinectX.depthImageFrameHeight, 96, 96, PixelFormats.Bgr32, null, kinectX.GetDepthColorBytePixelData, kinectX.depthStride);
            });
    }
}

  上面代码中kinectX.GetColorStream()和kinectX.GetDepthStream()是使用轮询模型向Kinect“要”数据，具体内容如下：

public void GetColorStream()
{
    using (ColorImageFrame colorImageFrame = _kinect.ColorStream.OpenNextFrame(30))
    {
        if (colorImageFrame == null)
        {
            ColorImageAvailable = false;
            return;
        }
        byte[] pixels = new byte[colorImageFrame.PixelDataLength];
        colorImageFrame.CopyPixelDataTo(pixels);
        colorImageFrameWidth = colorImageFrame.Width;
        colorImageFrameHeight = colorImageFrame.Height;
        colorStride = colorImageFrame.Width * 4;
        colorPixelsData = pixels;
        ColorImageAvailable = true;
    }
}

public void GetDepthStream()
{
    using (DepthImageFrame depthImageFrame = _kinect.DepthStream.OpenNextFrame(30))
    {
        if (depthImageFrame == null)
        {
            depthImageAvailable = false;
            return;
        }
        short[] depthPixelData = new short[depthImageFrame.PixelDataLength];
        depthImageFrame.CopyPixelDataTo(depthPixelData);
        depthImageFrameWidth = depthImageFrame.Width;
        depthImageFrameHeight = depthImageFrame.Height;
        byte[] pixels = ConvertDepthFrameToColorFrame(depthPixelData, _kinect.DepthStream);
        depthBytePixelsData = pixels;
        depthStride = depthImageFrame.Width * 4;
        depthImageAvailable = true;
    }
}

  然而在主线程和XAML控件交互时，又使用了委托机制去向kinectX对象“要”数据，这样处理不是很高效。但当前还没有想到比较好的解决办法，待日后解决此问题后修改。

  以深度数据为例。_kinect.DepthStream.OpenNextFrame(30)意思是让Kinect返回下一帧的深度数据流，时间间隔为30ms。由于启动时选择的帧率时30FPS，所以每隔30ms去“要”一次数据比较合适。如果参数设置为0，也并不是时间间隔为0，因为轮询模型下该方法调用也需要消耗一定时间，虽然非常小，并且在如此短的时间间隔内Kinect并不能采集完一帧的数据，所以此时返回的depthImageFrame为null，多次方法调用只能获取一次有效的结果，这样会造成不必要的资源浪费。

完整的KinectX代码

class KinectX
{
    private KinectSensor _kinect;
    private DepthImageStream depthImageStream;
    private ColorImageStream colorImageStream;
    private SkeletonStream skeletonStream;
    private SkeletonFrame skeletonFrame;
    private Skeleton[] skeletons;
    private WriteableBitmap manBitmap;
    private Int32Rect manImageRect;
    private Joint[] joints;
    const float maxDepthDistance = 4095;
    const float minDepthDistance = 850;
    const float maxDepthDistancOddset = maxDepthDistance - minDepthDistance;
    public int manBitmapStride;
    public int colorStride;
    public int depthStride;
    public int colorImageFrameWidth;
    public int colorImageFrameHeight;
    public int depthImageFrameWidth;
    public int depthImageFrameHeight;
    private const int redIndex = 2;
    private const int greenIndex = 1;
    private const int blueIndex = 0;
    private static readonly int bgr32BytesPerPixel = (PixelFormats.Bgr32.BitsPerPixel + 7) / 8;
    private static readonly int[] intensityShiftByPlayerR = { 1, 2, 0, 2, 0, 0, 2, 0 };
    private static readonly int[] intensityShiftByPlayerG = { 1, 2, 2, 0, 2, 0, 0, 1 };
    private static readonly int[] intensityShiftByPlayerB = { 1, 0, 2, 2, 0, 2, 0, 2 };
    private short[] depthShortPixelsData;
    private byte[] colorPixelsData;
    private byte[] depthBytePixelsData;
    private bool colorImageAvailable;
    private bool depthImageAvailable;
    public enum StartModel
    {
        EventAllFrame,
        EventApartFrame,
        EventColorFrame,
        EventDepthFrame,
        EventSkeletonFrame,
        StreamAll,
        StreamColor,
        StreamSkeleton,
        StreamDepth
    };

    public KinectX()
    {
        if (KinectSensor.KinectSensors.Count <= 0)
        {
            throw new CustomKinectException("No Kinect Found");
        }
        _kinect = KinectSensor.KinectSensors[0];
        _kinect.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
        _kinect.DepthStream.Enable(DepthImageFormat.Resolution640x480Fps30);
        _kinect.SkeletonStream.Enable();
    }

    public void Start(StartModel startModel)
    {
        switch (startModel)
        {
            case (StartModel.EventAllFrame):
                {
                    _kinect.AllFramesReady += KinectAllFramesReady;
                    break;
                }
            case (StartModel.EventApartFrame):
                {
                    _kinect.ColorFrameReady += KinectColorFrameReady;
                    _kinect.DepthFrameReady += KinectDepthFrameReady;
                    _kinect.SkeletonFrameReady += KinectSkeletonFrameReady;
                    break;
                }
            default:
                break;
        }
        _kinect.Start();
    }

    private void KinectAllFramesReady(object sender, AllFramesReadyEventArgs e)
    {
        using (ColorImageFrame colorFrame = e.OpenColorImageFrame())
        {
            using (DepthImageFrame depthFrame = e.OpenDepthImageFrame())
            {
            }
        }
    }

    public void Release()
    {
        if (_kinect != null)
        {
            if (_kinect.Status == KinectStatus.Connected)
            {
                _kinect.Stop();
            }
        }
    }

    public void ViewUp()
    {
        if (_kinect == null)
            return;
        if (!_kinect.IsRunning)
            return;
        if (_kinect.ElevationAngle <= _kinect.MaxElevationAngle - 5)
        {
            _kinect.ElevationAngle += 5;
        }
    }

    public void ViewDown()
    {
        if (_kinect == null)
            return;
        if (!_kinect.IsRunning)
            return;
        if (_kinect.ElevationAngle >= _kinect.MinElevationAngle + 5)
        {
            _kinect.ElevationAngle -= 5;
        }
    }

    public void GetColorStream()
    {
        using (ColorImageFrame colorImageFrame = _kinect.ColorStream.OpenNextFrame(30))
        {
            if (colorImageFrame == null)
            {
                ColorImageAvailable = false;
                return;
            }
            byte[] pixels = new byte[colorImageFrame.PixelDataLength];
            colorImageFrame.CopyPixelDataTo(pixels);
            colorImageFrameWidth = colorImageFrame.Width;
            colorImageFrameHeight = colorImageFrame.Height;
            colorStride = colorImageFrame.Width * 4;
            colorPixelsData = pixels;
            ColorImageAvailable = true;
        }
    }

    public void GetDepthStream()
    {
        using (DepthImageFrame depthImageFrame = _kinect.DepthStream.OpenNextFrame(30))
        {
            if (depthImageFrame == null)
            {
                depthImageAvailable = false;
                return;
            }
            short[] depthPixelData = new short[depthImageFrame.PixelDataLength];
            depthImageFrame.CopyPixelDataTo(depthPixelData);
            depthImageFrameWidth = depthImageFrame.Width;
            depthImageFrameHeight = depthImageFrame.Height;
            byte[] pixels = ConvertDepthFrameToColorFrame(depthPixelData, _kinect.DepthStream);
            depthBytePixelsData = pixels;
            depthStride = depthImageFrame.Width * 4;
            depthImageAvailable = true;
        }
    }

    public void GetSkeletonStream()
    {
       
    }

    public void GetSkeletons()
    {
        skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
        skeletonFrame.CopySkeletonDataTo(skeletons);
    }

    public byte[] GetDepthColorBytePixelData
    {
        get
        {
            return depthBytePixelsData;
        }
    }
    public byte[] GetColorPixelsData
    {
        get
        {
            return colorPixelsData;
        }
    }
    public short[] GetDepthShortPixelData
    {
        get
        {
            return depthShortPixelsData;
        }
    }
    public bool ColorImageAvailable
    {
        get
        {
            return colorImageAvailable;
        }
        set
        {
            colorImageAvailable = value;
        }
    }

    public bool DepthImageAvailable
    {
        get
        {
            return depthImageAvailable;
        }
        set
        {
            depthImageAvailable = value;
        }
    }

    private void GetSkeletonStreamAsync()
    {
        skeletonFrame = skeletonStream.OpenNextFrame(34);
    }

    private void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
    {
        bool isSkeletonDataReady = false;
        using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame())
        {
            if (skeletonFrame != null)
            {
                skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength];
                skeletonFrame.CopySkeletonDataTo(skeletons);
                isSkeletonDataReady = true;
            }
        }
    }

    private void KinectColorFrameReady(object sender, ColorImageFrameReadyEventArgs e)
    {
        using (ColorImageFrame colorImageFrame = e.OpenColorImageFrame())
        {
            if (colorImageFrame == null)
                return;
            byte[] pixels = new byte[colorImageFrame.PixelDataLength];
            colorImageFrame.CopyPixelDataTo(pixels);
            colorStride = colorImageFrame.Width * 4;
            colorPixelsData = pixels;
            ColorImageAvailable = true;
        }
    }

    private void KinectDepthFrameReady(object sender, DepthImageFrameReadyEventArgs e)
    {
        
    }

    private void RenderMan(ColorImageFrame colorFrame, DepthImageFrame depthFrame)
    {
        if (!(depthFrame != null && colorFrame != null))
            return;
        int depthPixelIndex;
        int playerIndex;
        int colorPixelIndex;
        ColorImagePoint colorPoint;
        int colorStride = colorFrame.BytesPerPixel * colorFrame.Width;
        int bytePerPixelOfBgrImage = 4;
        int playerImageIndex = 0;
        depthFrame.CopyPixelDataTo(depthShortPixelsData);
        colorFrame.CopyPixelDataTo(colorPixelsData);
        byte[] manImage = new byte[depthFrame.Height * manBitmapStride];
        for (int j = 0; j < depthFrame.Height; j++)
        {
            for (int i = 0; i < depthFrame.Width; i++, playerImageIndex += bytePerPixelOfBgrImage)
            {
                depthPixelIndex = i + (j * depthFrame.Width);
                playerIndex = depthShortPixelsData[depthPixelIndex] & DepthImageFrame.PlayerIndexBitmask;
                //用户索引标识不为0，则该处属于人体部位。
                if (playerIndex != 0)
                {
                    //深度图像中某一个点映射到彩色图像坐标点
                    colorPoint = _kinect.MapDepthToColorImagePoint(depthFrame.Format, i, j, depthShortPixelsData[depthPixelIndex], colorFrame.Format);
                    colorPixelIndex = (colorPoint.X * colorFrame.BytesPerPixel) + (colorPoint.Y * colorStride);
                    manImage[playerImageIndex] = colorPixelsData[colorPixelIndex];//Blue
                    manImage[playerImageIndex + 1] = colorPixelsData[colorPixelIndex];//Green
                    manImage[playerImageIndex + 2] = colorPixelsData[colorPixelIndex];//Red
                    manImage[playerImageIndex + 3] = 0xFF;//Alpha
                }
                manBitmap.WritePixels(manImageRect, manImage, manBitmapStride, 0);
            }
        }
    }

    /// <summary>
    /// 单色直方图计算公式，返回256色灰阶，颜色越黑越远。
    /// </summary>
    /// <param name="dis">深度值，有效值为......</param>
    /// <returns></returns>
    private static byte CalculateIntensityFromDepth(int dis)
    {
        return (byte)(255 - (255 * Math.Max(dis - minDepthDistance, 0) / maxDepthDistancOddset));
    }

    /// <summary>
    /// 生成BGR32格式的图片字节数组
    /// </summary>
    /// <param name="depthImageFrame"></param>
    /// <returns></returns>
    private byte[] ConvertDepthFrameToGrayFrame(DepthImageFrame depthImageFrame)
    {
        short[] rawDepthData = new short[depthImageFrame.PixelDataLength];
        depthImageFrame.CopyPixelDataTo(rawDepthData);
        byte[] pixels = new byte[depthImageFrame.Height * depthImageFrame.Width * 4];
        for (int depthIndex = 0, colorIndex = 0; depthIndex < rawDepthData.Length && colorIndex < pixels.Length; depthIndex++, colorIndex += 4)
        {
            int player = rawDepthData[depthIndex] & DepthImageFrame.PlayerIndexBitmask;
            int depth = rawDepthData[depthIndex] >> DepthImageFrame.PlayerIndexBitmaskWidth;
            if (depth <= 900)
            {
                //离Kinect很近
                pixels[colorIndex + blueIndex] = 255;
                pixels[colorIndex + greenIndex] = 0;
                pixels[colorIndex + redIndex] = 0;
            }
            else if (depth > 900 && depth < 2000)
            {
                pixels[colorIndex + blueIndex] = 0;
                pixels[colorIndex + greenIndex] = 255;
                pixels[colorIndex + redIndex] = 0;
            }
            else if (depth >= 2000)
            {
                //离Kinect超过2米
                pixels[colorIndex + blueIndex] = 0;
                pixels[colorIndex + greenIndex] = 0;
                pixels[colorIndex + redIndex] = 255;
            }
            //单色直方图着色
            byte intensity = CalculateIntensityFromDepth(depth);
            pixels[colorIndex + blueIndex] = intensity;
            pixels[colorIndex + greenIndex] = intensity;
            pixels[colorIndex + redIndex] = intensity;
            //如果是人体区域，用亮绿色标记
            if (player > 0)
            {
                pixels[colorIndex + blueIndex] = Colors.LightGreen.B;
                pixels[colorIndex + greenIndex] = Colors.LightGreen.G;
                pixels[colorIndex + redIndex] = Colors.LightGreen.R;
            }
        }
        return pixels;
    }

    /// <summary>
    /// 将16位灰阶深度图转为32位彩色深度图
    /// </summary>
    /// <param name="depthImageFrame">16位灰阶深度图</param>
    /// <param name="depthImageStream">用于获得深度数据流的相关属性</param>
    /// <returns></returns>
    private byte[] ConvertDepthFrameToColorFrame(short[] depthImageFrame, DepthImageStream depthImageStream)
    {
        byte[] depthFrame32 = new byte[depthImageStream.FrameWidth * depthImageStream.FrameHeight * bgr32BytesPerPixel];
        //通过常量获取有效视距，不用硬编码
        int tooNearDepth = depthImageStream.TooNearDepth;
        int tooFarDepth = depthImageStream.TooFarDepth;
        int unknowDepth = depthImageStream.UnknownDepth;
        for (int i16 = 0, i32 = 0; i16 < depthImageFrame.Length && i32 < depthFrame32.Length; i16++, i32 += 4)
        {
            int player = depthImageFrame[i16] & DepthImageFrame.PlayerIndexBitmask;
            int realDepth = depthImageFrame[i16] >> DepthImageFrame.PlayerIndexBitmaskWidth;
            //通过位运算，将13位的深度图裁剪位8位
            byte intensity = (byte)(~(realDepth >> 4));
            if (player == 0 && realDepth == 0)
            {
                depthFrame32[i32 + redIndex] = 255;
                depthFrame32[i32 + greenIndex] = 255;
                depthFrame32[i32 + blueIndex] = 255;
            }
            else if (player == 0 && realDepth == tooFarDepth)
            {
                //深紫色
                depthFrame32[i32 + redIndex] = 66;
                depthFrame32[i32 + greenIndex] = 0;
                depthFrame32[i32 + blueIndex] = 66;
            }
            else if (player == 0 && realDepth == unknowDepth)
            {
                //深棕色
                depthFrame32[i32 + redIndex] = 66;
                depthFrame32[i32 + greenIndex] = 66;
                depthFrame32[i32 + blueIndex] = 33;
            }
            else
            {
                depthFrame32[i32 + redIndex] = (byte)(intensity >> intensityShiftByPlayerR[player]);
                depthFrame32[i32 + greenIndex] = (byte)(intensity >> intensityShiftByPlayerG[player]);
                depthFrame32[i32 + blueIndex] = (byte)(intensity >> intensityShiftByPlayerB[player]);
            }
        }
        return depthFrame32;
    }
}

class CustomKinectException : ApplicationException
{
    public CustomKinectException()
    {
    }
    public CustomKinectException(string message) : base(message)
    {
    }
    public CustomKinectException(string message, Exception inner) : base(message, inner)
    {
    }
}
二、配置VS2019中Azure Kinect SDK环境——Azure Kinect DK入门
qq_54804745的博客
08-12 2121
Azure Kinect DK 文档 VS2019创建项目打开VS2019创建新项目配置新项目创建完成选择release X64 or debug X64配置包含目录和库目录配置包含目录配置库目录配置附加依赖项检验总结 创建项目 打开VS2019 点击创建新项目 创建新项目 选择控制台应用 配置新项目 项目名称：自己取一个名字（文件名称尽量不要有空格） 位置：选择一个自己记得住的位置 解决方案名称：自己取一个名字（文件名尽量不要有空格） 注： 建议将解决方案和项目放在同一目录下！！！ 创建完成
三、获取Azure Kinect DK序列号——Azure Kinect DK入门
qq_54804745的博客
08-12 621
Azure Kinect DK 文档 Azure-Kinect-Sensor-SDK 文档 参考文档学习，边学，边查资料 目的：获取设备序列号 设备：一台Azure Kinect DK 基本函数： uint32_t k4a_device_get_installed_count (void) 函数功能：获取已连接的设备数量 k4a_result_t k4a_device_open (uint32_t index,k4a_device_t * device_handle) 函数功能：打开设备 参数：
Kinect面部模型（2D）
u011450843的博客
10-13 1411
Kinect面部模型（2D）本文是参考这篇博客高清面部帧-面部模型2D而来，对博主的资源加以整理归纳。主要通过IFaceModel接口获得面形的94个浮点值和面部1347个特征点，其中面形的94个浮点值，官方文档有介绍面形数据描述。基本步骤如下： 创建资源与事件（主要是高清面部资源）； 在高清面部临帧事件里更新面部对齐，计算面部模型，将面部模型顶点映射至彩色空间； 在刻画时画出这些点即可； 对应的主
Kinect 轮询方式下 握住 放开
atxtk的专栏
01-09 857
// by jiabin namespace xnaGame {     //实现交互端接口的类           public class InteractionClient : IInteractionClient           {          //实现得到交互对象                   public InteractionInfo GetInterac
java 轮询http_HTTP轮询模型
weixin_30545587的博客
02-16 623
HTTP轮询模型长短轮询http协议是一种client-server模型的应用层协议，这种c-s的模式虽然大多数情况都能满足需求，但是某些场景也需要服务端能够将一些信息实时的推送到客户端，即实现服务器向客户端推消息的功能。比如：配置管理中心服务端需要将更新的配置推送到client端消息推送服务器需要将一些消息推送到Android、iOS客户端利用Http协议实现服务器推送有两种常见的思路：短轮询拉...
VS配置Azure Kinect 3 BodyTrack（身体追踪）开发环境
qq_48188557的博客
10-07 2549
在进行本篇文章的配置之前，我们需要先配置好Azure Kinect 3的开发环境(没有配置好Azure Kinect 3环境的可以看我之前的文章点此阅读如何配置Azure Kinect 3开发环境) 目录： 一，初次在VS配置Azure Kinect3 BodyTrack开发环境(C++) 1，下载并且安装Azure Kinect3 BodyTrack SDK 2 ，配置开发环境 2.1，新建一个c++空项目文件 2.2，新建props文件...
Azure Kinect 3深度相机开发--人体姿态估计并输出各个关节点坐标
最新发布
a302540436的博客
04-10 3407
本文为笔者第一次配置Azure Kinect相机的流程记录，参考以下4个博客：主要通过深度相机完成了对姿态点的实时估计，在可视化界面将估计的骨架点实时绘出，并同时计算各个关节的二维角度。同时将各个关节点的二维信息和深度以及时间和关节角度保存至表格文件中。
kinect
03-28
kinect
Kinect尝鲜（1）——第一个程序
壶中天
09-13 4080
第一个Kinect程序，使用Kinect V1。
通过kinect实现3d扫描建立打印模型（processing、skanect、ReconstructMe）
hongqiang200的专栏
04-08 1万+
http://www.sigvc.org/bbs/thread-722-1-1.html 在本文中将详细梳理使用Kinect进行3d扫描的过程，一共包含3种实现方法：processing编程实现、skanect软件实现、ReconstructMe软件实现。RecontructMe只能基于32位系统的驱动与kinect连接，而skanect与processing不论是32位还是64
Kinect学习（三）：获取RGB颜色数据
hongbin_xu的博客
06-22 6282
前言 在前面的文章中介绍了如何搭建Kinect开发环境：Kinect学习（一）：开发环境搭建。搭建好环境后，首先要做的当然就是试着读取Kinect中的数据了。 Kinect有三个镜头，中间的是RGB摄像头，左边的是红外线发射器，右边的是红外线CMOS摄像头构成的3D结构光摄像头，用来采集深度数据。彩色摄像头最大支持1280*960分辨率成像，红外摄像头最大支持640*480成像。 接...
KinectSDK2.0面部模型3D
10-10
《Kinect for Windows SDK v2.0 开发笔记 (十四) 高清面部帧(5) 面部模型 3D》所附带资源
基于kinect v2的模型三维重建算法（个人毕设总结）
weixin_43235829的博客
03-30 1804
https://blog.csdn.net/u010848251/article/details/70992345 根据调试中遇到的问题 对文章中的代码进行了修改 问题解决依据: https://blog.csdn.net/berlinpand/article/details/79044333 #define vtkRenderingCore_AUTOINIT 4(vtkInteractionStyle,vtkRenderingFreeType,vtkRenderingFreeType,vtkRenderi
添加Kinect模型及kinect.dae文件的下载
m0_56588389的博客
10-29 1042
古月居ROS教程中，给小车添加Kinect传感器 Kinect模型描述文件如下： <?xml version="1.0"?> <robot name="kinect_camera" xmlns:xacro="http://www.ros.org/wiki/xacro"> <xacro:macro name="kinect_camera" params="prefix"> <link name="${prefix}_link"&gt
Kinect尝鲜（2）——骨骼识别
壶中天
11-21 3343
本篇简单介绍了Kinect SDK的骨骼识别。微软还是一家很强悍的公司，替开发者将很多底层部分做好了，我们所做的只是使用SDK封装好的一些方法，就可以快速开发出一些有趣或使用的应用。
Kinect
09-22
Kinect基本原理，Kinect测量身高，测量三围，抠图等等
Kinect V2 开发指南（三）
Legend_of_Dagger_Lee的博客
04-15 504
上一节讲到如何进行点云分割得到自己所需要的点云，这一节刀哥带你们去对点云进行三维重建和测量三维模型。 话不多说，我们来发车吧! 上一节我们将完好的挡书板点云分割出来了，然后使用统计滤波对其进行离散点的滤除，这样一来我们就得到了一块完整的点云模型了。那我们就先把点云模型祭出来吧。 接下来就是怎么对模型进行表面重建，最简单的方法就是贪婪投影三角化算法对有向点云进行三角化的成像，这个计算量不是...
Kinect V2的urdf/xacro模型
跃动的风的博客
05-07 1233
在使用kinect v2传感器时，我发现我找不到一个完美的kinect v2 urdf模型。所以我做了这个模型，希望这会对你有所帮助。 [https://github.com/wangxian4423/kinect_v2_udrf]( To use in rviz: roslaunch kinect_...
KinectFusion三维重建过程
热门推荐
Kindy
07-29 1万+
       基于深度相机的三维重建是一个非常流行、低成本的重建方案。基于Kinect一代是一种低成本的重建方案，图1是Kinect一代结构图。红外发射器发射红外线模板，通过红外CMOS获取反射红外光，采用光编码方式获得深度图。（Kinect二代采用ToF飞行时间法）。 为了能对深度相机的三维重建技术有深入了解，现对算法过程进行详细描述： 深度数据获取---去躁； 生成点云---计算摄像...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值