TensorRT 7 动态输入和输出

教程文档:

【1】https://docs.nvidia.com/deeplearning/tensorrt/index.html

【2】https://developer.nvidia.com/zh-cn/tensorrt

【3】Nvidia TensorRT文档——开发者指南

【4】github: https://github.com/NVIDIA/TensorRT

[5] pytorch-onnx-tensorrt全链路简单教程(支持动态输入)

[6] Pytorch转onnx, TensorRT踩坑实录

流程:

(1)Torch模型转onnx

(2)Onnx转TensorRT engine文件

(3)TensorRT加载engine文件并实现推理

Torch模型转onnx

def torch_2_onnx(model, MODEL_ONNX_PATH ):
    OPERATOR_EXPORT_TYPE = torch._C._onnx.OperatorExportTypes.ONNX
    """
    这里构建网络的输入,有几个就构建几个
    和网络正常的inference时输入一致就可以
    """
    org_dummy_input = (inputs_1, inputs_2, inputs_3, inputs_4)
 
    #这是支持动态输入和输出的第一步
    #每一个输入和输出中动态的维度都要在此注明,下标从0开始
    dynamic_axes = {
                        'inputs_1': {0:'batch_size', 1:'text_length'},
                        'inputs_2': {0:'batch_size', 1:'text_length'},
                        'inputs_3': {0:'batch_size', 1:'text_length'},
                        'inputs_4': {0:'batch_size', 1:'text_length'},
                        'outputs': {0:'batch_size', 1:'text_length'},
                        }
    output = torch.onnx.export( model,
                                org_dummy_input,
                                MODEL_ONNX_PATH,
                                verbose=True,
                                opset_version=11,
                                operator_export_type=OPERATOR_EXPORT_TYPE,
                                input_names=['inputs_1', 'inputs_2', 'inputs_3', 'inputs_4'],
                                    output_names=['outputs'],
                                    dynamic_axes=dynamic_axes
                                )
    print("Export of model to {}".format(MODEL_ONNX_PATH))


使用onnxruntime进行验证

1. 安装onnxruntime

pip install onnxruntime
2. 使用onnxruntime验证

import onnxruntime as ort
	
ort_session = ort.InferenceSession('xxx.onnx')
img = cv2.imread('test.jpg')
net_input = preprocess(img) # 你的预处理函数
outputs = ort_session.run(None, {ort_session.get_inputs()[0].name: net_input})
print(outputs)

3. 上面的这段代码有一点需要注意,可以发现通过ort_session.get_inputs()[0].name可以得到输入的tensor名称,同理,也可以通过ort_session.get_outputs()[0].name来获得输出tensor的名称,如果你的网络有两个输出,则使用ort_session.get_outputs()[0].name和ort_session.get_outputs()[1].name来获得,这里得到的名称在后续tensorrt调用中会使用

onnx转TensorRT的engine文件


import tensorrt as trt
import sys
import os

def ONNX_build_engine(onnx_file_path, write_engine = False):
    '''
    通过加载onnx文件,构建engine
    :param onnx_file_path: onnx文件路径
    :return: engine
    '''
    G_LOGGER = trt.Logger(trt.Logger.WARNING)
    # 1、动态输入第一点必须要写的
    explicit_batch = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH) 
    batch_size = 10 # trt推理时最大支持的batchsize
    with trt.Builder(G_LOGGER) as builder, builder.create_network(explicit_batch) as network, trt.OnnxParser(network, G_LOGGER) as parser:
        builder.max_batch_size = batch_size
        config = builder.create_builder_config()
        config.max_workspace_size = common.GiB(2) #common文件可以自己去tensorrt官方例程下面找
        config.set_flag(trt.BuilderFlag.FP16)
        print('Loading ONNX file from path {}...'.format(onnx_file_path))
        with open(onnx_file_path, 'rb') as model:
            print('Beginning ONNX file parsing')
            parser.parse(model.read())
        print('Completed parsing of ONNX file')
        print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))
        # 重点 
        profile = builder.create_optimization_profile() #动态输入时候需要 分别为最小输入、常规输入、最大输入
        # 有几个输入就要写几个profile.set_shape 名字和转onnx的时候要对应
        profile.set_shape("inputs_1", (1,3), (1,256), (10,512))
        profile.set_shape("inputs_2", (1,3), (1,256), (10,512)) 
        profile.set_shape("inputs_3", (1,3), (1,256), (10,512)) 
        profile.set_shape("inputs_4", (1,3), (1,256), (10,512)) 
        config.add_optimization_profile(profile)
 
        engine = builder.build_engine(network, config)
        print("Completed creating Engine")
        # 保存engine文件
        if write_engine:
            engine_file_path = 'correction_fp16.trt'
            with open(engine_file_path, "wb") as f:
                f.write(engine.serialize())
        return engine

TensorRT 加载engine文件并进行推理

def trt_inference(engine_file):
    #此处的输入应当转成numpy的array,同时dtype一定要和原网络一致不然结果会不对
    inputs_1= np.array(inputs_1, dtype=np.int32, order='C')
    inputs_2= np.array(inputs_2, dtype=np.int32, order='C')
    inputs_3= np.array(inputs_3, dtype=np.int32, order='C')
    inputs_4= np.array(inputs_4, dtype=np.int32, order='C')
    with get_engine(engine_file) as engine, engine.create_execution_context() as context:
        #增加部分 动态输入需要
        context.active_optimization_profile = 0
        origin_inputshape=context.get_binding_shape(0)
        origin_inputshape[0],origin_inputshape[1]=inputs_1.shape
        context.set_binding_shape(0, (origin_inputshape)) #若每个输入的size不一样,可根据inputs_i的size更改对应的context中的size
        context.set_binding_shape(1, (origin_inputshape))
        context.set_binding_shape(2, (origin_inputshape))
        context.set_binding_shape(3, (origin_inputshape))
        #增加代码结束
        inputs, outputs, bindings, stream = common.allocate_buffers(engine, context)
        # Do inference
        inputs[0].host = inputs_1
        inputs[1].host = inputs_2
        inputs[2].host = inputs_3
        inputs[3].host = inputs_4
        trt_outputs = common.do_inference_v2(context, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream)


def get_engine(engine_path ):
    logger = trt.Logger(trt.Logger.INFO)
    trt.init_libnvinfer_plugins(logger, namespace="")
    with open(engine_path, 'rb') as f, trt.Runtime(logger) as runtime:
        return runtime.deserialize_cuda_engine(f.read())

common文件中的allcate_buffers()函数:

def allocate_buffers(engine, context):
    inputs = []
    outputs = []
    bindings = []
    stream = cuda.Stream()
    for i, binding in enumerate(engine):
        size = trt.volume(context.get_binding_shape(i))
        dtype = trt.nptype(engine.get_binding_dtype(binding))
        # Allocate host and device buffers
        host_mem = cuda.pagelocked_empty(size, dtype)
        device_mem = cuda.mem_alloc(host_mem.nbytes)
        # Append the device buffer to device bindings.
        bindings.append(int(device_mem))
        # Append to the appropriate list.
        if engine.binding_is_input(binding):
            inputs.append(HostDeviceMem(host_mem, device_mem))
        else:
            outputs.append(HostDeviceMem(host_mem, device_mem))
    return inputs, outputs, bindings, stream

Boosting Monocular Depth Estimation-不同尺度的深度图融合的Refine网络

目标: 实现具有一致整体结构的高频细节的深度图结果

GitHub地址:

1、https://github.com/compphoto/BoostingMonocularDepth(main repo)

2、https://github.com/compphoto/BoostYourOwnDepth(Merging Operator:基于深度图的Refine过程的实现)a stand-alone implementation of our merging operator

论文:Boosting Monocular Depth Estimation Models to High-Resolution via
Content-Adaptive Multi-Resolution Merging

卷积神经网络显示出从单个图像估计深度的非凡能力。 然而,由于网络结构和硬件限制,估计的深度图分辨率较低,仅显示整体场景结构,缺乏精细细节,这限制了其适用性。 我们证明了场景结构的一致性与有关输入内容和分辨率的高频细节之间存在权衡。 基于这种二元性,我们提出了一个双重估计框架来改进整个图像的深度估计和一个块选择步骤来添加更多的局部细节。 我们的方法通过基于图像内容合并不同分辨率的估计,获得具有清晰细节的数百万像素深度估计。 我们方法的一个关键优势是我们可以使用任何现成的基于 CNN 的预训练单眼深度估计模型,而无需进一步微调。

(融合网络)该方法是基于优化一个预训练网络的性能,通过合并不同分辨率和不同补丁的估计来生成一个高分辨率的估计。

  • 首先图像以低分辨率和高分辨率的格式输入网络(MiDas网络+10层U-net的Pix2Pix架构作为生成器)
  • 然后,合并MiDaS 的结果(不同高低分辨率估计融合),获得具有一致结构和良好边界定位的基础估计(b)。【高分辨率:细节,低分辨率:结构一致性】
  • 接着,确定图像中的不同补丁,如图(c)显示了选定补丁的子集及其深度估计。
  • 最后,将补丁估计合并到来自(b)的基本估计上,以获得最终的高分辨率结果(d)。
  • 解决的问题: 如何实现在高分辨和高细节度折中的单张图像深度估计

单张图像深度估计的目的是从单张图像中提取场景的结构。与深度相机或者多视角数据所提取的深度信息不同,单张图像深度估计主要依赖于高层单眼深度线索。基于深度学习的方法已然成为单张图像深度估计的标准解决方案。但是对于高分辨深度估计,使其具有好的边界准确性和一致的场景结构,这仍然存在难题。虽然有基于全卷积层结构的方法可以控制任意输入尺寸,但现实中GPU内存、高分辨率数据缺失、CNN感受野尺寸,这些都限制了对应方法的发展。

因此,本文提出采用预训练的单张图像深度估计模型,实现具有高边界准确性的高分辨率结果。

论文的贡献:

  1. 提出一种双重深度估计模型,提高单目图像深度估计的性能;一种基于块选择的方法能加入局部信息到最后的估计结果。
  2. 所提出的方法可以改进最新的单目图像深度估计方法,在提高分辨率与细节的同时,几乎不额外引入计算量。

想法:

我们的主要见解来自观察到单目深度估计网络的输出特性随输入图像的分辨率而变化。 在接近训练分辨率的低分辨率下估计具有一致的结构,但缺乏高频细节。 当以更高分辨率将相同的图像馈送到网络时,可以更好地捕获高频细节,同时估计的结构一致性逐渐降低。(因此:高低分辨率深度图各有优势)

我们的第二个观察是关于输出特征与输入中高级深度线索的数量和分布之间的关系。 网络感受野尺寸主要依赖于网络结构以及训练分辨率。由于单目深度估计依赖于上下文线索,当图像中的这些线索比感受野更远时,网络无法在未接收到足够信息的像素周围生成连贯的深度估计。(选取Patch进行进一步深度图refine)

初步方法

我们的目标是对要合并的单个图像生成多个深度估计,以实现具有一致整体结构的高频细节的结果。这需要:

(i) 检索图像中上下文线索的分布,我们将使用它来确定网络的输入,以及 (ii) 合并操作以将高频细节从一个估计转移到另一个具有结构一致性的估计。
1) 估计的上下文线索。我们使用通过对 RGB 梯度进行阈值处理获得的图像的近似边缘图作为代理。
2)合并单目深度估计。包括输入小分辨率到网络所对应的低分辨率图,相同图像的高分辨率深度图。
使用具有10层U-net的Pix2Pix结构作为生成器。我们训练网络将细粒度的细节从高分辨率输入传输到低分辨率输入
如下图,尽管增加的分辨率提供了更清晰的结果,但在 (c) 之外,深度估计在整体结构方面变得不稳定,通过背景中不正确的工作台深度范围和轮胎周围不切实际的深度梯度可见。

我们展示了在不同分辨率下获得的深度估计,(a)在 MiDaS [34] 的训练分辨率384 × 384下 ,(b)在所选分辨率下,边缘最多间隔 384 个像素,(c)在更高的分辨率下 使 20% 的像素没有附近边缘。(d) 我们的合并网络能够将 (c) 中的细粒度细节融合到 (a) 中的一致结构中,以实现两全其美。

双重估计

我们将二进制膨胀应用于具有不同分辨率的感受野大小内核的边缘图。然后,扩张边缘图停止产生全为一结果的分辨率是每个像素将在前向传递中接收上下文信息的最大分辨率,将其记为 R0 ,分辨率高于R0 的估计将失去结构一致性,但它们在结果中将具有更丰富的高频内容。
因此,我们提出双重估计:为了获得两全其美的结果,我们以两种不同的分辨率将图像馈送到网络,并合并估计以获得具有高频细节的一致结果。如图6所示。

局部提升的块估计

我们提出了一种块选择方法,为图像中的不同区域生成不同分辨率的深度估计,这些区域合并在一起以获得一致的完整结果。
理想情况下,块选择过程应由高级信息指导,以确定用于估计的最佳局部分辨率。但缺乏这样的数据集。因此本文提出一种简单的块选择方法,即做出谨慎的设计决策,以达到可靠的高分辨率深度估计管道,而无需额外的数据集或训练。
1)块选择。通过以基本分辨率平铺图像开始块选择过程,平铺大小等于感受野大小和 1/3 重叠。
2)块估计。采用双重估计方法进行估计。
3)基础分辨率调整。通过在块选择之前将基本深度估计上采样到更高的分辨率来解决这种情况下的这个问题。

  • 实验结果

测试方法:改进两个最新方法MiDaS、 SGR

测试数据:Middleburry 2014 [3]、IBMS-1 [4].

度量标准: 视差空间中的均方根误差 (RMSE)、1.25的像素百分比、方向错误(ORD、序数关系误差的变化

  1. 对比实验

参考

  1. ^Rene Ranftl, Katrin Lasinger, David Hafner, Konrad ´ Schindler, and Vladlen Koltun. Towards robust monocular depth estimation: Mixing datasets for zero-shot cross-dataset transfer. IEEE Trans. Pattern Anal. Mach. Intell., 2020.
  2. ^abcKe Xian, Jianming Zhang, Oliver Wang, Long Mai, Zhe Lin, and Zhiguo Cao. Structure-guided ranking loss for single image depth prediction. In Proc. CVPR, 2020
  3. ^D. Scharstein, H. Hirschmuller, York Kitajima, Greg Krath- ¨ wohl, Nera Nesic, X. Wang, and P. Westling. High-resolution stereo datasets with subpixel-accurate ground truth. In Proc. GCPR, 2014.
  4. ^Tobias Koch, Lukas Liebel, Friedrich Fraundorfer, and Marco Korner. Evaluation of CNN-Based Single-Image ¨ Depth Estimation Methods. In Proc. ECCV Workshops, 2018.

3D Photography –新视点合成

[CVPR 2020] 3D Photography using Context-aware Layered Depth Inpainting

Code地址: https://github.com/vt-vl-lab/3d-photo-inpainting

项目主页: https://shihmengli.github.io/3D-Photo-Inpainting/

本文作者来自弗吉尼亚理工学院、国立清华大学和 Facebook,作者提出了一种从 单张 RGB-D 图像生成 3D 照相 的方法,效果炫酷、惊艳,目前代码已开源。

3D相片的生成主要基于重建和渲染技术,传统的方法需要基线较长的精密的多视角图片捕捉设备或者其他特殊装置,如 Lytro Immerge 和 Facebook Manifold camera。最近有更多的工作尝试从智能相机来生成3D相片,如 Facebook 3D Photos 只需用双摄智能手机拍摄图片,生成RGB-D图像 (彩色图+深度图) 来制作3D相片。

本文同样考虑如何从输入的 RGB-D 图像来合成新的视角以生成3D照片。文章方法对深度图的质量要求并不高,只需要深度不连续处在彩色图和深度图中是合理对齐的即可。深度图可以从 双摄相机通过立体视觉的方式计算 得到,也可以借助 深度学习的方法从单张图片估计 得到,因此应用到智能手机完全没有问题,作者也对这两种来源的深度图进行了测试。

!!!重要:“ 对深度图的质量要求并不高,只需要深度不连续处在彩色图和深度图中是合理对齐的即可

Method

Layered Depth Image

文章方法输入一张 RGB-D 图像,输出分层的深度图像 (Layered Depth Image, LDI),在原始图像中被遮挡的部位填补了颜色和深度。

LDI 类似普通的图像,区别在于每个像素点可以容纳零个或多个像素值,每个 LDI 像素存储一个颜色和一个深度值。与原始论文介绍的 LDI 不同,本文作者显式地表示了像素的局部连通性:每个像素在左右上下四个方向上都存储了零个或最多一个直接相邻的像素指针。LDI 像素与普通图像一样在光滑区域内是四连通的,但是在深度不连续处没有邻接像素。

LDI 是一种对3D相片非常有用的表达,主要在三个方面

  1. 其可以处理任意数量的深度层,可以根据需要适应深度复杂的情况;
  2. 其表达是稀疏的,具有更高的内存和存储效率;
  3. 其可以转换为轻量级的纹理网格表示,直接用于快速渲染。

Method Overview

给定输入的 RGB-D 图像,首先初始化一个单层的四连通的简单 LDI。然后进入预处理阶段,检测深度不连续像素点,并将其分组成简单的相连的深度边。文章算法反复选择深度边来进行修复,先断开边缘上的 LDI 像素,仅考虑边缘处的背景像素进行修复,从边缘的 “已知” 侧提取局部语境区域 (context region),并在 “未知” 侧生成一个合成区域 (synthesis region),合成的区域是一个包含新像素的连续2D区域。作者使用基于学习的方法根据给定的上下文生成其颜色和深度值。修复完成后再将合成的像素合并回 LDI。整个方法以这种方式反复进行,直到所有的深度边缘都经过处理。

Image Preprocessing

初始化阶段首先将输入的 RGB-D 图的深度通道归一化到 0-1 之间,并对深度图进行双边中值滤波,以使得边缘更加明显,再基于此图片生成初始 LDI。然后再根据给定阈值判断相邻像素的视差,找到深度不连续像素,并经过一些简化、处理得到最终的深度不连续边。

初始化阶段首先将输入的 RGB-D 图的深度通道归一化到 0-1 之间,并对深度图进行双边中值滤波,以使得边缘更加明显,再基于此图片生成初始 LDI。然后再根据给定阈值判断相邻像素的视差,找到深度不连续像素,并经过一些简化、处理得到最终的深度不连续边。

Context and Synthesis Regions

接下来每次选择一条深度边借助填补算法来修复背景,首先在深度不连续处断开 LDI 像素连接,得到 (前景、背景) 轮廓像素,然后生成一个合成区域,使用洪水漫淹算法初始化颜色和深度值,再使用深度学习的方法填补该合成区域。

Context-aware Color and Depth Inpainting

给定语境区域和合成区域,这里的目标是合成颜色值和深度值。作者的网络与 EdgeConnect方法类似,将整个修复任务分解成三个子网络:

  • 边修复网络 (edge inpainting network)
  • 颜色修复网络 (color inpainting network)
  • 深度修复网络 (depth inpainting network)
Color &amp;amp;amp;amp; Depth Inpainting

首先将语境区域的边作为输入,使用边修复网络预测合成区域中的深度边,先预测边信息能够推断 (基于边的) 结构 信息,有助于约束 (颜色和深度的) 内容 预测。然后使用修复的边和语境区域的颜色作为输入,使用颜色修复网络预测颜色。最后再使用同样的方法预测深度信息。

下图展示了边指导的深度修复能够准确地延拓深度结构,并能减轻预测的彩色 / 深度不对齐的问题。

Converting to 3D Textured Mesh

通过将所有修复好的颜色和深度值重新集成到原始 LDI 中,形成最终的 3D 纹理网格。使用网格表示可以快速渲染新的视图,而无需对每个视角进行推理,因此文章算法得到的3D表示可以在边缘设备上通过标准图形引擎轻松渲染。

归纳过程:

开始修复之前,LDI上的每个像素都和上下左右的4个像素连通。AI每次选择一条深度边缘去修复,把空间上不相连的像素沿着边缘切开。这样,LDI就分成了前景和背景两个部分(b)。需要修复的部分,就在背景轮廓附近。因为,那里会有些原图上被挡的部分,需要在新视角里露出。前景就不用脑补了。至于怎样修复背景,方法是“联系上下文”,根据周围的像素来推测原本隐藏的部分。所以,首先要把背景分成“合成区”和“上下文区”:合成区是原本被前景挡住的部分,上下文区原本就是背景。

红为合成区,蓝为上下文区

分好两个区,修(nao)复(bu)环节就要开始了。

修复工作由三只小AI负责:先是边缘修复网络,它利用上下文区的边缘,来脑补被挡住的边缘;然后是色彩修复网络和深度修复网络,它们拿到了边缘修复网络提供的物体结构信息,便能更科学地脑补被遮挡的色彩和深度。

边缘修复网络,左为修复前,右为修复后

当三只AI脑补完成,只要把它们给出的结果融进当初的LDI里,新鲜的3D图像便出锅了。然后,把各种不同的视角集合起来,形成动态。

Experimental Results

Visual Comparisons

下图展示了文章方法与其他基于 MPI (Multi-Plane Representation) 方法的对比,文章方法能够合成较为合理的边缘结构,StereoMag 和 PB-MPI 方法在深度不连续处存在缺陷,LLFF 在生成新视角时会有鬼影现象。

参考

  1. 3D Photography using Context-aware Layered Depth Inpainting. Meng-Li Shih, Shih-Yang Su, Johannes Kopf, Jia-Bin Huang. CVPR, 2020.
  2. EdgeConnect: Generative Image Inpainting with Adversarial Edge Learning. Kamyar Nazeri, Eric Ng, Tony Joseph, Faisal Z. Qureshi, Mehran Ebrahimi. ICCV, 2019.

相机内参/外参–坐标转换

摘自:https://zhuanlan.zhihu.com/p/389653208

https://blog.csdn.net/zb1165048017/article/details/71104241

demo演示:http://ksimek.github.io/perspective_camera_toy.html

demo中提供了三种外参接口(世界坐标系,相机坐标系,look-at),三种交互效果不同,前两种的方向相反,世界坐标系中向左移动表示相机坐标系中向右移动,但是它们都有六个参数控制:

tx表示沿着水平方向移动相机
ty表示沿着垂直方向移动相机
tz表示沿着前后方向移动相机
px表示镜头不平移,但是绕x轴做俯仰旋转
py表示镜头不平移,但是绕垂直轴y轴做左右摇头旋转
pz表示镜头不平移,但是绕z轴做顺时针(或者逆时针)旋转
————————————————

demo也提供了内参的接口,包括四个参数控制:

焦距(Focal length):镜头的前后缩进(不是缩放)
轴倾斜(Axis Skew):可以导致球变形,平面上显示椭球形
x0表示主点偏移,相机不动,左右移动成像平面
y0 表示主点偏移,相机不动,上下移动成像平面
————————————————

相机参数都有哪些?估计它们需要的条件?评估所估算的相机参数好坏的标准?

①主要包含内参(intrinsics)、外参(extrinsics)、畸变系数(distortion coefficients)

②估计参数需要3D世界坐标及其对应的2D图像点。比如在重构3D姿态的时候,需要同时输入图片及图片中对应的人的骨骼2D坐标点。

③评估所估计相机参数的方法就是:首先画出相机和校准模式的相对位置;随后计算投影误差;最后计算参数的估算误差。在matlab中有Camera Calibrator来进行相机校准和评估参数精确度。

外参数([R|t])描述世界坐标系与相机坐标系的变换关系,参数包括:旋转R,平移T。

内参数(K)描述相机坐标系,图像坐标系,像素坐标系之间的变换关系,参数包括主点坐标,焦距,单位像素宽与高。

相机成像主要有4个坐标系:

成像的过程实质上是几个坐标系的转换。首先空间中的一点由世界坐标系转换到 摄像机坐标系 ,然后再将其投影到成像平面 ( 图像物理坐标系 ) ,最后再将成像平面上的数据转换到图像平面 (图像像素坐标系 ) 。

对应的左乘矩阵公式

摘要:本文介绍了相机的内参和外参以及推导过程,由三个部分组成:第一部分,相机内参; 第二部分,相机外参;第三部分,总结。

1 相机内参

在左图中,我们把相机看作是针孔,现实世界中的点P经过相机的光心O,投影到物理成像平面上,变为点P’。

在右图中,对这个模型进行了一个简化,将其看作是一个相似三角形。

下面我们来对这个模型进行建模。

设O−x−y−z为相机坐标系,习惯上我们把z轴指向相机前方,x向右,y向下。O为摄像机的光心,也是针孔模型中的针孔。

设真实世界点中的P的坐标为[X,Y,Z]T,成像的点P’的坐标为[X’, Y’, Z’]T, 物理成像平面和光心的距离为f(即为焦距)。

根据右图中的三角形相似关系,有:

其中,有负号是因为坐标轴方向,也就表示了成的像是倒立的。为了表示起来更方便,我们把成像平面从相机的后面对称到前面去,如下图所示。这样,负号就没有了。

在对称后,有:

整理解出P’的坐标:

上面两个式子就描述了P点与它所成像的坐标关系,可以看到,X对应的X’与焦距f有关,与距离Z有关。映射到成像平面上还不够,我们还需要将这个像给放到像素坐标系内。
我们设在物理成像平面上固定着像素平面o-u-v。

设P’在像素平面坐标系上的坐标是[u, v]T

像素坐标系通常定义方式是:原点o’位于图像的左上角,u轴向右与x轴平行,v轴向下与y轴平行。我们设像素坐标在u轴上缩放α倍,在v轴上缩放了β倍。同时,原点平移了[cx, cy]T

因此可以得到P’与像素坐标的关系:

用齐次坐标,把上式写出矩阵的形式:

上式中,K即为相机的内参矩阵(Intrinsics)。通常来说,相机的内参在出厂之后就是固定的了。

2 相机外参

相机外参的作用是把坐标从【世界坐标系】转换到【相机坐标系】中

在上面的推导中,我们用的是P在相机坐标系的坐标(也就是以相机为O点),所以我们应该先将世界坐标系中的Pw给变换到相机坐标系中的P。

相机的位姿由旋转矩阵R和平移向量t来描述,因此:

旋转矩阵:R欧拉角:wiki百科

Rot(x, θ)   表示绕X轴旋转  θ表示旋转的角度  其它同理。矩阵右下角的表示放大倍数,矩阵第4行和第4列可以不要

3 镜头畸变

透镜由于制造精度以及组装工艺的偏差会引入畸变,导致原始图像的失真。镜头的畸变分为径向畸变和切向畸变两类。

  1. 径向畸变

顾名思义,径向畸变就是沿着透镜半径方向分布的畸变,产生原因是光线在原理透镜中心的地方比靠近中心的地方更加弯曲,这种畸变在普通廉价的镜头中表现更加明显,径向畸变主要包括桶形畸变和枕形畸变两种。以下分别是枕形和桶形畸变示意图:

成像仪光轴中心的畸变为0,沿着镜头半径方向向边缘移动,畸变越来越严重。畸变的数学模型可以用主点(principle point)周围的泰勒级数展开式的前几项进行描述,通常使用前两项,即k1和k2,对于畸变很大的镜头,如鱼眼镜头,可以增加使用第三项k3来进行描述,成像仪上某点根据其在径向方向上的分布位置,调节公式为:

公式里(x0,y0)是畸变点在成像仪上的原始位置,(x,y)是畸变较真后新的位置,下图是距离光心不同距离上的点经过透镜径向畸变后点位的偏移示意图,可以看到,距离光心越远,径向位移越大,表示畸变也越大,在光心附近,几乎没有偏移。

  1. 切向畸变
    切向畸变是由于透镜本身与相机传感器平面(成像平面)或图像平面不平行而产生的,这种情况多是由于透镜被粘贴到镜头模组上的安装偏差导致。畸变模型可以用两个额外的参数p1和p2来描述:

下图显示某个透镜的切向畸变示意图,大体上畸变位移相对于左下——右上角的连线对称的,说明该镜头在垂直于该方向上有一个旋转角度。

径向畸变和切向畸变模型中一共有5个畸变参数,在Opencv中他们被排列成一个5*1的矩阵,依次包含k1、k2、p1、p2、k3,经常被定义为Mat矩阵的形式,如Mat distCoeffs=Mat(1,5,CV_32FC1,Scalar::all(0));这5个参数就是相机标定中需要确定的相机的5个畸变系数。求得这5个参数后,就可以校正由于镜头畸变引起的图像的变形失真,下图显示根据镜头畸变系数校正后的效果:

3 总结

本文介绍了:

  1. 从相机坐标系转换到像素坐标系中,相机内参的作用
  2. 从世界坐标系转换到相机坐标系中,相机外参的作用

相机内参是这样的一个矩阵:

里面的参数一般都是相机出厂就定下来的,可以通过相机标定的方式人为计算出来。

相机外参是旋转矩阵R和平移向量t构成,一般来说写成:

这个矩阵决定了相机的位姿。

TensorRT – 使用trtexec工具转换模型、运行模型、测试网络性能

转换模型将onnx转换为TensorRT:

方法一、trtexec

trtexec是在tensorrt包中自带的转换程序,该程序位于bin目录下,用起来比较方便,也是最简单的trt模型转换方式,在使用之前需要系统安装好cuda和cudnn,否则无法正常运行。使用示例如下:

首先将pytorch模型先转换成onnx模型,示例代码如下:

def torch2onnx(model_path,onnx_path):
model = load_model(model_path)
test_arr = torch.randn(1,3,32,448)
input_names = ['input']
output_names = ['output']
tr_onnx.export(
model,
test_arr,
onnx_path,
verbose=False,
opset_version=11,
input_names=input_names,
output_names=output_names,
dynamic_axes={"input":{3:"width"}} #动态推理W纬度,若需其他动态纬度可以自行修改,不需要动态推理的话可以注释这行
)
print('->>模型转换成功!')

trtexec转换命令如下:

固定尺寸模型转换:将ONNX模型转换为静态batchsize的TensorRT模型,启动所有精度以达到最佳性能,工作区大小设置为1024M

./trtexec --onnx=repvgg_a1.onnx --saveEngine=repvgg_a1.engine --workspace=1024  --fp16 --verbose

动态尺寸模型转换:将ONNX模型转换为动态batchsize的TensorRT模型,启动所有精度以达到最佳性能,工作区大小设置为1024M

./trtexec --onnx=repvgg_a1.onnx --saveEngine=repvgg_a1.engine --workspace=1024 --minShapes=input:1x3x32x32 --optShapes=input:1x3x32x320 --maxShapes=input:1x3x32x640 --fp16

注意:
–minShapes,–optShapes ,–maxShapes必须全部设置,设置的形式为:batchsize x 通道数 x 输入尺寸x x 输入尺寸y

例如:
--minShapes=input:1x3x416x416
--optShapes=input:8x3x416x416
--maxShapes=input:8x3x416x416

参看命名详解: ./trtexec –help, -h

trtexec的参数使用说明

1.1 Model Option 模型选项

–uff : UFF模型文件名–onnx : ONNX模型文件名–model : Caffe模型文件名,模式时无模型,使用随机权重–deploy : Caffe prototxt 文件名–output : 输出名称(可多次指定);UFF和Caffe至少需要一个输出–uffInput : 输入blob名称及其维度(X、Y、Z=C、H、W),可以多次指定;UFF型号至少需要一个–uffNHWC : 设置输入是否在NHWC布局中而不是NCHW中(在–uffInput中使用X、Y、Z=H、W、C顺序)

1.2 Build Options 构建选项

–maxBatch : 设置最大批处理大小并构建隐式批处理引擎(默认值=1)–explicitBatch :构建引擎时使用显式批量大小(默认 = 隐式)–minShapes=spec : 使用提供的最小形状的配置文件构建动态形状–optShapes=spec : 使用提供的 opt 形状的配置文件构建动态形状–maxShapes=spec : 使用提供的最大形状的配置文件构建动态形状–minShapesCalib=spec : 使用提供的最小形状的配置文件校准动态形状–optShapesCalib=spec : 使用提供的 opt 形状的配置文件校准动态形状–maxShapesCalib=spec :使用提供的最大形状的配置文件校准动态形状注意:必须提供所有三个 min、opt 和 max 形状。但是,如果只提供了 opt 形状,那么它将被扩展,以便将最小形状和最大形状设置为与 opt 形状相同的值。此外,使用 动态形状意味着显式批处理。 输入名称可以用转义单引号括起来(例如:‘Input:0’)。示例输入形状规范:input0:1x3x256x256,input1:1x3x128x128 每个输入形状都作为键值对提供,其中 key 是输入名称 值是用于该输入的维度(包括批次维度)。 每个键值对都使用冒号 (😃 分隔键和值。 可以通过逗号分隔的键值对提供多个输入形状。–inputIOFormats=spec : 每个输入张量的类型和格式(默认所有输入为fp32:chw)注意:如果指定此选项,请按照与网络输入ID相同的顺序为所有输入设置逗号分隔的类型和格式(即使只有一个输入需要指定IO格式)或设置一次类型和格式以进行广播。–outputIOFormats=spec : 每个输出张量的类型和格式(默认所有输入为fp32:chw)注意:如果指定此选项,请按照与网络输出ID相同的顺序为所有输出设置逗号分隔的类型和格式(即使只有一个输出需要指定IO格式)或设置一次类型和格式以进行广播。–workspace=N : 以M为单位设置工作区大小(默认值 = 16)–noBuilderCache : 在构建器中禁用时序缓存(默认是启用时序缓存)–nvtxMode=mode : 指定 NVTX 注释详细程度。 mode ::= default|verbose|none–minTiming=M : 设置内核选择中使用的最小迭代次数(默认值 = 1)–avgTiming=M : 为内核选择设置每次迭代的平均次数(默认值 = 8)–noTF32 : 禁用 tf32 精度(默认是启用 tf32,除了 fp32)–refit : 将引擎标记为可改装。这将允许检查引擎内的可改装层和重量。–fp16 : 除 fp32 外,启用 fp16 精度(默认 = 禁用)–int8 : 除 fp32 外,启用 int8 精度(默认 = 禁用)–best : 启用所有精度以达到最佳性能(默认 = 禁用)–calib= : 读取INT8校准缓存文件–safe : 仅测试安全受限流中可用的功能–saveEngine= : 保存序列化模型的文件名–loadEngine= : 加载序列化模型的文件名–tacticSources=tactics : 通过从默认策略源(默认 = 所有可用策略)中添加 (+) 或删除 (-) 策略来指定要使用的策略。

1.3 Inference Options 推理选项

–batch=N : 为隐式批处理引擎设置批处理大小(默认值 = 1)–shapes=spec : 为动态形状推理输入设置输入形状。注意:使用动态形状意味着显式批处理。 输入名称可以用转义的单引号括起来(例如:‘Input:0’)。 示例输入形状规范:input0:1x3x256x256, input1:1x3x128x128 每个输入形状都作为键值对提供,其中键是输入名称,值是用于该输入的维度(包括批次维度)。 每个键值对都使用冒号 (😃 分隔键和值。 可以通过逗号分隔的键值对提供多个输入形状。–loadInputs=spec :从文件加载输入值(默认 = 生成随机输入)。 输入名称可以用单引号括起来(例如:‘Input:0’)–iterations=N : 至少运行 N 次推理迭代(默认值 = 10)–warmUp=N : 在测量性能之前运行 N 毫秒以预热(默认值 = 200)–duration=N : 运行至少 N 秒挂钟时间的性能测量(默认值 = 3)–sleepTime=N : 延迟推理以启动和计算之间的 N 毫秒间隔开始(默认 = 0)–streams=N : 实例化 N 个引擎以同时使用(默认值 = 1)–exposeDMA : 串行化进出设备的 DMA 传输。 (默认 = 禁用)–noDataTransfers : 在推理过程中,请勿将数据传入和传出设备。 (默认 = 禁用)–useSpinWait : 主动同步 GPU 事件。 此选项可能会减少同步时间,但会增加 CPU 使用率和功率(默认 = 禁用)–threads : 启用多线程以驱动具有独立线程的引擎(默认 = 禁用)–useCudaGraph : 使用 cuda 图捕获引擎执行,然后启动推理(默认 = 禁用)–separateProfileRun : 不要在基准测试中附加分析器; 如果启用分析,将执行第二次分析运行(默认 = 禁用)–buildOnly : 跳过推理性能测量(默认 = 禁用)

1.4 Build and Inference Batch Options 构建和推理批处理选项
使用隐式批处理时,引擎的最大批处理大小(如果未指定)设置为推理批处理大小; 使用显式批处理时,如果仅指定形状用于推理,它们也将在构建配置文件中用作 min/opt/max; 如果只为构建指定了形状,则 opt 形状也将用于推理; 如果两者都被指定,它们必须是兼容的; 如果启用了显式批处理但都未指定,则模型必须为所有输入提供完整的静态维度,包括批处理大小

1.5 Reporting Options 报告选项

–verbose : 使用详细日志记录(默认值 = false)–avgRuns=N : 报告 N 次连续迭代的平均性能测量值(默认值 = 10)–percentile=P : 报告 P 百分比的性能(0<=P<=100,0 代表最大性能,100 代表最小性能;(默认 = 99%)–dumpRefit : 从可改装引擎打印可改装层和重量–dumpOutput : 打印最后一次推理迭代的输出张量(默认 = 禁用)–dumpProfile : 每层打印配置文件信息(默认 = 禁用)–exportTimes= : 将计时结果写入 json 文件(默认 = 禁用)–exportOutput= : 将输出张量写入 json 文件(默认 = 禁用)–exportProfile= : 将每层的配置文件信息写入 json 文件(默认 = 禁用)

1.6 System Options 系统选项

–device=N :选择 cuda 设备 N(默认 = 0)–useDLACore=N : 为支持 DLA 的层选择 DLA 核心 N(默认 = 无)–allowGPUFallback : 启用 DLA 后,允许 GPU 回退不受支持的层(默认 = 禁用)–plugins : 要加载的插件库 (.so)(可以多次指定)

1.7 Help 帮助
–help, -h : 打印以上帮助信息

方法2、使用python脚本

参考官方给到的demo写一个脚本转:官方脚本位于下载的目录:TensorRT-7.2.3.4/samples/python/yolov3_onnx/onnx_to_tensorrt.py

import os 
import tensorrt as trt
os.environ["CUDA_VISIBLE_DEVICES"]='0'
TRT_LOGGER = trt.Logger()
onnx_file_path = 'Unet375-simple.onnx'
engine_file_path = 'Unet337.trt'

EXPLICIT_BATCH = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
            builder.max_workspace_size = 1 << 28 # 256MiB
            builder.max_batch_size = 1
            # Parse model file
            if not os.path.exists(onnx_file_path):
                print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))
                exit(0)
            print('Loading ONNX file from path {}...'.format(onnx_file_path))
            with open(onnx_file_path, 'rb') as model:
                print('Beginning ONNX file parsing')
                if not parser.parse(model.read()):
                    print ('ERROR: Failed to parse the ONNX file.')
                    for error in range(parser.num_errors):
                        print (parser.get_error(error))

            network.get_input(0).shape = [1, 3, 300, 400]
            print('Completed parsing of ONNX file')
            print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))
            #network.mark_output(network.get_layer(network.num_layers-1).get_output(0))
            engine = builder.build_cuda_engine(network)
            print("Completed creating Engine")
            with open(engine_file_path, "wb") as f:
                f.write(engine.serialize())

运行ONNX模型

  • 在具有静态输入形状的全维模式下运行 ONNX 模型
trtexec --onnx=model.onnx
  • 使用给定的输入形状在全维模式下运行 ONNX 模型

trtexec –onnx=model.onnx –shapes=input:32x3x244x244

  • 使用一系列可能的输入形状对 ONNX 模型进行基准测试
trtexec --onnx=model.onnx --minShapes=input:1x3x244x244 --optShapes=input:16x3x244x244 --maxShapes=input:32x3x244x244 --shapes=input:5x3x244x244



trtexec --onnx=depth_feat_model.onnx --minShapes=input:1x4x128x128 --maxShapes=input:1x4x896x896 --shapes=input:1x4x512x512 --saveEngine=depth_feat_model.engine --verbose --workspace=1024 --fp32

网络性能测试

  • 加载转换后的TensorRT模型进行性能测试,指定batch大小
trtexec --loadEngine=mnist16.trt --batch=1

打印输出:
trtexec会打印出很多时间,这里需要对每个时间的含义进行解释,然后大家各取所需,进行评测。总的打印如下:
[09/06/2021-13:50:34] [I] Average on 10 runs - GPU latency: 2.74553 ms - Host latency: 3.74192 ms (end to end 4.93066 ms, enqueue 0.624805 ms)  # 跑了10次,GPU latency: GPU计算耗时, Host latency:GPU输入+计算+输出耗时,end to end:GPU端到端的耗时,eventout - eventin,enqueue:CPU异步耗时
[09/06/2021-13:50:34] [I] Host Latency
[09/06/2021-13:50:34] [I] min: 3.65332 ms (end to end 3.67603 ms)
[09/06/2021-13:50:34] [I] max: 5.95093 ms (end to end 6.88892 ms)
[09/06/2021-13:50:34] [I] mean: 3.71375 ms (end to end 5.30082 ms)
[09/06/2021-13:50:34] [I] median: 3.70032 ms (end to end 5.32935 ms)
[09/06/2021-13:50:34] [I] percentile: 4.10571 ms at 99% (end to end 6.11792 ms at 99%)
[09/06/2021-13:50:34] [I] throughput: 356.786 qps
[09/06/2021-13:50:34] [I] walltime: 3.00741 s
[09/06/2021-13:50:34] [I] Enqueue Time
[09/06/2021-13:50:34] [I] min: 0.248474 ms
[09/06/2021-13:50:34] [I] max: 2.12134 ms
[09/06/2021-13:50:34] [I] median: 0.273987 ms
[09/06/2021-13:50:34] [I] GPU Compute
[09/06/2021-13:50:34] [I] min: 2.69702 ms
[09/06/2021-13:50:34] [I] max: 4.99219 ms
[09/06/2021-13:50:34] [I] mean: 2.73299 ms
[09/06/2021-13:50:34] [I] median: 2.71875 ms
[09/06/2021-13:50:34] [I] percentile: 3.10791 ms at 99%
[09/06/2021-13:50:34] [I] total compute time: 2.93249 s

Host Latency gpu: 输入+计算+输出 三部分的耗时
Enqueue Time:CPU异步的时间(该时间不具有参考意义,因为GPU的计算可能还没有完成)
GPU Compute:GPU计算的耗时
综上,去了Enqueue Time时间都是有意义的
  • 收集和打印时序跟踪信息
trtexec --deploy=data/AlexNet/AlexNet_N2.prototxt --output=prob --exportTimes=trace.json
  • 使用多流调整吞吐量

调整吞吐量可能需要运行多个并发执行流。例如,当实现的延迟完全在所需阈值内时,我们可以增加吞吐量,即使以一些延迟为代价。例如,为批量大小 1 和 2 保存引擎并假设两者都在 2ms 内执行,延迟阈值:

trtexec --deploy=GoogleNet_N2.prototxt --output=prob --batch=1 --saveEngine=g1.trt --int8 --buildOnly
trtexec --deploy=GoogleNet_N2.prototxt --output=prob --batch=2 --saveEngine=g2.trt --int8 --buildOnly
  • 保存的引擎可以尝试找到低于 2 ms 的组合批次/流,以最大化吞吐量:
trtexec --loadEngine=g1.trt --batch=1 --streams=2
trtexec --loadEngine=g1.trt --batch=1 --streams=3
trtexec --loadEngine=g1.trt --batch=1 --streams=4
trtexec --loadEngine=g2.trt --batch=2 --streams=2

python调用 TensorRT模型的推理

推理依旧分为动态尺寸的和固定尺寸的,动态推理这一块C++版本的资料比较多,python接口的比较少,固定尺寸的推理官方也有demo,分为异步同步推理。

python推理接收numpy格式的数据输入。

动态推断

import tensorrt as trt
import pycuda.driver as cuda
#import pycuda.driver as cuda2
import pycuda.autoinit
import numpy as np
import cv2
def load_engine(engine_path):
    #TRT_LOGGER = trt.Logger(trt.Logger.WARNING)  # INFO
    TRT_LOGGER = trt.Logger(trt.Logger.ERROR)
    with open(engine_path, 'rb') as f, trt.Runtime(TRT_LOGGER) as runtime:
        return runtime.deserialize_cuda_engine(f.read())
 
path ='/home/caidou/trt_python/model_1_-1_-1_3.engine'
#这里不以某个具体模型做为推断例子.
 
# 1. 建立模型,构建上下文管理器
engine = load_engine(path)
context = engine.create_execution_context()
context.active_optimization_profile = 0
 
#2. 读取数据,数据处理为可以和网络结构输入对应起来的的shape,数据可增加预处理
imgpath = '/home/caidou/test/aaa.jpg'
image = cv2.imread(imgpath)
image = np.expand_dims(image, 0)  # Add batch dimension.  
 
 
#3.分配内存空间,并进行数据cpu到gpu的拷贝
#动态尺寸,每次都要set一下模型输入的shape,0代表的就是输入,输出根据具体的网络结构而定,可以是0,1,2,3...其中的某个头。
context.set_binding_shape(0, image.shape)
d_input = cuda.mem_alloc(image.nbytes)  #分配输入的内存。
 
 
output_shape = context.get_binding_shape(1) 
buffer = np.empty(output_shape, dtype=np.float32)
d_output = cuda.mem_alloc(buffer.nbytes)    #分配输出内存。
cuda.memcpy_htod(d_input,image)
bindings = [d_input ,d_output]
 
#4.进行推理,并将结果从gpu拷贝到cpu。
context.execute_v2(bindings)  #可异步和同步
cuda.memcpy_dtoh(buffer,d_output)  
output = buffer.reshape(output_shape)
 
#5.对推理结果进行后处理。这里只是举了一个简单例子,可以结合官方静态的yolov3案例完善。

静态推断:

静态推断和动态推断差不多,只不过不需要每次都分配输入和输出的内存空间。

import tensorrt as trt
import pycuda.driver as cuda
#import pycuda.driver as cuda2
import pycuda.autoinit
import numpy as np
import cv2
path ='/home/caidou/trt_python/model_1_4_256_256.engine'
engine = load_engine(path)
imgpath = 'aaa.jpg'
context = engine.create_execution_context()
image1 = cv2.write(imgpath)
image1 = cv2.resize(image1,(256,256))
image2 = image1.copy()
image3 = image1.copy()
image4 = image1.copy()
image = np.concatenate((image1,image2,image3,image4))
image = image.reshape(-1,256,256)
 
# image = np.expand_dims(image, axis=1)
image = image.astype(np.float32)
 
image = image.ravel()#数据平铺
outshape= context.get_binding_shape(1) 
output = np.empty((outshape), dtype=np.float32)
d_input = cuda.mem_alloc(1 * image.size * image.dtype.itemsize)
d_output = cuda.mem_alloc(1*output.size * output.dtype.itemsize)
bindings = [int(d_input), int(d_output)]
stream = cuda.Stream()
for i in tqdm.tqdm(range(600)):
    cuda.memcpy_htod(d_input,image)
    context.execute_v2(bindings)
    cuda.memcpy_dtoh(output, d_output)

更新:

SLAM-同时定位与地图构建

同时定位与地图构建(英语:Simultaneous localization and mapping,一般直接称SLAM)是一种概念:希望机器人从未知环境的未知地点出发,在运动过程中通过重复观测到的地图特征(比如,墙角,柱子等)定位自身位置和姿态,再根据自身位置增量式的构建地图,从而达到同时定位和地图构建的目的。

一、SLAM的典型应用领域

机器人定位导航领域:地图建模。SLAM可以辅助机器人执行路径规划、自主探索、导航等任务。国内的科沃斯、塔米以及最新面世的岚豹扫地机器人都可以通过用SLAM算法结合激光雷达或者摄像头的方法,让扫地机高效绘制室内地图,智能分析和规划扫地环境,从而成功让自己步入了智能导航的阵列。国内思岚科技(SLAMTEC)为这方面技术的主要提供商,SLAMTEC的命名就是取自SLAM的谐音,其主要业务就是研究服务机器人自主定位导航的解决方案。目前思岚科技已经让关键的二维激光雷达部件售价降至百元,这在一定程度上无疑进一步拓展了SLAM技术的应用前景。

VR/AR方面:辅助增强视觉效果。SLAM技术能够构建视觉效果更为真实的地图,从而针对当前视角渲染虚拟物体的叠加效果,使之更真实没有违和感。VR/AR代表性产品中微软Hololens、谷歌ProjectTango以及MagicLeap都应用了SLAM作为视觉增强手段。

无人机领域:地图建模。SLAM可以快速构建局部3D地图,并与地理信息系统(GIS)、视觉对象识别技术相结合,可以辅助无人机识别路障并自动避障规划路径,曾经刷爆美国朋友圈的Hovercamera无人机,就应用到了SLAM技术。

无人驾驶领域:视觉里程计。SLAM技术可以提供视觉里程计功能,并与GPS等其他定位方式相融合,从而满足无人驾驶精准定位的需求。例如,应用了基于激光雷达技术Google无人驾驶车以及牛津大学MobileRoboticsGroup11年改装的无人驾驶汽车野猫(Wildcat)均已成功路测。

二、SLAM框架

SLAM系统框架如图所示,一般分为五个模块,包括传感器数据、视觉里程计、后端、建图及回环检测。

传感器数据:主要用于采集实际环境中的各类型原始数据。包括激光扫描数据、视频图像数据、点云数据等。

视觉里程计:主要用于不同时刻间移动目标相对位置的估算。包括特征匹配、直接配准等算法的应用。

后端:主要用于优化视觉里程计带来的累计误差。包括滤波器、图优化等算法应用。

建图:用于三维地图构建。

回环检测:主要用于空间累积误差消除

其工作流程大致为:

传感器读取数据后,视觉里程计估计两个时刻的相对运动(Ego-motion),后端处理视觉里程计估计结果的累积误差,建图则根据前端与后端得到的运动轨迹来建立地图,回环检测考虑了同一场景不同时刻的图像,提供了空间上约束来消除累积误差。

三、SLAM分类(基于传感器的SLAM分类)

目前用在SLAM上的传感器主要分为这两类,一种是基于激光雷达的激光SLAM(Lidar SLAM)和基于视觉的VSLAM(Visual SLAM)。

1.激光SLAM

激光SLAM采用2D或3D激光雷达(也叫单线或多线激光雷达),2D激光雷达一般用于室内机器人上(如扫地机器人),而3D激光雷达一般使用于无人驾驶领域。激光雷达的出现和普及使得测量更快更准,信息更丰富。激光雷达采集到的物体信息呈现出一系列分散的、具有准确角度和距离信息的点,被称为点云。通常,激光SLAM系统通过对不同时刻两片点云的匹配与比对,计算激光雷达相对运动的距离和姿态的改变,也就完成了对机器人自身的定位。

激光雷达测距比较准确,误差模型简单,在强光直射以外的环境中运行稳定,点云的处理也比较容易。同时,点云信息本身包含直接的几何关系,使得机器人的路径规划和导航变得直观。激光SLAM理论研究也相对成熟,落地产品更丰富。

对比相机、ToF 和其他传感器,激光可以使精确度大大提高,常用于自动驾驶汽车和无人机等高速移动运载设备的相关应用。激光传感器的输出值一般是二维 (x, y) 或三维 (x, y, z) 点云数据。激光传感器点云提供了高精确度距离测度数据,特别适用于 SLAM 建图。一般来说,首先通过点云匹配来连续估计移动。然后,使用计算得出的移动数据(移动距离)进行车辆定位。对于激光点云匹配,会使用迭代最近点 (ICP) 和正态分布变换 (NDT) 等配准算法。二维或三维点云地图可以用栅格地图或体素地图表示。

但就密度而言,点云不及图像精细,因此并不总能提供充足的特征来进行匹配。例如,在障碍物较少的地方,将难以进行点云匹配,因此可能导致跟丢车辆。此外,点云匹配通常需要高处理能力,因此必须优化流程来提高速度。鉴于存在这些挑战,自动驾驶汽车定位可能需要融合轮式测距、全球导航卫星系统 (GNSS) 和 IMU 数据等其他测量结果。仓储机器人等应用场景通常采用二维激光雷达 SLAM,而三维激光雷达点云 SLAM 则可用于无人机和自动驾驶。

2.视觉SLAM

眼睛是人类获取外界信息的主要来源。视觉SLAM也具有类似特点,它可以从环境中获取海量的、富于冗余的纹理信息,拥有超强的场景辨识能力。早期的视觉SLAM基于滤波理论,其非线性的误差模型和巨大的计算量成为了它实用落地的障碍。近年来,随着具有稀疏性的非线性优化理论(Bundle Adjustment)以及相机技术、计算性能的进步,实时运行的视觉SLAM已经不再是梦想。

视觉SLAM的优点是它所利用的丰富纹理信息。例如两块尺寸相同内容却不同的广告牌,基于点云的激光SLAM算法无法区别他们,而视觉则可以轻易分辨。这带来了重定位、场景分类上无可比拟的巨大优势。同时,视觉信息可以较为容易的被用来跟踪和预测场景中的动态目标,如行人、车辆等,对于在复杂动态场景中的应用这是至关重要的。

通过对比我们发现,激光SLAM和视觉SLAM各擅胜场,单独使用都有其局限性,而融合使用则可能具有巨大的取长补短的潜力。例如,视觉在纹理丰富的动态环境中稳定工作,并能为激光SLAM提供非常准确的点云匹配,而激光雷达提供的精确方向和距离信息在正确匹配的点云上会发挥更大的威力。而在光照严重不足或纹理缺失的环境中,激光SLAM的定位工作使得视觉可以借助不多的信息进行场景记录。

近年来,SLAM导航技术已取得了很大的发展,它将赋予机器人和其他智能体前所未有的行动能力,而激光SLAM与视觉SLAM必将在相互竞争和融合中发展,使机器人从实验室和展厅中走出来,做到真正的服务于人类。

顾名思义,视觉 SLAM(又称 vSLAM)使用从相机和其他图像传感器采集的图像。视觉 SLAM 可以使用普通相机(广角、鱼眼和球形相机)、复眼相机(立体相机和多相机)和 RGB-D 相机(深度相机和 ToF 相机)。

视觉 SLAM 所需的相机价格相对低廉,因此实现成本较低。此外,相机可以提供大量信息,因此还可以用来检测路标(即之前测量过的位置)。路标检测还可以与基于图的优化结合使用,这有助于灵活实现 SLAM。

使用单个相机作为唯一传感器的 vSLAM 称为单目 SLAM,此时难以定义深度。这个问题可以通过以下方式解决:检测待定位图像中的 AR 标记、棋盘格或其他已知目标,或者将相机信息与其他传感器信息融合,例如测量速度和方向等物理量的惯性测量单元 (IMU) 信息。vSLAM 相关的技术包括运动重建 (SfM)、视觉测距和捆绑调整。

视觉 SLAM 算法可以大致分为两类。稀疏方法:匹配图像的特征点并使用 PTAM 和 ORB-SLAM 等算法。稠密方法:使用图像的总体亮度以及 DTAM、LSD-SLAM、DSO 和 SVO 等算法。

SIFT–尺度不变特征变换

https://docs.opencv.org/4.1.2/da/df5/tutorial_py_sift_intro.html

SIFT,即尺度不变特征变换(Scale-invariant feature transform,SIFT),是用于图像处理领域的一种描述。这种描述具有尺度不变性,可在图像中检测出关键点,是一种局部特征描述子。

尺度不变特征变换 (Scale-invariant feature transform, SIFT) 是计算机视觉中一种检测、描述和匹配图像局部特征点的方法,通过在不同的尺度空间中检测极值点或特征点 (Conrner Point, Interest Point) ,提取出其位置、尺度和旋转不变量,并生成特征描述子,最后用于图像的特征点匹配。SIFT 特征凭借其良好的性能广泛应用于运动跟踪 (Motion tracking) 、图像拼接 (Automatic mosaicing) 、3D 重建 (3D reconstruction) 、移动机器人导航 (Mobile robot navigation) 以及目标识别 (Object Recognition) 等领域。

SIFT特征的特点

SIFT是一种检测、描述、匹配图像局部特征点的算法,通过在尺度空间中检测极值点,提取位置、尺度、旋转不变量,并抽象成特征向量加以描述,最后用于图像特征点的匹配。SIFT特征对灰度、对比度变换、旋转、尺度缩放等保持不变性,对视角变化、仿射变化、噪声也具有一定的鲁棒性。但其实时性不高,对边缘光滑的目标无法准确提取特征点。

SIFT算法主要包括四个步骤。

1. 尺度空间极值检测

从上图可以明显看出,我们不能使用相同的窗口来检测具有不同比例的关键点。即便小拐角可以。但是要检测更大的拐角,我们将需要更大的窗口。为此,使用了比例空间滤波。在其中,找到具有各种σ值的图像的高斯拉普拉斯算子。LoG用作斑点检测器,可检测由于σ的变化而导致的各种大小的斑点。简而言之,σ用作缩放参数。例如,在上图中,低σ的高斯核对于较小的拐角给出较高的值,而高σ的高斯核对于较大的拐角而言非常合适。因此,我们可以找到整个尺度和空间上的局部最大值,这给了我们(x,y,σ)值的列表,这意味着在(x,y在σ尺度上有一个潜在的关键点。

但是这种LoG代价昂贵,因此SIFT算法使用的是高斯差值,它是LoG的近似值。高斯差是作为具有两个不同σ的图像的高斯模糊差而获得的,设为σ和kσ。此过程是针对高斯金字塔中图像的不同八度完成的。如下图所示:

一旦找到该DoG,便会在图像上搜索比例和空间上的局部极值。例如,将图像中的一个像素与其8个相邻像素以及下一个比例的9个像素和前一个比例的9个像素进行比较。如果是局部极值,则可能是关键点。从根本上说,关键点是最好的代表。如下图所示:

对于不同的参数,本文给出了一些经验数据,可以概括为:octaves=4,缩放尺度=5,初始σ=1.6,k=√2等作为最佳值。

2. 关键点定位

一旦找到潜在的关键点位置,就必须对其进行优化以获取更准确的结果。他们使用了标度空间的泰勒级数展开来获得更精确的极值位置,如果该极值处的强度小于阈值(根据论文为0.03),则将其拒绝。在OpenCV DoG中,此阈值称为**ContrastThreshold**,它对边缘的响应较高,因此也需要删除边缘。

为此,使用类似于哈里斯拐角检测器的概念。他们使用2×2的Hessian矩阵(H)计算主曲率。从哈里斯拐角检测器我们知道,对于边缘,一个特征值大于另一个特征值。因此,这里他们使用了一个简单的函数。

如果该比率大于一个阈值(在OpenCV中称为**edgeThreshold**),则该关键点将被丢弃。论文上写的值为10。

因此,它消除了任何低对比度的关键点和边缘关键点,剩下的就是很可能的目标点。

3. 方向分配

现在,将方向分配给每个关键点,以实现图像旋转的不变性。根据比例在关键点位置附近采取邻域,并在该区域中计算梯度大小和方向。创建了一个具有36个覆盖360度的bin的方向直方图(通过梯度幅度和σ等于关键点比例的1.5的高斯加权圆窗加权)。提取直方图中的最高峰,并且将其超过80%的任何峰也视为计算方向。它创建的位置和比例相同但方向不同的关键点。它有助于匹配的稳定性。

4. 关键点描述

现在创建了关键点描述符。在关键点周围采用了16×16的邻域。它分为16个4×4大小的子块。对于每个子块,创建8 bin方向直方图。因此共有128个bin值可用。它被表示为形成关键点描述符的向量。除此之外,还采取了几种措施来实现针对照明变化,旋转等的鲁棒性。

5. 关键点匹配

通过识别两个图像的最近邻,可以匹配两个图像之间的关键点。但是在某些情况下,第二个最接近的匹配可能非常接近第一个。它可能是由于噪音或其他原因而发生的。在那种情况下,采用最接近距离与第二最接近距离之比。如果大于0.8,将被拒绝。根据论文,它可以消除大约90%的错误匹配,而仅丢弃5%的正确匹配。 因此,这是SIFT算法的总结。有关更多详细信息和理解,强烈建议阅读原始论文。记住一件事,该算法已申请专利。所以这个算法包含在opencv contrib repo中.

OpenCV中的SIFT

现在,让我们来看一下OpenCV中可用的SIFT功能。让我们从关键点检测开始并进行绘制。首先,我们必须构造一个SIFT对象。我们可以将不同的参数传递给它,这些参数是可选的,它们在docs中已得到很好的解释。

import numpy as np
import cv2 as cv
img = cv.imread('home.jpg')
gray= cv.cvtColor(img,cv.COLOR_BGR2GRAY)
sift = cv.xfeatures2d.SIFT_create()
kp = sift.detect(gray,None)
img=cv.drawKeypoints(gray,kp,img)
cv.imwrite('sift_keypoints.jpg',img)

sift.detect()函数在图像中找到关键点。如果只想搜索图像的一部分,则可以通过掩码。每个关键点是一个特殊的结构,具有许多属性,例如其(x,y)坐标,有意义的邻域的大小,指定其方向的角度,指定关键点强度的响应等。

OpenCV还提供**cv.drawKeyPoints**()函数,该函数在关键点的位置绘制小圆圈。 如果将标志**cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS**传递给它,它将绘制一个具有关键点大小的圆,甚至会显示其方向。 请参见以下示例。

img=cv.drawKeypoints(gray,kp,img,flags=cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) cv.imwrite('sift_keypoints.jpg',img)

查看下面的结果: 

现在要计算描述符,OpenCV提供了两种方法。 1. 由于已经找到关键点,因此可以调用**sift.compute**(),该函数根据我们找到的关键点来计算描述符。例如:kp,des = sift.compute(gray,kp) 2. 如果找不到关键点,则可以使用**sift.detectAndCompute**()函数在单步骤中直接找到关键点和描述符。

我们将看到第二种方法:

sift = cv.xfeatures2d.SIFT_create() 
kp, des = sift.detectAndCompute(gray,None)

这里的kp将是一个关键点列表,而des是一个形状为NumberofKeypoints×128的数字数组。

这样我们得到了关键点,描述符等。

MVS学习–《A Comparison and Evaluation of Multi-View Stereo Reconstruction Algorithms》

1. 前言

Middlebury是计算机视觉和三维中间领域著名的高校,特别是提供了著名的立体匹配benchmark数据库,并不断提供新数据的更新。在MVS领域,也同样提供了经典的benchmark数据库,包含两个物体-Temple和Dino,其中Temple有312张相片,Dino有363张相片,如下图所示。并且每个物体还提供了由激光Lidar测量得到的地面真值(Groud Truth)数据,因此可以用来准确的衡量不同MVS算法的准确性(重建的三维模型与真值的差异)和完整性(有多少真值包含在重建的三维模型中)。

在建立该数据库的过程中,Middlebury的研究团队分类总结了当时(2006年)的state-of-art的算法,提出了算法有效性评价标准。基于该标准,并使用该数据库验证这些算法的有效性,最终形成该文章1。这篇文章是后来几乎每一篇研究MVS算法的文章的必引参考文献,其中对于算法的分类介绍和有效性验证规则十分经典,下面分别进行总结。

2. MVS算法分类

MVS是指Multiview Stereo,具体来说是通过多幅已知拍摄方位信息(外方位元素)的图像来估计目标三维信息的算法,数据基于图像的三维重建中一大类非常重要和实用的算法。文章中提到类似的方法还有双目或者三目立体匹配方法,这一类方法能够获得单一的视差图,但是受限于照片数量和拍摄角度,无法覆盖物体的全部表面。另一类方法是多基线立体重建方法,可以构建稀疏特征点集。

一般来说,MVS可以按照如下6个方面的标准进行分类:

  1. 场景表达方式(scene representation);
  2. 图像一致性计算方法(photo consistency measure);
  3. 可见性模型(visible model);
  4. 在重建时优先考虑的形状约束(shape prior);
  5. 重建算法(reconstruction algorithm);
  6. 初始化条件(initialization requirements)。

下面分别对每个方面进行简单的描述。

2.1 场景表达(Scene Representation)

场景表达是指重建得到的三维场景使用什么样的数学模型进行表达,一般来说有如下4种方式:

  1. 体素(Voxel)
  2. 层次级(level set):记录每个点到某个最近平面的距离
  3. 多边形实体(polygon mesh):这是应该是我们最熟悉的表达方式,也是人工三维建模最常见的数据表达方式
  4. 深度图(depth map):一般基于像方立体匹配算法算法生成的结果就是深度图,每个像素的灰度值代表该像素距离当前图像平面的距离。

2.2 图像一致性计算方法(Photo Consistency Measure)

这部分和双目立体匹配中用到的图像一致性计算方法类似,但是考虑到MVS本身的特殊性,一般来说,MVS中图像一致性计算根据搜索内容的不同分为以下两种方法

1. 基于物方的图像一致性计算方法

通常使用体素表达方法,搜索空间中的每个体素在对应两幅图像中的投影位置的图像一致性,如果该一致性计算值小于某个阈值,则该体素可以认为是代表了真实物体。

2. 基于像方的图像一致性计算方法

根据极线约束,对于一幅图像的某个点,搜索其对应极线上最相似的匹配点(一致性最高),这种方法通常在双目立体视觉中使用。

需要注意的是这两种方法都是基于物体表面为Lambartian的假设,但是也有进一步的研究利用BRDF进行计算,或者考虑物体的阴影,消除物体阴影对于一致性计算的影响。

2.3 可见性模型(Visible Model)

可见性模型是在计算图像一致性时,决定究竟哪些图像和参考图像有共视区域,可以进行图像一致性计算的方法。一般来说,有如下三种模型

  • 几何模型。
  • 准几何模型。
  • 基于粗差(outlier)的模型,通常是将遮挡视为粗差,因为对于一个点来说,在两视中被看到的可能性大于被遮挡的可能性。

2.4 在重建时优先考虑的形状约束(Shape Prior)

由于常见的弱纹理(大范围区域颜色相同或者相近)或者无纹理等原因,导致在匹配是在这些区域无法得到良好的匹配结果,因此需要引入形状约束来近似约束这些区域的可能形状,可以使得最终得到的场景具有某种特殊的性质。这种方法在双目立体匹配的研究中是极为常见的方法,但是在MVS中,由于多幅图像提供更强的约束,较少使用这种方法。常见的形状约束方法如下:

  1. 基于场景重建的技术通常采用“最少平面数”约束,因为过多的多边形面片会使得场景过于破碎。
  2. 基于体素和Space carve的重建方法通常增加“最多平面数”约束,使得表面具有更加丰富的细节。
  3. 在基于像方的匹配方法中,通常添加局部平滑约束:例如双目立体匹配中常见的piece-wise smothness,假设场景中的弱纹理区域是与摄影平面平行的小平面。

2.5 重建算法(Reconstruction Algorithm)

  1. 体素着色算法:从一个volumn中提取一个平面出来
  2. 通过递推的方法展开一个平面:在过程中最小化代价函数(based on voxels, level-set, mesh)
  3. 基于像方的匹配,生成深度图,并对不同图像间的深度图进行融合
  4. 提取特征点,拟合一个面来重建特征

2.6 初始化条件(Initialization Requirements)

  1. 需要图像集(毕竟是基于图像的三维重建,需要尽可能多的多角度拍摄的同一场景的图像)
  2. 几乎所有的算法都要求或者假设待重建三维目标的空间范围或者scene geometry
  3. 基于像方的方法要求最大/最小视差(这一点要求和2类似)

3. MVS算法的评价

文章中提出,对于MVS算法应该从一下两个方面进行评价

1. 准确性

准确性是指重建结果与真值间的差距,一般方法是,对于重建结果中的一个三维空间点,寻找其对应真值中的点,计算其距离,最后统计所有点距离真值的距离。 根据统计结果来评价重建结果的准确性。

2. 完整性

完整性是指有多少真值被包含在重建结果中。一般方法与准确性计算类似,但是是计算真值中的点到重建结果中最近点的距离,统计所有真值点的计算结果来评价重建的完整性。需要注意的是,如果真值中的点距离重建结果中最近点的距离大于某个阈值,则认为是没有找打匹配点,也就是该真值点没有被覆盖。

SFM的重建成果是稀疏三维点云,而MVS可以获得更好的结果

(1)如何理解密集点云的生成原理

  MVS是生成密集点云的方法,事实上,为什么我们在SFM中不能得到密集点云?因为,SFM中我们用来做重建的点是由特征匹配提供的!这些匹配点天生不密集!而使用计算机来进行三维点云重建,我们必须认识到,点云的密集程度是由人为进行编程进行获取的。SFM获得点的方式决定了它不可能直接生成密集点云。

  而MVS则几乎对照片中的每个像素点都进行匹配,几乎重建每一个像素点的三维坐标,这样得到的点的密集程度可以较接近图像为我们展示出的清晰度。

  其实现的理论依据在于,多视图照片间,对于拍摄到的相同的三维几何结构部分,存在极线几何约束。

描述这种几何约束:

  想象,对于在两张图片中的同一个点。现在回到拍摄照片的那一刻,在三维世界中,存在一条光线从照片上这一点,同时穿过拍摄这张照片的相机的成像中心点,最后会到达空间中一个三维点,这个三维点同时也会在另一张照片中以同样的方式投影。

  这个过程这样看来,很普通,就如同普通的相机投影而已。但是因为两张图片的原因,他们之间存在联系,这种联系的证明超过了能力范围,但是我们只需要知道,此种情况下,两张照片天然存在了一种约束。

  X表示空间中的一点,x1、x2为X在两张图片中的同一点。由于天然的约束,已知x1,想要在另一张图片中找到x2,可以在直线L2上进行一维寻找。  MVS主要做的就是如何最佳搜索匹配不同相片的同一个点。

2)初步探究MVS中的点匹配方法

  在有了约束的基础上,接下来就是在图片上的一条线上进行探测,寻找两张图片上的同一点。主要方法为逐像素判断,两个照片上的点是否是同一点——为此提出图像点间的“一致性判定函数”

   π (p)是使得点p投影到照片上一点的函数, Ω(x) 函数定义了一个点x周围的区域,I(x) 函数代表了照片区域的强度特征,ρ(f, g) 是用来比较两个向量之间的相似程度的

  ρ函数和Ω函数的具体选择决定这个”一致性判别“的准确度。这个函数的具体实现,由编程实现。

  

参考文献


  1. Seitz, S. M., Curless, B., Diebel, J., Scharstein, D., & Szeliski, R. (n.d.). A Comparison and Evaluation of Multi-View Stereo Reconstruction Algorithms. In 2006 IEEE Computer Society Conference on Computer Vision and Pattern Recognition – Volume 1 (CVPR’06) (Vol. 1, pp. 519–528). IEEE. https://doi.org/10.1109/CVPR.2006.19

基于SfM(Structure from motion)的三维重建

SfM(Structure from motion) 是一种三维重建的方法,用于从motion中实现3D重建。也就是从时间系列的2D图像中推算3D信息。

人的大脑可以从动的物体中取得其三维的信息,是因为大脑在动的2D图像中找到了匹配的地方,即Corresponding area (points)。然后通过匹配点之间的视差得到相对的深度信息,在这一点上,原理和基于Stereo的三维重建相同。

SfM的输入是一段motion或者一时间系列的2D图群,如下图所示 [1],这里不需要任何相机的信息。然后通过2D图之间的匹配可以推断出相机的各项参数Corresponding points可以用SIFT,SURF来匹配,也可以用最新的AKAZE(SIFT的改进版,2010)来匹配。而Corresponding points的跟踪则可以用Lucas-Kanede的Optical Flow来完成。

在SfM中,误匹配会造成较大的Error,所以要对匹配进行筛选,目前流行的方法是RANSAC(Random Sample Consensus)。2D的误匹配点可以应用3D的Geometric特征来进行排除。

Bundler [2] 就是一种SfM的方法,Bundler使用了基于SIFT的匹配算法,并且对匹配进行了过滤去噪处理。下图显示了一组测试数据(一时间系列的2D图群):

将这些图片保存到同一个文件夹,然后将文件夹的目录输入,Bundler会自行处理,之后会得到一群Corresponding points。比如其中的一组Corresponding points (A1,A2,A3,…Am),其实他们来自同一个三维点A的Projection。所以通过这些点可以重建三维点A。然后将很多组Corresponding points 进行重建,则得到了一群三维的点,这里称为3D点阵。

然后3D点阵可以通过MeshLab(开源Source,支持Windows/Linux/Mac)来重建稀疏的Mesh。也可以通过PMVS(Patch-based Multi-view Stereo)来重建Dense的Mesh[3]。

[1] 満上育久 ”Structure from Motion – Osaka University“ 映像情报メディア学会志 Vol.65, No.4, pp.479-482, 2011.

[2] N.Snavely, S.M. Seitz, R.Szeliski, “Modeling the World from Internet Photo Collections”, International Journal of Computer Vision, vol.80, no.2, 2008.

[3] Y. Furukawa, J.Ponce, “Accurate, Dense and Robust Multi-view Stereopsis” IEEE Transactions on Pattern Analysis and Machine Intelligence, 2009.

补充:通过视差d求解深度图:

同一水平线上的两个照相机拍摄到的照片是服从以下物理规律的:

这种思路最先应用于使用单张图片生成新视角问题:DeepStereo 和 Deep3d之中, 在传统的视角生成问题之中,首先会利用两张图(或多张)求取图片之间的视差d,其次通过得到的视差(相当于三维场景)来生成新视角

通过同一水平线的两个视图获得深度图

神奇的达尔文进化定律告诉我们,单个眼睛的自然界生物大都灭绝了。自然界的大多物种都是和人一样,需要两只眼睛来做三维空间定位。那为什么需要两只眼睛呢?

因为一只眼睛看到的图像是二维的,二维的信息是无法用来表示三维的空间的,如上图所示,虽然处于同一水平面上的照相机L,R拍摄了同一个物体,两者之间产生的图片是不同的。并且这种不同是不能通过平移生成的图片所消除的。离照相机近的物体偏离的位置比较大,离照相机远的物体偏离的比较少。这种差异性的存在就是三维空间带来的。(这部分请参考双眼可以测距和建立立体环境,双摄像头可以吗?)。同时同一水平线上的两个照相机拍摄到的照片是服从以下物理规律的:

这种思路最先应用于使用单张图片生成新视角问题:DeepStereo 和 Deep3d之中, 在传统的视角生成问题之中,首先会利用两张图(或多张)求取图片之间的视差d,其次通过得到的视差(相当于三维场景)来生成新视角