用奥比深度相机扫描一个非常平的平面，为什么深度值会出现厘米级的误差？

奥比中光3D视觉开发者社区

于 2022-05-27 11:23:34 发布

阅读量1.1k

点赞数 3

分类专栏：开发者结构光文章标签：平面计算机视觉 c++ 结构光相机人工智能

本文链接：https://blog.csdn.net/limingmin2020/article/details/125000281

版权

开发者同时被 2 个专栏收录

146 篇文章 35 订阅

订阅专栏

结构光

60 篇文章 9 订阅

订阅专栏

编辑整理自 || 3D视觉开发者社区
✨如果觉得文章内容不错，别忘了三连支持下哦😘~

用奥比深度相机扫描一个非常平的平面，出现了4个毫米的误差。

这个误差是如何产生的？是应为相机平面与我给定的平面存在倾斜造成的？还是相机本身精度造成的？

运算代码如下：

#include <iostream>
#include <vector>
#include "OpenNI.h"
#include "OniSampleUtilities.h"

using namespace openni;
using namespace std;

#define MIN_DISTANCE 20  //单位毫米
#define MAX_DISTANCE 1200 //单位毫米
#define RESOULTION_X 640.0  //标定时的分辨率
#define RESOULTION_Y 480.0  //标定时的分辨率

#define MAX_FRAME_COUNT 50

typedef struct SPoint
{
    float x, y, z;
    SPoint(float u = 0.0f, float v = 0.0f, float w = 0.0f)
        : x(u), y(v), z(w) 
    { }
} Point;

typedef struct xnIntrinsic_Params
{
    xnIntrinsic_Params() :
        c_x(320.0), c_y(240.0), f_x(480.0), f_y(480.0)
    {}

    xnIntrinsic_Params(float c_x_, float c_y_, float f_x_, float f_y_) :
        c_x(c_x_), c_y(c_y_), f_x(f_x_),f_y(f_y_)
    {}

    float c_x; //u轴上的归一化焦距
    float c_y; //v轴上的归一化焦距
    float f_x; //主点x坐标
    float f_y; //主点y坐标
}xIntrinsic_Params;

xIntrinsic_Params g_IntrinsicParam; //存储相机内参的全局变量

void getCameraParams(openni::Device& Device, xIntrinsic_Params& IrParam)
{
    OBCameraParams cameraParam;
    int dataSize = sizeof(cameraParam);
    memset(&cameraParam, 0, sizeof(cameraParam));
    openni::Status rc = Device.getProperty(openni::OBEXTENSION_ID_CAM_PARAMS, (uint8_t *)&cameraParam, &dataSize);
    if (rc != openni::STATUS_OK)
    {
        std::cout << "Error:" << openni::OpenNI::getExtendedError() << std::endl;
        return;
    }
    IrParam.f_x = cameraParam.l_intr_p[0]; //u轴上的归一化焦距
    IrParam.f_y = cameraParam.l_intr_p[1]; //v轴上的归一化焦距
    IrParam.c_x = cameraParam.l_intr_p[2]; //主点x坐标
    IrParam.c_y = cameraParam.l_intr_p[3]; //主点y坐标
}

void convertDepthToPointCloud(const uint16_t *pDepth, int width, int height, int middleIndex)
{
    if (NULL == pDepth)
    {
        printf("depth frame is NULL!");
        return;
    }

    //分辨率缩放，这里假设标定时的分辨率分RESOULTION_X，RESOULTION_Y
    float fdx = g_IntrinsicParam.f_x * ((float)(width) / RESOULTION_X);
    float fdy = g_IntrinsicParam.f_y * ((float)(height) / RESOULTION_Y);
    float u0  = g_IntrinsicParam.c_x * ((float)(width) / RESOULTION_X);
    float v0  = g_IntrinsicParam.c_y * ((float)(height) / RESOULTION_Y);
    // 得到被扫描平面中心点的坐标
    SPoint midPoint(pDepth[middleIndex] * (width / 2 - u0) / fdx, pDepth[middleIndex] * ((height + 1) / 2 - v0) / fdy, pDepth[middleIndex]);

    vector<Point> points;
    uint16_t max_depth = MAX_DISTANCE;
    uint16_t min_depth = MIN_DISTANCE;
    float x, y, z;

    for (int v = 0; v < height; ++v)
    {
        for (int u = 0; u < width; ++u)
        {
            uint16_t depth = pDepth[v * width + u];
            if (depth <= 0 || depth < min_depth || depth > max_depth)
                continue;

            float tx = (u - u0) / fdx;
            float ty = (v - v0) / fdy;
            // 将中心点定义为世界坐标系的原点
            x = depth * tx - midPoint.x, y = depth * ty - midPoint.y, z = depth;

            if (x + 100.0f <= 0.001f || x - 100.0f >= 0.001f) continue;  // 滤波
            if (y + 100.0f <= 0.001f || y - 100.0f >= 0.001f) continue;
            points.push_back(SPoint(x, y, z));

        }
    }
    for (size_t i = 0; i < points.size(); ++i)
        cout << points[i].x << " " << points[i].y << " " <<points[i].z << endl;
}

int g_imageCount = 0;

void analyzeFrame(const VideoFrameRef& frame)
{
    DepthPixel* pDepth;

    g_imageCount++;
    if (MAX_FRAME_COUNT < g_imageCount)
    {
        return;
    }

    //int middleIndex = (frame.getHeight() + 1)*frame.getWidth() / 2;

    switch (frame.getVideoMode().getPixelFormat())
    {
    case PIXEL_FORMAT_DEPTH_1_MM:
        pDepth = (DepthPixel*)frame.getData();
        //printf("[%08llu] %8d\n", (long long)frame.getTimestamp(),
        //    pDepth[middleIndex]);

        //将深度数据转换为点云并保存成ply文件，每帧深度数据对应一个ply文件
        convertDepthToPointCloud(pDepth, frame.getWidth(), frame.getHeight(), (frame.getHeight() + 1) * frame.getWidth() / 2);
        break;
    default:
        printf("Unknown format\n");
    }
}

class PrintCallback : public VideoStream::NewFrameListener
{
public:
    void onNewFrame(VideoStream& stream)
    {
        stream.readFrame(&m_frame);

        analyzeFrame(m_frame);
    }
private:
    VideoFrameRef m_frame;
};

int main(int argc, char* argv[])
{
    //initialize openNI sdk
    Status rc = OpenNI::initialize();
    if (rc != STATUS_OK)
    {
        printf("Initialize failed\n%s\n", OpenNI::getExtendedError());
        return 1;
    }

    //open deivce
    Device device;
    rc = device.open(ANY_DEVICE);
    if (rc != STATUS_OK)
    {
        printf("Couldn't open device\n%s\n", OpenNI::getExtendedError());
        return 2;
    }

    VideoStream depth;

    //create depth stream
    if (device.getSensorInfo(SENSOR_DEPTH) != NULL)
    {
        rc = depth.create(device, SENSOR_DEPTH);
        if (rc != STATUS_OK)
        {
            printf("Couldn't create depth stream\n%s\n", OpenNI::getExtendedError());
        }
    }

    //start depth stream
    rc = depth.start();
    if (rc != STATUS_OK)
    {
        printf("Couldn't start the depth stream\n%s\n", OpenNI::getExtendedError());
    }

    PrintCallback depthPrinter;

    // Register frame listener
    depth.addNewFrameListener(&depthPrinter);

    //get intrinsic parameter from device
    getCameraParams(device, g_IntrinsicParam);

    // Wait while we're getting frames through the printer
    while (MAX_FRAME_COUNT > g_imageCount)
    {
        Sleep(100);
    }

    depth.removeNewFrameListener(&depthPrinter);

    //stop depth stream
    depth.stop();

    //destroy depth stream
    depth.destroy();

    //close device
    device.close();

    //shutdown OpenNI
    OpenNI::shutdown();

    return 0;
}