分类： 论文

3D视频会议系统VirtualCube：相隔万里也如近在咫尺般身临其境

https://www.microsoft.com/en-us/research/project/virtualcube/

微软亚洲研究院的研究项目 3D 视频会议系统 VirtualCube，可以让在线会议的与会者建立自然的眼神交互，沉浸式的体验就像在同一个房间内面对面交流一样。该技术的相关论文被全球虚拟现实学术会议 IEEE Virtual Reality 2022 接收并获得了大会的最佳论文奖（Best Paper Award – Journal Papers Track）。

在日常交谈中，相互注视和摆动头部等动作都是自然对话的组成部分，尤其是当我们在面对面交流中变换话题、控制发言或转换交流对象时，都会伴随眼神和肢体动作的交流。然而，当前的视频会议技术却存在着一定的缺陷——由于摄像头和屏幕不在同一高度，如果看向屏幕眼神往往很不自然，如果看向摄像头则无法关注到其他与会者的反应，因此视频会议缺少了线下交流的真实感和互动感。而且在实际的工作中，我们还会有各种不同的会议场景，比如多人会议、同排而坐协同工作等情况，对于捕捉与会者的侧方视线和动作来说，现有的视频会议系统就更无能为力了。

如果有一个会议系统，可以让人们即使身处不同的地方，也能像在同一房间里一样交流，视线转动就能与同伴建立起眼神沟通，这是否会给远程办公增添一份沉浸式的真实感呢？

利用现有的普通硬件设备搭建的 3D 视频系统：

为了解决这些问题，微软亚洲研究院提出了创新的 3D 视频会议系统——VirtualCube，它可以在远程视频会议中建立起真人等大的 3D 形象，无论是正面沟通，还是侧方交流，系统都能够正确捕捉到与会者的眼神、动态，建立起眼神和肢体交流。相关论文被全球虚拟现实学术会议 IEEE Virtual Reality 2022 接收并获得了大会的最佳论文奖（Best Paper Award – Journal Papers Track）

VirtualCube 系统具有三大优势：

标准化、简单化，全部使用现有的普通硬件设备。与办公场所中常见的格子间（Cubicle）类似，每个 VirtualCube 都提供了一致的物理环境和设备配置：与会者正前方安装有6个 Azure Kinect RGBD 摄像头，以捕捉真人的图像和眼神等动作；在与会者的正面和左右两侧还各有一个大尺寸的显示屏，以创造出身临其境的参会感。使用现有的、标准化的硬件能够大大简化用户设备校准的工作量，从而实现 3D 视频系统的快速部署和应用。

感。使用现有的、标准化的硬件能够大大简化用户设备校准的工作量，从而实现 3D 视频系统的快速部署和应用。

6个 Azure Kinect RGBD 摄像头捕捉人像和眼神等动作

多人、多场景，任意组合。作为在线视频会议的基础构建，VirtualCube 的虚拟会议环境可由多个空间（Cube）按照不同的布局组成，以支持不同的会议场景，例如两人的面对面会议、两人并排会议，以及多人的圆桌会议等。

多个空间（Cube）可实现任意组合

实时、高质量渲染真人图像。VirtualCube 可以捕捉到参与者的各种细微变化，包括人的皮肤颜色、纹理，面部或衣服上的反射光泽等，并实时渲染生成真人大小的 3D 形象，显示在远程与会者的屏幕中。而且虚拟会议环境的背景也可以根据用户的需求自由选择。

任意变换会议场景，都能身临其境

V-Cube View和V-Cube Assembly算法双剑合璧，沉浸式会议体验不再是难题

其实业界对 3D 视频会议的研究从未间断过。早在2000年，就有人曾提出过与类似混合现实技术有关的畅想。基于这个设想，科研人员一直在探索如何将视频会议以更逼真、更自然的方式呈现，期间也出现了不同的技术路线和解决方案，但都没有达到理想的效果。对此，微软亚洲研究院主管研究员张译中和杨蛟龙表示，过往的研究仍然有很多没有解决的问题：首先，在真实环境下，无论放置怎样的单目摄像设备，即使图像质量再高，与会者也很难形成自然的眼神交流，特别是多人会议的情况；其次，很多研究针对特定的会议场景进行优化，如两个人面对面的会议或三人的圆桌会议，很难支持不同的会议设置；第三，虽然在影视界我们能够看到一些逼真的虚拟人，但那是需要专业的技术和影视团队长时间打磨和优化才能实现的，仍然需要一定的手工劳动，目前无法进行实时捕捉和实时渲染。

为此，微软亚洲研究院提出了 V-Cube View 和 V-Cube Assembly 两大全新算法，在 VirtualCube 中实现了自动捕捉参与者的手势动作和眼神变化，实时渲染形成高保真图像，让参与者在虚拟会议中体验到真实会议的氛围。

“两个人在交谈且相互注视对方时，对方看到的自己就相当于在自己眼睛的位置放置一个摄像头。但屏幕和摄像头的位置存在高低差，所以当一方注视屏幕中对方的眼睛时，摄像头捕捉到的眼神就会偏离。因此在 VirtualCube 中，我们在与会者正前方的屏幕边缘放置了六个摄像头，通过 V-Cube View 算法合成正确的视点图像，并利用 V-Cube Assembly 确定正确的相对位置，进而给与会者一个沉浸式的会议体验”，张译中介绍道。

基于深度学习的 V-Cube View 算法，通过 VirtualCube 中的六个摄像头的 RGBD 图像作为输入，实时渲染任意目标视点下人的高保真视频。这里的技术挑战是如何同时做到高保真和实时。对此，微软亚洲研究院主管研究员杨蛟龙解释道：“实时渲染高保真的人像，特别是高保真的人脸一直是个具有挑战性的研究课题。传统的三维重建和纹理贴图的做法虽然可以做到实时绘制，却无法重现出真实人脸复杂的材质和在不同视点下外观的变化。为此我们提出了一种新的 Lumi-Net 渲染方法，其核心思想是利用重构的三维几何作为参考来实现一个四维光场的实时渲染，并结合神经网络进行图像增强，从而提高了渲染的质量，特别是人脸区域的高保真度。”

具体而言，V-Cube View 算法分为三步进行。首先，研究员设计了一个神经网络来快速求解目标视点深度图作为人体的几何参考（geometry proxy）。然后，算法在给定的几何参考下将获取的多视角 RGB 图像（即光线）进行融合，实现绘制。在这一步中，研究员受传统的非结构化流明图（Unstructured Lumigraph）方法启发，将输入光线与目标像素光线的方向和深度差异作为先验，通过神经网络学习最合适的融合权重。最后，为了进一步提升绘制质量，研究员们使用了神经网络对上一步的绘制结果进行图像增强。整个算法实现了端到端的训练，并在训练过程中引入了感知损失函数及对抗学习技术，使得算法可以自动学习出最优的神经网络，实现高保真的绘制。而且为了保证绘制的实时性，算法的前两步都在低分辨率图像上执行，这样可以在不损失太多精度的情况下大大降低所需计算量。经过精心设计和优化的 V-Cube View 算法，将实时的三维人物渲染质量提升到了一个新的高度。

V-Cube View 算法示意图

另外，为了让 VirtualCube 的使用者拥有和线下交流同样的体验，在将与会者映射到虚拟环境时，系统还要考虑他们之间的相对位置关系，这时 V-Cube Assembly 算法就发挥了重要的作用。“在整个虚拟会议环境中，V-Cube Assembly 可以被定义为全局坐标系统，单个的 VirtualCube 则为局部坐标系统。全局坐标系与局部坐标系之间的正确 3D 几何变化，对在视频显示器上正确呈现远程与会者的图像至关重要”杨蛟龙介绍。

研究员们首先会在 VirtualCube 中捕捉与会者的 3D 几何体，形成局部坐标系，然后将这些局部坐标系的 3D 几何体数据，投射到全局坐标系，经过 V-Cube Assembly 处理，在全局虚拟会议环境中确定每个 VirtualCube 参与者正确的相对位置，最后再将全局 3D 几何体转换为 VirtualCube 的局部坐标系，影射到 VirtualCube 的屏幕上。

V-Cube Assembly 算法示意图

抛砖引玉，畅想未来办公无限可能

VirtualCube 给 3D 视频会议系统提供了一种全新的思路。无论从算法设计、端到端设备部署还是工程调试上，VirtualCube 都证明了利用现有的普通硬件设备就可以实现沉浸式的 3D 视频会议体验。

除了让与会者“共享”同一个物理空间外，研究员们还在探索利用 VirtualCube 系统满足远程办公中的更多协作需求。例如，研究员们展示了这样一种场景：在协同工作时，两位与会者及其电脑桌面都将是视频会议的一部分，因此与会者并排而坐，并且跨屏幕传递自己桌面上的文档和应用程序会让远程协作更加方便。

随着技术的不断精进，未来，大家或许都可以实现身隔万里，却能亲临其境一起办公，自然沟通的遥在体验，而这将极大地提高混合办公的效率。微软亚洲研究院的研究员们也希望 VirtualCube 可以成为一颗探索的种子，给更多研究人员带来启发，在大家共同的努力下，找到更好的虚拟空间交互形式，打开未来办公的更多可能。

论文： CVPR2022 PointCLIP: Point Cloud Understanding by CLIP

代码：https://github.com/ZrrSkywalker

本文提出PointCLIP：第一个将 CLIP 应用于点云识别的工作，它将2D预训练的知识迁移到3D领域，可在没有任何 3D 训练的情况下对点云进行跨模态零样本识别。

在本文中，我们通过提出 PointCLIP 来确定这种设置是可行的，它在 CLIP 编码的点云和 3D 类别文本之间进行对齐。

因为重新训练clip的代价太大（原始clip的训练数据 有4yi对文本图像对），因此没法去修改clip的模型结构，因此也就意味之模型的输入：text-image形式。因此作者将三d点云数据经过不同视角的渲染，变成M个RGB的二维maps，送如encoder中并获得M个特征，通过与对应的文本特征做一个相似度，来确定 当前的点云类别。

具体来说，我们通过将点云投影到多视图深度图中而不进行渲染来编码点云，并聚合视图方式的零样本预测以实现从 2D 到 3D 的知识迁移。最重要的是，我们设计了一个视图间适配器，以更好地提取全局特征，并将从 3D 中学到的小样本知识自适应地融合到 2D 中预训练的 CLIP 中。

通过在小样本设置中微调轻量级适配器，PointCLIP 的性能可以大大提高。此外，我们观察到 PointCLIP 和经典 3D 监督网络之间的互补特性。通过简单的集成，PointCLIP 提高了基线的性能，甚至超越了最先进的模型。因此，PointCLIP 是在低资源成本和数据机制下通过 CLIP 进行有效 3D 点云理解的有前途的替代方案。

ensembling聚合部分：可以认为是把pointclip作为一个即插即用的模块，用于辅助3D点云分类网络做分类任务 。

实验结果

我们对广泛采用的 ModelNet10、ModelNet40 和具有挑战性的 ScanObjectNN 进行了彻底的实验，以证明 PointCLIP 的有效性。

论文：https://arxiv.org/abs/1706.02413（NIPS 2017）

code： https://github.com/charlesq34/pointnet2

1、改进

PointNet因为是只使用了MLP和max pooling，没有能力捕获局部结构，因此在细节处理和泛化到复杂场景上能力很有限。

1. point-wise MLP，仅仅是对每个点表征，对局部结构信息整合能力太弱 –> PointNet++的改进：sampling和grouping整合局部邻域
2. global feature直接由max pooling获得，无论是对分类还是对分割任务，都会造成巨大的信息损失 –> PointNet++的改进：hierarchical feature learning framework，通过多个set abstraction逐级降采样，获得不同规模不同层次的local-global feature
3. 分割任务的全局特征global feature是直接复制与local feature拼接，生成discriminative feature能力有限 –> PointNet++的改进：分割任务设计了encoder-decoder结构，先降采样再上采样，使用skip connection将对应层的local-global feature拼接

2、方法

PointNet++的网络大体是encoder-decoder结构

encoder为降采样过程，通过多个set abstraction结构实现多层次的降采样，得到不同规模的point-wise feature，最后一个set abstraction输出可以认为是global feature。其中set abstraction由sampling，grouping，pointnet三个模块构成。

decoder根据分类和分割应用，又有所不同。分类任务decoder比较简单，不介绍了。分割任务decoder为上采样过程，通过反向插值和skip connection实现在上采样的同时，还能够获得local+global的point-wise feature，使得最终的表征能够discriminative（分辩能力）。

思考：

1. PointNet++降采样过程是怎么实现的？/PointNet++是如何表征global feature的？（关注set abstraction, sampling layer, grouping layer, pointnet layer）
2. PointNet++用于分割任务的上采样过程是怎么实现的？/PointNet++是如何表征用于分割任务的point-wise feature的？（关注反向插值，skip connection）

 🐖：上图中的 d 表示坐标空间维度， C 表示特征空间维度

2.1 encoder

在PointNet的基础上增加了hierarchical （层级）feature learning framework的结构。这种多层次的结构由set abstraction层组成。

在每一个层次的set abstraction，点集都会被处理和抽象，而产生一个规模更小的点集，可以理解成是一个降采样表征过程，可参考上图左半部分。

set abstraction由三个部分构成（代码贴在下面）：

def pointnet_sa_module(xyz, points, npoint, radius, nsample, mlp, mlp2, group_all, is_training, bn_decay, scope, bn=True, pooling='max', knn=False, use_xyz=True, use_nchw=False):
    ''' PointNet Set Abstraction (SA) Module
        Input:
            xyz: (batch_size, ndataset, 3) TF tensor
            points: (batch_size, ndataset, channel) TF tensor
            npoint: int32 -- #points sampled in farthest point sampling
            radius: float32 -- search radius in local region
            nsample: int32 -- how many points in each local region
            mlp: list of int32 -- output size for MLP on each point
            mlp2: list of int32 -- output size for MLP on each region
            group_all: bool -- group all points into one PC if set true, OVERRIDE
                npoint, radius and nsample settings
            use_xyz: bool, if True concat XYZ with local point features, otherwise just use point features
            use_nchw: bool, if True, use NCHW data format for conv2d, which is usually faster than NHWC format
        Return:
            new_xyz: (batch_size, npoint, 3) TF tensor
            new_points: (batch_size, npoint, mlp[-1] or mlp2[-1]) TF tensor
            idx: (batch_size, npoint, nsample) int32 -- indices for local regions
    '''
    data_format = 'NCHW' if use_nchw else 'NHWC'
    with tf.variable_scope(scope) as sc:
        # Sample and Grouping
        if group_all:
            nsample = xyz.get_shape()[1].value
            new_xyz, new_points, idx, grouped_xyz = sample_and_group_all(xyz, points, use_xyz)
        else:
            new_xyz, new_points, idx, grouped_xyz = sample_and_group(npoint, radius, nsample, xyz, points, knn, use_xyz)
        # Point Feature Embedding
        if use_nchw: new_points = tf.transpose(new_points, [0,3,1,2])
        for i, num_out_channel in enumerate(mlp):
            new_points = tf_util.conv2d(new_points, num_out_channel, [1,1],
                                        padding='VALID', stride=[1,1],
                                        bn=bn, is_training=is_training,
                                        scope='conv%d'%(i), bn_decay=bn_decay,
                                        data_format=data_format) 
        if use_nchw: new_points = tf.transpose(new_points, [0,2,3,1])
        # Pooling in Local Regions
        if pooling=='max':
            new_points = tf.reduce_max(new_points, axis=[2], keep_dims=True, name='maxpool')
        elif pooling=='avg':
            new_points = tf.reduce_mean(new_points, axis=[2], keep_dims=True, name='avgpool')
        elif pooling=='weighted_avg':
            with tf.variable_scope('weighted_avg'):
                dists = tf.norm(grouped_xyz,axis=-1,ord=2,keep_dims=True)
                exp_dists = tf.exp(-dists * 5)
                weights = exp_dists/tf.reduce_sum(exp_dists,axis=2,keep_dims=True) # (batch_size, npoint, nsample, 1)
                new_points *= weights # (batch_size, npoint, nsample, mlp[-1])
                new_points = tf.reduce_sum(new_points, axis=2, keep_dims=True)
        elif pooling=='max_and_avg':
            max_points = tf.reduce_max(new_points, axis=[2], keep_dims=True, name='maxpool')
            avg_points = tf.reduce_mean(new_points, axis=[2], keep_dims=True, name='avgpool')
            new_points = tf.concat([avg_points, max_points], axis=-1)
        # [Optional] Further Processing 
        if mlp2 is not None:
            if use_nchw: new_points = tf.transpose(new_points, [0,3,1,2])
            for i, num_out_channel in enumerate(mlp2):
                new_points = tf_util.conv2d(new_points, num_out_channel, [1,1],
                                            padding='VALID', stride=[1,1],
                                            bn=bn, is_training=is_training,
                                            scope='conv_post_%d'%(i), bn_decay=bn_decay,
                                            data_format=data_format) 
            if use_nchw: new_points = tf.transpose(new_points, [0,2,3,1])
        new_points = tf.squeeze(new_points, [2]) # (batch_size, npoints, mlp2[-1])
        return new_xyz, new_points, idx

2.1.1 sampling layer

使用FPS（最远点采样）对点集进行降采样，将输入点集从规模 N1 降到更小的规模 N2 。FPS可以理解成是使得采样的各个点之间尽可能远，这种采样的好处是可以降采样结果会比较均匀。

FPS实现方式如下：随机选择一个点作为初始点作为已选择采样点，计算未选择采样点集中每个点与已选择采样点集之间的距离distance，将距离最大的那个点加入已选择采样点集，然后更新distance，一直循环迭代下去，直至获得了目标数量的采样点。

class FarthestSampler:
    def __init__(self):
        pass
    def _calc_distances(self, p0, points):
        return ((p0 - points) ** 2).sum(axis=1)
    def __call__(self, pts, k):
        farthest_pts = np.zeros((k, 3), dtype=np.float32)
        farthest_pts[0] = pts[np.random.randint(len(pts))]
        distances = self._calc_distances(farthest_pts[0], pts)
        for i in range(1, k):
            farthest_pts[i] = pts[np.argmax(distances)]
            distances = np.minimum(
                distances, self._calc_distances(farthest_pts[i], pts))
        return farthest_pts

输入规模为 B∗N∗(d+C) ，其中 B 表示batch size， N 表示点集中点的数量， d 表示点的坐标维度， C 表示点的其他特征（比如法向量等）维度。一般 d=3 ， c=0

输出规模为 B∗N1∗(d+C) ， N1<N ，因为这是一个降采样过程。

sampling和grouping具体实现是写在一个函数里的：

def sample_and_group(npoint, radius, nsample, xyz, points, knn=False, use_xyz=True):
    '''
    Input:
        npoint: int32
        radius: float32
        nsample: int32
        xyz: (batch_size, ndataset, 3) TF tensor
        points: (batch_size, ndataset, channel) TF tensor, if None will just use xyz as points
        knn: bool, if True use kNN instead of radius search
        use_xyz: bool, if True concat XYZ with local point features, otherwise just use point features
    Output:
        new_xyz: (batch_size, npoint, 3) TF tensor
        new_points: (batch_size, npoint, nsample, 3+channel) TF tensor
        idx: (batch_size, npoint, nsample) TF tensor, indices of local points as in ndataset points
        grouped_xyz: (batch_size, npoint, nsample, 3) TF tensor, normalized point XYZs
            (subtracted by seed point XYZ) in local regions
    '''
    new_xyz = gather_point(xyz, farthest_point_sample(npoint, xyz)) # (batch_size, npoint, 3)
    if knn:
        _,idx = knn_point(nsample, xyz, new_xyz)
    else:
        idx, pts_cnt = query_ball_point(radius, nsample, xyz, new_xyz)
    grouped_xyz = group_point(xyz, idx) # (batch_size, npoint, nsample, 3)
    grouped_xyz -= tf.tile(tf.expand_dims(new_xyz, 2), [1,1,nsample,1]) # translation normalization
    if points is not None:
        grouped_points = group_point(points, idx) # (batch_size, npoint, nsample, channel)
        if use_xyz:
            new_points = tf.concat([grouped_xyz, grouped_points], axis=-1) # (batch_size, npoint, nample, 3+channel)
        else:
            new_points = grouped_points
    else:
        new_points = grouped_xyz
    return new_xyz, new_points, idx, grouped_xyz

其中sampling对应的部分是：

new_xyz = gather_point(xyz, farthest_point_sample(npoint, xyz)) # (batch_size, npoint, 3)

xyz既是 B∗N∗3 的点云，npoint是降采样点的规模。注意：PointNet++的FPS均是在坐标空间做的，而不是在特征空间做的。这一点很关键，因为FPS本身是不可微的，无法计算梯度反向传播。

本着刨根问题的心态，我们来看看farthest_point_sample和gather_point究竟在做什么

farthest_point_sample输入输出非常明晰，输出的是降采样点在inp中的索引，因此是 B∗N1 int32类型的张量

def farthest_point_sample(npoint,inp):
    '''
input:
    int32
    batch_size * ndataset * 3   float32
returns:
    batch_size * npoint         int32
    '''
    return sampling_module.farthest_point_sample(inp, npoint)

gather_point的作用就是将上面输出的索引，转化成真正的点云

def gather_point(inp,idx):
    '''
input:
    batch_size * ndataset * 3   float32
    batch_size * npoints        int32
returns:
    batch_size * npoints * 3    float32
    '''
    return sampling_module.gather_point(inp,idx)

2.1.2 grouping layer

上一步sampling的过程是将 N∗(d+C) 降到 N1∗(d+C) （这里论述方便先不考虑batch，就考虑单个点云），实际上可以理解成是在 N 个点中选取 N1 个中心点(key point)。

那么这一步grouping的目的就是以这每个key point为中心，找其固定规模（令规模为 K）的邻点，共同组成一个局部邻域(patch)。也就是会生成 N1 个局部邻域，输出规模为 N1∗K∗(d+C)

if knn:
    _,idx = knn_point(nsample, xyz, new_xyz)
else:
    idx, pts_cnt = query_ball_point(radius, nsample, xyz, new_xyz)
    grouped_xyz = group_point(xyz, idx) # (batch_size, npoint, nsample, 3)

1)找邻域的过程也是在坐标空间进行（也就是以上代码输入输出维度都是 d ，没有 C ， C 是在后面的代码拼接上的），而不是特征空间。

2)找邻域这里有两种方式：KNN和query ball point.

其中前者KNN就是大家耳熟能详的K近邻，找K个坐标空间最近的点。
后者query ball point就是划定某一半径，找在该半径球内的点作为邻点。

还有个问题：query ball point如何保证对于每个局部邻域，采样点的数量都是一样的呢？
事实上，如果query ball的点数量大于规模 K ，那么直接取前 K 个作为局部邻域；如果小于，那么直接对某个点重采样，凑够规模 K

KNN和query ball的区别：（摘自原文）Compared with kNN, ball query’s local neighborhood guarantees a fixed region scale thus making local region feature more generalizable across space, which is preferred for tasks requiring local pattern recognition (e.g. semantic point labeling).也就是query ball更加适合于应用在局部/细节识别的应用上，比如局部分割。

补充材料中也有实验来对比KNN和query ball:

sample_and_group代码的剩余部分：

sample和group操作都是在坐标空间进行的，因此如果还有特征空间信息（即point-wise feature），可以在这里将其与坐标空间拼接，组成新的point-wise feature，准备送入后面的unit point进行特征学习。

if points is not None:
    grouped_points = group_point(points, idx) # (batch_size, npoint, nsample, channel)
    if use_xyz:
        new_points = tf.concat([grouped_xyz, grouped_points], axis=-1) # (batch_size, npoint, nample, 3+channel)
    else:
        new_points = grouped_points
else:
    new_points = grouped_xyz

2.1.3 PointNet layer

使用PointNet对以上结果表征

输入 B∗N∗K∗(d+C) ，输出 B∗N∗(d+C1)

以下代码主要分成3个部分：

1)point feature embedding

这里输入是 B∗N∗K∗(d+C) ，可以类比成是batch size为 B ，宽高为 N∗K ，通道数为 d+C 的图像，这样一类比，这里的卷积就好理解多了实际上就是 1∗1 卷积，不改变feature map大小，只改变通道数，将通道数升高，实现所谓“embedding”

这部分输出是 B∗N∗K∗C1

2)pooling in local regions

pooling，只是是对每个局部邻域pooling,输出是 B∗N∗1∗C1

3)further processing

再对池化后的结果做MLP，也是简单的 1∗1 卷积。这一部分在实际实验中PointNet++并没有设置去做

# Point Feature Embedding
if use_nchw: new_points = tf.transpose(new_points, [0,3,1,2])
for i, num_out_channel in enumerate(mlp):
    new_points = tf_util.conv2d(new_points, num_out_channel, [1,1],
                                padding='VALID', stride=[1,1],
                                bn=bn, is_training=is_training,
                                scope='conv%d'%(i), bn_decay=bn_decay,
                                data_format=data_format) 
if use_nchw: new_points = tf.transpose(new_points, [0,2,3,1])

# Pooling in Local Regions
if pooling=='max':
    new_points = tf.reduce_max(new_points, axis=[2], keep_dims=True, name='maxpool')
elif pooling=='avg':
    new_points = tf.reduce_mean(new_points, axis=[2], keep_dims=True, name='avgpool')
elif pooling=='weighted_avg':
    with tf.variable_scope('weighted_avg'):
        dists = tf.norm(grouped_xyz,axis=-1,ord=2,keep_dims=True)
        exp_dists = tf.exp(-dists * 5)
        weights = exp_dists/tf.reduce_sum(exp_dists,axis=2,keep_dims=True) # (batch_size, npoint, nsample, 1)
        new_points *= weights # (batch_size, npoint, nsample, mlp[-1])
        new_points = tf.reduce_sum(new_points, axis=2, keep_dims=True)
elif pooling=='max_and_avg':
    max_points = tf.reduce_max(new_points, axis=[2], keep_dims=True, name='maxpool')
    avg_points = tf.reduce_mean(new_points, axis=[2], keep_dims=True, name='avgpool')
    new_points = tf.concat([avg_points, max_points], axis=-1)

# [Optional] Further Processing 
if mlp2 is not None:
    if use_nchw: new_points = tf.transpose(new_points, [0,3,1,2])
    for i, num_out_channel in enumerate(mlp2):
        new_points = tf_util.conv2d(new_points, num_out_channel, [1,1],
                                    padding='VALID', stride=[1,1],
                                    bn=bn, is_training=is_training,
                                    scope='conv_post_%d'%(i), bn_decay=bn_decay,
                                    data_format=data_format) 
    if use_nchw: new_points = tf.transpose(new_points, [0,2,3,1])

2.1.4 Encoder还有一个问题

pointnet++实际上就是对局部邻域表征。

那就不得不面对一个挑战：non-uniform sampling density(点云的密度不均匀)，也就是在稀疏点云局部邻域训练可能不能很好挖掘点云的局部结构

PointNet++做法：learn to combine features from regions of different scales when the input sampling density changes.

因此文章提出了两个方案：

一、Multi-scale grouping（MSG）

对当前层的每个中心点，取不同radius的query ball，可以得到多个不同大小的同心球，也就是得到了多个相同中心但规模不同的局部邻域，分别对这些局部邻域表征，并将所有表征拼接。如上图所示。

该方法比较麻烦，运算较多。

代码层面其实就是加了个遍历radius_list的循环，分别处理，并最后concat

new_xyz = gather_point(xyz, farthest_point_sample(npoint, xyz))
new_points_list = []
for i in range(len(radius_list)):
    radius = radius_list[i]
    nsample = nsample_list[i]
    idx, pts_cnt = query_ball_point(radius, nsample, xyz, new_xyz)
    grouped_xyz = group_point(xyz, idx)
    grouped_xyz -= tf.tile(tf.expand_dims(new_xyz, 2), [1,1,nsample,1])
    if points is not None:
        grouped_points = group_point(points, idx)
        if use_xyz:
            grouped_points = tf.concat([grouped_points, grouped_xyz], axis=-1)
    else:
        grouped_points = grouped_xyz
    if use_nchw: grouped_points = tf.transpose(grouped_points, [0,3,1,2])
    for j,num_out_channel in enumerate(mlp_list[i]):
        grouped_points = tf_util.conv2d(grouped_points, num_out_channel, [1,1],
                                        padding='VALID', stride=[1,1], bn=bn, is_training=is_training,
                                        scope='conv%d_%d'%(i,j), bn_decay=bn_decay)
    if use_nchw: grouped_points = tf.transpose(grouped_points, [0,2,3,1])
    new_points = tf.reduce_max(grouped_points, axis=[2])
    new_points_list.append(new_points)
new_points_concat = tf.concat(new_points_list, axis=-1)

二、Multi-resolution grouping（MRG）

（摘自原文）features of a region at some level Li is a concatenation of two vectors.

One vector (left in figure) is obtained by summarizing the features at each subregion from the lower level Li−1 using the set abstraction level.

The other vector (right) is the feature that is obtained by directly processing all raw points in the local region using a single PointNet.

简单来说，就是当前set abstraction的局部邻域表征由两部分构成：

左边表征：对上一层set abstraction（还记得上一层的点规模是更大的吗？）各个局部邻域（或者说中心点）的特征进行聚合。 右边表征：使用一个单一的PointNet直接在局部邻域处理原始点云

2.2 decoder：

2.2.1 分类任务的decoder

比较简单，将encoder降采样得到的global feature送入几层全连接网络，最后通过一个softmax分类。

2.2.2 分割任务的decoder

经过前半部分的encoder，我们得到的是global feature，或者是极少数点的表征（其实也就是global feature）

而如果做分割，我们需要的是point-wise feature，这可怎么办呢？

PointNet处理思路很简单，直接把global feature复制并与之前的local feature拼接，使得这个新point-wise feature能够获得一定程度的“邻域”信息。这种简单粗暴的方法显然并不能得到很discriminative的表征

别急，PointNet++来了。

PointNet++设计了一种反向插值的方法来实现上采样的decoder结构，通过反向插值和skip connection来获得discriminative point-wise feature：

设红色矩形点集 P1 : N1∗C ，蓝色矩形点集 P2 : N2∗C2 ，因为decoder是上采样过程，因此 N2>N1

一、反向插值具体做法：

对于 P2 中的每个点 x ，找在原始点云坐标空间下， P1 中与其最接近的 k 个点 x1,…,xk

当前我们想通过反向插值的方式用较少的点把更多的点的特征插出来，实现上采样

此时 x1,…,xk 的特征我们是知道的，我们想得到 x 的特征。如上公式，实际上就是将 x1,…,xk 的特征加权求和，得到x的特征。其中这个权重是与x和 x1,…,xk 的距离成反向相关的，意思就是距离越远的点，对x特征的贡献程度越小。P2 中其他点以此类推，从而实现了特征的上采样回传

二、skip connection具体做法：

回传得到的point-wise feature是从decoder的上一层得到的，因此算是global级别的信息，这对于想得到discriminative还是不够，因为我们还缺少local级别的信息！！！

如上图就是我们反向插值只得到了 C2 ，但是我们还需要提供local级别信息的 C1 特征！！！

这时skip connection来了！！！

skip connection其实就是将之前encoder对应层的表征直接拼接了过来

因为上图中encoder蓝色矩形点集的 C1 表征是来自于规模更大的绿色矩形点集的表征，这在一定程度上其实是实现了local级别的信息

我们通过反向插值和skip connection在decoder中逐级上采样得到local + global point-wise feature，得到了discriminative feature，应用于分割任务。

2.3 loss

无论是分类还是分割应用，本质上都是分类问题，因此loss就是分类任务中常用的交叉熵loss

2.4 其他的问题

Q：PointNet++梯度是如何回传的？？？

A：PointNet++ fps实际上并没有参与梯度计算和反向传播。

可以理解成是PointNet++将点云进行不同规模的fps降采样，事先将这些数据准备好，再送到网络中去训练的

3 dataset and experiments

3.1 dataset

• MNIST: Images of handwritten digits with 60k training and 10k testing samples.（用于分类）
• ModelNet40: CAD models of 40 categories (mostly man-made). We use the official split with 9,843 shapes for training and 2,468 for testing. （用于分类）
• SHREC15: 1200 shapes from 50 categories. Each category contains 24 shapes which are mostly organic ones with various poses such as horses, cats, etc. We use five fold cross validation to acquire classification accuracy on this dataset. （用于分类）
• ScanNet: 1513 scanned and reconstructed indoor scenes. We follow the experiment setting in [5] and use 1201 scenes for training, 312 scenes for test. （用于分割）

3.2 experiments

主要关心的实验结果是2个：

1. ModelNet40分类结果
2. ShapeNet Part分割结果

4、 conclusion

PointNet++是PointNet的续作，在一定程度上弥补了PointNet的一些缺陷，表征网络基本和PN类似，还是MLP、 1∗1 卷积、pooling那一套，核心创新点在于设计了局部邻域的采样表征方法和这种多层次的encoder-decoder结合的网络结构。

第一次看到PointNet++网络结构，觉得设计得非常精妙，特别是设计了上采样和下采样的具体实现方法，并以此用于分割任务的表征，觉得设计得太漂亮了。但其实无论是分类还是分割任务，提升幅度较PointNet也就是1-2个点而已。

PointNet++，特别是其前半部分encoder，提供了非常好的表征网络，后面很多点云处理应用的论文都会使用到PointNet++作为它们的表征器。

论文：https://arxiv.org/abs/1612.00593（cvpr2017）

code：https://github.com/charlesq34/pointnet

基础知识：

1、什么是点云？

简单来说就是一堆三维点的集合，必须包括各个点的三维坐标信息，其他信息比如各个点的法向量、颜色等均是可选。点云的文件格式可以有很多种，包括xyz，npy，ply，obj，off等（有些是mesh不过问题不大，因为mesh可以通过泊松采样等方式转化成点云）。对于单个点云，如果你使用np.loadtxt得到的实际上就是一个维度为 (num_points,num_channels) 的张量，num_channels一般为3，表示点云的三维坐标。

这里以horse.xyz文件为例，实际就是文本文件，打开后数据长这样（局部，总共有2048个点）：

实际就是一堆点的信息，这里只有三维坐标，将其可视化出来长这样：

2、点云处理任务是重要的？

三维图形具有多种表现形式，包括了mesh、体素、点云等，甚至还有些方法使用多视图来对三维图形表征。而点云在以上各种形式的数据中算是日常生活中最能够大规模获取和使用的数据结构了，包括自动驾驶、增强现实等在内的应用需要直接或间接从点云中提取信息，点云处理也逐渐成为计算机视觉非常重要的一部分。

正文：

PointNet所作的事情就是对点云做特征学习，并将学习到的特征去做不同的应用：分类（shape-wise feature）、分割（point-wise feature）等。

PointNet之所以影响力巨大，就是因为它为点云处理提供了一个简单、高效、强大的特征提取器（encoder），几乎可以应用到点云处理的各个应用中，其地位类似于图像领域的AlexNet。

1、动机

点云或者mesh，大多数研究人员都是将其转化成3D体素或者多视图来做特征学习的，这其中的工作包括了VoxelNet, MVCNN等。这些工作都或多或少存在了一些问题。

直接对点云做特征学习也不是不可以，但有几个问题需要考虑：特征学习需要对点云中各个点的排列保持不变性、特征学习需要对rigid transformation保持不变性等。虽然有挑战，但是深度学习强大的表征能力以及其在图像领域取得的巨大成功，因此是很有必要直接在点云上进行尝试的。

2、贡献

1. 我们设计了一个新颖的深层网络架构来处理三维中的无序点集
2. 我们设计的网络表征可以做三维图形分类、图形的局部分割以及场景的语义分割等任务
3. 我们提供了完备的经验和理论分析来证明PointNet的稳定和高效。
4. 充分的消融实验，证明网络各个部分对于表征的有效性。

3、方法

3.1 点云的几个特点：

1. 无序性 –> 对称函数设计用于表征
2. 点不是孤立的，需要考虑局部结构 –> 局部全局特征结合
3. 仿射变换无关性 –> alignment network

（重要）关于第三点：相同的点云在空间中经过一定的刚性变化（旋转或平移），坐标发生变化。其实对于点云分类or分割任务来说（分割可以认为是点的分类），例如，整体的旋转和平移不应修改全局点云类别和每个点的类别，也不应修改点的分割因此需要保证仿射变换无关性（简单来说，“仿射变换”就是：“线性变换”+“平移”），但是对于位置 敏感的 任务：点云配准、点云补全任务，对于位置敏感，就不需要保证 仿射变换的无关性 。

我们希望不论点云在怎样的坐标系下呈现，网络都能正确的识别出。这个问题可以通过STN（spacial transform netw）来解决。三维不太一样的是点云是一个不规则的结构（无序，无网格），不需要重采样的过程。pointnet通过学习一个矩阵来达到对目标最有效的变换。

解决方法

1. 空间变换网络解决旋转问题：三维的STN可以通过学习点云本身的位姿信息学习到一个最有利于网络进行分类或分割的DxD旋转矩阵（D代表特征维度，pointnet中D采用3和64）。至于其中的原理，我的理解是，通过控制最后的loss来对变换矩阵进行调整，pointnet并不关心最后真正做了什么变换，只要有利于最后的结果都可以。pointnet采用了两次STN，第一次input transform是对空间中点云进行调整，直观上理解是旋转出一个更有利于分类或分割的角度，比如把物体转到正面；第二次feature transform是对提取出的64维特征进行对齐，即在特征层面对点云进行变换。
2. maxpooling解决无序性问题：网络对每个点进行了一定程度的特征提取之后，maxpooling可以对点云的整体提取出global feature。

3.2 网络结构:

网络分成了分类网络和分割网络2个部分，大体思路类似，都是设计表征的过程分类网络设计global feature，分割网络设计point-wise feature。两者都是为了让表征尽可能discriminative，也就是同类的能分到一类，不同类的距离能拉开。

输入 n*3 n是点数

inputtransform：放射变换（为了保证仿射变换的不变性）：直接预测一个变换矩阵（3*3）来处理输入点的坐标（对所有坐标进行变换）。因为会有数据增强的操作存在，这样做可以在一定程度上保证网络可以学习到变换无关性。T-Net模型，它的主要作用是学习出变化矩阵来对输入的点云或特征进行规范化处理。

MLP：

有两种实现方法：

1、输入 B,N,3 —- nn.liner层 — B,N,64

2、输入 B,3,N —- conv1d(1×1) — B,64,N

Pooling:

为了解决无序性（点云本质上是一长串点（nx3矩阵，其中n是点数）。在几何上，点的顺序不影响它在空间中对整体形状的表示，例如，相同的点云可以由两个完全不同的矩阵表示。）使用 maxpooling或sumpooling，也就是说，最后的D维特征对每一维都选取N个点中对应的最大特征值或特征值总和，这样就可以通过g来解决无序性问题。

最后再经过一个mlp（代码中运用全连接）得到k个score。分类网络最后接的loss是softmax。

分割网络：

将池化后的特征和前一阶段特征拼接，池化后的特征有全局信息，在和之前的拼接，以此得到同时对局部信息和全局信息感知的point-wise特征，提升表征效果。然后最后输出n*m, m为类别数量，表示每个点的类别信息。

损失函数：

分类中常用的交叉熵+alignment network中用于约束生成的alignment matrix的loss

dataset and experiments

evaluate metric

分类：分类准确率acc
分割：mIoU

dataset

分类：ModelNet40
分割：ShapeNet Part dataset和Stanford 3D semantic parsing dataset

experiments

1、分类：

2、局部分割：

code：

1. 如何对点云使用MLP？
2. alignment network怎么做的？
3. 对称函数如何实现来提取global feature的？
4. loss?

def get_model(point_cloud, is_training, bn_decay=None):
    """ Classification PointNet, input is BxNx3, output Bx40 """
    batch_size = point_cloud.get_shape()[0].value
    num_point = point_cloud.get_shape()[1].value
    end_points = {}
    with tf.variable_scope('transform_net1') as sc:
        transform = input_transform_net(point_cloud, is_training, bn_decay, K=3)
    point_cloud_transformed = tf.matmul(point_cloud, transform)
    input_image = tf.expand_dims(point_cloud_transformed, -1)
    net = tf_util.conv2d(input_image, 64, [1,3],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv1', bn_decay=bn_decay)
    net = tf_util.conv2d(net, 64, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv2', bn_decay=bn_decay)
    with tf.variable_scope('transform_net2') as sc:
        transform = feature_transform_net(net, is_training, bn_decay, K=64)
    end_points['transform'] = transform
    net_transformed = tf.matmul(tf.squeeze(net, axis=[2]), transform)
    net_transformed = tf.expand_dims(net_transformed, [2])
    net = tf_util.conv2d(net_transformed, 64, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv3', bn_decay=bn_decay)
    net = tf_util.conv2d(net, 128, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv4', bn_decay=bn_decay)
    net = tf_util.conv2d(net, 1024, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv5', bn_decay=bn_decay)
    # Symmetric function: max pooling
    net = tf_util.max_pool2d(net, [num_point,1],
                             padding='VALID', scope='maxpool')
    net = tf.reshape(net, [batch_size, -1])
    net = tf_util.fully_connected(net, 512, bn=True, is_training=is_training,
                                  scope='fc1', bn_decay=bn_decay)
    net = tf_util.dropout(net, keep_prob=0.7, is_training=is_training,
                          scope='dp1')
    net = tf_util.fully_connected(net, 256, bn=True, is_training=is_training,
                                  scope='fc2', bn_decay=bn_decay)
    net = tf_util.dropout(net, keep_prob=0.7, is_training=is_training,
                          scope='dp2')
    net = tf_util.fully_connected(net, 40, activation_fn=None, scope='fc3')
    return net, end_points

MLP的核心做法：

input_image = tf.expand_dims(point_cloud_transformed, -1)
net = tf_util.conv2d(input_image, 64, [1,3],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='conv1', bn_decay=bn_decay)
net = tf_util.conv2d(net, 64, [1,1],
                     padding='VALID', stride=[1,1],
                     bn=True, is_training=is_training,
                     scope='conv2', bn_decay=bn_decay)

这里input_image维度是 B×N×3×1 ，因此将点云看成是W和H分为N和3的2D图像，维度是 1

然后直接基于这个“2D图像”做卷积，第一个卷积核size是 [1,3] ，正好对应的就是“2D图像”的一行，也就是一个点（三维坐标），输出通道数是64，因此输出张量维度应该是 B×N×1×64

第二个卷积核size是 [1,1] ， 1∗1 卷积只改变通道数，输出张量维度是 B×N×1×64

conv2d就是将卷积封装了一下，核心部分也就是调用tf.nn.conv2d，实现如下：

def conv2d(inputs,
           num_output_channels,
           kernel_size,
           scope,
           stride=[1, 1],
           padding='SAME',
           use_xavier=True,
           stddev=1e-3,
           weight_decay=0.0,
           activation_fn=tf.nn.relu,
           bn=False,
           bn_decay=None,
           is_training=None):
  """ 2D convolution with non-linear operation.
  Args:
    inputs: 4-D tensor variable BxHxWxC
    num_output_channels: int
    kernel_size: a list of 2 ints
    scope: string
    stride: a list of 2 ints
    padding: 'SAME' or 'VALID'
    use_xavier: bool, use xavier_initializer if true
    stddev: float, stddev for truncated_normal init
    weight_decay: float
    activation_fn: function
    bn: bool, whether to use batch norm
    bn_decay: float or float tensor variable in [0,1]
    is_training: bool Tensor variable
  Returns:
    Variable tensor
  """
  with tf.variable_scope(scope) as sc:
      kernel_h, kernel_w = kernel_size
      num_in_channels = inputs.get_shape()[-1].value
      kernel_shape = [kernel_h, kernel_w,
                      num_in_channels, num_output_channels]
      kernel = _variable_with_weight_decay('weights',
                                           shape=kernel_shape,
                                           use_xavier=use_xavier,
                                           stddev=stddev,
                                           wd=weight_decay)
      stride_h, stride_w = stride
      outputs = tf.nn.conv2d(inputs, kernel,
                             [1, stride_h, stride_w, 1],
                             padding=padding)
      biases = _variable_on_cpu('biases', [num_output_channels],
                                tf.constant_initializer(0.0))
      outputs = tf.nn.bias_add(outputs, biases)
      if bn:
        outputs = batch_norm_for_conv2d(outputs, is_training,
                                        bn_decay=bn_decay, scope='bn')
      if activation_fn is not None:
        outputs = activation_fn(outputs)
      return outputs

alignment network ：

input_transform_net为例：

def input_transform_net(point_cloud, is_training, bn_decay=None, K=3):
    """ Input (XYZ) Transform Net, input is BxNx3 gray image
        Return:
            Transformation matrix of size 3xK """
    batch_size = point_cloud.get_shape()[0].value
    num_point = point_cloud.get_shape()[1].value
    input_image = tf.expand_dims(point_cloud, -1)
    net = tf_util.conv2d(input_image, 64, [1,3],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='tconv1', bn_decay=bn_decay)
    net = tf_util.conv2d(net, 128, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='tconv2', bn_decay=bn_decay)
    net = tf_util.conv2d(net, 1024, [1,1],
                         padding='VALID', stride=[1,1],
                         bn=True, is_training=is_training,
                         scope='tconv3', bn_decay=bn_decay)
    net = tf_util.max_pool2d(net, [num_point,1],
                             padding='VALID', scope='tmaxpool')
    net = tf.reshape(net, [batch_size, -1])
    net = tf_util.fully_connected(net, 512, bn=True, is_training=is_training,
                                  scope='tfc1', bn_decay=bn_decay)
    net = tf_util.fully_connected(net, 256, bn=True, is_training=is_training,
                                  scope='tfc2', bn_decay=bn_decay)
    with tf.variable_scope('transform_XYZ') as sc:
        assert(K==3)
        weights = tf.get_variable('weights', [256, 3*K],
                                  initializer=tf.constant_initializer(0.0),
                                  dtype=tf.float32)
        biases = tf.get_variable('biases', [3*K],
                                 initializer=tf.constant_initializer(0.0),
                                 dtype=tf.float32)
        biases += tf.constant([1,0,0,0,1,0,0,0,1], dtype=tf.float32)
        transform = tf.matmul(net, weights)
        transform = tf.nn.bias_add(transform, biases)
    transform = tf.reshape(transform, [batch_size, 3, K])
    return transform

实际上，前半部分就是通过卷积和max_pooling对batch内各个点云提取global feature，再将global feature降到 3×K 维度，并reshape成 3×3 ，得到transform matrix

通过数据增强丰富训练数据集，网络确实应该学习到有效的transform matrix，用来实现transformation invariance

loss：

监督分类任务中常用的交叉熵loss + alignment network中的mat_diff_loss

 对于特征空间的alignment network，由于特征空间维度比较高，因此直接生成的alignment matrix会维度特别大，不好优化，因此这里需要加个loss约束一下。

总结：

PointNet之所以影响力巨大，并不仅仅是因为它是第一篇，更重要的是它的网络很简洁（简洁中蕴含了大量的工作来探寻出简洁这条路）却非常的work，这也就使得它能够成为一个工具，一个为点云表征的encoder工具，应用到更广阔的点云处理任务中。

MLP+max pooling竟然就击败了众多SOTA，令人惊讶。另外PointNet在众多细节设计也都进行了理论分析和消融实验验证，保证了严谨性，这也为PointNet后面能够大规模被应用提供了支持。