精华内容
下载资源
问答
  • python opencv 双目测距代码
    千次阅读
    2019-05-21 19:56:34

    最近高摄像头项目,顺便扩展学习python+opencv的图片处理和视频处理。

    拍照效果:

     

    代码:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    import cv2
    import time
    
    AUTO = True  # 自动拍照,或手动按s键拍照
    INTERVAL = 2 # 自动拍照间隔
    
    cv2.namedWindow("left")
    cv2.namedWindow("right")
    cv2.moveWindow("left", 0, 0)
    cv2.moveWindow("right", 400, 0)
    left_camera = cv2.VideoCapture(0)
    #cv2.waitKey(50)
    #left_camera.set(cv2.CV_CAP_PROP_FRAME_WIDTH,320)
    #left_camera.set(cv2.CV_CAP_PROP_FRAME_HEIGHT,240)
    right_camera = cv2.VideoCapture(1)
    #right_camera.set(cv2.CV_CAP_PROP_FRAME_WIDTH,320)
    #right_camera.set(cv2.CV_CAP_PROP_FRAME_HEIGHT,240)
    
    counter = 0
    utc = time.time()
    pattern = (12, 8) # 棋盘格尺寸
    folder = "./snapshot/" # 拍照文件目录
    
    def shot(pos, frame):
        global counter
        path = folder + pos + "_" + str(counter) + ".jpg"
    
        cv2.imwrite(path, frame)
        print("snapshot saved into: " + path)
    
    while True:
        ret, left_frame = left_camera.read()
        ret, right_frame = right_camera.read()
    
        cv2.imshow("left", left_frame)
        cv2.imshow("right", right_frame)
    
        now = time.time()
        if AUTO and now - utc >= INTERVAL:
            shot("left", left_frame)
            shot("right", right_frame)
            counter += 1
            utc = now
    
        key = cv2.waitKey(1)
        if key == ord("q"):
            break
        elif key == ord("s"):
            shot("left", left_frame)
            shot("right", right_frame)
            counter += 1
    
    left_camera.release()
    right_camera.release()
    cv2.destroyWindow("left")
    cv2.destroyWindow("right")

     

    更多相关内容
  • 基于C++的双摄像头的立体双目测距算法。可以实现对物体目标的捕捉 。
  • 双目测距代码 python opencv 利用双目摄像头拍照,测距

    万次阅读 热门讨论 2018-03-19 22:33:03
    好久没有写博客了,手都感觉好生疏,最近一直在研究工控机,水下机器人等,好不容易闲下来,没办法呀,继续前行吧,前面一直说双目测距,但没有高速大家如何获得这个双目标注得图像,我在这把这代码贴一下吧,获得...

    环境:ubuntu14.04
    软件:opencv3.3 +pycharm
    好久没有写博客了,手都感觉好生疏,最近一直在研究工控机,水下机器人等,好不容易闲下来,没办法呀,继续前行吧,前面一直说双目测距,但没有高速大家如何获得这个双目标注得图像,我在这把这代码贴一下吧,获得这些双目拍摄的图片就可以利用matlab和opencv进行标注了。

    小编查了网上好多代码,在利用双目摄像头i实现拍照得时候总是出线黑框,无法获取图片,经过修改之后,我将代码改成了自动拍照或者按键S进行拍照
    不多说,看看效果吧

    这里写图片描述

    这里写图片描述

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    import cv2
    import time
    
    AUTO = True  # 自动拍
    展开全文
  • Python-OpenCV双目测距代码实现以及参数解读

    万次阅读 多人点赞 2021-04-16 16:22:43
    1、双目相机拍照后使用Matlab进行双目标定 主要参考:https://blog.csdn.net/dulingwen/article/details/98071584 感谢大佬的分享!!!(*≧ω≦)!! Python-openCV 中cv2.StereoSGBM_create()参数的含义 参考:...

    一、双目相机拍照后使用Matlab进行双目标定

    必看: USB双目相机的具体标定过程:https://blog.csdn.net/qq_40700822/article/details/124251201?spm=1001.2014.3001.5501

    主要参考:https://blog.csdn.net/dulingwen/article/details/98071584
    感谢大佬的分享!!!(*≧ω≦)!!

    二、标定后生成深度图,之后在进行测距

    1、导入相关库和相机的标定参数

    首先导入需要的相关库以及双目相机标定的各项参数:

     # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import stereoconfig_040_2 #导入相机标定的参数
    import pcl
    import pcl.pcl_visualization
    

    首先对导入的左右相机的图片进行预处理,一般可以削弱光照不均的影响,使得两个图片的曝光值差距缩小。
    小知识:python-opencv读取的灰度图像是二维列表(数组),彩色图像是三位列表(数组)。
    .ndim返回的是数组的维度,返回的只有一个数,该数即表示数组的维度。
    参考:https://blog.csdn.net/mokeding/article/details/17599585

    #像素的访问和访问numpy中ndarray的方法完全一样
    img[j,i] = 255  # 灰度图访问;j,i 分别表示图像的行和列 即 j * i 二维
     
    #BGR 图像访问 彩色 BGR 图像 为 j * i * 3 三维
    img[j,i,0] = 255   # 0 -- 为通道,指B通道
    img[j,i,1] = 255   # 1 -- 为通道,指G通道
    img[j,i,2] = 255   # 2 -- 为通道,指R通道
    

    2、图像预处理

    # 预处理
    def preprocess(img1, img2):
        # 彩色图->灰度图
        if(img1.ndim == 3): #判断是否为三维数组
            img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)  # 通过OpenCV加载的图像通道顺序是BGR
        if(img2.ndim == 3):#判断是否为三维数组
            img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
        # 直方图均衡
        # 当然这里也可以按需对图像进行处理
        img1 = cv2.equalizeHist(img1)
        img2 = cv2.equalizeHist(img2)
    
        return img1, img2
    

    3、消除图像的畸变

    cv.undistort()消除畸变函数参数含义
    参考OpenCV官网:https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga69f2545a8b62a6b0fc2ee060dc30559d

    cv.undistort(	src, cameraMatrix, distCoeffs[, dst[, newCameraMatrix]]	) ->	dst
    

    各个参数的含义:

    参数名含义
    src输入未畸变矫正的图片
    dst输出矫正之后的图片,与src输入的图片具有相同的大小和类型
    cameraMatrix输入相机的内参数矩阵 A = [ [fx, 0, cx], [0, fy, cy], [0, 0, 1] ]
    distCoeffs输入相机的畸变参数向量 ( (k1,k2,p1,p2[,k3[,k4,k5,k6[,s1,s2,s3,s4[,τx,τy ] ] ] ] ) )中的4, 5, 8, 12 或 14 个元素。如果向量为NULL /空,则假定失真系数为零。一般取标定后相机的[k1, k2, p1, p2, k3]
    newCameraMatrix畸变图像的相机矩阵。 默认情况下,它与cameraMatrix相同,但是您还可以使用其他矩阵来缩放和移动结果。

    消除畸变函数的定义:

    # 消除畸变
    def undistortion(image, camera_matrix, dist_coeff):
        undistortion_image = cv2.undistort(image, camera_matrix, dist_coeff)
    
        return undistortion_image
    

    调用示例,不能直接使用(stereoconfig_040_2.py完整代码见文末):

     # 读取相机内参和外参
    config = stereoconfig_040_2.stereoCamera()
    i = 3
    string = 'Val'
    # 读取数据集的图片
    iml = cv2.imread('./%sLeft%d.bmp' %(string,i) )  # 左图
    imr = cv2.imread('./%sRight%d.bmp'%(string,i) )  # 右图
    iml = undistortion(iml, config.cam_matrix_left, config.distortion_l)
    imr = undistortion(imr, config.cam_matrix_right, config.distortion_r)
    
    #cv2.undistort()的dist_coeff参数的形式
    # 左右相机畸变系数:[k1, k2, p1, p2, k3]
    #config.distortion_l = np.array([[-0.0806, 0.3806, -0.0033, 0.0005148, -0.5229]])
    #config.distortion_r = np.array([[-0.0485, 0.2200, -0.002,  0.0017,    -0.2876]])
    

    4、立体校正

    
    # 获取畸变校正和立体校正的映射变换矩阵、重投影矩阵
    # @param:config是一个类,存储着双目标定的参数:config = stereoconfig.stereoCamera()
    def getRectifyTransform(height, width, config):
        # 读取内参和外参
        left_K = config.cam_matrix_left
        right_K = config.cam_matrix_right
        left_distortion = config.distortion_l
        right_distortion = config.distortion_r
        R = config.R
        T = config.T
    
        # 计算校正变换
        R1, R2, P1, P2, Q, roi1, roi2 = cv2.stereoRectify(left_K, left_distortion, right_K, right_distortion, 
                                                        (width, height), R, T, alpha=0)
    
        map1x, map1y = cv2.initUndistortRectifyMap(left_K, left_distortion, R1, P1, (width, height), cv2.CV_32FC1)
        map2x, map2y = cv2.initUndistortRectifyMap(right_K, right_distortion, R2, P2, (width, height), cv2.CV_32FC1)
    
        return map1x, map1y, map2x, map2y, Q
    
    
    

    cv.stereoRectify()参数含义:
    官网定义的形式:

    cv.stereoRectify(
    cameraMatrix1, 
    distCoeffs1, 
    cameraMatrix2, 
    distCoeffs2, 
    imageSize, 
    R, 
    T[, R1
     [, R2
     [, P1
     [, P2
     [, Q
     [, flags
     [, alpha
     [, newImageSize]]]]]]]]	
     ) ->	R1, R2, P1, P2, Q, validPixROI1, validPixROI2
    

    cv.stereoRectify()参数的含义:

    参数名含义
    cameraMatrix1第一个相机的内参数矩阵。
    distCoeffs1第一个相机的畸变参数。
    cameraMatrix2第二个相机的内参数矩阵。
    distCoeffs2第二个相机的畸变参数。
    imageSize双目相机标定的图像的尺寸大小。
    R从第一个摄像头的坐标系到第二个摄像头的坐标系的旋转矩阵,请参见stereoCalibrate。(输出旋转矩阵。连同平移矢量T一起,此矩阵将第一个摄像机坐标系中给定的点带到第二个摄像机坐标系中的点。用更专业的术语来说,R和T的元组执行的基础是从第一相机的坐标系到第二相机的坐标系的变化。由于其二元性,该元组等效于第一摄像机相对于第二摄像机坐标系的位置。)
    T(输出转换向量,请参见上面的描述。)从第一个摄像机的坐标系到第二个摄像机的坐标系的平移向量,请参见stereoCalibrate
    R1为第一个摄像机输出3x3立体矫正的变换(旋转矩阵)。 该矩阵将未校正的第一照相机的坐标系中给定的点带到校正的第一照相机的坐标系中的点。 用更多的专业术语来说就是,它执行了从未校正的第一摄像机的坐标系到校正了的第一摄像机的坐标系的基准的更改。
    R2为第二个摄像机输出3x3立体矫正的变换(旋转矩阵)。 该矩阵将未校正的第二照相机的坐标系中给定的点带到校正的第二照相机的坐标系中的点。 用更多的专业术语来说就是,它执行了从未校正的第二摄像机的坐标系到校正了的第二摄像机的坐标系的基准的更改。
    P1在第一个摄像机的新(校正)坐标系中输出3x4投影矩阵,即它将在校正后的第一摄像机坐标系中给定的点,投影到校正后的第一摄像机的图像中。
    P2在第二个摄像机的新(校正)坐标系中输出3x4投影矩阵,即它将在校正后的第二摄像机坐标系中给定的点,投影到校正后的第二摄像机的图像中。
    Q输出4×4视差深度映射矩阵(请参阅reprojectImageTo3D)。
    flags可能为零或CALIB_ZERO_DISPARITY的操作标志。如果设置了该标志,则该功能使每个摄像机的主要的像素点在校正后的视图中具有相同的像素坐标。并且,如果未设置该标志,则该功能仍可以在水平或垂直方向上移动图像(取决于对极线的方向),以最大化可用图像区域。
    alpha自由缩放参数。如果它是-1或缺省,则该函数将执行默认缩放。否则,该参数应在0到1之间。alpha = 0表示对校正的图像已经经过缩放和移动了,以便仅有效像素可见(在校正之后的非黑色区域)。 alpha = 1表示对校正后的图像进行抽取和移位,以便将来自摄像机的原始图像中的所有像素保留在校正后的图像中(不丢失任何源图像像素)。任何中间值(0~1)都会在这两种极端情况之间产生中间结果。
    newImageSize校正后的新图像的分辨率。应将相同的大小传递给initUndistortRectifyMap(请参阅OpenCV示例目录中的stereo_calib.cpp示例)。传递(0,0)(默认值)时,将其设置为原始imageSize。将其设置为较大的值可以帮助您保留原始图像中的细节,尤其是在径向变形较大的情况下。
    validPixROI1在所有像素均有效的已校正图像内的可选输出矩形。如果alpha = 0,则ROI覆盖整个图像。否则,它们可能会更小(请参见下图)。
    validPixROI2在所有像素均有效的已校正图像内的可选输出矩形。如果alpha = 0,则ROI覆盖整个图像。否则,它们可能会更小(请参见下图)。
    cv.initUndistortRectifyMap()函数的定义:
    cv.initUndistortRectifyMap(	
    cameraMatrix, 
    distCoeffs, 
    R, 
    newCameraMatrix, 
    size, 
    m1type[, map1
    	  [, map2]
    	  ]	
      ) ->	map1, map2
    

    cv.initUndistortRectifyMap()函数各个参数的含义:
    参考OpenCV官网:
    https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga7dfb72c9cf9780a347fbe3d1c47e5d5a

    参数名含义
    cameraMatrix相机的内参数矩阵。
    distCoeffs输入相机的畸变参数向量 (一般取标定后相机的[k1, k2, p1, p2, k3] )。
    R对象空间中的可选的校正变换(3x3矩阵)。由stereoRectify计算的R1或R2可以在此处传递。如果矩阵为空,则假定身份转换。在cvInitUndistortMap中,R是一个单位矩阵。
    newCameraMatrix新相机内参数的矩阵。
    size未校正的图片的尺寸。
    m1type第一个输出映射的类型可以是CV_32FC1,CV_32FC2或CV_16SC2,请参见convertMaps
    map1第一个输出图。
    map2第二个输出图。

    5、视差计算

    # 视差计算
    def stereoMatchSGBM(left_image, right_image, down_scale=False):
        # SGBM匹配参数设置
        if left_image.ndim == 2:
            img_channels = 1
        else:
            img_channels = 3
            
        blockSize = 3
        paraml = {'minDisparity': 0,
                 'numDisparities': 128,
                 'blockSize': blockSize,
                 'P1': 8 * img_channels * blockSize ** 2,
                 'P2': 32 * img_channels * blockSize ** 2,
                 'disp12MaxDiff': 1,
                 'preFilterCap': 63,
                 'uniquenessRatio': 15,
                 'speckleWindowSize': 100,
                 'speckleRange': 1,
                 'mode': cv2.STEREO_SGBM_MODE_SGBM_3WAY
                 }
    
        # 构建SGBM对象
        left_matcher = cv2.StereoSGBM_create(**paraml)
        paramr = paraml
        paramr['minDisparity'] = -paraml['numDisparities']
        right_matcher = cv2.StereoSGBM_create(**paramr)
    
        # 计算视差图
        size = (left_image.shape[1], left_image.shape[0])
        if down_scale == False:
            disparity_left = left_matcher.compute(left_image, right_image)
            disparity_right = right_matcher.compute(right_image, left_image)
    
        else:
            left_image_down = cv2.pyrDown(left_image)
            right_image_down = cv2.pyrDown(right_image)
            factor = left_image.shape[1] / left_image_down.shape[1]
    
            disparity_left_half = left_matcher.compute(left_image_down, right_image_down)
            disparity_right_half = right_matcher.compute(right_image_down, left_image_down)
            disparity_left = cv2.resize(disparity_left_half, size, interpolation=cv2.INTER_AREA)
            disparity_right = cv2.resize(disparity_right_half, size, interpolation=cv2.INTER_AREA)
            disparity_left = factor * disparity_left
            disparity_right = factor * disparity_right
    
        # 真实视差(因为SGBM算法得到的视差是×16的)
        trueDisp_left = disparity_left.astype(np.float32) / 16.
        trueDisp_right = disparity_right.astype(np.float32) / 16.
    
        return trueDisp_left, trueDisp_right
    
    

    Python-openCV 中cv2.StereoSGBM_create()参数的含义:

    参考:https://docs.opencv.org/trunk/d2/d85/classcv_1_1StereoSGBM.html
    参考OpenCV官网:https://docs.opencv.org/trunk/d2/d85/classcv_1_1StereoSGBM.html
    cv2.StereoSGBM_create()的SGBM算法的定义:

    cv2.StereoSGBM_create(
    [,minDisparity 
    [,numDisparities 
    [,blockSize 
    [,P1 
    [,P2 
    [,disp12MaxDiff 
    [,preFilterCap 
    [,uniquenessRatio 
    [,speckleWindowSize 
    [,speckleRange 
    [,mode]]]]]]]]]]]]
    )
    

    各个参数的含义:

    参数名含义
    minDisparity最小可能的差异值。通常情况下,它是零,但有时整流算法可能会改变图像,所以这个参数需要作相应的调整。
    numDisparities最大差异减去最小差异。该值总是大于零。在当前的实现中,该参数必须可以被16整除。
    blockSize匹配的块大小。它必须是> = 1的奇数。通常情况下,它应该在3~11的范围内。
    P1控制视差平滑度的第一个参数。见下文。
    P2第二个参数控制视差平滑度。值越大,差异越平滑。P1是相邻像素之间的视差变化加或减1的惩罚。P2是相邻像素之间的视差变化超过1的惩罚。该算法需要P2> P1。请参见stereo_match.cpp示例,其中显示了一些相当好的P1和P2值(即分别设置为 P1 = 8 * number_of_image_channels * blockSize * blockSize和 P2 = 32 * number_of_image_channels * blockSize * blockSize)。
    disp12MaxDiff左右视差检查中允许的最大差异(以整数像素为单位)。将其设置为非正值以禁用检查。
    preFilterCap预滤波图像像素的截断值。该算法首先计算每个像素的x导数,并通过[-preFilterCap,preFilterCap]间隔剪切其值。结果值传递给Birchfield-Tomasi像素成本函数。
    uniquenessRatio最佳(最小)计算成本函数值应该“赢”第二个最佳值以考虑找到的匹配正确的百分比保证金。通常,5-15范围内的值就足够了。
    speckleWindowSize平滑视差区域的最大尺寸,以考虑其噪声斑点和无效。将其设置为0可禁用斑点过滤。否则,将其设置在50-200的范围内。
    speckleRange每个连接组件内的最大视差变化。如果你做斑点过滤,将参数设置为正值,它将被隐式乘以16.通常,1或2就足够好了。
    mode将其设置为StereoSGBM :: MODE_HH以运行全尺寸双通道动态编程算法。它将消耗O(W * H * numDisparities)字节,这对640x480立体声很大,对于HD尺寸的图片很大。默认情况下,它被设置为false。

    Python-openCV 中cv2.pyrDown()中的参数和含义:
    参考OpenCV官网:https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaf9bba239dfca11654cb7f50f889fc2ff

    cv.pyrDown(	src[, dst[, dstsize[, borderType]]]	) ->	dst
    
    参数名含义
    src输入图像
    dst输出图像;与上面的输入图像具有相同的尺寸大小和类型
    dstsize输出图像的大小
    borderType像素外推方法,请参见BorderTypes(不支持BORDER_CONSTANT

    6、其他函数的参数以及含义

    reprojectImageTo3D的定义:

    cv.reprojectImageTo3D(	
    disparity, 
    Q
    [, _3dImage
    [, handleMissingValues
    [, ddepth]]]	
     ) ->	_3dImage
    

    cv2.reprojectImageTo3D()参数以及其含义:
    参考官网:https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga1bc1152bd57d63bc524204f21fde6e02

    参数名含义
    disparity输入单通道8位无符号,16位有符号,32位有符号或32位浮点视差图像。 假定8位/ 16位带符号格式的值没有小数位。 如果视差是由StereoBM或StereoSGBM以及其他算法计算出的16位带符号格式,则应在此处使用之前将其除以16(并缩放为浮点数)。
    _3dImage输出与视差大小相同的3通道浮点图像。 _3dImage(x,y)的每个元素都包含根据视差图计算的点(x,y)的3D坐标。 如果使用通过stereoRectify获得的Q,则返回的点将在第一个摄像机的校正坐标系中表示。
    Q可以使用stereoRectify获得的4×4透视变换矩阵。
    handleMissingValues指示函数是否应处理缺失值(即未计算视差的点)。如果handleMissingValues = true,则具有与异常值相对应的最小视差的像素(请参见StereoMatcher :: compute)将转换为Z值非常大(当前设置为10000)的3D点。
    ddepth可选的输出数组深度。如果为-1,则输出图像将具有CV_32F深度。 ddepth也可以设置为CV_16S,CV_32S或CV_32F。

    三、双目测距代码的实现

    1、stereoconfig_040_2.py–相机标定的参数

    import numpy as np
    
    
    ####################仅仅是一个示例###################################
    
    
    # 双目相机参数
    class stereoCamera(object):
        def __init__(self):
            # 左相机内参
            self.cam_matrix_left = np.array([   [830.5873,   -3.0662,  658.1007],
                                                [       0,  830.8116,  482.9859],
                                                [       0,         0,         1]
                                            ])
            # 右相机内参
            self.cam_matrix_right = np.array([  [830.4255,   -3.5852,  636.8418],
                                                [       0,  830.7571,  476.0664],
                                                [       0,         0,         1]
                                            ])
    
            # 左右相机畸变系数:[k1, k2, p1, p2, k3]
            self.distortion_l = np.array([[-0.0806, 0.3806, -0.0033, 0.0005148, -0.5229]])
            self.distortion_r = np.array([[-0.0485, 0.2200, -0.002,  0.0017,    -0.2876]])
    
            # 旋转矩阵
            self.R = np.array([ [      1,  0.0017, -0.0093],
                                [-0.0018,  1.0000, -0.0019],
                                [ 0.0093,  0.0019,  1.0000]   
                                ])
    
            # 平移矩阵
            self.T = np.array([[-119.9578], [0.1121], [-0.2134]])
    
            # 焦距
            self.focal_length = 859.367 # 默认值,一般取立体校正后的重投影矩阵Q中的 Q[2,3]
    
            # 基线距离
            self.baseline = 119.9578 # 单位:mm, 为平移向量的第一个参数(取绝对值)
    
           
    
    
    

    2、dianyuntu.py–测距实现代码

     # -*- coding: utf-8 -*-
    import cv2
    import numpy as np
    import stereoconfig_040_2   #导入相机标定的参数
    import pcl
    import pcl.pcl_visualization
    
    
    # 预处理
    def preprocess(img1, img2):
        # 彩色图->灰度图
        if(img1.ndim == 3):#判断为三维数组
            img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)  # 通过OpenCV加载的图像通道顺序是BGR
        if(img2.ndim == 3):
            img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
        # 直方图均衡
        img1 = cv2.equalizeHist(img1)
        img2 = cv2.equalizeHist(img2)
    
        return img1, img2
    
    
    # 消除畸变
    def undistortion(image, camera_matrix, dist_coeff):
        undistortion_image = cv2.undistort(image, camera_matrix, dist_coeff)
    
        return undistortion_image
    
    
    # 获取畸变校正和立体校正的映射变换矩阵、重投影矩阵
    # @param:config是一个类,存储着双目标定的参数:config = stereoconfig.stereoCamera()
    def getRectifyTransform(height, width, config):
        # 读取内参和外参
        left_K = config.cam_matrix_left
        right_K = config.cam_matrix_right
        left_distortion = config.distortion_l
        right_distortion = config.distortion_r
        R = config.R
        T = config.T
    
        # 计算校正变换
        R1, R2, P1, P2, Q, roi1, roi2 = cv2.stereoRectify(left_K, left_distortion, right_K, right_distortion, 
                                                        (width, height), R, T, alpha=0)
    
        map1x, map1y = cv2.initUndistortRectifyMap(left_K, left_distortion, R1, P1, (width, height), cv2.CV_32FC1)
        map2x, map2y = cv2.initUndistortRectifyMap(right_K, right_distortion, R2, P2, (width, height), cv2.CV_32FC1)
    
        return map1x, map1y, map2x, map2y, Q
    
    
    # 畸变校正和立体校正
    def rectifyImage(image1, image2, map1x, map1y, map2x, map2y):
        rectifyed_img1 = cv2.remap(image1, map1x, map1y, cv2.INTER_AREA)
        rectifyed_img2 = cv2.remap(image2, map2x, map2y, cv2.INTER_AREA)
    
        return rectifyed_img1, rectifyed_img2
    
    
    # 立体校正检验----画线
    def draw_line(image1, image2):
        # 建立输出图像
        height = max(image1.shape[0], image2.shape[0])
        width = image1.shape[1] + image2.shape[1]
    
        output = np.zeros((height, width, 3), dtype=np.uint8)
        output[0:image1.shape[0], 0:image1.shape[1]] = image1
        output[0:image2.shape[0], image1.shape[1]:] = image2
    
        # 绘制等间距平行线
        line_interval = 50  # 直线间隔:50
        for k in range(height // line_interval):
            cv2.line(output, (0, line_interval * (k + 1)), (2 * width, line_interval * (k + 1)), (0, 255, 0), thickness=2, lineType=cv2.LINE_AA)
    
        return output
    
    
    # 视差计算
    def stereoMatchSGBM(left_image, right_image, down_scale=False):
        # SGBM匹配参数设置
        if left_image.ndim == 2:
            img_channels = 1
        else:
            img_channels = 3
        blockSize = 3
        paraml = {'minDisparity': 0,
                 'numDisparities': 128,
                 'blockSize': blockSize,
                 'P1': 8 * img_channels * blockSize ** 2,
                 'P2': 32 * img_channels * blockSize ** 2,
                 'disp12MaxDiff': 1,
                 'preFilterCap': 63,
                 'uniquenessRatio': 15,
                 'speckleWindowSize': 100,
                 'speckleRange': 1,
                 'mode': cv2.STEREO_SGBM_MODE_SGBM_3WAY
                 }
    
        # 构建SGBM对象
        left_matcher = cv2.StereoSGBM_create(**paraml)
        paramr = paraml
        paramr['minDisparity'] = -paraml['numDisparities']
        right_matcher = cv2.StereoSGBM_create(**paramr)
    
        # 计算视差图
        size = (left_image.shape[1], left_image.shape[0])
        if down_scale == False:
            disparity_left = left_matcher.compute(left_image, right_image)
            disparity_right = right_matcher.compute(right_image, left_image)
    
        else:
            left_image_down = cv2.pyrDown(left_image)
            right_image_down = cv2.pyrDown(right_image)
            factor = left_image.shape[1] / left_image_down.shape[1]
    
            disparity_left_half = left_matcher.compute(left_image_down, right_image_down)
            disparity_right_half = right_matcher.compute(right_image_down, left_image_down)
            disparity_left = cv2.resize(disparity_left_half, size, interpolation=cv2.INTER_AREA)
            disparity_right = cv2.resize(disparity_right_half, size, interpolation=cv2.INTER_AREA)
            disparity_left = factor * disparity_left
            disparity_right = factor * disparity_right
    
        # 真实视差(因为SGBM算法得到的视差是×16的)
        trueDisp_left = disparity_left.astype(np.float32) / 16.
        trueDisp_right = disparity_right.astype(np.float32) / 16.
    
        return trueDisp_left, trueDisp_right
    
    
    # 将h×w×3数组转换为N×3的数组
    def hw3ToN3(points):
        height, width = points.shape[0:2]
    
        points_1 = points[:, :, 0].reshape(height * width, 1)
        points_2 = points[:, :, 1].reshape(height * width, 1)
        points_3 = points[:, :, 2].reshape(height * width, 1)
    
        points_ = np.hstack((points_1, points_2, points_3))
    
        return points_
    
    
    # 深度、颜色转换为点云
    def DepthColor2Cloud(points_3d, colors):
        rows, cols = points_3d.shape[0:2]
        size = rows * cols
    
        points_ = hw3ToN3(points_3d)
        colors_ = hw3ToN3(colors).astype(np.int64)
    
        # 颜色信息
        blue = colors_[:, 0].reshape(size, 1)
        green = colors_[:, 1].reshape(size, 1)
        red = colors_[:, 2].reshape(size, 1)
    
        rgb = np.left_shift(blue, 0) + np.left_shift(green, 8) + np.left_shift(red, 16)
    
        # 将坐标+颜色叠加为点云数组
        pointcloud = np.hstack((points_, rgb)).astype(np.float32)
    
        # 删掉一些不合适的点
        X = pointcloud[:, 0]
        Y = -pointcloud[:, 1]
        Z = -pointcloud[:, 2]
    
        remove_idx1 = np.where(Z <= 0)
        remove_idx2 = np.where(Z > 15000)
        remove_idx3 = np.where(X > 10000)
        remove_idx4 = np.where(X < -10000)
        remove_idx5 = np.where(Y > 10000)
        remove_idx6 = np.where(Y < -10000)
        remove_idx = np.hstack((remove_idx1[0], remove_idx2[0], remove_idx3[0], remove_idx4[0], remove_idx5[0], remove_idx6[0]))
    
        pointcloud_1 = np.delete(pointcloud, remove_idx, 0)
    
        return pointcloud_1
    
    
    # 点云显示
    def view_cloud(pointcloud):
        cloud = pcl.PointCloud_PointXYZRGBA()
        cloud.from_array(pointcloud)
    
        try:
            visual = pcl.pcl_visualization.CloudViewing()
            visual.ShowColorACloud(cloud)
            v = True
            while v:
                v = not (visual.WasStopped())
        except:
            pass
    
    
    if __name__ == '__main__':
    
        i = 3
        string = 're'
        # 读取数据集的图片
        iml = cv2.imread('./%sLift%d.bmp' %(string,i) )  # 左图
        imr = cv2.imread('./%sRight%d.bmp'%(string,i) ) # 右图
        height, width = iml.shape[0:2]
    
        print("width = %d \n"  % width)
        print("height = %d \n" % height)
        
    
        # 读取相机内参和外参
        config = stereoconfig_040_2.stereoCamera()
    
        # 立体校正
        map1x, map1y, map2x, map2y, Q = getRectifyTransform(height, width, config)  # 获取用于畸变校正和立体校正的映射矩阵以及用于计算像素空间坐标的重投影矩阵
        iml_rectified, imr_rectified = rectifyImage(iml, imr, map1x, map1y, map2x, map2y)
    
        print("Print Q!")
        print(Q)
    
        # 绘制等间距平行线,检查立体校正的效果
        line = draw_line(iml_rectified, imr_rectified)
        cv2.imwrite('./%s检验%d.png' %(string,i), line)
    
        # 消除畸变
        iml = undistortion(iml, config.cam_matrix_left, config.distortion_l)
        imr = undistortion(imr, config.cam_matrix_right, config.distortion_r)
    
        # 立体匹配
        iml_, imr_ = preprocess(iml, imr)  # 预处理,一般可以削弱光照不均的影响,不做也可以
    
        iml_rectified_l, imr_rectified_r = rectifyImage(iml_, imr_, map1x, map1y, map2x, map2y)
    
        disp, _ = stereoMatchSGBM(iml_rectified_l, imr_rectified_r, True) 
        cv2.imwrite('./%s视差%d.png' %(string,i), disp)
    
        
    
        # 计算像素点的3D坐标(左相机坐标系下)
        points_3d = cv2.reprojectImageTo3D(disp, Q)  # 可以使用上文的stereo_config.py给出的参数
    
        #points_3d = points_3d
    
            # 鼠标点击事件
        def onMouse(event, x, y, flags, param):
            if event == cv2.EVENT_LBUTTONDOWN:
                print('点 (%d, %d) 的三维坐标 (%f, %f, %f)' % (x, y, points_3d[y, x, 0], points_3d[y, x, 1], points_3d[y, x, 2]))
                dis = ( (points_3d[y, x, 0] ** 2 + points_3d[y, x, 1] ** 2 + points_3d[y, x, 2] **2) ** 0.5) / 1000
                print('点 (%d, %d) 距离左摄像头的相对距离为 %0.3f m' %(x, y, dis) )
    
            # 显示图片
        cv2.namedWindow("disparity",0)
        cv2.imshow("disparity", disp)
        cv2.setMouseCallback("disparity", onMouse, 0)
    
        
    
        # 构建点云--Point_XYZRGBA格式
        pointcloud = DepthColor2Cloud(points_3d, iml)
    
        # 显示点云
        view_cloud(pointcloud)
    
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    

    3、代码打包下载地址

    本人瞎写的代码,如有错误,还请见谅!
    https://download.csdn.net/download/qq_40700822/18378679

    4、查看实现的效果

    直接使用python运行上边打包的代码的dianyuntu.py即可,如果报错,就是环境没有搭建好,自行解决吧。

    PS. 我的摄像头的分辨率是1920*720,所以效果一般。
    得到的视差图:
    在这里插入图片描述
    得到的点云图:
    在这里插入图片描述

    展开全文
  • python、opencv 双目视觉测距代码

    千次阅读 2021-02-05 07:52:25
    两个部分,一个是相机的参数设置,一个是测距运用matlab里面的stereo Camera Calibrator APP进行拍照 拍个30多张,然后拉线,留个10-20张进行计算,把双目摄像机的数据填到camera_configs.py里面camera_configs.py...

    傻瓜版,拿个双目摄像头,标定,得到数据,填进去,调调参数。

    两个部分,一个是相机的参数设置,一个是测距

    运用matlab里面的stereo Camera Calibrator APP进行拍照

    a089fdbcf480b4e99807679884cacc24.png

    拍个30多张,然后拉线,留个10-20张进行计算,把双目摄像机的数据填到camera_configs.py里面

    camera_configs.py

    from cv2 import cv2

    import numpy as np

    left_camera_matrix = np.array([[ 392.9351, 0.1468, 310.0016],

    [0, 393.6869, 279.4163],

    [0., 0., 1.]])

    left_distortion = np.array([[0.0396, -0.0643, 0.0038, 0.0013, 0.0370]])

    right_camera_matrix = np.array([[ 393.0777, 0.4140, 344.1193],

    [ 0, 394.0348, 242.2463],

    [ 0, 0, 1.0000]])

    right_distortion = np.array([[0.0503, -0.0820, 0.0045, 0.0014, 0.0571]])

    R = np.matrix([

    [ 1.0000, 0.0014, 0.0033],

    [-0.0014, 1.0000, 0.0020],

    [-0.0033, -0.0020, 1.0000],

    ])

    # print(R)

    T = np.array([-18.1454, -0.3016, 0.4750]) # 平移关系向量

    size = (640, 480) # 图像尺寸

    # 进行立体更正

    R1, R2, P1, P2, Q, validPixROI1, validPixROI2 = cv2.stereoRectify(left_camera_matrix, left_distortion,

    right_camera_matrix, right_distortion, size, R,

    T)

    # 计算更正map

    left_map1, left_map2 = cv2.initUndistortRectifyMap(left_camera_matrix, left_distortion, R1, P1, size, cv2.CV_16SC2)

    right_map1, right_map2 = cv2.initUndistortRectifyMap(right_camera_matrix, right_distortion, R2, P2, size, cv2.CV_16SC2)

    depth.py

    # 该脚本实现深度图以及点击深度图测量像素点的真实距离

    # 可以运行看到效果之后最好自己重新标定一次

    from cv2 import cv2

    import numpy as np

    import camera_configs # 摄像头的标定数据

    cam1 = cv2.VideoCapture(1) # 摄像头的ID不同设备上可能不同

    cam2 = cv2.VideoCapture(0) # 摄像头的ID不同设备上可能不同

    # cam1 = cv2.VideoCapture(1 + cv2.CAP_DSHOW) # 摄像头的ID不同设备上可能不同

    # cam1.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) # 设置双目的宽度

    # cam1.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) # 设置双目的高度

    # 创建用于显示深度的窗口和调节参数的bar

    cv2.namedWindow("depth")

    cv2.moveWindow("left", 0, 0)

    cv2.moveWindow("right", 600, 0)

    # 创建用于显示深度的窗口和调节参数的bar

    # cv2.namedWindow("depth")

    cv2.namedWindow("config", cv2.WINDOW_NORMAL)

    cv2.moveWindow("left", 0, 0)

    cv2.moveWindow("right", 600, 0)

    cv2.createTrackbar("num", "config", 0, 60, lambda x: None)

    cv2.createTrackbar("blockSize", "config", 30, 255, lambda x: None)

    cv2.createTrackbar("SpeckleWindowSize", "config", 1, 10, lambda x: None)

    cv2.createTrackbar("SpeckleRange", "config", 1, 255, lambda x: None)

    cv2.createTrackbar("UniquenessRatio", "config", 1, 255, lambda x: None)

    cv2.createTrackbar("TextureThreshold", "config", 1, 255, lambda x: None)

    cv2.createTrackbar("UniquenessRatio", "config", 1, 255, lambda x: None)

    cv2.createTrackbar("MinDisparity", "config", 0, 255, lambda x: None)

    cv2.createTrackbar("PreFilterCap", "config", 1, 65, lambda x: None) # 注意调节的时候这个值必须是奇数

    cv2.createTrackbar("MaxDiff", "config", 1, 400, lambda x: None)

    # 添加点击事件,打印当前点的距离

    def callbackFunc(e, x, y, f, p):

    if e == cv2.EVENT_LBUTTONDOWN:

    print(threeD[y][x])

    if abs(threeD[y][x][2]) < 3000:

    print("当前距离:"+str(abs(threeD[y][x][2])))

    else:

    print("当前距离过大或请点击色块的位置")

    cv2.setMouseCallback("depth", callbackFunc, None)

    # 初始化计算FPS需要用到参数 注意千万不要用opencv自带fps的函数,那个函数得到的是摄像头最大的FPS

    frame_rate_calc = 1

    freq = cv2.getTickFrequency()

    font = cv2.FONT_HERSHEY_SIMPLEX

    imageCount = 1

    while True:

    t1 = cv2.getTickCount()

    ret1, frame1 = cam1.read()

    ret1, frame2 = cam2.read()

    if not ret1:

    print("camera is not connected!")

    break

    # 这里的左右两个摄像头的图像是连在一起的,所以进行一下分割

    # frame1 = frame[0:480, 0:640]

    # frame2 = frame[0:480, 640:1280]

    ####### 深度图测量开始 #######

    # 立体匹配这里使用BM算法,

    # 根据标定数据对图片进行重构消除图片的畸变

    img1_rectified = cv2.remap(frame1, camera_configs.left_map1, camera_configs.left_map2, cv2.INTER_LINEAR,

    cv2.BORDER_CONSTANT)

    img2_rectified = cv2.remap(frame2, camera_configs.right_map1, camera_configs.right_map2, cv2.INTER_LINEAR,

    cv2.BORDER_CONSTANT)

    # 如有些版本 remap()的图是反的 这里对角翻转一下

    # img1_rectified = cv2.flip(img1_rectified, -1)

    # img2_rectified = cv2.flip(img2_rectified, -1)

    # 将图片置为灰度图,为StereoBM作准备,BM算法只能计算单通道的图片,即灰度图

    # 单通道就是黑白的,一个像素只有一个值如[123],opencv默认的是BGR(注意不是RGB), 如[123,4,134]分别代表这个像素点的蓝绿红的值

    imgL = cv2.cvtColor(img1_rectified, cv2.COLOR_BGR2GRAY)

    imgR = cv2.cvtColor(img2_rectified, cv2.COLOR_BGR2GRAY)

    out = np.hstack((img1_rectified, img2_rectified))

    for i in range(0, out.shape[0], 30):

    cv2.line(out, (0, i), (out.shape[1], i), (0, 255, 0), 1)

    cv2.imshow("epipolar lines", out)

    # 通过bar来获取到当前的参数

    # BM算法对参数非常敏感,一定要耐心调整适合自己摄像头的参数,前两个参数影响大 后面的参数也要调节

    num = cv2.getTrackbarPos("num", "config")

    SpeckleWindowSize = cv2.getTrackbarPos("SpeckleWindowSize", "config")

    SpeckleRange = cv2.getTrackbarPos("SpeckleRange", "config")

    blockSize = cv2.getTrackbarPos("blockSize", "config")

    UniquenessRatio = cv2.getTrackbarPos("UniquenessRatio", "config")

    TextureThreshold = cv2.getTrackbarPos("TextureThreshold", "config")

    MinDisparity = cv2.getTrackbarPos("MinDisparity", "config")

    PreFilterCap = cv2.getTrackbarPos("PreFilterCap", "config")

    MaxDiff = cv2.getTrackbarPos("MaxDiff", "config")

    if blockSize % 2 == 0:

    blockSize += 1

    if blockSize < 5:

    blockSize = 5

    # 根据BM算法生成深度图的矩阵,也可以使用SGBM,SGBM算法的速度比BM慢,但是比BM的精度高

    stereo = cv2.StereoBM_create(

    numDisparities=16 * num,

    blockSize=blockSize,

    )

    stereo.setROI1(camera_configs.validPixROI1)

    stereo.setROI2(camera_configs.validPixROI2)

    stereo.setPreFilterCap(PreFilterCap)

    stereo.setMinDisparity(MinDisparity)

    stereo.setTextureThreshold(TextureThreshold)

    stereo.setUniquenessRatio(UniquenessRatio)

    stereo.setSpeckleWindowSize(SpeckleWindowSize)

    stereo.setSpeckleRange(SpeckleRange)

    stereo.setDisp12MaxDiff(MaxDiff)

    # 对深度进行计算,获取深度矩阵

    disparity = stereo.compute(imgL, imgR)

    # 按照深度矩阵生产深度图

    disp = cv2.normalize(disparity, disparity, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)

    # 将深度图扩展至三维空间中,其z方向的值则为当前的距离

    threeD = cv2.reprojectImageTo3D(disparity.astype(np.float32) / 16., camera_configs.Q)

    # 将深度图转为伪色图,这一步对深度测量没有关系,只是好看而已

    fakeColorDepth = cv2.applyColorMap(disp, cv2.COLORMAP_JET)

    cv2.putText(frame1, "FPS: {0:.2f}".format(frame_rate_calc), (30, 50), font, 1, (255, 255, 0), 2, cv2.LINE_AA)

    # 按下S可以保存图片

    interrupt = cv2.waitKey(10)

    if interrupt & 0xFF == 27: # 按下ESC退出程序

    break

    if interrupt & 0xFF == ord('s'):

    cv2.imwrite('images/left' +'.jpg', frame1)

    cv2.imwrite('images/right' +'.jpg', frame2)

    cv2.imwrite('images/img1_rectified' +'.jpg', img1_rectified)#畸变,注意观察正反

    cv2.imwrite('images/img2_rectified' +'.jpg', img2_rectified)

    cv2.imwrite('images/depth' +'.jpg', disp)

    cv2.imwrite('images/fakeColor' +'.jpg', fakeColorDepth)

    cv2.imwrite('mages/epipolar' + '.jpg', out)

    ####### 任务1:测距结束 #######

    # 显示

    # cv2.imshow("frame", frame) # 原始输出,用于检测左右

    cv2.imshow("frame1", frame1) # 左边原始输出

    cv2.imshow("frame2", frame2) # 右边原始输出

    cv2.imshow("img1_rectified", img1_rectified) # 左边矫正后输出

    cv2.imshow("img2_rectified", img2_rectified) # 右边边矫正后输出

    cv2.imshow("depth", disp) # 输出深度图及调整的bar

    cv2.imshow("fakeColor", fakeColorDepth) # 输出深度图的伪色图,这个图没有用只是好看

    # 需要对深度图进行滤波将下面几行开启即可 开启后FPS会降低

    img_medianBlur = cv2.medianBlur(disp, 25)

    img_medianBlur_fakeColorDepth = cv2.applyColorMap(img_medianBlur, cv2.COLORMAP_JET)

    img_GaussianBlur = cv2.GaussianBlur(disp, (7, 7), 0)

    img_Blur = cv2.blur(disp, (5, 5))

    cv2.imshow("img_GaussianBlur", img_GaussianBlur) # 右边原始输出

    cv2.imshow("img_medianBlur_fakeColorDepth", img_medianBlur_fakeColorDepth) # 右边原始输出

    cv2.imshow("img_Blur", img_Blur) # 右边原始输出

    cv2.imshow("img_medianBlur", img_medianBlur) # 右边原始输出

    t2 = cv2.getTickCount()

    time1 = (t2 - t1) / freq

    frame_rate_calc = 1 / time1

    cam1.release()

    cv2.destroyAllWindows()

    如何判断数据有没有填对a56533299d5360019230302fec5054f3.png

    看矫正图,每根极线上对应的点是不是一样的。

    可能问题:1.摄像头左右标反了、

    2. 如有些opencv版本 remap()的图是反的 这里对角翻转一下

    # img1_rectified = cv2.flip(img1_rectified, -1)

    # img2_rectified = cv2.flip(img2_rectified, -1)

    3.摄像头输出的是一张图还是两张图,这里的左右两个摄像头的图像是连在一起的,所以进行一下分割

    # frame1 = frame[0:480, 0:640]

    # frame2 = frame[0:480, 640:1280]

    我的是两张图,所以这一段注释了

    参数自己看着调,先调前面两个,前面两个出不了距离后面调了也没用

    效果:

    8f05f33829511cf488cf62debe90d694.png

    5abf8e54759fc61653e1561137732d81.png

    在depth窗口点击进行测距

    550a452072d1e183aec62672eedc6654.png

    先这么写着,以后有时间再写具体的

    展开全文
  • 双目测距 SGBM算法 Python

    千次阅读 2021-09-16 15:26:18
    一、双目测距 效果 基于SGBM算法,生成视差图的效果 用鼠标点击视差图,程序会自动计算该点的世界坐标、距离,输出信息如下: 像素坐标 x = 523, y = 366 世界坐标xyz 是: 0.37038836669.
  • 实现双目测距功能,需要python环境,安装OpenCV,自行标定
  • 双目测距 BM算法 Python

    千次阅读 多人点赞 2021-09-17 10:57:04
    一、双目测距 效果 基于BM算法,生成视差图的效果 用鼠标点击视差图,程序会自动计算该点的世界坐标、距离,输出信息如下: 像素坐标 x = 523, y = 366 世界坐标xyz 是: 0.37038836...
  • opencv-python双目测距

    千次阅读 2020-04-20 23:04:41
    双目测距原理 下图是双目摄像头成像示意图,其中P点为目标物体,O1和O2分别为左右摄像头的投影中心,x1和x2分别是目标物体在左右摄像头成像平面上的坐标,f为焦距,T为左右摄像头中心线距离,Z为摄像头投影中心到...
  • 双目测距Python-OpenCV代码及详细解释

    千次阅读 2021-12-02 16:12:29
    双目测距的基本流程 双目标定-->立体校正(含消除畸变)-->立体匹配-->视差计算-->深度计算/3D坐标计算 二 双目标定 参照之前的文章求出相册的内参,外参以及畸变函数,其中内参包括左右相机的fx...
  • 可以先+Q,在下载哦~ 首先pip install -r rerequirements.txt 搭建好yolov5的环境 搭建好yolov5的环境后直机运行 python detect_and_stereo_video_003.py
  • 双目测距理论及其python实现

    万次阅读 多人点赞 2019-09-03 23:19:09
    一、双目测距基本流程 双目测距属于双目SLAM的一个应用领域。 关于双目测距的基本原理,其实并不复杂,但说起来内容也不少,其核心原理就是三角测量,三角测量在土地测量、天文测量等领域都得到了广泛应用,是一种...
  • 找到双目测距代码中计算障碍物深度的代码段。 将1中得到的障碍物框依次输入到2中的代码段中,得到目标框中障碍物的深度。 找到目标识别网络中显示障碍物种类的额代码段,将深度值添加到里面,进行测距 多目标测距 ...
  • 在做SLAM时,希望用到深度图来辅助生成场景,所以要构建立体视觉,在这里使用OpenCV的Stereo库和python来进行双目立体视觉的图像处理。立体标定应用标定数据转换成深度图标定在开始之前,需要准备的当然是两个摄相头...
  • 最近搞摄像头项目,顺便扩展...该代码实现了双目摄像头的调用,代码运行稳定没有错误。 最近搞摄像头项目,顺便扩展学习python+opencv的图片处理和视频处理。该代码实现了双目摄像头的调用,代码运行稳定没有错误。
  • importcv2importnumpy as npimportstereoconfigdefgetRectifyTransform(height, width, config):#读取矩阵参数left_K =config.cam_matrix_leftright_K=config.cam_matrix_rightleft_distortion=config.distortion_l...
  • 文章名称:3-D Point Cloud ...文章(英文)详细讲解了双目视觉的一些基本原理,已经如何使用两个普通的网络摄像头来实现双目视觉,以及如何根据两个摄像头来计算物体深度信息。 代码为文章中附带的代码 仅供参考学习
  • 本博客将实现Python版本的双目三维重建系统,项目代码实现包含:`双目标定`,`立体校正(含消除畸变)`,`立体匹配`,`视差计算`和`深度距离计算/3D坐标计算` 的知识点。限于篇幅,本博客不会过多赘述算法原理,而是...
  • BM算法实现双目视觉测距--python实现

    千次阅读 2022-04-22 18:51:03
    python实现双目相机的深度测距,获取点的三维坐标。
  • sift算法实现双目测距

    千次下载 热门讨论 2011-11-13 21:23:58
    用opencv以及sift算法实现的双目测距工程,测量误差在500mm-1000mm时达到5mm以内
  • 通过双目视觉测距.zip

    2020-07-09 16:03:52
    通过双目视觉测距Python代码,可以运行。
  • 相信看过 OpenCV 第 12 章的朋友对上图中的 Q 矩阵不会陌生,根据以上变换公式,按理说 OpenCV 应该也是通过矩阵运算的方式来计算出三维坐标数据的,但实际上仔细查看源代码,会发现 cvReprojectImageTo3D 用了比较...
  • 这个工程代码是视频中代码的修改版 修改内容:屏蔽了用cvblobslib实现的功能,但是主要功能标定以及测距都可以实现,而且不用安装那反人类的cvblobslib扩展库。 实现环境: 1,两个普通摄像头 2.opencv2.4.9 3....
  • 双目测距、重构 楼主之前用的SFM来进行重构,但是得到的是视差图,点云和实物存在比例关系,单目的还是不能解决scale这个问题的。所以今天用双目的来进行重构,期间遇到了很多坑,实属难受。 双目测距过程大致可以...
  • 所以我的第一篇博客就这么诞生啦~双目测距属于立体视觉这一块,我觉得应该有很多人踩过这个坑了,但网上的资料依旧是云里雾里的,要么是理论讲一大堆,最后发现还不知道怎么做,要么就是直接代码一贴,让你懵逼。...
  • YOLO v5与双目测距结合,实现目标的识别和定位测距

    万次阅读 多人点赞 2021-07-06 16:34:00
    python版本:python3.6.13(anaconda安装的python3.6的虚拟环境) yolov5模型版本:YOLO v5s 双目摄像头间距:12cm 双目摄像头输出分辨率为:2560*720。 1、首先安装YOLO v5 YOLO v5的安装请参考我的另一篇博客:...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 267
精华内容 106
关键字:

双目测距代码python