opencv双目测量棋盘格三轴转动原理与代码

最新推荐文章于 2024-07-01 21:31:10 发布
最新推荐文章于 2024-07-01 21:31:10 发布
阅读量222 收藏
点赞数 9
文章标签： opencv 人工智能 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1309348145/article/details/139882211
版权

来自本科毕设

1、匹配棋盘格角点

2、利用p1 p2 p3生成旋转矩阵然后分解成欧拉角

代码

#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>
#include <iostream>
using namespace std;
using namespace cv;
cv::Point2d pixel2cam(const cv::Point2f& p, const cv::Mat& K) {
    return cv::Point2d(
        (p.x - K.at<double>(0, 2)) / K.at<double>(0, 0),
        (p.y - K.at<double>(1, 2)) / K.at<double>(1, 1)
    );
}

int main() {

    // 定义左右相机的相机矩阵

    cv::Mat T1 = (cv::Mat_<float>(3, 4) <<
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0);
    /*cv::Mat T2 = (cv::Mat_<float>(3, 4) <<
        0.953637062614699, 0.00658496811859602, -0.300887007035011, 4.458319257471509e+02,
        -0.00250704140519836, 0.999899730598709, 0.0139371263904078, 11.501725596171031,
        0.300948612807905, -0.0125366240873153, 0.953557950785106, 65.623152047724048);*/
        //cv::triangulatePoints(T2, T1, pts1, pts2, points4D);//for 2
        //cv::triangulatePoints(T1, T2, pts2, pts1, points4D);//for 2
        //cv::triangulatePoints(T2, T1, pts2, pts1, points4D);//啥也不是
        //cv::triangulatePoints(T1, T2, pts1, pts2, points4D);//啥也不是
    cv::Mat T2 = (cv::Mat_<float>(3, 4) <<
        0.995305136270557, -0.0144566356161613, 0.0957010522413938, -862.944841702106,
        0.0152041841514424, 0.999859296099956, -0.00708666259880605, -25.7816438948644,
        -0.0955851374311795, 0.00850844810537307, 0.995384894306268, 26.6371015576055);
    cv::Mat K1 = (cv::Mat_<double>(3, 3) <<
        13803.4389203154, 0, 635.162923580742,
        0, 13804.0945005903, 629.015160590977,
        0, 0, 1);
    cv::Mat K2 = (cv::Mat_<double>(3, 3) <<
        14138.2738088473, 0, 583.581246482159,
        0, 14136.9818157979, 622.304905721788,
        0, 0, 1);

    int total_img = 11;//多少张图片
    // 定义棋盘格内角点的行数和列数
    int chessboardRows = 8; // 棋盘格行数
    int chessboardCols = 11; // 棋盘格列数


    string l_path = "../../../../实验数据/图片数据/原始图片/12m5/测量/l/";
    string r_path = "../../../../实验数据/图片数据/原始图片/12m5/测量/r/";

    vector<double> x_d, y_d,z_d;


    // 读取图像
    cv::Mat image1 = cv::imread(l_path+"6.bmp");
    cv::Mat image2 = cv::imread(r_path + "6.bmp");
    /*
    // 获取帧的宽度和高度
    int frameWidth = static_cast<int>(image1.cols*2);
    int frameHeight = static_cast<int>(image2.rows);
    // 定义视频编解码器和创建 VideoWriter 对象
    int fps = 1; // 帧率
    std::string outputVideo = "E:/BaiduNetdiskDownload/毕设/12m5/output_video.avi"; // 输出视频文件路径
    cv::VideoWriter videoWriter(outputVideo, cv::VideoWriter::fourcc('M', 'J', 'P', 'G'), fps, cv::Size(frameWidth, frameHeight));
    if (!videoWriter.isOpened()) {
        std::cerr << "Error: Could not open the output video file for writing." << std::endl;
        return -1;
    }
    */
    /*
    cv::Mat image1, image2;

    Mat distort1 = (cv::Mat_<double>(4, 1) << 0.359491204591065, 42.5099982392409,  0, 0);
    Mat distort2 = (cv::Mat_<double>(4, 1) << 0.444058777698131, 34.8489892235698, 0, 0);
    undistort(dist_img1, image1, K1, distort1);
    undistort(dist_img2, image2, K2, distort2);

    */
    Mat gray1, gray2;
    cvtColor(image1, gray1, COLOR_BGR2GRAY);
    cvtColor(image2, gray2, COLOR_BGR2GRAY);

    // 用于存储检测到的角点
    std::vector<cv::Point2f> corners1, corners2;
    // 尝试在图像中检测棋盘格角点
    bool patternFound1 = cv::findChessboardCorners(image1, cv::Size(chessboardCols, chessboardRows), corners1, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK);
    bool patternFound2 = cv::findChessboardCorners(image2, cv::Size(chessboardCols, chessboardRows), corners2, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK);
    int t1 = 0;
    //for (int i = 5; i >= 1; i--)
    for(int i=1;i<=total_img;i++)
    {
    cv::Mat image3 = cv::imread(l_path+to_string(i)+".bmp");
    cv::Mat image4 = cv::imread(r_path + to_string(i) + ".bmp");
    /*cv::Mat image3, image4;
    undistort(dist_img3, image3, K1, distort1);
    undistort(dist_img4, image4, K2, distort2);
    */
    Mat  gray3, gray4;
    cvtColor(image3, gray3, COLOR_BGR2GRAY);
    cvtColor(image4, gray4, COLOR_BGR2GRAY);

    // 检查图像是否成功加载
    if (image1.empty() || image2.empty() || image3.empty() || image4.empty()) {
        std::cerr << "无法加载图像文件！" << std::endl;
        return -1;
    }

    // 计时开始
    double time1 = static_cast<double>(getTickCount());
    // 用于存储检测到的角点
    std::vector<cv::Point2f> corners3, corners4;
    bool patternFound3 = cv::findChessboardCorners(image3, cv::Size(chessboardCols, chessboardRows), corners3, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK);
    bool patternFound4 = cv::findChessboardCorners(image4, cv::Size(chessboardCols, chessboardRows), corners4, CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE + CALIB_CB_FAST_CHECK);

    // 计时结束
    time1 = ((double)getTickCount() - time1) / getTickFrequency();

    t1 += time1;
    // 如果找到棋盘格角点
    if (patternFound1 && patternFound2 && patternFound3 && patternFound4) {
        /*
        // 在图像中绘制检测到的角点
        cv::drawChessboardCorners(image1, cv::Size(chessboardCols, chessboardRows), corners1, patternFound1);
        cv::drawChessboardCorners(image2, cv::Size(chessboardCols, chessboardRows), corners2, patternFound2);
        // 在图像中绘制检测到的角点
        cv::drawChessboardCorners(image3, cv::Size(chessboardCols, chessboardRows), corners3, patternFound3);
        cv::drawChessboardCorners(image4, cv::Size(chessboardCols, chessboardRows), corners4, patternFound4);
        */
        // 提高角点的精确度
        cornerSubPix(gray1, corners1, Size(11, 11), Size(-1, -1),
            TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 50, 0.01));
        cornerSubPix(gray2, corners2, Size(11, 11), Size(-1, -1),
            TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 50, 0.01));
        cornerSubPix(gray3, corners3, Size(11, 11), Size(-1, -1),
            TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 50, 0.01));
        cornerSubPix(gray4, corners4, Size(11, 11), Size(-1, -1),
            TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 50, 0.01));
        

        std::vector<cv::Point2d> pts1, pts2, pts3, pts4;
        for (int i = 0; i < corners1.size(); i++)
        {
            // 调用函数将像素坐标系下的点转换为相机坐标系下的点
            pts1.push_back(pixel2cam(corners1[i], K1));
            pts2.push_back(pixel2cam(corners2[i], K2));
            pts3.push_back(pixel2cam(corners3[i], K1));
            pts4.push_back(pixel2cam(corners4[i], K2));
        }
        /*
        std::vector<cv::Point2f> p1;
        p1.push_back(pixel2cam(corners1[1], K1));
        std::vector<cv::Point2f> p2;
        p2.push_back(pixel2cam(corners2[1], K2));
        */
        // 通过三角测量计算三维点坐标
        cv::Mat points4D1, points4D2;
        cv::triangulatePoints(T1, T2, pts1, pts2, points4D1);//T2 == T21 服了
        cv::triangulatePoints(T1, T2, pts3, pts4, points4D2);//T2 == T21 服了
        //cv::triangulatePoints(T2, T1, pts1, pts2, points4D);//for 2
        // 将齐次坐标转换为非齐次坐标
        cv::Mat points3D1, points3D2;
        cv::convertPointsFromHomogeneous(points4D1.t(), points3D1);
        cv::convertPointsFromHomogeneous(points4D2.t(), points3D2);
        /*
        std::vector<cv::Point3d> px1, py1, px2, py2;

        for (int i = 0; i < chessboardCols; i++)
        {
            px1.push_back(points3D1.at<cv::Vec3d>(i, 0));
            px2.push_back(points3D2.at<cv::Vec3d>(i, 0));
        }
        for (int i = 0; i < chessboardRows; i++)
        {
            py1.push_back(points3D1.at<cv::Vec3d>(i* chessboardCols, 0));
            py2.push_back(points3D2.at<cv::Vec3d>(i* chessboardCols, 0));
        }
        Vec6f linesx1, linesx2,linesy1, linesy2;
        fitLine(px1, linesx1, DIST_L2, 0.0, 1e-2, 1e-2);
        fitLine(px2, linesx2, DIST_L2, 0.0, 1e-2, 1e-2);
        fitLine(py1, linesy1, DIST_L2, 0.0, 1e-2, 1e-2);
        fitLine(py2, linesy2, DIST_L2, 0.0, 1e-2, 1e-2);
        cv::Vec3d X1, X2, Y1, Y2;


        if (linesx1[0] > 0)
        {
            X1[0] = linesx1[0];
            X1[1] = linesx1[1];
            X1[2] = linesx1[2];
        }
        else
        {
            X1[0] = -linesx1[0];
            X1[1] = -linesx1[1];
            X1[2] = -linesx1[2];
        }
        if (linesy1[1] > 0)
        {
            Y1[0] = linesy1[0];
            Y1[1] = linesy1[1];
            Y1[2] = linesy1[2];
        }
        else
        {
            Y1[0] = -linesy1[0];
            Y1[1] = -linesy1[1];
            Y1[2] = -linesy1[2];
        }
        if (linesx2[0] > 0)
        {
            X2[0] = linesx2[0];
            X2[1] = linesx2[1];
            X2[2] = linesx2[2];
        }
        else
        {
            X2[0] = -linesx2[0];
            X2[1] = -linesx2[1];
            X2[2] = -linesx2[2];
        }
        if (linesy2[1] > 0)
        {
            Y2[0] = linesy2[0];
            Y2[1] = linesy2[1];
            Y2[2] = linesy2[2];
        }
        else
        {
            Y2[0] = -linesy2[0];
            Y2[1] = -linesy2[1];
            Y2[2] = -linesy2[2];
        }
        
        */
        cv::Vec3d X0(1.0, 0.0, 0.0);
        cv::Vec3d Y0(0.0, 1.0, 0.0);
        cv::Vec3d Z0(0.0, 0.0, 1.0);
        cv::Vec3d X1(points3D1.at<cv::Vec3d>(10, 0)[0] - points3D1.at<cv::Vec3d>(0, 0)[0],
            points3D1.at<cv::Vec3d>(10, 0)[1] - points3D1.at<cv::Vec3d>(0, 0)[1],
            points3D1.at<cv::Vec3d>(10, 0)[2] - points3D1.at<cv::Vec3d>(0, 0)[2]);
        cv::Vec3d Y1(points3D1.at<cv::Vec3d>(77, 0)[0] - points3D1.at<cv::Vec3d>(0, 0)[0],
            points3D1.at<cv::Vec3d>(77, 0)[1] - points3D1.at<cv::Vec3d>(0, 0)[1],
            points3D1.at<cv::Vec3d>(77, 0)[2] - points3D1.at<cv::Vec3d>(0, 0)[2]);
        /* cv::normalize(_X1, _X1, 1.0, 0, cv::NORM_L2);
         cv::normalize(_Y1, _Y1, 1.0, 0, cv::NORM_L2);*/
        
        cv::Vec3d Z1 = X1.cross(Y1);
        //归一化
        cv::normalize(X1, X1, 1.0, 0, cv::NORM_L2);
        cv::normalize(Y1, Y1, 1.0, 0, cv::NORM_L2);
        cv::normalize(Z1, Z1, 1.0, 0, cv::NORM_L2);

        cv::Vec3d X2(points3D2.at<cv::Vec3d>(10, 0)[0] - points3D2.at<cv::Vec3d>(0, 0)[0],
            points3D2.at<cv::Vec3d>(10, 0)[1] - points3D2.at<cv::Vec3d>(0, 0)[1],
            points3D2.at<cv::Vec3d>(10, 0)[2] - points3D2.at<cv::Vec3d>(0, 0)[2]);
        cv::Vec3d Y2(points3D2.at<cv::Vec3d>(77, 0)[0] - points3D2.at<cv::Vec3d>(0, 0)[0],
            points3D2.at<cv::Vec3d>(77, 0)[1] - points3D2.at<cv::Vec3d>(0, 0)[1],
            points3D2.at<cv::Vec3d>(77, 0)[2] - points3D2.at<cv::Vec3d>(0, 0)[2]);
        /*cv::normalize(_X2, _X2, 1.0, 0, cv::NORM_L2);
        cv::normalize(_Y2, _Y2, 1.0, 0, cv::NORM_L2);*/

        cv::Vec3d Z2 = X2.cross(Y2);
        //归一化
        cv::normalize(X2, X2, 1.0, 0, cv::NORM_L2);
        cv::normalize(Y2, Y2, 1.0, 0, cv::NORM_L2);
        cv::normalize(Z2, Z2, 1.0, 0, cv::NORM_L2);





        cv::Mat R12 = (cv::Mat_<double>(3, 3) <<
            X2.dot(X1), Y2.dot(X1), Z2.dot(X1),
            X2.dot(Y1), Y2.dot(Y1), Z2.dot(Y1),
            X2.dot(Z1), Y2.dot(Z1), Z2.dot(Z1));

        // 计算欧拉角
        double sy = std::sqrt(R12.at<double>(0, 0) * R12.at<double>(0, 0) + R12.at<double>(1, 0) * R12.at<double>(1, 0));
        bool singular = sy < 1e-6; // 如果sy接近0，矩阵是奇异的

        double x, y, z;
        if (!singular) {
            x = std::atan2(R12.at<double>(2, 1), R12.at<double>(2, 2));
            y = std::atan2(-R12.at<double>(2, 0), sy);
            z = std::atan2(R12.at<double>(1, 0), R12.at<double>(0, 0));
        }
        else {
            x = std::atan2(-R12.at<double>(1, 2), R12.at<double>(1, 1));
            y = std::atan2(-R12.at<double>(2, 0), sy);
            z = 0;
        }

        double xdeg, ydeg, zdeg;
        xdeg = x * 180 / CV_PI;
        ydeg = y * 180 / CV_PI;
        zdeg = z * 180 / CV_PI;

        x_d.push_back(xdeg);
        y_d.push_back(ydeg);
        z_d.push_back(zdeg);
        /*
        // 水平拼接图像
        Mat result1;
        hconcat(image3, image4, result1);
        */
        /*
        // 构造DMatch对象
        std::vector<cv::DMatch> lrmatches;
        for (size_t i = 0; i < 3; i++) {
            lrmatches.push_back(cv::DMatch(i, i, 0));
        }

        // 转换为KeyPoint对象
        std::vector<cv::KeyPoint> keypointsl, keypointsr;
        
        keypointsl.push_back(cv::KeyPoint(corners3[0], 1.f));
        keypointsl.push_back(cv::KeyPoint(corners3[10], 1.f));
        keypointsl.push_back(cv::KeyPoint(corners3[77], 1.f));
        keypointsr.push_back(cv::KeyPoint(corners4[0], 1.f));
        keypointsr.push_back(cv::KeyPoint(corners4[10], 1.f));
        keypointsr.push_back(cv::KeyPoint(corners4[77], 1.f));
        // 绘制匹配结果
        cv::Mat img_matches;
        cv::drawMatches(image3, keypointsl, image4, keypointsr, lrmatches, img_matches);
        // 使用 putText 函数写入文字
        cv::putText(img_matches, "X:"+to_string(-xdeg), Point(2000, 50), FONT_HERSHEY_SIMPLEX, 2, Scalar(0, 0, 255), 3);
        cv::putText(img_matches, "Y:" + to_string(-ydeg), Point(2000, 100), FONT_HERSHEY_SIMPLEX, 2, Scalar(0, 0, 255), 3);
        cv::putText(img_matches, "Z:" + to_string(-zdeg), Point(2000, 150), FONT_HERSHEY_SIMPLEX, 2, Scalar(0, 0, 255), 3);
        // 将当前帧写入视频文件
        videoWriter.write(img_matches);
        */
        /*// 水平拼接图像
        Mat result2;
        hconcat(image1, image2, result2);
        Mat result3;
        vconcat(result1, result2, result3);
        */
        double dis = points3D1.at<cv::Vec3d>(0, 0)[2];


    }
    else {
        std::cerr << "未能检测到棋盘格角点！" << std::endl;
    }
    }
    //videoWriter.release();
    return 0;
}

传感器精度0.02°（不公布）

残月独悬
关注
  • 9
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
opencv双目视觉棋盘格标定，特征匹配点，三维坐标计算
04-25
总结来说，本教程涵盖了OpenCV中双目视觉的关键步骤，包括棋盘格标定以获取摄像头参数，特征匹配点的寻找，以及利用三角测量计算三维坐标。这些技术在机器人导航、自动驾驶、增强现实等领域有着广泛的应用。通过理解...
opencv生成棋盘格
m0_72429728的博客
12-13 841
我们对摄像头进行标定时，常会用到棋盘格图像。下面就给出一个生成棋盘格图像的opencv代码。cvSaveImage("棋盘格标定图.bmp",img);cvNamedWindow("棋盘格", 1);int dx=80;//棋盘格大小，像素为单位。cvShowImage("棋盘格",img);cvDestroyWindow("棋盘格");//---END生成标定图。//---生成标定图。
相机+棋盘格opencv-python标定生成yaml文件
大胡子大叔的专栏
06-09 1249
1、标定相机生成的yml代码2、棋盘格下载地址3、注意事项不想废话，直接上代码环境为opencv-python==4.7版本，python==3.9版本，棋盘格为9行6列，15mm格子的棋盘格。
OpenCVSharp 相机棋盘格校正
jimtien的专栏
07-22 2556
用OpenCVSharp 4.5跑一遍 OpenCV官方教程。 原OpenCV 官方教程链接：OpenCV: Camera calibration With OpenCV 这个教程的程序源码比较复杂，这里简化一下以集中精力在核心的校正部分：只限于用棋盘格图片校正，本来就少量几个参数直接写进程序里，免去xml文件读写的麻烦。 using System; using OpenCvSharp; using System.Linq; using System.Text; using System...
opencv c++实现棋盘格标定
qq_43468018的博客
06-23 3061
opencv实现相机标定
OpenCvSharp 棋盘格标定助手
Yoto_Jo的博客
06-05 3265
使用的是VS调用OpenCvSharp资源库进行一个Winform操作界面编写，网上找了很多开源的程序，发现根本用不了的，用的时候还需要你配置各种电脑系统变量，显得好麻烦。现在弄了个简单的标定助手，可以完美运行，带有棋盘格图像生成工具，操作简单，源码也不复杂。 使用了OpenCvSharp资源开发包，在VS下做了一个棋盘格图像下的相机标定助手小Demo，显然，C#也可以用OpenCv了。这是一个比较好的案例，可以参考下。鄙人不才，也用它做了一个SFM三维重建的Demo，这里就不放了。 using Op.
opencv寻找棋盘格简单使用
random_repick的专栏
03-30 4521
需要棋盘格周围有一圈白边 #include <opencv2/calib3d.hpp> #include <opencv2/opencv.hpp> #include <iostream> int main(int argc, char **argv) { // 内部角点的每行个数和每列个数，即黑色方块的交点 cv::Size pattern(8, 6); cv::Mat image = cv::imread(argv[1], 0); .
opencv4 findChessboardCornersSB 棋盘格角点提取
lita5906的博客
05-14 1万+
opencv4中全新的棋盘格角点提取函数findChessboardCornersSB函数用法简介官方文档介绍opencv4.1安装配置环境findChessboardCornersSB提取棋盘格角点示例程序 简介 用opencv相机标定一直不如matlab标定稳定和精度高。用opencv标定相机经常会发生棋盘格角点提取不到的现象，之前在做一个三维成像项目，需要比较高的成像精度，用opencv标定...
利用Python-OpenCV及PS制作棋盘格标定板
qq_43557907的博客
02-09 4450
Python代码 import cv2 import numpy as np # 定义棋盘格的尺寸 size = 140 # 定义标定板尺寸 boardx = size * 10 boardy = size * 7 canvas = np.zeros((boardy, boardx, 1), np.uint8) # 创建画布 for i in range(0, boardx): for j in range(0, boardy): if (int(i/size) + int(j/
OpenCV C++双目三维重建：双目摄像头实现双目测距
AI吃大瓜的博客
10-23 2万+
opencv C++实现双目测距，opencv三维重建，c++实现三维重建，双目测距，WLS滤波，opencv视差图
Opencv相机校准之棋盘格标定
热门推荐
y459541195的博客
03-02 2万+
Reference： https://yq.aliyun.com/articles/62472
OpenCV相机标定棋盘格
12-01
OpenCV（开源计算机视觉库）提供了丰富的功能来实现这一过程，而棋盘格作为相机标定的标准工具，被广泛应用于各种应用中，例如自动驾驶、无人机导航、机器人视觉和3D重建等。 首先，我们需要理解相机标定的基本概念...
qt opencv 棋盘格图片 棋盘格标定代码
01-16
本文将详细讲解如何利用OpenCV的棋盘格标定功能与Qt结合，实现摄像头的校准，以及相关的编程知识。 首先，棋盘格图片是OpenCV进行摄像头标定的重要工具。它由一系列相同大小的正方形组成，通常是黑白相间的，用于...
棋盘格INI.zip_OpenCV 标定_棋盘格_棋盘格标定_相机标定
07-15
本资源"棋盘格INI.zip"提供了用于OpenCV相机标定的一个自定义棋盘格生成程序，结合视频截图和OpenCV自带的标定例程，可以有效地完成相机标定过程。 OpenCV（Open Source Computer Vision Library）是一个开源的...
idea导入opencv和mediapipe
wangwei的博客
07-01 257
1.参考2.pip install opencv-python。
Python + OpenCV 酷游地址教学V鄋KWK3589
最新发布
KUBET9的博客
07-01 425
OpenCV 安装完成后，将一张测试的图片放到指定位置( 范例中将图片和Python 程式码放在同一格资料夹里)，执行下方程式码，就会开启图片指定的图片，如果可以看到图片，表示OpenCV 已经可以正常运作( 点击开启的视窗后，按下键盘的q 可以关闭图片)。OpenCV 是一个跨平台的电脑视觉函式库( 模组) ，可应用于脸部辨识、手势辨识、图像分割...等影像辨识相关的领域，这篇教学将会简单介绍OpenCV 函式库，以及使用Anaconda 安装OpenCV 函式库。安装OpenCV 函式库。
OPENCV清晰度判断(二)
新兴IT民工的专栏
06-28 1214
这一篇里面主要说的是用sobel算子，或者是拉普拉斯算子来进行梯度的计算，根据清晰的图像梯度更大的逻辑来判断图像的清晰度。不过这种算法有一个问题，就是整个图像是有足够的信息来提供梯度，或者换句话说，图像大部分区域都是有效区域。在实际项目中，碰到一种拍摄细胞的情况，需要对细胞对焦过程中的图像进行清晰度判断：对于这种情况，直接计算图像的梯度，是不太有效果的，因为整个图像大部分区域的梯度都是一样的(模糊的，清晰的，只有小部分区域会有一些梯度差别)，所以直接计算整图的梯度方式是无效的。
3.opencv读取本地视频或摄像头并修改编码
qq_62943420的博客
06-29 272
【代码】3.opencv读取本地视频或摄像头并修改编码。
【opencv学习】完全基于opencv的双目景深与测距的实现
11-23
通过学习opencv和双目测距的原理，并实际动手进行实践，我深刻理解了双目测距的基本原理和实现过程。通过对两个摄像头的图像进行处理和匹配，我们可以得到场景中物体的距离信息。这对于许多应用来说是非常有价值的，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

残月独悬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值