【OpenCV】双相机结构光成像与图像交叉融合实现【C++篇】

双相机结构光成像与图像交叉融合实现

下面介绍双相机结构光系统的实现方法，包括图像采集、相位计算、三维重建以及双相机数据的交叉融合。

一、系统架构设计

1. 硬件配置

• 2台同步的工业相机（左右布置）
• 1台结构光投影仪（DLP或LCD）
• 同步触发装置
• 计算机与图像采集卡

2. 软件流程

投影图案序列 → 双相机同步采集 → 单相机相位计算 → 
双相机相位匹配 → 三维点云生成 → 点云融合 → 三维重建

二、核心代码实现

1. 双相机同步采集

#include <opencv2/opencv.hpp>
#include <vector>

// 模拟双相机采集类
class DualCameraCapture {
public:
    DualCameraCapture(int cam1_id, int cam2_id) {
        cap1.open(cam1_id);
        cap2.open(cam2_id);
        // 设置相机参数
        cap1.set(cv::CAP_PROP_FRAME_WIDTH, 1280);
        cap1.set(cv::CAP_PROP_FRAME_HEIGHT, 720);
        cap2.set(cv::CAP_PROP_FRAME_WIDTH, 1280);
        cap2.set(cv::CAP_PROP_FRAME_HEIGHT, 720);
    }
    
    bool capturePair(cv::Mat& frame1, cv::Mat& frame2) {
        // 实际应用中这里需要硬件触发同步
        bool ret1 = cap1.read(frame1);
        bool ret2 = cap2.read(frame2);
        return ret1 && ret2;
    }

private:
    cv::VideoCapture cap1, cap2;
};

2. 相位计算（四步相移法）

// 计算包裹相位
cv::Mat computePhaseMap(const std::vector<cv::Mat>& patterns) {
    CV_Assert(patterns.size() == 4); // 四步相移
    
    cv::Mat I1 = patterns[0], I2 = patterns[1];
    cv::Mat I3 = patterns[2], I4 = patterns[3];
    
    cv::Mat numerator, denominator;
    cv::subtract(I4, I2, numerator);   // I4 - I2
    cv::subtract(I1, I3, denominator); // I1 - I3
    
    cv::Mat phaseMap;
    cv::phase(numerator, denominator, phaseMap); // atan2(I4-I2, I1-I3)
    
    return phaseMap;
}

3. 双相机相位匹配与三维重建

// 三维重建参数
struct ReconstructionParams {
    cv::Mat K1, K2;      // 相机内参矩阵
    cv::Mat D1, D2;      // 畸变系数
    cv::Mat R, T;        // 相机间旋转和平移
    float projectorPitch; // 投影仪像素间距
    float baseline;       // 基线距离
};

// 基于相位匹配的三维重建
cv::Mat reconstruct3D(
    const cv::Mat& phase1, // 相机1的相位图
    const cv::Mat& phase2, // 相机2的相位图 
    const ReconstructionParams& params)
{
    CV_Assert(phase1.size() == phase2.size());
    
    cv::Mat pointCloud(phase1.size(), CV_32FC3);
    
    for (int y = 0; y < phase1.rows; ++y) {
        for (int x = 0; x < phase1.cols; ++x) {
            float phi1 = phase1.at<float>(y, x);
            float phi2 = phase2.at<float>(y, x);
            
            // 相位匹配 - 计算视差
            float disparity = (phi1 - phi2) / (2 * CV_PI) * params.projectorPitch;
            
            // 三角测量计算深度
            float Z = params.baseline * params.K1.at<float>(0,0) / disparity;
            float X = (x - params.K1.at<float>(0,2)) * Z / params.K1.at<float>(0,0);
            float Y = (y - params.K1.at<float>(1,2)) * Z / params.K1.at<float>(1,1);
            
            pointCloud.at<cv::Vec3f>(y, x) = cv::Vec3f(X, Y, Z);
        }
    }
    
    return pointCloud;
}

4. 双相机点云融合

// 点云融合类
class PointCloudFusion {
public:
    void fuse(const cv::Mat& cloud1, const cv::Mat& cloud2, 
              const cv::Mat& R, const cv::Mat& T, 
              cv::Mat& fusedCloud)
    {
        // 将cloud2转换到cloud1的坐标系
        cv::Mat cloud2Transformed;
        cv::transform(cloud2.reshape(1, cloud2.total()), 
                     cloud2Transformed, 
                     R, T);
        cloud2Transformed = cloud2Transformed.reshape(3, cloud2.rows);
        
        // 简单平均融合
        fusedCloud.create(cloud1.size(), cloud1.type());
        for (int y = 0; y < cloud1.rows; ++y) {
            for (int x = 0; x < cloud1.cols; ++x) {
                cv::Vec3f p1 = cloud1.at<cv::Vec3f>(y, x);
                cv::Vec3f p2 = cloud2Transformed.at<cv::Vec3f>(y, x);
                
                // 有效性检查
                if (p1[2] > 0 && p2[2] > 0) {
                    fusedCloud.at<cv::Vec3f>(y, x) = (p1 + p2) / 2.0f;
                } else if (p1[2] > 0) {
                    fusedCloud.at<cv::Vec3f>(y, x) = p1;
                } else {
                    fusedCloud.at<cv::Vec3f>(y, x) = p2;
                }
            }
        }
    }
};

三、完整工作流程实现

int main() {
    // 1. 初始化双相机
    DualCameraCapture cameras(0, 1);
    
    // 2. 投影和采集四步相移图案
    std::vector<cv::Mat> patterns1(4), patterns2(4);
    for (int i = 0; i < 4; ++i) {
        // 实际应用中这里需要控制投影仪
        cameras.capturePair(patterns1[i], patterns2[i]);
    }
    
    // 3. 计算相位图
    cv::Mat phase1 = computePhaseMap(patterns1);
    cv::Mat phase2 = computePhaseMap(patterns2);
    
    // 4. 相位解包裹 (可使用前面介绍的相位解包裹算法)
    cv::Mat unwrappedPhase1, unwrappedPhase2;
    phaseUnwrap(phase1, unwrappedPhase1);
    phaseUnwrap(phase2, unwrappedPhase2);
    
    // 5. 三维重建参数 (需要实际标定)
    ReconstructionParams params;
    // ... 初始化相机参数 ...
    
    // 6. 三维重建
    cv::Mat cloud1 = reconstruct3D(unwrappedPhase1, unwrappedPhase2, params);
    cv::Mat cloud2 = reconstruct3D(unwrappedPhase2, unwrappedPhase1, params);
    
    // 7. 点云融合
    PointCloudFusion fuser;
    cv::Mat fusedCloud;
    fuser.fuse(cloud1, cloud2, params.R, params.T, fusedCloud);
    
    // 8. 保存或显示结果
    savePointCloud(fusedCloud, "fused_cloud.ply");
    
    return 0;
}

四、关键技术点详解

1. 双相机同步

• 硬件同步：使用外部触发信号确保两相机同时曝光
• 软件同步：精确控制采集时序，误差<1ms
• 时间戳对齐：为每帧图像添加精确时间戳

2. 相位匹配优化

// 改进的相位匹配算法
float computeDisparityWithConfidence(
    float phi1, float phi2, 
    float confidence1, float confidence2)
{
    // 加权相位差
    float weightedDiff = (phi1 * confidence1 - phi2 * confidence2) / 
                        (confidence1 + confidence2 + 1e-6f);
    
    // 处理周期跳变
    if (weightedDiff > CV_PI) weightedDiff -= 2*CV_PI;
    if (weightedDiff < -CV_PI) weightedDiff += 2*CV_PI;
    
    return weightedDiff;
}

3. 点云融合改进

• 基于ICP的精确配准：先进行点云精细对齐
• 基于曲率的加权融合：在特征区域保留更多细节
• 离群点剔除：统计滤波去除噪声点

五、性能优化建议

1. 并行计算：

   // 使用OpenMP并行化相位计算
   #pragma omp parallel for
   for (int y = 0; y < height; y++) {
       // 相位计算代码
   }
   

2. GPU加速：

   • 使用CUDA实现核心算法
   • OpenCL跨平台加速

3. 内存优化：

   • 使用金字塔处理大分辨率图像
   • 分块处理点云数据

六、实际应用注意事项

1. 系统标定：

   • 精确标定双相机内外参数
   • 投影仪-相机几何关系标定
   • 相位-深度映射标定

2. 误差补偿：

   • 镜头畸变校正
   • 亮度不均匀补偿
   • 环境光干扰消除

3. 实时性优化：

   • ROI区域处理
   • 多分辨率处理
   • 流水线并行

这个实现框架可以根据具体应用需求进行调整，例如添加更多的相位解包裹算法选项、改进点云融合策略，或者集成更先进的特征匹配方法。