随着生成 3D 模型的 AI 的出现，3D 行业正在经历一场真正的革命。在我测试过的所有 AI 中，Rodin 有望改变 3D 角色和模型的创建方式。在技术进步的背景下，了解这些类型的 AI 如何不仅可以补充现有工具，还可以通过现有工具得到增强至关重要。

ActorCore 和 AccuRIG 为专业 3D 内容创作提供了完整且优化的解决方案。与此 AI 一起，这些工具为没有 3D 技能的艺术家提供了前所未有的机会，可以基于三维环境进行项目工作。

1、Rodin：3D AI 生成的新前沿

Rodin 代表了 3D 模型生成的巨大飞跃，它使用高级算法创建具有前所未有的细节和真实感的角色。这种 AI 不仅能够生成复杂的几何图形，而且还可以根据我们的草图以连贯的方式理解和应用纹理和材质。能够直接从角色的概念设计转到 3D 模型，大大减少了从构思到最终结果所需的时间。

Rodin 是一种从图像或文本生成 3D 模型的工具，它通过生成几何图形和材料，让艺术家有机会以三维模型的形式查看他们的 2D 草图。其主要特色之一是可以多次“重做”模型和纹理，以找到完美的效果。它还允许通过边界框、体素或点云进行 3D 控制，以操纵比例和形状。最后，还有一个网格编辑器，用于快速调整和高级选项，例如添加负面提示和姿势控制，这些选项提供的控制比当今任何其他 AI 都要多。

Rodin 的突出之处在于它能够根据相同的参考免费生成多个结果，我们可以从中选择最适合我们想要的结果。这给了我们当今大多数 AI 无法给予我们的控制权，并使 3D 创作过程更具创造性。

然而，当它与已经在行业中证明过自己的工具集成时，它的真正优势就会显现出来。这就是 ActorCore 和 AccuRIG 发挥作用的地方，它们提供的功能完美地补充了 Rodin 的功能。

2、AccuRIG：AI 生成模型的完美补充

AccuRIG 是补充 Rodin 的最佳免费工具。虽然 Rodin 可以生成复杂的模型，但装配过程仍然是这些模型有效动画的关键阶段。这就是 AccuRIG 证明其价值的地方，它以惊人的精度自动装配，同时还允许艺术家手动调整结果，以便角色骨架正是我们想要的，并且角色可以以连贯的方式动画化。

AccuRIG 兼容各种模型的装配，从人形到奇幻生物，使其成为 Rodin 生成角色设计的理想补充。 Rodin 和 AccuRIG 之间的这种协同作用不仅简化了装配过程，而且还确保模型已准备好使用 ActorCore 3D 运动进行动画处理，然后可以在 iClone 中使用。这样，我们可以在几分钟内从 2D 角色设计转变为 Unreal Engine 或 Unity 项目中功能齐全的 3D 模型。

3、ActorCore：通过 3D 动画提升 AI 的潜力

ActorCore 是一个平台，已成为任何 3D 专业人士的宝贵资源。凭借其丰富的高质量动画库，ActorCore 不仅允许用户利用 Rodin 生成的作品，还可以通过精确自然的动作为任何 3D 角色赋予生命。

ActorCore 的动作捕捉动画采用先进的动作捕捉技术创建，可确保任何 Rodin 生成的角色都具有令人印象深刻的流畅性和真实感。此外，ActorCore 允许我们在 3D 查看器中免费直接在角色上可视化这些动画，确保它们完全适合任何类型的专业项目的特定需求。这也允许艺术家以更有效的方式向团队的其他成员展示他们的想法，而不仅仅是展示几张草图，现在艺术家可以在几分钟内完全免费地展示一个充满活力的角色，而无需任何 3D 建模或动画知识。

4、iClone：最快的实时 3D 动画工具

要处理装配和动画角色，没有比 iClone 更好的程序了。借助其工具，我们可以编辑动画并与角色一起工作，以根据需要对其进行尽可能多的调整。例如，借助这一点，我们可以让我们的角色适应我们项目的场景或让它们相互交互。当我们完成后，我们将看到使用 iClone 的一大优势是它与其他程序的集成，只需不到一分钟我们就能够将角色发送给Unity 或 Unreal。因此，iClone 将使我们免于使用多个程序，并且借助其提供的工具集，我们可以专注于重要的事情。

5、协同集成：Rodin、AccuRIG 和 ActorCore

Rodin 与 ActorCore 和 AccuRIG 的集成可以推动 3D 内容制作的新时代。虽然 Rodin 带来了更具创意的 3D 模型生成的承诺，但 ActorCore 和 AccuRIG 确保这些模型不仅在视觉上令人惊叹，而且功能齐全且动画准确。这种组合的真正力量在于这些工具能够协同工作，从而创建一种工作流程，最大限度地提高效率，同时为创造力和实验留下更多空间。

原文链接：Animating AI-Generated Models: A Step-by-Step Guide

BimAnt翻译整理，转载请标明出处

本文介绍了一种使用扫描网格数据生成精确的平面图和建筑内部 3D 模型的新方法。与以前从激光测距仪的高分辨率点云开始的方法不同，我们的方法从三角形网格数据开始，例如来自 Microsoft HoloLens。它生成两种类型的平面图，一种是保留细节的“笔墨”风格，另一种是减少混乱的绘图风格。它通过将 3D 模型与坐标轴对齐、注释重要对象、将其划分为楼层以及移除天花板来处理 3D 模型以供应用程序使用。它的性能在商业和住宅建筑上进行了评估，并通过实验来评估质量和尺寸精度。我们的方法展示了自动数字化和定向扫描网格数据的巨大潜力，使平面图和 3D 模型能够在导航、室内设计、家具摆放、设施管理、建筑施工和暖通空调设计等各种应用中生成。

1、简介

平面图可用于多种应用，包括建筑内部导航、改造、家具的有效摆放、管道的摆放、供暖、通风和空调 (HVAC) 设计以及制定紧急疏散计划。根据应用，不同类型的平面图是合适的。对于改造建筑内部或设计 HVAC 系统，用户可能更喜欢绘图式平面图，该平面图侧重于平面墙壁并移除家具和其他杂物。对于家具摆放、导航或疏散计划，用户可能更喜欢更详细的平面图，该平面图显示家具、橱柜、台面等的位置。无论哪种情况，制作平面图都很耗时，需要专业技能，例如测量距离和角度或将数据输入 CAD 程序。此外，可能需要多次制作平面图，因为当墙壁和家具被移动、添加或移除时，建筑物会发生变化。因此，能够在很少或没有培训的情况下自动生成平面图是很有价值的。

要生成平面图，从可以自动收集的准确数据开始会很有帮助。激光测距仪、智能手机、平板电脑和增强现实 (AR) 耳机等设备使以 RGBD 图像、点云和三角网格形式收集高分辨率建筑数据变得更加容易。在本文中，我们描述了一种通过利用不完整和不完美的三角网格数据来生成绘图风格和钢笔和墨水风格平面图的方法。这种方法可以高效准确地生成这两种类型的平面图，支持广泛的应用。

我们描述了一种使用 Microsoft HoloLens 2 中捕获不佳的三角网格数据生成准确平面图的新方法。主要贡献是：

• 一种改进的基于密度的噪声应用空间聚类 (DBSCAN) 算法，使用块来捕获墙壁高度和厚度。
• 一种基于方向的聚类方法，可找到任意角度的墙壁。
• 使用 k 均值聚类将网格旋转到主轴并识别地板和天花板。
• 从不完整的网格数据生成两种精确的平面图。

2、相关工作

平面图对于许多应用至关重要。平面图创建的软件方法取决于数据可用性和数据格式。我们的工作建立在先前的数据收集和平面图计算研究的基础上。

数据收集。室内环境可以以多种格式捕获，包括 RGBD 图像、点云和三角网格。Zhang 等人 [29] 使用全景 RGBD 图像作为输入，并使用结构语法重建几何图形，而 [21] 使用 3D 扫描提取平面图元并使用启发式方法生成模型。一些深度学习方法 [8,11,13,14,30] 使用单个图像来生成单个房间的长方体布局。完整房屋的详细半约束平面图计算需要处理房屋的 3D 扫描 [15]；完整扫描提高了准确性，但增加了计算要求和时间。 Pintore 和 Gobbetti [23] 提出了一种使用 Android 设备摄像头创建平面图和 3D 模型的技术，利用传感器数据和统计技术。Chen 等人 [7] 介绍了一种利用 Microsoft Hololens 进行室内布局评估的增强现实系统，解决了直观评估和效率挑战。在我们的方法中，我们从 HoloLens 2 的三角形网格开始，使用其空间映射软件 [18]，该软件已由 Weinmann 等人 [27] 进行了调查。

平面图计算早期方法 [1,3,22,28] 依靠图像处理技术（例如直方图和平面拟合）从 3D 数据创建平面图。虽然 [22] 通过检测 3D 点云中的垂直平面来创建平面图，但 [3] 使用平面结构提取来创建平面图。这些技术依赖于启发式方法，并且容易因数据中的噪声而失败。

使用图形模型进行平面图计算已经取得了很大进展 [4,9,12]。此类模型 [10] 还用于从众包图像和位置数据中恢复布局和楼层平面图。一个交互式工具 [16] 通过符合设计约束来创建理想的楼层平面图。

Pintore 等人 [24] 描述了几个可用的输入源（包括我们使用的三角形网格）和输出模型，并讨论了重建流程的主要元素。它还确定了几个用于生成楼层平面图的系统，包括 FloorNet [15] 和 Floor-SP [6]。

Monszpart 等人 [19] 引入了一种算法，该算法利用远处墙壁通常是平行的观察结果，使用 k 均值识别主要墙壁方向。我们的方法也利用了 k 均值，但这样做是为了识别所有方向的墙壁，而不仅仅是主要方向的墙壁。

Cai 等人 [5] 使用几何先验，包括点密度、室内区域识别和法线信息，从原始点云重建楼层平面图。

与 Arikan 等人相比， [2] 采用贪婪算法在用户交互的帮助下找到平面法线方向并将平面拟合到点，而我们的方法是自动的。它也不同于 [20] 的工作，后者专注于消除杂乱并将内部划分为 3D 单元复合体；我们的方法专门将建筑物划分为单独的墙壁。

我们的工作与 [22] 和 [26] 相关。在 [22] 中，平面图生成从激光范围数据点云开始，然后使用高度直方图检测地板和天花板。其余点投影到地面上，在那里应用密度直方图和霍夫变换来生成形成平面图的线段。在投影到 2D 时，他们的方法可能会丢失可能对创建 3D 模型或详细平面图有用的信息。同样，[26] 采用基于直方图的方法来检测天花板和地板。他们的方法包括识别较高的墙段以创建 2D 直方图，然后采用基于直方图点密度的启发式方法来计算平面图。我们的方法与 [22] 和 [26] 不同，它将网格与全局坐标轴对齐，而不依赖于激光数据或点云。它主要处理整个管道中的 3D 数据，从增强的信息中受益，并生成 3D 模型和平面图。

3、方法论

我们通过四个主要步骤计算楼层平面图（参见算法 1）。首先，用户使用增强现实耳机将建筑物内部捕获为三角形网格。网格的方向与主轴对齐，并将建筑物分为多个楼层。移除地板和天花板，并根据需要检测平坦的墙壁。最后，通过切片和投影生成的 3D 模型生成两种楼层平面图样式之一。接下来我们将详细描述这些步骤。

数据收集可以使用不同的设备以各种格式捕获室内环境。我们使用 Microsoft HoloLens 2 耳机捕获三角形网格数据，并使用语音命令注释网格。

捕获三角形网格 HoloLens 提供硬件和软件，使用三角形创建室内环境的 3D 表示，如图 1 左所示。耳机将三角形叠加在用户对建筑物内部的视图上。虽然耳机捕捉到了大部分墙壁、地板和天花板，但某些区域的数据可能缺失，如图所示。

注释网格为了捕获传感器、恒温器、窗户和门等物体的位置，我们开发了一个增强现实 (AR) 用户界面。该界面使用视线检测和语音命令，使用户能够将合成物体放置在所需位置，如图 1 右图所示，其中合成传感器物体被添加到沉浸式环境中，叠加在物理传感器上。

3.1 网格方向

捕获带注释的三角形网格后，执行几何处理。最初，网格的方向基于用户的起始位置和注视方向。要生成楼层平面图，我们必须确定楼层的位置和朝向。AR 头戴设备可以粗略估计重力方向，但额外的计算可以提高精度。

确定楼层方向 为了确定网格方向，我们测试了两种方法：(1) 计算网格边界框的最短边，(2) 使用球面 k 均值对网格三角形的朝向进行聚类。方法 (1) 适用于高度恒定且楼层面积较大的建筑物，但不适用于其他建筑物，因此我们主要使用算法 2 中描述的方法 (2)。

算法 2 适用于广泛的网格，包括具有垂直优势的多层建筑。它使用网格 M 中每个三角形 ∆ 的表面法向量，​​并过滤掉明显偏离正 y 方向的三角形，保留可能代表楼层 (∆ ′) 的三角形。

我们使用球面坐标 k 均值算法（k = 1）来查找这些三角形的主导方向 gm。我们丢弃与主导方向相差大于角度φ的三角形，并重复k均值算法，直到达到φmin（例如，从φ= 30度开始，到φmin = 3结束）。这给出了真实重力方向gt的估计值。

为了定位网格，我们计算gt和负y轴之间的角度θ，并通过取它们的叉积来确定旋转轴Y。我们围绕Y轴将网格旋转θ，确保地板水平。有关此地板定位方法的更多详细信息，请参阅算法2。

图2显示了一个模型，其中地板不是水平的，而是从近到远、从右到左向下倾斜。经过算法2后，地板是水平的。

查找地板的高度在将网格定位为具有水平地板后，我们找到地板在y方向上的高度：我们取每个网格三角形的质心，其朝向在正y轴的一个小角度内。我们创建了这些质心的 y 坐标的直方图，每个桶代表一个垂直范围，例如 2 英寸。我们考虑相邻的桶对，并寻找具有最高点数的桶对，例如 (0, 1)、(1, 2) 等。对于单层建筑，我们搜索两个大桶对，分别代表地板（靠近底部）和天花板（靠近顶部）。

如果建筑物的地板下沉或天花板升高，则直方图将显示相似但不完全相同的高度的峰值。为了确保我们找到真正的天花板和地板，我们会在低直方图峰值和高直方图峰值之间寻找几英尺的间隙（例如房间的预期地板到天花板的高度）。这个间隙以下的峰值可能是地板，上面的可能是天花板。

为了生成楼层平面图，我们分别选择最高的楼层和最低的天花板作为计算的楼层和天花板。将存储桶配对而不是单独使用可以确保我们不会忽略直方图中的峰值（如果网格三角形均匀分布在两个相邻的存储桶中）。

旋转网格和相关注释 我们的下一个目标是将网格模型的主要墙壁方向与欧几里得坐标的轴对齐。

一个可选步骤是消除表面法线与正或负 y 方向成小角度的网格三角形，因为这些三角形可能是天花板或地板三角形。此步骤不是强制性的，但可以减少要处理的三角形数量。此外，我们消除了所有低于计算的地板高度和高于计算的天花板高度的三角形。

然后，我们检查剩余三角形的表面法线。我们用球面坐标表示每个法线，并使用球面 k 均值聚类来识别主要的墙壁方向。假设建筑物的墙壁主要为垂直的，则墙壁将有四个主要方向，因此我们可以将 k 均值聚类设置为 k = 4。如果模型仍然有地板和天花板三角形，我们可以将 k = 6 设置为两个额外的主要方向。图 3 左图显示了办公楼网格在球坐标系中的表面法线方向热图。

图 3 左侧包含许多远离任何聚类中心的浅蓝色矩形（例如，远离红色、橙色和白色的桶）。这些表示面向方向与任何主要墙壁、地板或天花板都不对齐的三角形。存在此类三角形的原因有两个：(1) 建筑物内部包含许多不是墙壁、地板或天花板的物体，例如家具、文件、办公设备、艺术品等。这些物体可以以任何角度放置。(2) AR 耳机生成跨多个表面（例如，接触多个墙壁）的三角形，因此指向中间方向。为了进行补偿，我们使用了球面坐标 k 均值聚类的改进版本，该版本忽略了异常三角形方向，如下所示：

以通常的方式计算球面 k 均值后，我们在每个聚类中查找所有朝向方向与聚类中心距离大于阈值 θ1 的三角形。我们丢弃所有这样的三角形。然后我们再次运行 k 均值，计算更新后的聚类中心。然后我们丢弃距离每个聚类中心大于 θ2 的所有三角形，其中 θ2 < θ1。我们重复此过程几次，直到达到所需的精度。例如，在我们当前的实现中，我们使用这个角度 θi 序列（以度为单位）：[50, 40, 30, 20, 10, 5, 3]。一旦我们的改进 k 均值算法完成，我们就有 4 个（或 6 个）聚类中心。图 3 右侧显示了 k = 6 的示例结果。

计算出主要墙壁方向后，我们选择三角形数量最多的簇，取其方向（簇中心），将该方向投影到 x-z 平面上，并将其称为 θwall。我们将网格旋转 θwall 和 x 轴之间的角度。现在，主要墙壁将指向 x 轴。图 4 左侧显示了未与轴对齐的建筑物。图 4 右侧显示了墙壁旋转后的同一建筑物。添加 x 轴（红色）和 z 轴（蓝色），我们看到墙壁现在与轴对齐。

将网格划分为不同的级别 HoloLens 可以数字化多层建筑。给定一个多层模型，我们可以计算每个楼层的楼层平面图。该过程类似于 3.1 中用于确定楼层高度的过程。首先，我们的系统计算

一个直方图，如图 5 所示，并将建筑物划分为多个层次，如图 5 中间和右侧所示。

3.2 平面图计算

我们的平面图计算取决于所需的平面图类型以及网格是否相对于全局轴定向。如果我们想要一个钢笔画风格的平面图，并且网格是有方向的，我们可以简单地将网格 M 传递给 ComputeAndSuperimposeSlices() 函数，如算法 3.2 的第 14 行所示。

但是，如果网格方向不正确，我们会在计算平面图之前将其与全局轴对齐。如果需要绘图风格的平面图，我们利用算法 3.2 的第 2-13 行来计算平面墙。

计算平面墙 为了生成绘图式平面图，我们计算平面墙，并使用以下步骤将其与其他建筑内容分开：

DBSCAN 对于每个墙方向，我们执行修改后的 DBSCAN 算法：我们计算每个三角形 ∆i 的质心 C。对于 DBSCAN 期间的每个质心点 Ci，我们计算足够近以被视为邻居的其他质心点的数量。但是，我们不是像传统的 3D DBSCAN 那样在每个点周围的球体中寻找邻居，而是在以该点为中心的长度为 l、宽度为 w 和高度为 h 的矩形块中寻找邻居。这个块的高度足以在 y 方向上从地板延伸到天花板，在与拟议墙平行的方向上比门稍窄（例如 1.5 英尺），在墙方向上有几英寸（以允许墙略微偏离完全平坦）。根据国家建筑规范，墙的最小高度设定为 8 英尺，厚度为 8 英寸。 DBSCAN 之后，网格三角形被分组为墙段 W S。

过滤 我们丢弃不适合的墙段，例如太小、离地板较远或离天花板较远的墙段。

平面拟合 对于每个墙段，我们找到一个与墙方向具有相同朝向且与该墙段中的三角形质心非常吻合的平面。考虑到这些点紧密地集中在这个方向上，只需让平面穿过任何质心，效果就会出奇地好。但是，也可以更仔细地选择一个点，例如在墙方向的中间位置找到一个点。

矩形构造 对于每个剩余的墙段，我们构造位于拟合平面中的矩形 R，其宽度与墙段三角形一样宽，高度与墙段三角形一样高。

网格替换 对于平面图构造，我们丢弃原始网格三角形，并用新的平面墙矩形替换它们，以用作整理后的网格。如果后续步骤使用的库需要三角形网格，我们将使用两个相邻的直角三角形代替每个矩形。

对于每个 i，0 ≤ i ≤ n。对于每个 yi，我们计算网格与平面 y = yi 的交点。我们最终得到一堆切片（见图 7）。

我们可以使用相同的方法来生成绘图式平面图。在这种情况下，我们从平墙模型开始，而不是完整的网格。此模型在多个高度进行切片时需要捕捉的细节较少，因此我们可以选择在单个中间高度进行切片。

绘制平面图对于任何一种平面图样式，我们都可以通过忽略所得线段的 y 坐标并将所得 (x, z) 坐标绘制为二维图像，将切片投影到平面

。我们还发现，用半透明的颜色绘制每个切片的线条既有信息量，又美观，这样出现在多个高度的特征看起来比只出现在一个高度的特征更暗。

例如，图 8 左图显示了从商业建筑收集的网格。图 8 中图显示了我们对该数据进行 DBSCAN 的结果。图 8 右图显示了网格替换后得到的平墙。图 9 右图显示了切片平墙得到的绘图式平面图。图 9 左图显示了通过在多个高度切片定向网格而制作的钢笔和墨水平面图。

绘制合成对象 因为我们的数据来自 AR 头戴式设备，所以我们可以添加合成对象来标记房间中物体的位置，例如传感器和窗户。我们可以在我们的 3D 模型和平面图中显示这些对象。对于上面描述的网格处理步骤，我们注意到应用于网格的几何变换，并将相同的变换应用于合成对象，然后这些合成对象会出现在 3D 视图和平面图中的正确位置。例如，图 8 左中的黑色对象表示用户放置的对象，以显示传感器和窗户的位置。同样，图 9 左的平面图中的红色对象也是相同的对象，投影到与网格切片相同的平面上

4、实验

我们评估了使用 AR 耳机捕获 3D 扫描的方法。我们将平面图尺寸与实际建筑尺寸进行了比较，并提供了中间结果：平面图和 3D 模型。我们还计算了算法步骤所需的时间。为了证明该方法的稳健性，我们使用多种建筑类型进行了评估，包括商业建筑 B1 和 B3 以及住宅建筑 B3。此外，我们在 Matterport2D 数据集 [25] 上验证了我们的平面图生​​成。

扫描数据分析我们通过将房间的实际尺寸与计算出的平面图进行比较来评估平面图生成的精度。图 10（a）展示了使用我们的 AR 扫描两次的建筑物的测量结果。我们将这些扫描称为 S1 和 S2（见图 10(b) 和图 10(c)）。对于每个扫描，都会计算平面图并使用几何建模软件 Rhino [17] 计算​​尺寸。然后，我们将计算出的尺寸与实际房间尺寸进行了比较，如表 1 所示。这些结果表明我们的方法适用于多种建筑类型。

我们的方法甚至可以从相对不完整的网格数据中计算出平面图。使用更高质量的 HoloLens 扫描，生成的平面图更精确。图 11 显示了 S1 结果：两种类型的平面图和 3D 模型。

定位地板和墙壁 我们必须正确定位网格。球面 k 均值需要大量计算，因此我们对其进行了优化以获得良好的性能。在图 4 中，我们可以看到对齐前后的 B1 网格，这耗时 12.4 秒，其中 10.6 秒用于使用球面 k 均值对齐墙壁。

划分楼层 我们可以检测多层建筑，并通过额外的步骤将其划分为楼层。该算法将三角形投影到正 y 轴上，并创建一个显示水平峰值的直方图。通过分析直方图中的峰值，我们可以确定楼层数。图 5 和图 12 显示了 Matterport3D 数据集 [25] 中划分为楼层的 2 层住宅建筑和多层模型。

查找平面墙 为了生成绘图式平面图，我们消除了细节并识别平面墙。修改后的 DBSCAN 算法是最耗时的步骤。在图 13 的模型中，有 79,931 个顶点和 134,235 个面，准备数据和运行 DBSCAN 需要 27.4 秒，从生成的集群构建平面墙需要 3.79 秒。对于图 14 的住宅建筑，有 173,941 个顶点和 285,840 个面，准备和运行 DBSCAN 需要 76 秒，计算平面墙需要 23.36 秒。 Matterport3D 模型的结果如图 15 所示。

生成平面图 我们生成平面图的最后一步是将网格切成不同的高度并叠加切片。图 13、14 和 15 显示了使用我们的方法生成的平面图。

我们进行了实验，以评估在渲染钢笔画平面图时更改图形设置的效果。每个设置都由不同的线段不透明度和切片数组合组成。我们发现，不透明度设置为 0.5 可以生成符合我们预期的平面图。我们还发现，包含 100 个切片的平面图在细节水平和减少杂乱之间实现了良好的平衡。最佳数量取决于用例。

5、结论和未来工作

总之，我们利用增强现实 (AR) 耳机收集的三角形网格数据生成平面图的新方法产生了两种风格：详细的钢笔和墨水风格和简化的绘图风格。我们的算法将网格数据与主坐标轴对齐，以生成具有垂直和水平墙壁的整洁平面图，同时还允许移除天花板和地板并将多层建筑分成单独的楼层。我们的方法与 AR 集成，支持将合成对象添加到物理几何图形中并提供详细的 3D 模型和平面图。

潜在应用包括导航、室内设计、家具摆放、设施管理、建筑施工和 HVAC 设计。展望未来，我们计划支持倾斜天花板，自动检测墙壁和门，并与能量模拟器等其他工具集成。最后，我们计划在准确性和计算时间方面将我们的方法与现有的最先进方法进行比较。我们还计划探索基于块的 DBScan 对不完整扫描进行 3D 重建的适用性。我们的方法有可能彻底改变我们生成和可视化平面图的方式。

原文链接：Using Scanned Mesh Data for Auto-Digitized 3D Modeling: Abstract and Introduction

BimAnt翻译整理，转载请标明出处

如果这个市场的主要参与者继续以现在的方式发展，我们不妨猜猜 VR/AR 行业的近期前景会是什么样子。

一切都很简单：它是一种设备、头盔或眼镜，重量为 300-600 克（有时更多），元件由玻璃、塑料或铝制成，操作时间长达数小时。毫无疑问，它看起来很棒。几乎就像 Ernest Klein 的科幻小说《头号玩家》中那样。

似乎在日常生活中，你很难用这样的小工具进入实际的平行数字现实。当然，这对你的脖子来说将是一场灾难……

我确实相信核心问题隐藏在技术本身的哲学中。我一直在问自己，为什么我们还要试图把一个能够进行一些计算的巨大盒子直接放在我们的头顶上？为什么我们要这样做，而不是用更复杂的方式解决问题，使用一种重量轻几十倍（甚至几百倍）的设备，而且更重要的是，这种设备可以大规模生产？

我确实相信未来在于 XR 技术和空间计算。它们的潜力如此巨大，前景如此光明，以至于 XR 小工具可以轻松成为用于任何用途的多功能设备。

让我解释一下我的意思。

在我理想的世界中，这样的小工具不仅可用于显示一些娱乐内容，还可用于解决医疗保健问题和沟通问题，也许，我们所有人都会进化成更像生物物种的东西。不过，我们不要操之过急。

现在似乎是向您更详细地解释 VR、AR 和 XR 的好时机。

VR 或虚拟现实 — 是一种用户只能看到数字环境的虚拟现实。人们可以使用特殊的小工具查看此环境。

AR 或增强现实 — 是一个增强现实世界。用户拥有某种小工具，通过它可以观察周围的真实环境。但与此同时，他可以看到周围添加的数字对象。

最后，XR或扩展现实是一整套虚拟技术的通用定义。XR涵盖了广泛的硬件和软件解决方案，包括传感器接口、应用程序及其基础设施。关键是XR可以广泛使用，从游戏到完成医疗保健、建筑、教育等领域的业务任务。应用程序基本上只受您的想象力限制。

目前的VR行业似乎是一个绝对的死胡同。这是因为主要关注的是VR/AR技术，而从定义上讲，它的功能有限。但为了证明这一点，我们必须回到过去，大约一个世纪左右！

因此，在这份宣言中，我们将尝试回答未来会给我们带来什么的问题。我是XPANCEO的创始人Roman Axelrod——让我们一起弄清楚吧！

1、VR的历史

你想知道我发现什么最有趣吗？增强现实设备的概念早在 1935 年就已出现。当时，美国科幻作家 Stanley Weinbaum 的小说《皮格马利翁的眼镜》出版。根据小说情节，一位教授发明了一种眼镜，可以让你创造一种视觉、听觉、味觉、动觉和嗅觉的现实幻觉。

请注意，皮格马利翁的眼镜实际上具有现代设备向我们承诺的所有功能。它们甚至看起来像标准的 AR 眼镜。

总的来说，该设备似乎与最新的小工具没有太大区别。

总的来说，该设备似乎与最新的小工具没有太大区别。

记住这些——皮格马利翁的眼镜。我们稍后会需要它们。从 50 年代初到 90 年代初，在掌握这项技术的同时，大量不同寻常的 VR 小工具被开发出来。它们都像皮格马利翁一样运作。

最初，这些小工具占据了房间的一半空间。例如，Sensorama“电影棚”，由电影摄影师 Morton Heilitt 于 1956 年设计和开发。里面有放映图像的电影放映机和播放立体声的扬声器。甚至还有一张振动扶手椅和一个模拟气味的装置！

到 1968 年，美国科学家 Ivan Sutherland 向公众推出了第一款名为达摩克利斯之剑的计算机化 VR 头盔。

这个看起来有点像中世纪酷刑工具的设备可以流畅地生成各种几何形状的简单 3D 模型。它还可以改变头部在环境中的位置以改变图像视角。

“达摩克利斯之剑”

乍一看，这些原型看起来绝对怪异。你应该把这个难以理解的盒子戴在头上，让自己感到不舒服，只是为了观看一些内容。每个人都明白世界需要虚拟现实，但它实现的方式似乎很奇怪。

然而，这些是推动行业发展最大的电脑游戏。顺便说一句，在 VR 技术还存在的时候，他们就做到了两次。

2、90 年代初

自 90 年代初以来，各种 VR 头盔、手部追踪手套和其他让您沉浸在数字世界中的好东西开始占领大众市场。任天堂凭借其 Virtual Boy成为该领域的主要先驱之一。

搭载 MS-DOS 的 Forte VFX1 头盔可让你在 VR 中玩当时的射击游戏。

毫无疑问，DOOM 在这样的耳机中看起来令人印象深刻。

总共有数十种设备被引入市场。然而，到 2000 年，VR 热潮开始下滑。可以肯定的是，那个时期的每一款设备都是真正的工程杰作和奇迹。现在，很难相信所有这些小玩意都是 20 年甚至 30 年前发明的！

然而，以下缺点也随之而来：

• 成本过高
• 笨拙且不友好的人体工程学
• 操作时间短
• 没有内容
• 日常使用时不够舒适（重量确实有影响！）

这听起来熟悉吗？ 没错！ 所有现代 VR 小玩意都有相同的缺点。 拜托，在这个行业存在的整个时间里，难道没有人想出如何处理它，或者得出任何结论吗？

很明显，如果一项技术在相当长的一段时间内没有发展，它就是死路一条，不是吗？

3、今天的 VR

无论如何，VR 行业已经成功地陷入了数十年的沉寂，直到它再次复活，主要是因为人们确实喜欢 VR。

你可能知道我在说什么。 这就是 Oculus Rift — VR 的复活。这位年轻人就是我们熟知的 Palmer Lucky，他真的变成了一个技术神秘主义者，把整个行业从坟墓里救了出来。Palmer 从青少年时期就对 VR 着迷。他的梦想就是打造他梦想中的 VR 头盔。在创建了原型后，他于 2012 年在 Kickstarter 上启动了他的项目，并取得了巨大的成功。

真正的复兴就此爆发！项目启动 600 天后，Facebook 收购了 Oculus Rift。与此同时，Valve 开始开发自己的头盔，甚至微软 也宣布了其 VR 开发。而苹果的 Vision Pro 头盔成为了这一趋势的巅峰。

因此，Vision Pro 配备了两个内置 4K 100Hz Micro-OLED 显示屏。视角——110 度。为了与外界互动并跟踪用户的位置，工程师为其配备了 12 个摄像头。听起来很棒，但别忘了它的重量为 600 克。外置电池续航时间从两小时到四小时不等。基础版售价 3500 美元。

总而言之，它做工非常精良，而且价格不菲。而我们正在努力解决的问题与几十年前一样：

• 不舒服
• 大
• 重
• 没有内容
• 操作时间短

因此，行业巨头加入了竞争。但说实话，无论是 Vision Pro 还是 Meta Quest，工程师们取得的成就都只是升级硬件并将其融入 90 年代的外形尺寸。

我个人称之为皮格马利翁的诅咒。近一百年前，斯坦利·温鲍姆 (Stanley Weinbaum) 设定了当今工程师试图复制的标准。

如果我们看看 PC 市场，VR 的发展也是以同样的方式开始的。一开始，有一台巨大的机器占据了整个房间。然后，随着技术的发展和成熟，它的尺寸缩小了。因此，现在我们有了智能手机。

但是，如果我们谈论的是 VR 小工具，那么它们的发展在 90 年代初就停止了。听起来像是死胡同，不是吗？假设苹果升级了它的头盔，并为其配备了 M10 芯片组和当时最先进的摄像头。该小工具的运行速度将提高十倍，并显示令人难以置信的图像质量，但它仍然是一个视野有限的头盔，你仍然必须戴在头上。

看来我们人类已经走上了 VR 小工具开发的错误道路。我们试图将非常复杂的组件（如屏幕、摄像头或电池）装入一小块电子设备中。相反，我们必须想办法避免这样做。

但在讨论这个问题之前，我们确实需要对另一件重要的事情进行一些推测——AR 眼镜！

最重要的是，我们最终会发现什么样的设备将成为关键的 XR 小工具。

所以，敬请期待！

原文链接：The Curse of Pygmalion: VR and AR Is at a Dead End

BimAnt翻译整理，转载请标明出处

重新照明（relighting）是在给定输入场景的情况下，在指定的目标照明条件下渲染场景的任务。这是计算机视觉和图形学中的关键任务。然而，这是一个不适定问题，因为场景中物体的外观是由光源、几何形状和表面材料属性等因素之间的复杂相互作用产生的。这些相互作用会产生歧义。例如，给定一个场景的照片，物体上的黑点是由于照明投射的阴影造成的，还是材料本身的颜色很暗？区分这些因素是有效重新照明的关键。

在这篇博文中，我们讨论了不同的论文如何通过扩散模型解决重新照明问题。重新照明包含各种子问题，包括简单的照明调整、图像协调、阴影去除和内在分解。这些领域对于优化场景编辑至关重要，例如在合成图像中平衡颜色和阴影或分离材料和照明属性。我们将首先介绍重新照明的问题，并简要讨论扩散模型和控制网络。然后，我们将讨论解决不同场景中重新照明问题的不同方法，这些场景包括从单个物体到肖像再到大型场景。

1、解决重新照明问题

目标是将场景分解为其基本组件（例如几何图形、材质和光线相互作用），并以参数方式对其进行建模。一旦解决，我们就可以根据自己的喜好进行更改。场景中某个点的外观可以通过渲染方程描述如下：

大多数方法旨在求解渲染方程的每个单个组件。一旦解决，我们就可以执行重新照明和材质编辑。由于照明项 L 在两边，因此无法通过分析评估该方程，只能通过蒙特卡洛方法或基于近似的方法求解。

另一种方法是数据驱动学习，它不是明确地建模场景属性，而是直接从数据中学习。例如，网络可以从数据中学习表面的材质属性，而不是拟合参数函数。事实证明，数据驱动方法比参数方法更强大。然而，它们需要大量高质量的数据，而这些数据很难收集，尤其是对于照明和材料估算任务而言。

用于照明和材料估算的数据集很少见，因为它们需要昂贵、复杂的设置（例如灯光舞台）来捕捉详细的照明交互。只有少数组织可以使用这些设置，这限制了用于训练和评估的数据的可用性。目前还没有公开的全身地面真实灯光舞台数据集，这进一步凸显了这一挑战。

2、扩散模型

随着在线上大量图像和视频数据上进行预训练的出现，计算机视觉经历了重大转变。这导致了基础模型的发展，这些模型是强大的通用模型，可以针对各种特定任务进行微调。扩散模型通过学习从独立样本中建模底层数据分布来工作，逐渐逆转噪声添加过程以生成真实数据。通过利用从学习分布中生成高质量样本的能力，扩散模型已成为解决各种生成任务的重要工具。

其中一个最突出的例子是稳定扩散 (SD)，它是在由 50 亿个图像文本对组成的大规模 LAION-5B 数据集上训练的。它编码了大量关于视觉概念的一般知识，使其适合针对特定任务进行微调。它在训练过程中学习了基本的关系和关联，例如椅子有 4 条腿或识别汽车的结构。这种内在理解使稳定扩散能够生成高度连贯和逼真的图像，并用于微调以预测其他模态。基于这个想法，问题出现了，我们是否可以利用预训练的 SD 来解决场景重新照明的问题。

那么我们如何微调 LDM？一种简单的方法是使用 LDM 进行迁移学习。这将冻结早期层（捕获一般特征）并针对特定任务微调模型。虽然这种方法已被一些论文如 Alchemist（用于材料转移）使用，但它需要大量配对数据才能使模型很好地概括。这种方法的另一个缺点是存在灾难性遗忘的风险，即模型会丢失在预训练期间获得的知识。这会限制其在各种条件下进行推广的能力。

另一种微调此类大型模型的方法是引入ControlNet。在这里，复制网络并冻结原始网络的权重。在训练期间，仅更新重复的网络权重，并将调节信号作为输入传递给重复的网络。原始网络继续利用其预训练的知识。

虽然这会增加内存占用，但优点是我们不会失去从大规模数据集训练中获得的泛化能力。它确保它保留了在广泛提示中生成高质量输出的能力，同时学习当前任务所需的任务特定关系。

此外，它还帮助模型学习控制输入和期望输出之间的稳健且有意义的联系。通过将控制网络与核心模型分离，可以避免过度拟合或灾难性遗忘的风险。它还需要更少的配对数据来训练。

虽然还有其他用于微调基础模型的技术——例如 LoRA（低秩自适应）等——但我们将重点介绍讨论的两种方法：传统迁移学习和 ControlNet。这些方法对于理解各种论文如何使用扩散模型解决基于图像的重新照明特别重要。

3、DiLightNet

这项工作提出了对输入图像重新照明的细粒度控制。输入图像可以生成或作为输入提供。此外，它还可以根据文本提示更改对象的材质。目标是对照明效果施加细粒度控制。

3.1 方法

给定输入图像，应用以下预处理步骤：

• 使用现成的 SOTA 模型估计背景和深度图。
• 通过对深度图进行三角测量来提取网格
• 生成 4 种不同的辐射提示图像。通过为提取的网格分配不同的材质并在目标照明下渲染它们来创建辐射提示图像。辐射提示图像作为编码照明效果（如镜面反射、阴影和全局照明）的基础。

一旦生成这些图像，它们就会训练 ControlNet 模块。输入图像和掩码通过编码器解码器网络，输出 12 通道特征图。然后将其与按通道连接在一起的辐射提示图像相乘。因此，在训练期间，使用这个自定义的 12 通道图像作为调节信号对嘈杂的目标图像进行去噪。

此外，还提供外观种子，以便在不同的照明下获得一致的外观。如果没有它，网络会对光与物质的相互作用做出不同的解释。此外，可以通过文本提供更多提示来改变外观，例如通过添加“塑料/闪亮金属”来改变生成图像的材质。

3.2 实现

数据集是使用来自 Objaverse 的 25K 合成对象策划的。每个对象都从 4 个独特的视图渲染，并使用 12 种不同的照明条件点亮，包括点源照明、多点源、环境地图和区域光。为了进行训练，辐射提示在搅拌机中渲染。

ControlNet 模块使用稳定扩散 v2.1 作为基础预训练模型进行改进。在 8x NVIDIA V100 GPU 上训练大约需要 30 小时。训练数据在 Blender 中以 512x512 分辨率渲染。

3.3 结果

此图显示了临时图像作为参考，以及对象重新点亮的相应目标照明。

来此图显示了如何使用文本提示来更改对象的材质。

此图显示了 AI 生成的临时图像的更多结果，然后在不同的输入环境光条件下进行渲染。

此图显示了如果外观种子不固定，网络为解决光相互作用而提出的不同解决方案。

3.4 局限性

由于对合成物体进行训练，该方法对真实图像的效果不是很好，而对 AI 生成的临时图像的效果要好得多。此外，材料光交互可能不符合提示的意图。由于它依赖深度图来生成辐射线索，因此可能无法获得令人满意的结果。最后，生成旋转光视频可能不会产生一致的结果。

4、神经 Gaffer

这项工作提出了一种端到端 2D 重新照明扩散模型。该模型从具有基于物理的材料和 HDR 环境图的合成数据集中学习物理先验。它可以进一步用于重新照亮多个视图并用于创建场景的 3D 表示。

4.1 方法

给定一个图像和一个目标 HDR 环境地图，目标是学习一个可以合成图像的重新照明版本（此处为单个对象）的模型。这是通过采用预先训练的 Zero-1-to-3 模型实现的。Zero-1-to-3 是一种扩散模型，它以视图方向为条件来渲染输入图像的新视图。它们丢弃了其新的视图合成组件。为了结合照明条件，它们将输入图像和环境地图编码与去噪潜伏连接起来。

输入 HDR 环境地图 E 分为两个组件：E_l，一种色调映射的 LDR 表示，用于捕获低强度区域的照明细节，以及 E_h，一种对数归一化地图，用于保留整个光谱的信息。它们共同为网络提供了能量谱的平衡表示，确保准确的重新照明，而不会因极端亮度而使生成的输出显得褪色。

此外，输入图像的 CLIP 嵌入也作为输入传递。因此，模型的输入是输入图像、LDR 图像、归一化 HDR 图像和图像的 CLIP 嵌入，所有这些都调节去噪网络。然后，该网络被用作进一步 3D 对象重新照明的先验。

4.2 实现

该模型在包含 90K 个对象的自定义 Relit Objaverse 数据集上进行训练。对于每个对象，有 204 张在不同照明条件和视点下渲染的图像。总的来说，数据集包含 18.4 M 张分辨率为 512x512 的图像。

该模型从 Zero-1-to-3 的检查点进行微调，并且只对去噪网络进行微调。输入环境图被下采样到 256x256 分辨率。该模型在 8 个 A6000 GPU 上训练了 5 天。可以实现进一步的下游任务，例如基于文本的重新照明和对象插入。

4.3 结果

它们显示了与不同背景的比较以及与其他作品（如 DilightNet 和 IC-Light）的比较。

此图比较了他们的方法与另一种基于 ControlNet 的方法 IC-Light 的重新照明结果。他们的方法可以通过旋转环境地图产生一致的照明和颜色。

此图比较了他们的方法与另一种基于 ControlNet 的方法 DiLightnet 的重新照明结果。他们的方法可以产生镜面高光和准确的颜色。

4.4 局限性

一个主要的限制是它只能产生低图像分辨率（256x256）。此外，它仅适用于物体，并且在肖像重新照明方面表现不佳。

5、重新照明协调

图像协调是将前景主体的颜色和照明特征与背景对齐以使其成为合理构图的过程。这项工作提出了一种基于扩散的方法来解决该任务。

5.1 方法

给定输入合成图像、alpha 蒙版和目标背景，目标是预测重新点亮的肖像图像。这是通过训练 ControlNet 来预测协调图像输出来实现的。

在第一阶段，我们训练一个背景控制网络模型，该模型以合成图像和目标背景为输入并输出重新点亮的肖像图像。在训练期间，去噪网络将噪声目标图像与合成图像连接起来并预测噪声。背景通过控制网络作为条件提供。由于背景图像本身是 LDR，因此它们无法提供足够的信号用于重新点亮。

在第二阶段，训练环境地图控制网络模型。HDR 环境地图为重新点亮提供了更多信号，这给出了更好的结果。然而在测试时，用户只提供 LDR 背景。因此，为了弥补这一差距，2 个控制网络模型相互对齐。

最后，使用环境地图 ControlNet 模型生成更多数据，然后对背景 ControlNet 模型进行微调以生成更逼真的结果。

5.2 实现

用于训练的数据集由使用 100 个 lightstage 策划的 400k 个图像对样本组成。在第三阶段，生成了另外 200k 个合成样本，用于微调以实现照片级真实感。

该模型是从 InstructPix2PIx 检查点微调的。该模型在 8 个 A100 GPU 上以 512x512 分辨率进行训练。

5.3 结果

该图显示了该方法如何中和输入中通常难以去除的明显阴影。左边是输入，右边是重新点亮的图像。

这些图显示了现实世界测试对象的结果。与其他方法相比，他们的方法能够去除阴影并使构图更合理。

5.4 局限性

虽然这种方法能够合理地重新照亮主体，但它在身份保存方面表现不佳，并且难以保持血凝块的颜色

他或头发。此外，它可能很难正确消除阴影。此外，它也无法估计对复杂光相互作用至关重要的反照率。

6、多照明合成

这项工作提出了一种 2D 重新照明扩散模型，该模型进一步用于重新照明场景的辐射场。它首先训练 ControlNet 模型来预测新光方向下的场景。然后，该模型用于生成更多数据，最终用于拟合可重新照明的辐射场。我们将在本节中讨论 2D 重新照明模型。

6.1 方法

给定一组图像 X_i 和相应的深度图 D（通过现成的方法计算）和光方向 l_i，目标是预测光方向 l_j 下的场景。在训练期间，去噪网络的输入是随机照明下的 X_i、深度图 D 与嘈杂的目标图像 X_j 连接。光方向用 4 阶 SH 编码并通过 ControlNet 模型进行调节。

虽然这会产生不错的结果，但也存在一些重大问题。它无法保留颜色并导致对比度损失。此外，它会产生扭曲的边缘。为了解决这个问题，他们将预测与输入图像进行颜色匹配以补偿色差。这是通过将图像转换为 LAB 空间然后进行通道归一化来完成的。然后在真实值和去噪输出之间计算损失。为了保留边缘，解码器在图像修复任务上进行了预训练，这有助于保留边缘。然后使用该网络在新的光方向下创建相应的场景，进一步用于创建可重新照明的辐射场表示。

6.2 实现

该方法是在多照明数据集上开发的。它包括在 25 个照明方向下拍摄的 1000 个室内场景的真实场景。这些图像还包含一个漫反射和一个金属球，可用于获取世界坐标中的光方向。此外，在 Blender 中渲染了一些场景。该网络在分辨率为 1536x1024 的图像上进行训练，训练包括 1015 个室内场景中的 18 个非正面光方向。

ControlNet 模块使用 Stable Diffusion v2.1 模型作为主干进行训练。它在多个 A6000 GPU 上进行了 150K 次迭代训练。

6.3 结果

此处漫反射球显示测试时间光方向。可以看出，该方法可以呈现合理的重新照明结果

该图显示了随着光方向的变化，镜面高光和阴影如何移动，如水壶上的闪亮高光所示。

该图将结果与其他可重新照明的辐射场方法进行了比较。与其他方法相比，他们的方法显然更好地保留了颜色和对比度。

6.3 局限性

该方法不强制物理准确性，可能会产生不正确的阴影。此外，它还难以以完全准确的方式完全去除阴影。此外，它对于光照差异不大的分布场景也确实有效。

7、LightIt

这项工作提出了一种单视图阴影估计方法来生成配对图像及其相应的直接光阴影。然后可以使用此阴影来指导场景的生成并重新照亮场景。他们将问题视为内在分解问题，其中场景可以分为反射和阴影。我们将在这里讨论重新照明组件。

7.1 方法

给定输入图像、其对应的表面法线、文本条件和目标直接阴影图像，它们会生成重新照明的风格化图像。这是通过训练 ControlNet 模块实现的。

在训练期间，将噪声目标图像与文本条件一起传递到去噪网络。将法线和目标直接阴影图像连接起来并通过残差控制编码器。然后使用特征图来调节网络。此外，它还通过残差控制解码器重建以规范训练

7.2 实现

数据集由户外 Laval 数据集组成，该数据集由户外真实世界 HDR 全景图组成。从这些图像中，裁剪了 250 张 512x512 图像并应用了各种相机效果。数据集由 51250 个 LDR 图像和文本提示样本以及估计的法线和阴影图组成。法线图是根据使用现成估计器估计的深度图估计的。

ControlNet 模块从稳定扩散 v1.5 进行了微调。网络训练了两个时期。其他训练细节不共享。

7.3 结果

该图显示，生成的图像具有与自定义风格化文本提示的目标着色一致的一致照明。这与其他讨论的论文不同，这些论文的唯一重点是照片写实主义。

该图显示了不同照明条件下的身份保存。

该图显示了在变化的照明条件下对不同风格和场景的结果。

该图将重新照明与另一种方法进行了比较。利用扩散先验有助于泛化和解决着色歧义。

7.4 局限性

由于此方法假设定向照明，因此它可以在任意方向上跟踪光线。它需要着色提示来生成不易获得的图像。此外，他们的方法不适用于肖像和室内场景。

8、要点

我们讨论了一份非详尽的论文清单，这些论文利用 2D 扩散模型进行重新照明。我们探索了不同的方法来调节扩散模型以进行重新照明，包括辐射提示、直接阴影图像、光方向和环境地图。这些方法中的大多数都在合成数据集上显示结果，并且不能很好地推广到分布外的数据集。每天都有更多论文出现，基础模型也在改进。最近发布了 IC-Light2，这是一个基于 Flux 模型的 ControlNet 模型。由于保持身份很棘手，因此它采取哪个方向将会很有趣。

原文链接：Let There Be Light! Diffusion Models and the Future of Relighting

BimAnt翻译整理，转载请标明出处

数据可视化是一个大问题🌶️：通过使用视觉元素对信息进行图形表示，我们可以最好地呈现和理解数据中的趋势、异常值和模式。你猜对了：使用代表真实世界形状的 3D 点云数据集，这是强制性的 🙂。

但是，当从激光扫描仪或摄影测量等 3D 重建技术收集时，点云通常过于密集，无法进行经典渲染。在许多情况下，数据集将远远超过 1000 万大关，这使得它们对于 Matplotlib 等经典可视化库来说不切实际。

这意味着我们经常需要跳出 Python 脚本（因此使用 I/O 函数将数据写入文件）并在外部进行可视化，这可能会成为一个非常繁琐的过程🤯。我不会撒谎，这几乎就是我在论文第一年所做的，试图猜测特定算法的结果🥴。

直接在脚本中可视化这些点云不是很棒吗？更好的是，将视觉反馈连接到脚本？想象一下，现在 iPhone 12 Pro 配备了 LiDAR；你可以创建一个完整的在线应用程序！好消息，有一种方法可以实现这一点，而无需离开舒适的 Python 环境和 IDE。☕ 准备好了吗？

1、启动你的 Python 环境

在上一篇文章中，我们了解了如何使用 Anaconda 轻松设置环境以及如何使用 IDE Spyder 管理代码。如果你打算成为一名成熟的 Python 应用程序开发人员，我建议您继续以这种方式学习 😆。

如果你使用的是 Jupyter Notebook 或 Google Colab，脚本可能需要进行一些调整才能使可视化后端工作，但性能不稳定。如果你想继续使用这些 IDE，我建议你查看步骤 4 中给出的所选库的替代方案。

2、下载点云数据集

我在之前的教程中说明了使用摄影测量和来自 Open Topography 的航空 LiDAR 获得的 3D 数据集的点云处理和网格划分。我将跳过下文中介绍的有关 LiDAR I/O 的详细信息，直接跳转到使用高效的 .las 文件格式。

只是这一次，我们将使用空中无人机数据集。它是通过摄影测量获得的，让一架小型 DJI Phantom Pro 4 在我们的大学校园里飞行，收集一些图像并运行摄影测量重建，如此处所述。

🤓 注意：对于本操作指南，你可以使用此存储库中的点云，我已经对其进行了过滤和翻译，以便你处于最佳条件。如果你想在不安装任何软件的情况下预先进行可视化和操作，可以查看 webGL 版本。

3、在脚本中加载点云

我们首先在脚本中导入必要的库（NumPy 和 LasPy），然后将 .las 文件加载到名为 point_cloud 的变量中。

import numpy as np
import laspy as lp
input_path="D:/CLOUD/POUX/ALL_DATA/"
dataname="2020_Drone_M"
point_cloud=lp.file.File(input_path+dataname+".las", mode="r")

很好，我们快准备好了！很棒的是，LasPy 库还为 point_cloud 变量提供了一个结构，我们可以使用简单的方法来获取例如 X、Y、Z、红色、蓝色和绿色字段。让我们这样做来将坐标与颜色分开，并将它们放入 NumPy 数组中：

points = np.vstack((point_cloud.x, point_cloud.y, point_cloud.z)).transpose()
colors = np.vstack((point_cloud.red, point_cloud.green, point_cloud.blue)).transpose()

🤓 注意：我们使用 NumPy 的垂直堆栈方法，我们必须将其转置以从 (n x 3) 变为 (3 x n) 点云矩阵。

4、最终预处理，可选

如果你的数据集太重，或者你想尝试子采样版本，我鼓励您可以查看这篇文章，其中提供了几种完成此类任务的方法。

为了方便起见，如果你的点云超过 1 亿个点，我们可以使用以下方法快速切分你的数据集：

factor=10
decimated_points_random = points[::factor]

🤓 注意：运行此操作将每 10 行保留 1 行，从而将原始点云的大小除以 10。

5、选择你的可视化策略

现在，让我们选择我们想要如何可视化我们的点云。我会在这里说实话：虽然可视化本身就很好，可以避免繁琐的 I/O 操作，但能够在 Python 中包含一些视觉交互和处理工具是一个很好的补充！因此，我推崇的解决方案是使用一个点云处理工具包，它可以实现这一点甚至更多。如果你想探索其他可能性，我仍然会为你提供替代方案⚖️。

解决方案 A（保留）：PPTK

PPTK 包有一个 3-d 点云查看器，它直接将 3 列 NumPy 数组作为输入，并且可以交互式地可视化 10 到 1 亿个点。它通过使用八叉树剔除视锥体之外的点并将远处点组近似为单个点，减少了每帧中需要渲染的点数。

首先，你可以使用 Pip 管理器安装库：

pip install pptk

然后，你可以通过键入以下内容从点云中可视化之前创建的点变量：

import pptk
import numpy as np
v = pptk.viewer(points)

启动时，查看器将输入点组织成八叉树。在操纵视点时，八叉树用于将远处的点组近似为单个点并剔除视锥体外的点，从而显著减少要渲染的点数。一旦视点不再发生变化，查看器将继续执行更耗时的详细点渲染。

你不觉得我们缺少一些颜色吗？让我们通过在控制台中输入以下内容来解决这个问题：

v.attributes(colors/65535)

🤓 注意：我们的颜色值是从 .las 文件中以 16 位编码的。我们需要 [0,1] 间隔内的值；因此，我们除以 65535。

这样好多了！但如果我们还想可视化其他属性怎么办？好吧，您只需将属性链接到路径，它就会即时更新。

💡 提示：不要最大化窗口大小以保持超过 30 FPS 的良好帧速率。目标是在拥有可读脚本的同时拥有最佳的执行运行时

你还可以参数化窗口以显示有关特定颜色渐变的每个属性，管理点大小，将背景设为黑色，而不显示网格和轴信息：

v.color_map('cool')
v.set(point_size=0.001,bg_color=[0,0,0,0],show_axis=0,show_grid=0)

替代方案 B：Open3D

对于任何想知道在 Python 中读取和显示点云的绝佳替代方案的人，我推荐 Open3D。你也可以使用 Pip 包管理器来安装必要的库：

pip install open3d

这将在你的机器上安装 Open3D，然后你将能够通过执行以下脚本读取和显示点云：

import open3d as o3d
pcd = o3d.geometry.PointCloud()
pcd.points = o3d.utility.Vector3dVector(points)
pcd.colors = o3d.utility.Vector3dVector(colors/65535)
pcd.normals = o3d.utility.Vector3dVector(normals)
o3d.visualization.draw_geometries([pcd])

Open3D 实际上正在不断发展，你可以通过一些有趣的方式来显示点云，以填补最终的漏洞，例如创建体素结构：

voxel_grid = o3d.geometry.VoxelGrid.
create_from_point_cloud(pcd,voxel_size=0.40)
o3d.visualization.draw_geometries([voxel_grid])

点云的 3D 体素表示，其中每个体素代表一个 40 x 40 厘米的立方体。

🤓 注意：为什么 Open3d不是此时的选择？如果你处理的数据集少于 5000 万个点，那么这就是我推荐的。如果你需要在此阈值以上进行交互式可视化，我建议你对数据集进行采样以进行可视化，或者使用 PPTK，因为你为此目的创建了八叉树结构，因此可视化效率更高。

其他（Colab 友好型）替代方案：Pyntcloud 和 Pypotree

如果你希望能够简单且交互式地探索点云数据，无论使用哪种传感器来生成它或用例是什么，我建议你研究 Pyntcloud 或 PyPotree。这些将允许你在笔记本中可视化点云，但要注意性能！Pyntcloud 实际上依赖于 Matplotlib，而 PyPotree 需要 I/O 操作；因此，两者实际上都不是超级高效的。尽管如此，我想提到它们，因为对于小点云和 Google Colab 中的简单实验，你可以集成可视化。一些示例：

### PyntCloud ###
conda install pyntcloud -c conda-forge
from pyntcloud import PyntCloud

pointcloud = PyntCloud.from_file("example.ply")
pointcloud.plot()

### PyntCloud ###
pip install pypotree

import pypotree 
import numpy as np
xyz = np.random.random((100000,3))
cloudpath = pypotree.generate_cloud_for_display(xyz)
pypotree.display_cloud_colab(cloudpath)

6、与点云交互

返回 PPTK。要进行交互式选择，比如停车场上的汽车，我将移动相机顶视图（快捷键为 7），然后按住 Ctrl+LMB 拖动矩形选择进行选择。

💡 提示：如果你对选择不满意，只需按 RMB 即可清除当前选择。是的，你可以进行多项选择 😀。

做出选择后，你可以返回 Python 控制台，然后获取分配的点标识符。

selection=v.get('selected')

这实际上会返回一个 1D 数组，如下所示：

你实际上可以扩展该过程以一次选择多个元素（Ctrl+LMB），同时细化选择以删除特定点（Ctrl+Shift+LMB）。

在此之后，可以毫不费力地在保存选定点索引的选择变量上交互地应用一系列过程。

让我们复制一个场景，在该场景中，你可以自动在地面和非地面元素之间细化初始选择（汽车）。

7、实现自动分割

在包含完整点云（存储在变量 v 中）的查看器中，我进行以下选择：

selection=v.get('selected') 

然后我计算每个点的法线。为此，我想说明使用 PPTK 的另一个关键要点：函数estimate_normals，可用于根据半径搜索或 k-最近邻获取每个点的法线。别担心，我将在另一本指南中深入说明这些概念，但现在，我将使用 6 个最近邻居来估计我的法线来运行它：

normals=pptk.estimate_normals(points[selection],k=6,r=np.inf)

💡 提示：请记住，selection 变量保存点的索引，即点云中的“线号”，从 0 开始。因此，如果我只想处理这个点子集，我会将其作为 points[selection] 传递。然后，我选择 k-NN 方法，只使用每个点的 6 个最近邻居，同时将 radius 参数设置为 np.inf，以确保我不使用它。我也可以使用这两个约束，或者如果我想进行纯半径搜索，则将 k 设置为 -1。

这基本上会返回以下内容：

然后，我想过滤并返回法线不与 Z 轴共线的原始点的索引。我建议使用以下代码行：

idx_normals=np.where(abs(normals[...,2])<0.9)

🤓 注意：normals[...,2] 是 NumPy 的一种说法，表示我只处理 3 x n 点矩阵的第 3 列，保存法线的 Z 属性。它相当于 normals[:,2]。然后，我将绝对值作为比较点，因为我的法线没有方向（因此可以指向天空或地球中心），并且只会使用函数 np.where() 保留满足条件 <0.9 的那个。

为了直观地展示结果，我创建了一个新的查看器窗口对象：

viewer1=pptk.viewer(points[idx_normals],colors[idx_normals]/65535)

如你所见，我们还过滤了汽车的一些点。这不好 🤨。因此，我们应将过滤与另一个过滤器相结合，以确保仅选择靠近地面的点作为法线过滤的主机：

idx_ground=np.where(points[...,2]>np.min(points[...,2]+0.3))
idx_wronglyfiltered=np.setdiff1d(idx_ground, idx_normals)
idx_retained=np.append(idx_normals, idx_wronglyfiltered)

viewer2=pptk.viewer(points[idx_retained],colors[idx_retained]/65535)

这很棒！现在，你可以探索这种强大的思维方式，并结合任何过滤（例如，在 RGB 上玩以摆脱剩余的草……）来创建一个完全交互式的分割应用程序。甚至更好的是，您可以将其与 3D 深度学习分类相结合！呵呵！但那是另一回事了 😉。

8、使用函数打包你的脚本

最后，我建议将你的脚本打包成函数，以便你可以直接将其部分重用为块。我们可以首先定义一个preparedata()，它将以任何.laspoint云作为输入，并对其进行格式化：

def preparedata():
    input_path="D:/CLOUD/OneDrive/ALL_DATA/GEODATA-ACADEMY/"
    dataname="2020_Drone_M_Features"
    point_cloud=lp.file.File(input_path+dataname+".las", mode="r")
    points = np.vstack((point_cloud.x, point_cloud.y, point_cloud.z) 
    ).transpose()
    colors = np.vstack((point_cloud.red, point_cloud.green,
    point_cloud.blue)).transpose()
    normals = np.vstack((point_cloud.normalx, point_cloud.normaly, 
    point_cloud.normalz)).transpose()
    return point_cloud,points,colors,normals

然后，我们编写一个显示函数pptkviz，返回查看器对象：

def pptkviz(points,colors):
    v = pptk.viewer(points)
    v.attributes(colors/65535)
    v.set(point_size=0.001,bg_color= [0,0,0,0],show_axis=0,
    show_grid=0)
    return v

另外，作为奖励，这里是 cameraSelector 函数，用于从打开的查看器中获取相机的当前参数：

def cameraSelector(v):
    camera=[]
    camera.append(v.get('eye'))
    camera.append(v.get('phi'))
    camera.append(v.get('theta'))
    camera.append(v.get('r'))
    return np.concatenate(camera).tolist()

我们定义了 computePCFeatures 函数来自动细化交互式分割：

def computePCFeatures(points, colors, knn=10, radius=np.inf):
    normals=pptk.estimate_normals(points,knn,radius)
    idx_ground=np.where(points[...,2]>np.min(points[...,2]+0.3))
    idx_normals=np.where(abs(normals[...,2])<0.9)
    idx_wronglyfiltered=np.setdiff1d(idx_ground, idx_normals)
    common_filtering=np.append(idx_normals, idx_wronglyfiltered)
    return points[common_filtering],colors[common_filtering]

Et voilà 😁，现在你只需启动包含上述函数的脚本，然后开始使用 computePCFeatures、cameraSelector 和更多功能与你的选择进行交互:

import numpy as np
import laspy as lp
import pptk

#Declare all your functions here

if __name__ == "__main__":
    point_cloud,points,colors,normals=preparedata()
    viewer1=pptkviz(points,colors,normals)

然后可以轻松调用脚本，然后使用控制台作为实验的基准。例如，我可以保存多个相机位置并创建动画：

cam1=cameraSelector(v)
#Change your viewpoint then -->
cam2=cameraSelector(v)
#Change your viewpoint then -->
cam3=cameraSelector(v)
#Change your viewpoint then -->
cam4=cameraSelector(v)

poses = []
poses.append(cam1)
poses.append(cam2)
poses.append(cam3)
poses.append(cam4)
v.play(poses, 2 * np.arange(4), repeat=True, interp='linear')

9、结束语

我们刚刚学习了如何导入、可视化和分割由 3000 多万个点组成的点云！做得好！

有趣的是，直接在 GPU 上执行的点云片段和单个点的交互式选择现在可以用于实时点云编辑和分割。但路径并未就此结束，未来的文章将深入探讨点云空间分析、文件格式、数据结构、分割 [2–4]、动画和深度学习 [1]。我们将特别研究如何管理下文定义的大点云数据。

原文链接：Visualise Massive point cloud in Python

汇智网翻译整理，转载请标明出处

计算几何是计算机科学的一个分支，专注于创建几何问题求解算法。许多行业，包括计算机图形学、机器人技术、地理信息系统、计算机视觉和计算生物学，都在一系列应用中使用这些方法。

它是计算机科学的一个分支，具有广泛的应用范围。计算几何在模式识别、计算机图形学、运筹学、制造和计算机辅助设计等领域面临着多项挑战。计算机图形学和 CAD/CAM（计算机辅助设计和制造）的进步是计算几何作为一门学科发展的主要驱动力。然而，许多计算几何问题具有经典性质，可以源于数学可视化。计算几何的其他重要应用包括机器人技术（运动规划和可见性问题）、地理信息系统 (GIS)（几何定位和搜索、路线规划）、集成电路设计（IC 几何设计和验证）和计算机辅助工程 (CAE)。计算几何与图形、科学计算和建模以及计算机视觉等研究领域密不可分。

我们将在本博客中详细介绍一些计算几何算法的应用。

计算机图形学是使用计算几何算法的主要领域之一。在 2D 和 3D 图形应用中，这些技术用于表示、处理和渲染几何对象。计算线、线段和平面等几何图元交点的算法是计算机图形学中使用的一些算法的例子，这些算法对于显示 3D 图像是必需的。

制作三维对象的多边形网格表示是计算机图形学中最基本的任务之一。此过程需要将对象的表面转换为可使用当前图形技术渲染的连接三角形网格。多边形网格是使用 Delaunay 三角剖分和 Voronoi 图等计算几何算法构建的，这些算法根据到一组点的距离将平面划分为区域。Delaunay 三角剖分计算一组点的三角剖分，以最大化所得三角形的最小角度。

机器人技术是计算几何算法广泛应用的领域。运动规划、碰撞检测和路径优化问题都是使用这些算法解决的。例如，机器人在规划从原始配置移动到目标配置时，必须考虑其工作空间中的障碍物。在机器人的工作空间中，使用可视性图算法和快速探索随机树 (RRT) 算法等计算几何技术计算无碰撞路径。

除了运动规划之外，计算几何算法还用于机器人抓取和操纵。例如，为了管理物体，机器人需要能够确定抓取物体的最佳位置和角度。物体的理想抓取位置和方向是使用计算几何算法确定的，例如凸包算法（计算包含一组点的最小凸多边形）和抓取质量指标算法（根据物体和机器人手的几何形状计算抓取质量）。

1、人工智能

人工智能是计算几何学的另一个常见领域；在确定最佳路线时，几何算法是基础

例如，A* 寻路可用于确定两点之间的最短路线。它采用了基于网格的方法和启发式方法，这是一种基本的机器学习类型，这意味着算法的经验越多，找到的路径就越好。沃罗诺伊图可用于确定道路是否畅通，因为如果其点代表障碍，则意味着其边缘代表理论上距离这些障碍和碰撞最远的路线。

计算机视觉是计算几何学在人工智能中得到应用的另一个领域。例如，凸包经常用于面部识别和自动驾驶汽车，因为它们可以帮助算法更一致地解释来自摄像头的数据，并允许算法学习。例如，与普通网格相比，汽车的凸包在物体避让中更容易使用，因为汽车具有多种形状和不同的特征。

2、网络

计算几何学至关重要的另一个领域是网络。由于每条边（与另一台路由器的连接）的成本将根据当前流量而有所不同，因此可以使用 Dijkstra 等最短路径算法来确定数据包传输的最短距离。这是一个实际的例子

y是使用最短路径算法的完美案例。在其他优化中，可以使用 Voronoi 图来映射无线网络的最大容量，使工程师能够决定每个节点、交换机等的位置。

GIS 或地理信息系统 称为地理信息系统 (GIS) 的计算机程序用于存储、处理和显示空间数据。为了管理和分析空间数据，GIS 应用程序中采用了计算几何技术。为了分析地理数据并确定影响区域或接近区域，可以利用计算一组点的凸包或计算一组点的 Voronoi 图的技术。

除了空间数据分析之外，GIS 应用程序中还采用计算几何方法进行空间数据显示。为了创建可用于可视化地形数据的区域的表面网格，可以使用计算一组点的 Delaunay 三角剖分的程序作为示例。

机器学习 创建用于解读从外部环境收集的视觉数据的算法是计算机科学学科（称为计算机视觉）的重点。计算机视觉应用（包括对象检测、跟踪和分割）需要计算几何方法。例如，可以使用计算线、线段和平面等几何图元的交点的方法来识别图像中对象的边界。

世界之美体现在几何中。几何是世界之美的原型。~ 约翰内斯·开普勒

根据搜索结果，计算几何是计算机科学的一个领域，专注于研究可以用几何形式表达的算法。计算机图形学、机器人技术、地理信息系统和计算机辅助设计等许多领域都使用了它。为了处理运动规划、路径规划、避障、空间分析和形状修改问题，应用了计算几何方法。实现该主题中的算法相对简单，因为它们以足够详细的伪代码描述。未来，计算几何学预计将获得更大的意义，因为它在计算机科学领域拥有众多应用，预计未来将变得更加重要。

总之，计算机图形学、机器人技术、地理信息系统和计算机辅助设计等众多领域都使用计算几何方法。这些方法解决了运动规划、路径规划、避障、空间分析和形状操作等问题。由于对自动化和数字化的需求不断增长，计算几何算法的重要性在未来只会越来越大。

原文链接：Applications Of Computational Geometry Algorithms

BimAnt翻译整理，转载请标明出处

在探索创建点云的第二部分中，我们将在第一部分建立的基础之上。

捕获并处理单个彩色点后，我们的下一个目标是将这些点合并为统一的点云。之后，我们将在 AR 视图中可视化点云，并最终将其导出到 .PLY 文件。

1、存储顶点

现在，我们从深度图中获得了每个点的颜色和 3D 位置。下一步是将这些点存储在点云中，但简单地附加我们捕获的每个点效率不高，并且可能导致不必要的大数据集。为了有效地处理这个问题，我们需要过滤来自不同深度图的点。

我们将使用基于网格的算法，而不是处理每个点。这种方法涉及将 3D 空间划分为均匀的网格单元或预定义大小的“框”。对于每个网格单元，我们只存储一个代表点，从而有效地对数据进行下采样。通过调整这些框的大小，我们可以控制点云的密度。

这种方法不仅减少了存储的数据量，还使我们能够根据应用程序的要求灵活地微调点云密度——无论我们需要更高的精度来获取详细的数据，还是需要更轻的数据集来加快处理速度。

让我们定义一个 Vertex、GridKey 和一个相应的字典作为 PointCloud 参与者的一部分。

actor PointCloud {

    //--
    struct GridKey: Hashable {
        
        static let density: Float = 100
    
        private let id: Int
        
        init(_ position: SCNVector3) {
            var hasher = Hasher()
            for component in [position.x, position.y, position.z] {
                hasher.combine(Int(round(component * Self.density)))
            }
            id = hasher.finalize()
        }
    }
    
    struct Vertex {
        let position: SCNVector3
        let color: simd_float4
    }
    
    private(set) var vertices: [GridKey: Vertex] = [:]
    //--

}

GridKey 的设计目的是根据指定的密度对点坐标进行舍入，这样我们就可以将彼此靠近的点分配给同一个键。

我们现在可以完成 process函数了。

func process(frame: ARFrame) async {
    guard let depth = (frame.smoothedSceneDepth ?? frame.sceneDepth),
          let depthBuffer = PixelBuffer<Float32>(pixelBuffer: depth.depthMap),
          let confidenceMap = depth.confidenceMap,
          let confidenceBuffer = PixelBuffer<UInt8>(pixelBuffer: confidenceMap),
          let imageBuffer = YCBCRBuffer(pixelBuffer: frame.capturedImage) else { return }
       
    let rotateToARCamera = makeRotateToARCameraMatrix(orientation: .portrait)
    let cameraTransform = frame.camera.viewMatrix(for: .portrait).inverse * rotateToARCamera
    
    // iterate through pixels in depth buffer
    for row in 0..<depthBuffer.size.height {
        for col in 0..<depthBuffer.size.width {
            // get confidence value
            let confidenceRawValue = Int(confidenceBuffer.value(x: col, y: row))
            guard let confidence = ARConfidenceLevel(rawValue: confidenceRawValue) else {
                continue
            }
                        
            // filter by confidence
            if confidence != .high { continue }
                        
            // get distance value from
            let depth = depthBuffer.value(x: col, y: row)
                        
            // filter points by distance
            if depth > 2 { return }
                        
            let normalizedCoord = simd_float2(Float(col) / Float(depthBuffer.size.width),
                                              Float(row) / Float(depthBuffer.size.height))
                        
            let imageSize = imageBuffer.size.asFloat
            let screenPoint = simd_float3(normalizedCoord * imageSize, 1)

            // Transform the 2D screen point into local 3D camera space
            let localPoint = simd_inverse(frame.camera.intrinsics) * screenPoint * depth
                
            // Converts the local camera space 3D point into world space.
            let worldPoint = cameraTransform * simd_float4(localPoint, 1)
                
            // Normalizes the result.
            let resulPosition = (worldPoint / worldPoint.w)
                
            let pointPosition = SCNVector3(x: resulPosition.x, 
                                           y: resulPosition.y, 
                                           z: resulPosition.z)

            let key = PointCloud.GridKey(pointPosition)
                
            if vertices[key] == nil {
                let pixelRow = Int(round(normalizedCoord.y * imageSize.y))
                let pixelColumn = Int(round(normalizedCoord.x * imageSize.x))
                let color = imageBuffer.color(x: pixelColumn, y: pixelRow)


                vertices[key] = PointCloud.Vertex(position: pointPosition,
                                                  color: color)
            }
        }
    }
}

2、点云可视化

为了在 AR 视图中可视化点云，我们将在每次处理帧时创建一个 SCNGeometry，并使用 SCNNode 显示。这种方法使我们能够实时动态渲染点云。

但是，渲染高密度点云会严重消耗设备的资源，可能会导致性能问题。为了解决这个问题并保持流畅的渲染，我们将实施一个微小的优化，即仅从云中绘制每 10 个点。这种选择性渲染将有助于平衡视觉保真度和性能，确保应用程序保持响应，同时点云仍能传达扫描环境的基本细节。

让我们在 ARManager 中创建一个 geometryNode 并将其附加到初始化程序中的 rootNode。

接下来，我们将添加一个异步 updateGeometry 函数，该函数将顶点从点云转换为 SCNGeometry 并替换 geometryNode 中的几何图形。

最后，我们将此 updateGeometry 函数集成到我们的处理管道中。

actor ARManager: NSObject, ARSessionDelegate, ObservableObject {
    
    //-- 
    @MainActor let geometryNode = SCNNode()
    //-- 
    
    @MainActor
    override init() {
        //--          
        sceneView.scene.rootNode.addChildNode(geometryNode)
    }
    
    @MainActor
    private func process(frame: ARFrame) async {
        guard !isProcessing && isCapturing else { return }
        
        isProcessing = true
        await pointCloud.process(frame: frame)
        await updateGeometry() // <- add here the geometry update
        isProcessing = false
    }

    func updateGeometry() async {
        // make an array of every 10th point
        let vertices = await pointCloud.vertices.values.enumerated().filter { index, _ in
                index % 10 == 9
            }.map { $0.element }
        
        // create a vertex source for geometry
        let vertexSource = SCNGeometrySource(vertices: vertices.map { $0.position } )
        
        // create a color source
        let colorData = Data(bytes: vertices.map { $0.color }, 
                             count: MemoryLayout<simd_float4>.size * vertices.count)

        let colorSource = SCNGeometrySource(data: colorData,
                                            semantic: .color,
                                            vectorCount: vertices.count,
                                            usesFloatComponents: true,
                                            componentsPerVector: 4,
                                            bytesPerComponent: MemoryLayout<Float>.size,
                                            dataOffset: 0,
                                            dataStride: MemoryLayout<SIMD4<Float>>.size)

        // as we don't use proper geometry, we can pass just an array of 
        // indices to our geometry element
        let pointIndices: [UInt32] = Array(0..<UInt32(vertices.count))
        let element = SCNGeometryElement(indices: pointIndices, primitiveType: .point)
        
        // here we can customize the size of the point, rendered in ARView
        element.maximumPointScreenSpaceRadius = 15
        
        let geometry = SCNGeometry(sources: [vertexSource, colorSource], 
                                   elements: [element])
        geometry.firstMaterial?.isDoubleSided = true
        geometry.firstMaterial?.lightingModel = .constant
        
        Task { @MainActor in
            geometryNode.geometry = geometry
        }
    }

3、将点云导出到 .PLY 文件

最后，我们将捕获的点云导出到 .PLY 文件，利用 Transferable 协议在 SwiftUI ShareLink 中实现无缝数据处理。

.PLY 文件格式相对简单，由一个文本文件组成，其中包含一个指定数据内容和结构的标题，后面是顶点列表及其相应的颜色成分。

struct PLYFile: Transferable {
    
    let pointCloud: PointCloud
    
    enum Error: LocalizedError {
        case cannotExport
    }
    
    func export() async throws -> Data {
        let vertices = await pointCloud.vertices
        
        var plyContent = """
        ply
        format ascii 1.0
        element vertex \(vertices.count)
        property float x
        property float y
        property float z
        property uchar red
        property uchar green
        property uchar blue
        property uchar alpha
        end_header
        """
        
        for vertex in vertices.values {
            // Convert position and color
            let x = vertex.position.x
            let y = vertex.position.y
            let z = vertex.position.z
            let r = UInt8(vertex.color.x * 255)
            let g = UInt8(vertex.color.y * 255)
            let b = UInt8(vertex.color.z * 255)
            let a = UInt8(vertex.color.w * 255)
            
            // Append the vertex data
            plyContent += "\n\(x) \(y) \(z) \(r) \(g) \(b) \(a)"
        }
        
        guard let data = plyContent.data(using: .ascii) else {
            throw Error.cannotExport
        }
        return data
    }
    
    static var transferRepresentation: some TransferRepresentation {
        DataRepresentation(exportedContentType: .data) {
            try await $0.export()
        }.suggestedFileName("exported.ply")
    }
}

4、完成 UI

现在我们已经构建了应用的核心功能，我们可以完成 UI 了。

UI 将包含一个用于启动和停止点云捕获的按钮，以及一个用于导出和共享生成的点云文件的选项。

在我们的主视图中，我们将创建一个 ZStack，它将覆盖 AR 视图，其中包含用于控制捕获过程和共享结果的按钮。

@main
struct PointCloudExampleApp: App {
    
    @StateObject var arManager = ARManager()
    
    var body: some Scene {
        WindowGroup {
            ZStack(alignment: .bottom) {
                UIViewWrapper(view: arManager.sceneView).ignoresSafeArea()
                
                HStack(spacing: 30) {
                    Button {
                        arManager.isCapturing.toggle()
                    } label: {
                        Image(systemName: arManager.isCapturing ? 
                                          "stop.circle.fill" : 
                                          "play.circle.fill")
                    }
                    
                    ShareLink(item: PLYFile(pointCloud: arManager.pointCloud), 
                                            preview: SharePreview("exported.ply")) {
                        Image(systemName: "square.and.arrow.up.circle.fill")
                    }
                }.foregroundStyle(.black, .white)
                    .font(.system(size: 50))
                    .padding(25)
            }
        }
    }
}

5、最后的想法

在这篇由两部分组成的文章中，我们构建了一个基本的 AR 应用程序，该应用程序能够使用 ARKit 和 LiDAR 在 Swift 中生成和呈现 3D 点云。我们发现了如何提取 LiDAR 数据，将其转换为 3D 空间中的点，并将其合并为单个点云，以及将其导出并共享为 .PLY 文件的能力。

这个应用程序只是一个开始。你可以通过添加更高级的过滤等功能来进一步增强它，允许用户调整点云密度，或者通过根据距离或其他因素替换网格字典中的点来提高云质量。

iPhone LiDAR 的紧凑和经济高效特性使开发人员能够使用高级深度感应，并为创新应用程序开辟了无限可能。

原文链接：ARKit & LiDAR: Building Point Clouds in Swift (part 2)

BimAnt翻译整理，转载请标明出处

ARKit 是 Apple 强大的增强现实框架，允许开发人员制作专为 iOS 设备设计的沉浸式交互式 AR 体验。

对于配备 LiDAR 的设备，ARKit 充分利用了深度感应功能，大大提高了环境扫描精度。与许多体积庞大且价格昂贵的传统 LIDAR 系统不同，iPhone 的 LiDAR 结构紧凑、经济高效，并可无缝集成到消费设备中，使更广泛的开发人员和应用程序能够使用高级深度感应。

LiDAR 允许创建点云，点云是一组数据点，表示 3D 空间中物体的表面。

在本文的第一部分中，我们将构建一个应用程序，演示如何提取 LiDAR 数据并将其转换为 AR 3D 环境中的单个点。

第二部分将解释如何将从 LiDAR 传感器连续接收的点合并为统一的点云。最后，我们将介绍如何将这些数据导出为广泛使用的 .PLY 文件格式，以便在各种应用程序中进行进一步分析和利用。

1、先决条件

我们将使用：

• Xcode 16 和 Swift 6。
• SwiftUI 用于应用程序的用户界面
• Swift Concurrency 用于高效的多线程。

请确保你可以使用配备 LiDAR 传感器的 iPhone 或 iPad 来跟进。

2、设置和创建 UI

创建一个新项目 ProjectCloudExample 并删除我们不会使用的所有不必要的文件，只保留 ProjectCloudExampleApp.swift。

接下来，让我们创建一个带有参与者的 ARManager.swift 来管理 ARSCNView 并处理相关的 AR 会话。由于 SwiftUI 目前缺乏对 ARSCNView 的原生支持，我们将它与 UIKit 桥接。

在 ARManager 的初始化程序中，我们将其作为 ARSession 的委托，并使用 ARWorldTrackingConfiguration 启动会话。鉴于我们的目标是配备 LiDAR 技术的设备，将 .sceneDepth 属性设置为框架语义至关重要。

import Foundation
import ARKit

actor ARManager: NSObject, ARSessionDelegate, ObservableObject {
    
    @MainActor let sceneView = ARSCNView()

    @MainActor
    override init() {
        super.init()
        
        sceneView.session.delegate = self

        // start session
        let configuration = ARWorldTrackingConfiguration()
        configuration.frameSemantics = .sceneDepth
        sceneView.session.run(configuration)
    }
}

现在让我们打开主 ProjectCloudExampleApp.swift，创建 ARManager 的一个实例作为状态对象，并将我们的 AR 视图呈现给 SwiftUI。我们将使用 UIViewWrapper 来实现后者。

struct UIViewWrapper<V: UIView>: UIViewRepresentable {
    
    let view: UIView
    
    func makeUIView(context: Context) -> some UIView { view }
    func updateUIView(_ uiView: UIViewType, context: Context) { }
}

@main
struct PointCloudExampleApp: App {
    
    @StateObject var arManager = ARManager()
    
    var body: some Scene {
        WindowGroup {
            UIViewWrapper(view: arManager.sceneView).ignoresSafeArea()
        }
    }
}

3、获取 LiDAR 深度数据

让我们回到 ARManager.swift。

AR 会话不断生成包含深度和相机图像数据的帧，可以使用委托函数进行处理。

为了保持实时性能，由于时间限制，处理每一帧是不切实际的。相反，我们会在处理一帧时跳过一些帧。

此外，由于我们的 ARManager 是作为参与者实现的，我们将在单独的线程上处理处理。这可以防止在密集操作期间 UI 出现任何潜在的冻结，从而确保流畅的用户体验。

添加 isProcessing 属性来管理正在进行的帧操作，并添加委托函数来处理传入的帧。实现专门用于帧处理的函数。

还添加 isCapturing 属性，我们稍后将在 UI 中使用它来切换捕获。

actor ARManager: NSObject, ARSessionDelegate, ObservableObject {
    
    //...
    @MainActor private var isProcessing = false
    @MainActor @Published var isCapturing = false
    
    // an ARSessionDelegate function for receiving an ARFrame instances
    nonisolated func session(_ session: ARSession, didUpdate frame: ARFrame) {
        Task { await process(frame: frame) }
    }
    
    // process a frame and skip frames that arrive while processing
    @MainActor
    private func process(frame: ARFrame) async {
        guard !isProcessing else { return }
        
        isProcessing = true
        //processing code here
        isProcessing = false
    }
    //...
}

由于我们的处理函数和 isProcessing 属性是独立的，因此我们无需担心线程之间的任何额外同步。

现在让我们创建一个 PointCloud.swift，其中包含一个用于处理 ARFrame 的参与者。

ARFrame 提供 depthMap、 confidenceMap 和 caughtImage，它们都由 CVPixelBuffer 表示，具有不同的格式：

• depthMap - Float32 缓冲区
• confidenceMap - UInt8 缓冲区
• capturedImage - YCbCr 格式的像素缓冲区

你可以将深度图视为 LiDAR 捕获的照片，其中每个像素都包含从相机到表面的距离（以米为单位）。这与捕获的图像提供的相机反馈一致。我们的目标是从捕获的图像中提取颜色并将其用于深度图中的相应像素。

置信度图与深度图共享相同的分辨率，包含从 [1, 3] 开始的值，表示每个像素深度测量的置信度。

actor PointCloud {
    
    func process(frame: ARFrame) async {
        if let depth = (frame.smoothedSceneDepth ?? frame.sceneDepth),
           let depthBuffer = PixelBuffer<Float32>(pixelBuffer: depth.depthMap),
           let confidenceMap = depth.confidenceMap,
           let confidenceBuffer = PixelBuffer<UInt8>(pixelBuffer: confidenceMap),
           let imageBuffer = YCBCRBuffer(pixelBuffer: frame.capturedImage) {
            
	     //process buffers
        }
    }
}

4、从 CVPixelBuffer 访问像素数据

要从 CVPixelBuffer 中提取像素数据，我们将为每种特定格式创建一个类，例如深度、置信度和颜色图。对于深度和置信度图，我们可以设计一个通用类，因为它们都遵循类似的结构。

4.1 深度和置信度缓冲区

从 CVPixelBuffer 读取的核心概念相对简单：我们需要锁定缓冲区以确保对其数据的独占访问。锁定后，我们可以通过计算要访问的像素的正确偏移量直接读取内存。

Value = Y * bytesPerRow + X

//struct for storing CVPixelBuffer resolution
struct Size {
    let width: Int
    let height: Int
    
    var asFloat: simd_float2 {
        simd_float2(Float(width), Float(height))
    }
}

final class PixelBuffer<T> {
    
    let size: Size
    let bytesPerRow: Int

    private let pixelBuffer: CVPixelBuffer
    private let baseAddress: UnsafeMutableRawPointer
    
    init?(pixelBuffer: CVPixelBuffer) {
        self.pixelBuffer = pixelBuffer

        // lock the buffer while we are getting its values
        CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
        
        guard let baseAddress = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0) else {
            CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
            return nil
        }
        self.baseAddress = baseAddress
        
        size = .init(width: CVPixelBufferGetWidth(pixelBuffer),
                     height: CVPixelBufferGetHeight(pixelBuffer))
        bytesPerRow =  CVPixelBufferGetBytesPerRow(pixelBuffer)
    }
    
    // obtain value from pixel buffer in specified coordinates
    func value(x: Int, y: Int) -> T {

        // move to the specified address and get the value bounded to our type
        let rowPtr = baseAddress.advanced(by: y * bytesPerRow)
        return rowPtr.assumingMemoryBound(to: T.self)[x]
    }
    
    deinit {
        CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
    }
}

4.2 YCbCr 捕获图像缓冲区

与使用典型的 RGB 缓冲区相比，从 YCbCr 格式的像素缓冲区中提取颜色值需要付出更多努力。YCbCr 颜色空间将亮度 (Y) 与色度 (Cb 和 Cr) 分开，这意味着我们必须将这些组件转换为更熟悉的 RGB 格式。

为了实现这一点，我们首先需要访问像素缓冲区内的 Y 和 Cb/Cr 平面。这些平面保存每个像素的必要数据。一旦我们从各自的平面获得值，我们就可以将它们转换为 RGB 值。转换依赖于一个众所周知的公式，其中 Y、Cb 和 Cr 值通过某些偏移量进行调整，然后乘以特定系数以产生最终的红色、绿色和蓝色值。

final class YCBCRBuffer {
    
    let size: Size
    
    private let pixelBuffer: CVPixelBuffer
    private let yPlane: UnsafeMutableRawPointer
    private let cbCrPlane: UnsafeMutableRawPointer
    private let ySize: Size
    private let cbCrSize: Size
    
    init?(pixelBuffer: CVPixelBuffer) {
        self.pixelBuffer = pixelBuffer
        CVPixelBufferLockBaseAddress(pixelBuffer, .readOnly)
        
        guard let yPlane = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0),
                let cbCrPlane = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1) else {
            CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
            return nil
        }
        
        self.yPlane = yPlane
        self.cbCrPlane = cbCrPlane
 
        size = .init(width: CVPixelBufferGetWidth(pixelBuffer),
                     height: CVPixelBufferGetHeight(pixelBuffer))
        
        ySize = .init(width: CVPixelBufferGetWidthOfPlane(pixelBuffer, 0),
                      height: CVPixelBufferGetHeightOfPlane(pixelBuffer, 0))
        
        cbCrSize = .init(width: CVPixelBufferGetWidthOfPlane(pixelBuffer, 1),
                         height: CVPixelBufferGetHeightOfPlane(pixelBuffer, 1))
    }
    
    func color(x: Int, y: Int) -> simd_float4 {
        let yIndex = y * CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0) + x
        let uvIndex = y / 2 * CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1) + x / 2 * 2
        
        // Extract the Y, Cb, and Cr values
        let yValue = yPlane.advanced(by: yIndex)
                .assumingMemoryBound(to: UInt8.self).pointee

        let cbValue = cbCrPlane.advanced(by: uvIndex)
                .assumingMemoryBound(to: UInt8.self).pointee

        let crValue = cbCrPlane.advanced(by: uvIndex + 1)
                .assumingMemoryBound(to: UInt8.self).pointee
        
        // Convert YCbCr to RGB
        let y = Float(yValue) - 16
        let cb = Float(cbValue) - 128
        let cr = Float(crValue) - 128
        
        let r = 1.164 * y + 1.596 * cr
        let g = 1.164 * y - 0.392 * cb - 0.813 * cr
        let b = 1.164 * y + 2.017 * cb
        
        // normalize rgb components
        return simd_float4(max(0, min(255, r)) / 255.0,
                           max(0, min(255, g)) / 255.0,
                           max(0, min(255, b)) / 255.0, 1.0)
    }
    
    deinit {
        CVPixelBufferUnlockBaseAddress(pixelBuffer, .readOnly)
    }
}

4.3 读取深度和颜色

现在我们已经设置了必要的缓冲区，我们可以返回 PointCloud 参与者中的核心处理功能。下一步是为我们的顶点数据创建一个结构，它将包括每个点的 3D 位置和颜色。

struct Vertex {
     let position: SCNVector3
     let color: simd_float4
}

接下来，我们需要遍历深度图中的每个像素，获取相应的置信度值和颜色。

我们将根据最佳置信度和距离筛选点，因为由于深度传感技术的性质，在较远距离捕获的点往往具有较低的准确性。

深度图和捕获的图像具有不同的分辨率。因此，为了正确地将深度数据映射到其相应的颜色，我们需要进行适当的坐标转换。

func process(frame: ARFrame) async {
    guard let depth = (frame.smoothedSceneDepth ?? frame.sceneDepth),
          let depthBuffer = PixelBuffer<Float32>(pixelBuffer: depth.depthMap),
          let confidenceMap = depth.confidenceMap,
          let confidenceBuffer = PixelBuffer<UInt8>(pixelBuffer: confidenceMap),
          let imageBuffer = YCBCRBuffer(pixelBuffer: frame.capturedImage) else { return }
       
    // iterate through pixels in depth buffer
    for row in 0..<depthBuffer.size.height {
        for col in 0..<depthBuffer.size.width {
            // get confidence value
            let confidenceRawValue = Int(confidenceBuffer.value(x: col, y: row))
            guard let confidence = ARConfidenceLevel(rawValue: confidenceRawValue) else {
                continue
            }
                        
            // filter by confidence
            if confidence != .high { continue }
                        
            // get distance value from
            let depth = depthBuffer.value(x: col, y: row)
                        
            // filter points by distance
            if depth > 2 { return }
                        
            let normalizedCoord = simd_float2(Float(col) / Float(depthBuffer.size.width),
                                              Float(row) / Float(depthBuffer.size.height))
                        
            let imageSize = imageBuffer.size.asFloat
                        
            let pixelRow = Int(round(normalizedCoord.y * imageSize.y))
            let pixelColumn = Int(round(normalizedCoord.x * imageSize.x))
                        
            let color = imageBuffer.color(x: pixelColumn, y: pixelRow)
        }
    }
}

5、将点转换为 3D 场景坐标

我们首先计算所拍摄照片上的点 2D 坐标：

let screenPoint = simd_float3(normalizedCoord * imageSize, 1)

使用相机内在函数，我们将此点转换为具有指定深度值的相机坐标空间中的 3D 点：

let localPoint = simd_inverse(frame.camera.intrinsics) * screenPoint *depth

iPhone 相机与手机本身不对齐，这意味着当你将 iPhone 保持在纵向时，相机会给我们一张实际上具有横向正确方向的图像。此外，为了正确地将点从相机的本地坐标转换为世界坐标，我们需要对 Y 轴和 Z 轴应用翻转变换。

让我们为此制作一个变换矩阵。

func makeRotateToARCameraMatrix(orientation: UIInterfaceOrientation) -> matrix_float4x4 {
    // Flip Y and Z axes to align with ARKit's camera coordinate system
    let flipYZ = matrix_float4x4(
        [1, 0, 0, 0],
        [0, -1, 0, 0],
        [0, 0, -1, 0],
        [0, 0, 0, 1]
    )
    // Get rotation angle in radians based on the display orientation
    let rotationAngle: Float = switch orientation {
        case .landscapeLeft: .pi
        case .portrait: .pi / 2
        case .portraitUpsideDown: -.pi / 2
        default: 0
    }
    // Create a rotation matrix around the Z-axis
    let quaternion = simd_quaternion(rotationAngle, simd_float3(0, 0, 1))
    let rotationMatrix = matrix_float4x4(quaternion)

    // Combine flip and rotation matrices
    return flipYZ * rotationMatrix
}

let rotateToARCamera = makeRotateToARCameraMatrix(orientation: .portrait)

// the result transformation matrix for converting point from local camera coordinates to the world coordinates
let cameraTransform = frame.camera.viewMatrix(for: .portrait).inverse * rotateToARCamera

最后将局部点与变换矩阵相乘，然后进行归一化，即可得到结果点。

// Converts the local camera space 3D point into world space using the camera's transformation matrix.
let worldPoint = cameraTransform * simd_float4(localPoint, 1)
let resulPosition = (worldPoint / worldPoint.w)

6、结束语

在第一部分中，我们为使用 ARKit 和 LiDAR 创建点云奠定了基础。我们探索了如何从 LiDAR 传感器获取深度数据以及相应的图像，将每个像素转换为 3D 空间中的彩色点。我们还根据置信度过滤点以确保数据准确性。

在第二部分中，我们将研究如何将捕获的点合并为统一的点云，在我们的 AR 视图中将其可视化并导出为 .PLY 文件格式以供进一步使用。

原文链接：ARKit & LiDAR: Building Point Clouds in Swift (part 1)

BimAnt翻译整理，转载请标明出处

在维姆·文德斯 (Wim Wenders) 的优秀作品《完美的日子》 (Perfect Days) 的结尾，男主角平山 (Hirayama) 在桥下喝啤酒，因为他看到一个商人在追求他的暗恋对象。突然，商人在桥下加入了他。事实证明，事情并没有那么简单，但重点是他们的对话将他们引向了一些基本问题：

商人：阴影。当它们重叠时，它们会变暗吗？
平山：不确定。
商人：还有很多事情我都不知道……我想，这就是生命的终结……。
平山：现在让我们来一探究竟。
商人：什么？

然后他们走进路灯的光亮中，调查他们的影子（完整场景）：

尽管商人看不出有什么不同，但平山确信重叠的阴影确实变暗了。“它必须变暗才能有意义。”多么感人的场景。

不幸的是，平山搞错了。阴影在那里不会变暗。只有一个光源，而且距离相对较远，所以阴影只是光的缺失。无论光被遮挡多少次都无关紧要。

在 3D 电子游戏中，阴影是另一回事。很容易在某个角色的脚下画出黑色斑点，并假设其他一切都是亮着的。也许平山想起了《合金装备》中的斑点阴影，当它与其他阴影重叠时，它会变暗？

在现实世界中，阴影只是存在，但在游戏中，它们既是工程化的，也是设计的。它们必须运行良好，但看起来也很好。我发现这种关系很有趣，我将向你展示原因。让我们从简单的开始。

1、屏幕上的 2D 阴影

你可以在绘制角色之前将阴影图像绘制到屏幕上。我说的不是像 Duke Nukem 3D 中的阴影精灵，而是实际上没有任何缩放的 2D 图像。如果角色位于 Winter Gold 或 MDK 中的所有内容前面，这种方法是可行的。

我说这很简单。

2、斑点阴影

现在在 3D 中好了。在角色下方绘制一个暗色圆盘。完成。

好吧，你还应该将阴影圆盘与地面对齐，并决定如何处理阴影超出壁架的情况。例如，在 Super Mario 64 中，斑点（blobs）是使用特殊硬件功能绘制的，该功能可以有效地剪切阴影以仅显示在地面上。

斑点阴影也可以动画化。在 Super Mario 64 中，跳跃时它会变小，在 Metal Gear Solid 中它会改变形状。如果你有雄心壮志，还可以通过像贴花一样投射斑点四边形来解决阴影越过壁架的问题。

3、带有渲染纹理的平面阴影

斑点只是一种纹理，通常可以在运行时渲染纹理。因此，从顶部渲染角色并使用它而不是黑色圆圈。这在 Crash 3（视频）中效果很好，但在 Soldier of Fortune 中效果不佳，因为他们将阴影分辨率保持在如此低的水平。

请注意，这与阴影贴图不同，阴影贴图是从光的视角渲染深度贴图。这里我们只渲染用作纹理的黑白图像。所以从某种意义上说，我们谈论的是 1 位阴影贴图。

我们怎样才能使阴影更清晰？

4、带有几何图形的平面阴影

一种直观的选择是通过将阴影投射器投射到远离光线的地方来使其在平面上变平。然后第二次渲染，但现在是黑色。它们通常保持不透明，以隐藏物体部分如何绘制在另一个物体之上。自然，阴影只有在平坦的地板上才会正确。

一些早期的飞行模拟器在跑道上绘制自上而下的平面阴影。在我的研究中，我期望看到飞行时也能看到阴影的例子，但找不到。

从视觉上看，这些看起来与投射在平面上的黑色模板阴影相同。

5、地形上的阴影

大卫·布拉本 (David Braben) 于 1987 年创作的 Virus 绘制了在地形上投射自上而下阴影的宇宙飞船。

一个更复杂的例子是 76 号州际公路。在那里，它们倾斜和拉伸平面阴影以匹配地面坡度。阴影偶尔会穿透地面，但总体上非常令人信服。有趣的是，下面的软件渲染截图有略微透明的阴影，而硬件加速的阴影则是漆黑一片。

他们还勇敢地尝试为桥梁等大型物体投射阴影，但并不完全成功。

但是你如何在任何类型的场景上投射阴影？

6、投影纹理阴影

这种方法与之前介绍的带有渲染纹理的平面阴影非常相似，但适用于任何形状的表面。游戏从顶部渲染阴影纹理，但不是将其显示在平面上，而是将其投射到其他物体上。可以将其想象成蝙蝠信号，但从天空直指下方。

这样的阴影可以做得非常清晰，但它们在垂直表面上看起来很奇怪，有时甚至会出现在天花板上。你可以看看这个 Sonic Adventure 2: Battle（2001，GameCube）的游戏视频。

这种技术也适用于树木：

投影阴影可以透过物体显示出来，这使得它们只适用于特殊情况。阴影图是您可以在任何地方使用的东西。

7、阴影图

事实上的阴影方法。游戏从光的角度绘制深度图像，即阴影贴图（shadow map），并在渲染世界时从该图像中读取。这很容易做到，因为你可以重复使用游戏引擎的常规渲染代码。

阴影贴图的分辨率有限，导致了一些众所周知的现象，这些现象有着富有创意的名字，例如“彼得潘”和“阴影痤疮”。人们提出了许多技巧，将更多的阴影贴图区域分配给最需要额外分辨率的相机附近的表面。阴影贴图通常需要进行一些调整才能看起来正确。

在阴影贴图占据主导地位之前，有一个很受欢迎的竞争对手。

8、模板阴影

一种过时的阴影处理方法。模板阴影（stencil  shadow）可以在任何类型的表面上绘制清晰的阴影。它们创造了一种独特的黑色电影外观，很难用阴影贴图模仿。最著名的例子当然是《毁灭战士 3》及其黑暗的房间：

模板阴影基于阴影体积的概念，阴影体积是一种将世界切割成有光和有阴影空间的不可见几何体。游戏只对不在阴影体积内的像素应用照明。

模板阴影需要多次绘制世界才能工作。稍微简化一下，游戏首先用环境光绘制整个世界。然后对于每个光源，绘制所有阴影体积，然后再次绘制世界，只影响无阴影像素。体积是使用为正面和背面设置的不同模板操作绘制的。需要绘制很多像素。

最早推出带有模板阴影的游戏可能是 2001 年的《Severance: Blade of Darkness》，其阴影效果非常棒。

阅读 2001 年 3 月的《Edge UK》游戏评论（pdf）可以清楚地看出，尽管图形方面取得了进步，但当时的世界还没有准备好迎接类似灵魂的游戏。

模板阴影现在用得不多了。原因之一是它们的运行时间成本不可预测。成本取决于屏幕上的体积大小，因此变化很大。此外，优化算法也获得了专利。对于《毁灭战士 3》，Id Software 显然达成了某种协议。

9、柔和的模板阴影

模板阴影不需要太清晰。2001 年的另一款游戏，PlayStation 2 上的《寂静岭 2》，之后模糊了模板阴影，如上图所示。它在控制台上看起来非常完美。

10、简化的角色阴影

如果阴影是由比屏幕上显示的更简单的模型投射的，会怎么样？例如，在 Nintendo 64 上的《塞尔达传说》中，林克的脚会投射阴影，尽管其他任何东西都不会投射阴影：

Hyperblade 中采用了一种独特的方法，未来冰球场上的玩家将平面阴影投射为简单的动画形状。

11、静态关卡照明中的阴影

顶点颜色和光照贴图是捕捉游戏关卡照明的技术。它们已在许多游戏中用作显示大规模阴影的唯一方法，这就是我将它们包括在这里的原因。

11.1 顶点颜色

Ico 展示了仅使用老式的顶点照明就可以呈现多么复杂的阴影。

对于低多边形贴图，即使是锐利的阴影也可以用顶点颜色表示。一个典型的例子是 Tony Hawk Pro Skater 2（2000 年，PlayStation），考虑到该技术的简单性，它看起来很棒。

11.2 光照贴图

光照贴图（lightmap）是存储关卡照明和阴影的经典方式。它不是为每个顶点存储一种颜色，而是有第二组仅表示照明的纹理。分辨率可以根据区域而变化，使阴影在需要时更准确。另一方面，光照贴图比顶点颜色消耗更多的内存。

光照贴图因 Quake（1996 年，PC）而流行，这就是它们的外观。

我们对传统阴影技术的了解到此结束。接下来让我们谈谈一般的照明。

12、现代游戏中的阴影

现代游戏在适当的时候使用传统技术。一些示例：

• 阴影贴图的变体，例如级联阴影贴图，可以覆盖大面积区域，同时保持速度。
• 光照贴图与其他技术（例如光探测器）相结合。使命召唤仍然有光照贴图，请参阅半球形照明洞察幻灯片。
• 简化的角色模型理念。《最后生还者》（2013 年，PlayStation 3）使用拉伸球体投射柔和的角色阴影。请参阅《最后生还者》（2013 年）幻灯片照明技术的幻灯片。虚幻引擎还支持角色的简化“胶囊阴影”。
• 投影阴影。在《风火轮赛道大战》（2010 年，Wii）中，他们将阴影网格渲染为纹理并将其投射到赛道上，如开发人员博客中所述。游戏在运动中看起来很棒！

一开始，我们确定阴影是由光线不足形成的。如果游戏真的试图模拟物理上正确的照明，那么阴影就会自然出现。即使是很小的几何细节也会投射出精确的阴影，这与阴影贴图不同。大灯会自然地产生柔和的阴影，间接光会照亮黑暗的角落。为了实现这一梦想，人们在光线追踪算法和硬件上投入了大量的时间和金钱。

实际上，现代游戏的场景非常复杂，上述模拟解决方案必须近似。例如，在《心灵杀手 2》（2023 年）的光线追踪阴影中，每个像素仅从单个随机选择的光源接收照明。结果最终被输入到降噪器，该降噪器可以智能地平滑嘈杂的图像。有关详细信息，请参阅整个演示文稿。因此，即使是光线追踪阴影也不会“完美”，并且会根据所做的权衡而拥有自己的外观。

最后，显而易见的选择。

13、没有阴影

有时你的优先事项在别处。

在电影场景中，当平山仔细研究阴影时，他的新朋友发表了评论：

商人：你真的很喜欢这个。

作为计算机图形爱好者，我想我们可以感同身受。

原文链接：Classic 3D videogame shadow techniques

BimAnt翻译整理，转载请标明出处

在第一部分中，我们了解了算法如何识别相机帧中的关键点。这些是跟踪和识别环境的基础。

对于增强现实，设备必须知道更多信息：它在世界上的 3D 位置。它通过自身与多个关键点之间的空间关系来计算这一点。这个过程称为“同时定位和地图构建” - 简称 SLAM。

1、用于感知世界的传感器

高级视图：当您首次使用 Google ARCore、Apple ARKit 或 Microsoft Mixed Reality 启动 AR 应用时，系统对环境了解不多。它开始处理来自各种来源的数据 - 主要是相机。为了提高准确性，设备会结合来自其他有用传感器（如加速度计和陀螺仪）的数据。

基于这些数据，算法有两个目标：

• 构建环境地图
• 在该环境中定位设备

对于某些场景，这很容易。如果您可以自由地将信标放置在已知位置，则只需对距离进行三角测量，即可准确知道自己的位置。

对于其他应用，GPS 可能就足够了。

但是，移动增强现实通常没有已知信标的奢侈。GPS 也不够准确——尤其是在室内。

2、不确定的空间关系

让我们从基础开始，如 Cheeseman 等人在“不确定空间关系的随机地图”（1987 年）中所述。

在理想的世界中，你将拥有有关所有事物的确切位置的完美信息。这包括信标 (1) 的位置以及机器人 (2) 的位置。

因此，你可以计算信标 (1) 和您自己的位置 (2) 之间的确切关系。如果你需要将机器人移动到 (3)，可以准确推断出您需要移动到的位置和方式。

不幸的是，在现实生活中的 SLAM 场景中，你必须使用不完善的知识。这会导致不确定性。

这些点彼此具有空间关系。因此，你可以获得每个位置可能所在的概率分布。对于某些点，你可能具有更高的精度。对于其他点，不确定性可能很大。根据不确定性计算位置的常用算法是扩展卡尔曼滤波器、最大后验 (MAP) 估计或捆绑调整 (BA)。

由于点之间的关系，每个新的传感器更新都会影响所有位置并更新整个地图。保持一切最新需要大量的数学运算。

3、对齐感知世界

为了使增强现实可靠，将新测量与早期知识对齐是 SLAM 算法的最重要方面之一。每个传感器测量都包含误差——无论它们是从相机图像中得出的，还是从使用加速度计（里程计）的帧间运动估计中得出的。

在“用于环境映射的全局一致范围扫描对齐”(1997) 中，Lu 和 Milios 描述了该问题的基本原理。在上图中，(a) 显示了范围扫描误差如何随时间累积。从一个位置 P1 ... Pn，每个小的测量误差都会随着时间的推移而累积，直到生成的环境地图不再一致。

通过基于相对姿势约束网络对齐 (b) 中的扫描，生成的匹配得到显着改善。在算法中，它们维护所有本地数据帧，以及它们之间的空间关系网络。

主要问题之一是：要保留多少历史记录？如果将每个新测量值与所有历史记录进行比较，应用程序运行的时间越长，复杂性就会增加到无法管理的水平。因此，算法通常会将历史记录减少到关键帧，并/或通过使用“适者生存”机制进一步完善策略，以便稍后删除没有预期那么有用的数据（如 ORB-SLAM 中所做的那样）。

4、SLAM – 同步定位和映射

要使增强现实发挥作用，SLAM 算法必须解决以下挑战：

• 未知空间。
• 不受控制的摄像头。对于当前基于手机的 AR，这通常只是一个单目摄像头。
• 实时。
• 无漂移。

这幅来自 I. D. Reid 等人（2007 年）的 MonoSLAM 算法的图像展示了您想要实现的目标。跟踪的特征点、它们在空间中的关系以及推断出的相机位置。

5、SLAM 剖析

如何在增强现实场景中应用和解决这个问题？

理解 SLAM 原理的一个很好的起点是：Cadena 等人的《同时定位和地图绘制的过去、现在和未来：迈向稳健感知时代》（2016 年）。他们描述了 SLAM 的典型架构如下：

该系统由 4 个部分组成：

• 传感器数据：在移动设备上，这通常包括摄像头、加速度计和陀螺仪。它可能由其他传感器增强，如 GPS、光传感器、深度传感器等。
• 前端：第一步是特征提取，如第 1 部分所述。这些特征还需要与地标相关联 - 具有 3D 位置的关键点，也称为地图点。此外，需要在视频流中跟踪地图点。
  长期关联通过识别以前遇到过的位置（环路闭合）来减少漂移。
• 后端：负责建立不同帧之间的关系、定位相机（姿势模型）以及处理整体几何重建。一些算法会创建稀疏重建（基于关键点）。其他算法则尝试捕获环境的密集 3D 点云。
• SLAM 估计：结果包含跟踪的特征、它们的位置和关系，以及相机在世界中的位置。

让我们仔细看看具体的 SLAM 实现：ORB-SLAM。

6、示例：ORB-SLAM 算法

Mur-Atal、Montiel 和 Tardós 的 ORB-SLAM 是一种非常有效且最新的算法。继任者 ORB-SLAM2 除了单目系统外，还增加了对立体或深度相机的支持。特别棒的是，这些算法在 GPL-v3 许可下以开源形式提供。Jeroen Zijllmas 在一篇博客文章中描述了如何在你自己的计算机上运行 ORB-SLAM，所以我不会在这里详细介绍。

ORB-SLAM 是一种视觉算法，因此不使用加速度计和陀螺仪的里程计。考虑到该算法仍然运行良好，结果令人印象深刻。

7、特征选择

如第 1 部分所述，许多算法的任务是找到关键点并生成描述符。传统的 SIFT 和 SURF 算法始终用作参考，但通常对于实时使用来说太慢了。

顾名思义，ORB-SLAM 算法依赖于 ORB 特征跟踪算法。ORB 基于与第 1 部分中的 BRISK 算法相同的底层方法来查找关键点和生成描述符，因此我不会详细介绍。

一般来说，ORB-SLAM 会分析每个帧中的关键点。然后，这些关键点会与检测到这些关键点的关键帧的引用一起存储在地图中。这种关联非常重要；它用于匹配未来的帧并优化之前存储的数据。

8、将关键点转换为 3D 地标

SLAM 最有趣的部分之一是 2D 相机帧中找到的关键点如何实际获得 3D 坐标（然后称为“地图点”或“地标”）。在 ORB-SLAM 中，这很大一部分发生在 LocalMapping::CreateNewMapPoints()（第 205 行）中。

每当算法从相机获得新帧时，它首先执行关键点检测。然后将这些关键点与前一个相机帧匹配。到目前为止，相机运动提供了一个很好的想法，即在新帧中再次找到相同的关键点；这有助于满足实时要求。匹配结果会产生初始相机姿势估计。

接下来，ORB-SLAM 尝试改进估计的相机姿势。该算法将其地图投射到新的相机帧中，以搜索更多关键点对应关系。如果足够确定关键点匹配，它会使用额外的数据来优化相机姿势。

通过对连接帧中的匹配关键点进行三角测量来创建新的地图点。三角测量基于帧中关键点的 2D 位置，以及整个帧之间的平移和旋转。最初，匹配是在两帧之间计算的 - 但稍后可以扩展到其他帧。

9、回环检测和回环闭合

SLAM 算法中的另一个关键步骤是回环检测和回环闭合：ORB-SLAM 检查帧中的关键点是否与之前从不同位置检测到的关键点匹配。如果相似度超过阈值，则算法知道用户已返回已知位置；但途中的不准确性可能会引入偏移。

通过将坐标校正从当前位置传播到上一个位置的整个图形，地图将使用新知识进行更新。

10、SLAM 和 Google + Microsoft + Apple？

快速现实检查：当今的移动 AR 中使用了什么？所有数据都将惯性传感器的数据与摄像头馈送融合在一起。

• Google：在文档中，Google 描述了 ARCore 正在使用一种称为并发里程计和地图绘制的过程 - 这本质上只是更广泛术语 SLAM 的另一个名称。该名称还表明他们正在集成惯性传感器进行里程计。专利中描述了一般架构。维基百科上关于 SLAM 的文章提到，谷歌正在使用之前描述的类似 Bundle Adjustment / Maximum a Posteriori (MAP) 估计。
• 微软：HoloLens 和 Windows Mixed Reality 中发生的许多事情都基于之前为 Kinect 所做的研究。因此，微软与 SLAM 相关的专利已于多年前发布。此外，HoloLens 的新研究模式允许访问执行的 SLAM 算法的结果。微软在 GitHub 上提供了一些入门示例 - 包括 OpenCV 集成。
• 苹果：几年前，苹果收购了开发 SLAM 算法的 Metaio 和 FlyBy。苹果正在使用视觉惯性测距/SLAM - 因此他们还将摄像头与其他手机传感器相结合以提高精度。WWDC 2018 的会议视频对该技术进行了很好的概述。

11、基于手机的增强现实的未来

SIFT 算法对许多研究课题都很有价值，包括自动驾驶汽车导航。因此，提高和扩展质量和性能是一个非常活跃的研究课题。

在“紧密耦合的单目、双目和立体 VINS 的比较分析”（2017 年）中，Paul 等人比较了将惯性测量单元 (IMU) 的数据与光学传感器相结合的算法，当今的大型商业 AR 框架也这样做了。除此之外，他们还将他们的新算法与最先进的 ORB-SLAM2 和 OKVIS 算法进行了比较，发现他们设法进一步提高了可靠性和速度。

此外，将语义含义引入 SLAM 算法的尝试也显示出希望，正如几周前 Schönberger、Johannes L. 等人发表的“语义视觉定位”（2018）所展示的那样。

当然，AR 系统通常会尝试越来越多地了解环境。虽然 ARKit 和 ARCore 从跟踪简单平面开始，但 HoloLens 已经尝试通过空间理解推断出更多知识。Apple 在 ARKit 2 中引入了 3D 对象跟踪。因此，我们将看到虚拟对象与真实环境之间的集成大大改善。

凭借这些有希望的结果和最新的研究进展，我们可以期待手机上的增强现实在未来几个月和几年内进一步得到很大改善！

原文链接：Basics of AR: SLAM – Simultaneous Localization and Mapping

BimAnt翻译整理，转载请标明出处

有许多工具可以帮助你为 Meta Spark Studio 创建 3D 对象，包括 Cinema4D、Blender 和 3ds Max。你还可以使用 Meta Spark Toolkit 优化 Blender 对象。

在本指南中，我们将介绍正确的设置，以便你可以成功地为 Meta Spark Studio 准备对象，并确保它们在你的体验中更有效地工作。

1、缩放和定位

以下是在缩放和定位对象以进行导出时需要牢记的要求列表。导入后，你还可以启用 Meta Spark Studio 真实世界比例设置。

• 以米为单位导出你的模型。Meta Spark Studio 假设模型以米为单位上传。
• 使用内置的 3D 测量工具检查对象的尺寸，并根据需要放大和缩小对象以匹配对象的真实尺寸或所需尺寸。
• 保持所有 3D 对象不小于 1 厘米且不大于 5 米。用户可能无法与超出这些尺寸的对象进行交互。
• 将对象的原点设置为其几何体的中心。
• 正确定位和缩放对象后，不要忘记将对象的新变换值设置为默认值。在导出对象之前执行此操作。

左侧的图像是导入的鸟类对象，但比例不正确。右侧的图像显示了一只正确缩放的鸟。

2、网格

3D 对象网格中的三角形数量或“三角形数量”会影响性能。最好将三角形数量保持在尽可能低的水平。每个对象的最大三角形数量应低于 50,000。将效果中所有对象的总三角形数量保持在 150,000 以下。

以下是减少三角形数量的一些技巧：

• 如果不需要可见，请从网格中删除任何内部几何图形：如果你的对象是戴帽子的角色，请删除隐藏在视图之外的头部部分。
• 修复几何图形：尝试删除松散的几何图形、三角形和顶点，制作平面，删除重叠的面并合并重叠的顶点。这将减少三角形数量和产生伪影（意外像素化和其他图形效果）的可能性，尤其是在使用 3D 扫描时。如果你在 Blender 中工作，Meta Spark Toolkit 将为你清理网格。
• 将网格中高度详细的部分转换为纹理：如果你正在制作花冠并且花朵不会聚焦，请将它们映射到低多边形凹盘上，而不是导入带有每个花瓣和所有柱头的整个 3D 花朵。你可以在不需要太多细节的选定区域中设置较低的网格密度。

在下图的右侧，可以删除构成短裤下方角色臀部和腿部的几何图形，因为用户看不到它们。

你还可以通过以下方式优化网格：

• 尽可能将网格合并在一起。这将减少效果中的对象数量，并通常提高性能。
• 将多边形保持在三角形和四边形中以避免伪影。

3、UV 贴图

UV 贴图是 3D 对象表面的 2D 表示。要获得最佳纹理效果，UV 贴图过程必须成功。要优化该过程：

• 手动生成 UV 贴图，而不是自动生成。
• 将 UV 外壳保持在最低限度，不要重叠，否则会出现伪影。
• 在外壳之间留出填充。例如，1K 纹理的外壳之间应有 8 像素的填充。
• 仅对 3D 对象使用一个 UV 贴图。

左侧的图像显示了具有重叠 UV 的 UV 贴图。右侧图像是组织良好的 UV 贴图。

4、材质

创建材料时：

• 优先考虑标准和平面着色器，而不是 PBR 着色器，以获得更高的性能。
• 对于需要它的逼真 3D 模型，使用基于物理的材料 (PBR) 和环境纹理。
• 尽可能少使用材料。
• 尽可能合并材料以提高性能。
• 使用着色器时，简单是最好的。加、乘、减函数比其他函数（pow、exp、log、cos、sin、tan）占用的资源更少。

5、纹理

GPU 内存是一种宝贵的资源，因此高效思考会让你的内容和其他内容的帧速率受益。要实现有趣而高效的纹理结果：

• 在 sRGB 空间中使用纹理，最大分辨率为 1024 x 1024 像素，并且只使用你需要的大小。
• 为了获得更好的性能，请以 2 的幂（64x64、128x128、256x256、512x512、1024x1024）制作纹理。
• 对于简单对象，请尝试使用顶点颜色和平面着色以减少对纹理内存的依赖。你可以使用顶点颜色在 Spark 中为视觉交互性制作动画。
• 尽可能利用纹理图集：将多个纹理组合成一个图像，以减少纹理和绘制调用的总数。更突出的英雄对象应该在你的图集中占用更多空间。
• 可以更进一步，使用颜色通道打包来节省空间：将纹理信息编码到图像的各个颜色通道中，以便在逻辑中使用。专业提示：你可以通过这种方式使纹理单调，并动态更改其颜色或通过在顶部乘以颜色图来更改颜色。
• 如果可能，请避免使用带有 alpha 通道的图像。这些图像比 RGB 图像消耗更多的 GPU 内存。你可以使用黑色背景和材质属性中的混合模式来实现类似的效果。
• 如果使用 Adob​​e® Substance Painter® 纹理软件创建纹理，请使用 Meta Spark 模板使你的纹理兼容。
• 对于具有重复图案的纹理，请导入较低分辨率的图像并使用 Meta Spark Studio 的视觉着色器和纹理平铺功能，而不是使用较大分辨率的图像。你还可以以独特的方式转换纹理以适当地重复使用它们。
• 在将纹理带入 Spark 之前对其进行压缩，以更好地控制质量和灵活性。

在 AR 效果中很难实现具有逼真灯光的纹理，并且需要大量的处理能力。为减少对性能的影响：

• 将照明直接烘焙到用于面部效果装饰的 3D 对象中，以暗示高光和阴影。
• 将照明烘焙到静态（非移动）对象（如家具和配饰）中，以获得更逼真的效果
• 使用柔和的灯光设置，不要使用强烈的高光或阴影。烘焙照明最适合光线、强度、颜色等在整个效果过程中不会发生变化的环境。
• 将 MatCap（材质捕捉）反射环境纹理与平面着色器结合使用。
• 不可以使用环境光将一个环境纹理用于所有 3D 对象，以便在场景中共享。

6、绑定和蒙皮

如果你正在构建动画 3D 对象，你将创建（装配）骨架并将网格附加（蒙皮）到骨架上，以控制对象移动时的变形方式。如果此过程未针对 Meta Spark 工作室进行优化，则动画的组件可能无法正常工作或性能不佳。

创建骨架时：

• 虽然动画对象中可以使用的骨骼数量没有上限，但我们建议使用尽可能少的骨骼以减少对性能和大小的影响。少于 20 个是一个不错的开始。
• 利用简单、直接动画的骨骼或“双骨架”装配导出到 Spark。Spark 无法理解约束和其他装配控件或高级设置。
• 对骨骼使用一致的命名约定，并为每个单独的骨骼使用单独的名称。例如，左臂为 arm_L，右臂为 arm_R。
• 使用 Z+ 向前和 Y+ 向上调整骨骼方向。
• 在所有轴上将每个骨骼的比例设置为 1。
• 以自然层次结构组织骨骼。Meta Spark Studio 将松散的骨骼视为空对象，不会将它们识别为变形器。

以下是两种可能的骨架层次结构。右侧图像是最佳实践示例。

不建议将下面的骨架层次结构用于动画 3D 骨架对象。

蒙皮过程的一些一般准则包括：

• 将装备绑定到网格时，将每个顶点的影响数限制为四个。这是 Meta Spark Studio 出于性能原因支持的最大数量。如果您的对象不符合这些准则，则可能会在动画之前和动画期间产生伪影。
• 确保骨骼处于预期位置以避免伪影。

左侧的图像是一只 3D 鸟，其骨架位置不正确。右侧图像显示了一个位置良好的骨架。

7、动画

使用 Meta Spark Studio 中的程序动画可让你实时生成动画，同时保持项目大小较小。

在 Meta Spark Studio 之外向对象添加关键帧动画是创建更复杂和更详细的动作的不错选择，但它可能会增加文件大小。如果你需要使用关键帧动画：

• 仅向标准属性（位置、比例和旋转）添加关键帧。
• 不要向不需要动画的属性添加关键帧。例如，如果不需要，请不要向比例添加关键帧。
• 请记住，自定义属性关键帧不会被导出。
• 在你使用的 3D 软件中使用 24 fps（每秒帧数）的帧速率。

向 3D 对象添加复杂动画的另一种方法是创建动画剪辑并将其分配给 Meta Spark Studio 中的对象。你可以：

• 使用 Autodesk® Maya® 中的 Game Exporter 插件等工具或 Blender 中的 NLA（非线性动画）操作来创建剪辑。
• 在导入对象之前，你还应注意Meta Spark对文件格式和功能的要求和限制。

我们都遇到过这种情况：浏览 Grasshopper 的组件选项卡时，我们遇到了这个术语：Brep。Grasshopper 中的 Brep 到底是什么？

Grasshopper 是一个著名的图形算法编辑器，可与 Rhino 的 3D 建模工具无缝集成。对于建筑师、工程师和设计师来说，它是一个改变游戏规则的工具。在 Grasshopper 的众多组件中，Brep 占有特殊的地位。但 Brep 到底是什么，为什么它在 Grasshopper 中如此重要？无论您是建筑师、工程师还是设计师，了解 Brep 都是必不可少的。

简而言之，Brep 是 Rhino 中 Polysurfaces 的替身。但它还有更多内容。它是关于掌握它如何运作以及如何在 Grasshopper 中有效地使用它。

我们将介绍所有 Brep 基本知识，并了解 Grasshopper 中的 5 个基本 Brep 组件，所以请继续关注！

让我们深入了解！

1、什么是 Brep？

Brep 是边界表示的缩写，是 3D 建模和 CAD 应用程序用来表示 3D 对象的方法，通过定义其体积的极限来表达3D对象。

想象一下 3D 对象作为实体。Brep 关注包围该实体的边界。与其他可能使用多边形或顶点的表示不同，Brep 由其表面之间的数学关系定义。这种数学精度可以更准确地表示复杂的形状和轮廓。

在 Rhino 和 Grasshopper 的背景下，你可以将 Brep 视为与“多面体”相同。

1.1 Brep 的历史

边界表示起源于 20 世纪 70 年代初。它是 3D 建模的一项突破，提供了一种灵活而详细的方式来表示复杂的形状。多年来，Brep 不断发展，并成为现代 3D 建模系统的标准。

1.2 CAD 行业中的 Brep

Brep 不仅仅是 Grasshopper 的东西；它在 CAD 行业中是一件大事。许多商业 CAD 系统（例如 Parasolid 和 ACIS）都是基于 Brep 的。这些系统被世界各地的专业人士用于从产品设计到建筑建模等各种应用。

2、Grasshopper 中 Brep 的构建块

Brep 就像一块拼布；它由几块拼凑在一起形成一个整体的碎片组成。这些碎片是 Brep 的拓扑组件，包括面、边和顶点。面是曲面的有界部分，边是曲线的有界部分，顶点位于某个点。这些元素以定义 3D 对象边界的方式连接在一起。

就像多边形表面一样，Brep 可以分为两种类型：开放和封闭。

开放的 Brep 至少有一个暴露的边，而封闭的 Brep 则完全封闭。想象一下一个开放的盒子和一个封闭的盒子。

Brep 的类型会影响你可以在 Rhino 和 Grasshopper 中执行的几何操作类型。

在 Grasshopper 中，完全封闭的 3D 对象或 Brep 也称为“实体”。布尔运算 - Rhino 中封闭 3D 对象的减法、并集或交集 - Grasshopper 将它们称为“实体”运算。

3、使用 Brep 的好处与坏处

Brep 的数学精度是它们的超能力。这种精度使设计师和工程师能够创建其设计的“完美”表示。尤其是在制造应用或 3D 打印中，准确性至关重要，Brep 非常有价值。

3.1 Brep vs. 网格：建模技术之战

现在，你可能想知道 Brep 与网格有何不同。网格由多边形组成，而 Brep 使用数学表示来定义表面。

想象一下放大弯曲的表面。使用网格，表面开始看起来块状，但使用 Brep，无论放大多少，表面都保持光滑。这使得 Breps 成为表示具有曲面的复杂 3D 对象的理想选择。

3.2 另一面：Brep 建模的局限性

然而，每个超级英雄都有自己的弱点。对于 Breps 来说，它就是繁重的文件格式和可视化所需的处理能力。Brep 文件存储了大量元数据，这会占用大量磁盘空间。此外，渲染或动画 Brep 对象可能会耗费大量资源。

此外，Brep 可能不是有机或自然物体的最佳选择。精确的数学公式可能使重新创建更流畅的形状变得具有挑战性。

4、Grasshopper 中必不可少的 Brep 组件

Brep 不仅仅是一个理论概念；它是我们在 Rhino 和 Grasshopper 中建模的核心。在 Grasshopper 中，你可以使用 Breps 执行一系列几何操作。一些组件会产生 Breps（例如挤压表面），其他组件则对 Breps 本身进行操作。

4.1 Grasshopper 中的 Brep 数据类型

在 Grasshopper 中，Breps 有自己的数据类型。这意味着某些对象（如框）只能通过 Brep 数据容器引用。Brep 容器组件位于“Params”组件选项卡的 “Geometry”下。

以下是 Grasshopper 中的五个必不可少的 Brep 组件：

4.2 Brep拆解

组装的一切都可以被拆解。Deconstruct Brep 组件就像一个 3D 拼图解算器，将任何 Brep 输入分解为其基本构建块：面、边和顶点。简而言之，它将复杂的结构分解为表面、曲线和点，为您提供要使用的元素部分。

应用示例：

使用此组件选择 Brep 的特定子元素，例如其表面之一。例如，要选择立方体的顶面，请使用 Deconstruct Brep 组件获取 Brep 所包含的所有表面的列表输出，然后使用 ListItem 组件选择所需的表面。

GH 中 Deconstruct Brep 组件的示例

4.3 Brep是否包含点

Brep 中的点 (BrepInc) 组件是一组分析组件的一部分。前提很简单：该组件帮助我们找出一个点是否在 Brep 中。当提供一个封闭的 Brep 和一个点列表时，它将输出一个布尔值列表。如果列表中包含一个点，则该值为 True，否则为 False。

因此，可以使用 Brep 中的点组件来选择包含在给定 Brep 体积中的对象。在下面的示例中，我使用“Cull Pattern”组件来处理具有 True/False 值的点列表。

4.3 实体差异

这个组件一开始可能很难找到，因为来自 Rhino，人们会寻找“布尔差异”来从另一个封闭的 3D 对象中减去一个。相反，在 Grasshopper 中，这些组件分别称为实体差异、交集和联合。

4.4 Brep最近点

Brep Closest Point 组件是最近点组件系列的一部分。这些组件根据点列表（在本例中为 Brep）计算出几何体上的最近点。

提供 Brep 和点列表后，Brep Closest Point 组件将输出 brep 上的最近点、这些点处 Brep 的法线以及距离。

4.5 Brep | Brep 交点

Grasshopper 中的交点组件有自己的组件选项卡，包含所有不同几何类型组合的交点组件。下面显示的是 Brep | Brep 交点组件。顾名思义，给定两个 Brep 输入 A 和 B，该组件将输出交点曲线 (C)，以及最终的交点 (P)。

这些只是 Grasshopper 中可用的 Brep 命令中的一小部分。双击画布并在搜索栏中输入“Brep”，查看 Grasshopper 还提供了哪些其他 Brep 组件！

请记住，Rhino 和 Grasshopper 中的命令有时使用不同的术语来指代相同的命令。某些组件即使执行相同的功能，也可能使用不同的名称。

5、结束语

了解 Grasshopper 中的 Brep 可让你将 3D 建模提升到一个新的水平。凭借其数学精度，Brep 是创建复杂而精确的 3D 对象的理想选择。虽然它有其局限性，但它的优势使其成为 CAD 工具箱中不可或缺的工具。

原文链接：What is a Brep in Grasshopper? A Comprehensive Guide

BimAnt翻译整理，转载请标明出处

增强现实 (AR) 被描述为一种通过计算机生成的内容增强现实世界的交互式体验。

使用软件、应用程序和硬件（例如 AR 眼镜），AR 能够将数字内容叠加到现实环境和物体上。早在 2024 年，许多像 Apple 这样的公司就已进入 VR/AR 市场，推出了新的耳机和工具，让用户体验一种新的人机交互形式。

考虑到这一点，AI Magazine 考虑了一些致力于利用最新技术的领先 AR 平台。

1、Sketchfab

Sketchfab 被描述为通过让任何人都可以轻松地在线发布和查找 3D 内容来赋能新时代的创造力。该平台允许用户发布、共享、发现、购买和销售 3D、VR 和 AR 内容。

Sketchfab还提供了基于 WebGL 和 WebXR 技术的查看器，允许用户在网络上显示 3D 模型，这些模型可在任何移动浏览器、桌面浏览器或虚拟现实耳机上查看。该平台支持兼容软件上的 VR 和 AR。

以下是一些关于Sketchfab的关键事实：

• 500 万+ 3D 模型
• 1000 万+ 注册用户
• 600 万+ 每月独立访客
• 自推出以来总页面浏览量超过 20 亿

2、Niantic

Niantic 最初于 2010 年作为 Google 内部初创公司成立，名为 Niantic Labs，2015 年从 Alphabet Inc. 分离出来后成为一家独立的私营公司。在获得 Pokémon Company Group、Google 和 Nintendo 的 3500 万美元 A 轮融资后，Niantic 宣布开发增强现实游戏 Pokémon GO。该平台一夜成名，至今仍拥有超过 8000 万用户。

Niantic 还热衷于利用 AR 的力量支持现实世界的社区。它与世界各地的非营利组织建立了多项合作伙伴关系，以鼓励和支持通过 AR 体验进行社区参与。

3、ARToolKit

artoolkitX 是一个开源项目，旨在继续支持 ARToolKit 社区，并确保未来几代增强现实开发者能够访问和理解推动这项创新技术的底层算法。

该项目由过去十年来负责所有 ARToolKit 开发的核​​心团队运营，并由领先的 AR 服务提供商 Ethar, Inc. 资助。它于 2001 年首次作为开源项目发布，直到 2015 年出售。

4、Adob​​e Aero

Adobe Aero 是 Adob​​e Inc. 在 Creative Cloud 上推出的 AR 创作和发布工具。它是一种在移动 AR 中构建、查看和分享强大的沉浸式叙事体验的直观方式。它在 iOS 上可用，并在 macOS 和 Windows 上作为桌面的公开测试版提供。

创作和查看平台使设计师和开发人员可以更轻松地在现实世界中设计、协作和发布交互式沉浸式体验。它免费使用，并提供清晰直观的界面，易于使用。

5、Wikitude

Wikitude 是一家位于奥地利萨尔茨堡的移动 AR 技术提供商。该平台成立于 2008 年，最初专注于通过 Wikitude World Browser App 提供基于位置的增强现实体验。其 AR 提供 iOS、Android 和智能眼镜应用，具有图像和对象跟踪、即时跟踪 (SLAM) 和 Geo AR 以及其他功能。

Wikitude 应用率先在 AR 中使用基于位置的方法。2021 年 9 月，Wikitude 被高通收购，Wikitude 服务将于 2024 年 9 月完全关闭。

如下是一些关于Wikitude的关键事实：

• 150 000+ 注册 AR 开发人员
• 40,000+ AR 应用
• 180 个国家/地区

6、Unity

Unity 提供强大的工具，可打造丰富且极具吸引力的 AR 体验，并与现实世界进行智能交互。它拥有自定义资源和业界领先的软件开发平台，该平台将专门为 AR 创作者打造的工具配对。它被广泛应用于汽车、制造业、政府、建筑、能源和零售业等多个行业。

此外，其统一的工作流程可跨设备扩展，让用户专注于突破想象力的界限。Unity 的 AR Foundation 是一个跨平台框架，允许用户编写 AR 体验并为 Android 或 iOS 设备构建。

7、NVIDIA XR Suite

NVIDIA 解决方案使用其 RTX GPU 和 RTX 虚拟工作站 (vWS) 为 Android 和 iOS 设备启用扩展现实 (XR) 应用程序。特别是，其 CloudXR 平台致力于最大限度地提高质量和帧速率，以支持下一代 VR/AR 体验。

CloudXR 允许用户从任何 OpenVR 应用程序流式传输令人惊叹的 VR/AR 体验。用户还可以通过 5G 和 WiFi 网络从远程服务器在任何设备上运行 VR/AR 体验，同时享受无线移动的自由。

8、Apple Reality Kit

Apple 正在快速开发其 AR 功能，尤其是即将发布的 Vision Pro 耳机。其 Reality Kit 旨在让开发人员更好地控制他们的 AR 创作，使开发更快、更轻松。

RealityKit 也是一个 AR 优先的 3D 框架，它利用 ARKit 将虚拟对象无缝集成到现实世界中。它使用逼真的基于物理的材质、环境反射、接地阴影、相机噪声和运动模糊将虚拟内容与现实世界融合在一起，使虚拟内容几乎与现实无法区分。

9、Meta Spark

MetaSpark Studio 平台为用户提供灵活的工具，可轻松构建和共享大规模 AR 体验。用户可以从模板开始开发，也可以使用代码构建自己的自定义 AR 体验。

使用该平台可以轻松构建交互式 AR 体验，允许进行目标跟踪、深度映射、遮挡以及音频和触觉集成。用户可以加入超过 100,000 名创作者的社区，通过 Meta 获得认证，或利用 Meta Spark AR Creation Training 学习如何使用 Meta Spark Studio 中的工具和技术来构建 AR 效果。

10、Google ARCore

ARCore 是 Google 的增强现实 SDK，提供跨平台 API，用于在 Android、iOS、Unity 和 Web 上构建新的沉浸式体验。它旨在通过对人、地点和事物的情境理解来改变人们体验世界的方式。

AR 平台还使用户能够使用易于集成的工作流程和 Google 通过 Google 地图对世界的学习理解无缝融合物理世界和数字世界。

该平台的基本原理包括运动跟踪、锚点、环境理解和深度理解以及光估计。

原文链接：Top 10: Augmented Reality (AR) Platforms

BimAnt翻译整理，转载请标明出处

设计中的创意过程始终是突破界限、探索新领域和重新想象一切可能。随着我们继续将先进的计算方法集成到设计工作流程中，一个特别令人兴奋的途径是探索生成式系统（generative system）中的隐空间（潜在空间）。潜在空间（latent space）是生成模型运行的抽象领域，为设计师提供了前所未有的机会，让他们以新颖和互动的方式参与创作。

在本文中，我将介绍“浏览潜在空间”（BLS），这是一种交互式工具，可利用 3D 生成式系统中潜在空间可视化和插值的潜力。该工具是作为一项更广泛的研究计划的一部分开发的，它通过为设计师提供直观而强大的方法来理解、操作和生成新设计，从而增强了设计探索过程。

1、使用潜在空间重新定义设计探索

生成式系统在从艺术和音乐到设计和建筑等各种创意领域都获得了显著的关注。然而，与这些系统的交互通常仅限于一个有点随机和不可预测的过程——运行模型、等待输出并希望它与设计师的意图一致。但是，如果有一种方法可以更深入地研究这些系统的机制，以了解甚至控制它们如何生成输出呢？

这就是潜在空间概念发挥作用的地方。潜在空间是生成模型在训练过程中学习到的数据的低维表示。它捕获数据中的底层模式和结构，可以对其进行操作以创建新的设计。通过可视化和与这个空间交互，设计师可以获得有关生成系统如何解释其输入的宝贵见解，从而做出更明智和更具创意的设计决策。

2、生成式系统实验：3D 椅子案例

在我们的研究中，我们以椅子作为案例研究，探索潜在空间的创造性可能性。椅子是设计实践的主要内容，为实验提供了丰富的基础，尤其是在生成式系统的背景下。从混搭和迭代设计文化中汲取灵感，我们寻求通过为设计师提供使用潜在空间探索、混搭和创建新椅子设计的工具来增强创作过程。

我们利用了 GET3D 生成模型——一种能够生成高质量 3D 模型的强大工具。通过利用该模型的潜在空间，我们能够可视化和操纵定义椅子的特征。这种方法不仅让设计师更好地理解生成式系统，而且还允许在潜在空间中现有设计之间创建全新的设计。

3、可视化潜在空间：从抽象数据到有形设计

我们方法中的关键创新之一是潜在空间的可视化。高维数据（例如由生成模型生成的数据）可能难以解释和导航。为了克服这一挑战，我们采用了降维技术将潜在空间投影到二维地图中。该地图提供了不同椅子设计如何根据其特征（例如纹理和形状）分布的视觉表示。

可视化允许设计师以交互方式缩放、平移和探索潜在空间。他们可以看到相似的设计是如何组合在一起的，从而揭示生成式模型所学习到的底层结构。这不仅有助于理解模型的行为，还为创造性探索开辟了新的可能性。

4、插值：从现有设计中创建新设计

除了可视化之外，BLS 工具还包括一个插值功能，使设计师能够通过混合现有设计来创建新的椅子设计。潜在空间中的插值涉及在已知数据点（在本例中为现有椅子设计）之间生成新点并观察生成的设计。此过程允许设计师探索不同设计特征之间的平滑过渡，从而创建创新而独特的输出。

例如，设计师可以从潜在空间中选择两把或更多把椅子，并使用插值工具生成融合所选椅子特征的中间设计。这个过程类似于在广阔的设计景观中导航，其中每一步都会揭示以前未探索过的新可能性和组合。

5、设计探索的新范式

“浏览潜在空间”工具代表了设计师与生成式系统交互方式的重大进步。通过提供对潜在空间的直观访问，我们使设计师能够超越传统设计探索方法的限制。这种方法不仅可以增强创造力，还可以更深入地了解生成式模型的功能，从而实现更明智和创新的设计实践。

随着我们不断完善和扩展此工具，我们设想它将成为设计师工具包的重要组成部分。未来的迭代可能包括实时基于云的模型推理、更复杂的降维算法以及将这种方法应用于 3D 椅子以外的其他生成系统。

6、结论：创意探索的未来

将潜在空间探索融入设计过程标志着创意和创新的新时代的到来。通过释放生成式系统的潜力，设计师可以突破可能的界限，创造出不仅新颖而且深受其所用模型底层机制影响的设计。

设计的未来取决于我们利用这些先进计算工具的能力，而“浏览潜在空间”工具只是一个开始。随着我们继续探索和完善这些技术，创意探索的可能性将无限。

原文链接：Unlocking Creative Potential: Exploring Latent Spaces in 3D Generative Design

BimAnt翻译整理，转载请标明出处

在 Open CASCADE 中，有不同的 API 可用于探索给定的形状（shape）。还有一些其他技术是探索形状的基础。在本文中，你将了解我尝试探索形状的不同技术和 API。那么，让我们开始旅程吧。

在本文中，我们将探索 6 个 API。

• TopExp_Explorer
• TopOpeBRepTool_ShapeExplorer
• ️TopoDS_Iterator
• ️TopTools_IndexedMapOfShape
• ️TopTools_IndexedDataMapOfShapeListOfShape
• ️ShapeAnalysis_ShapeContents

1、TopExp_Explorer

这是探索形状最著名的方法。你可能在阅读本文之前就听说过这个 API 😀。

在这里，形状是从上到下的层次结构进行探索的。因此，给定形状中的所有子形状都将通过探索进行计数。

示例：如果你想探索特定形状的所有边，则可以按如下方式定义：

在探索形状的边缘之前，它会先查看“面”级别。在这里，它会逐个面进行探索，并探索每个面的边。由于采用这种方法，公共边将被多次计算。

基于此，上述形状的边数将为 24。

你可能不会使用此 API 中的 ToAvoid参数。此参数的用途是避免在探索形状时考虑形状类型：

在上面的例子中，你将获得所有不属于面的边。这意味着形状的自由边。

如果你想要计算给定类型的子形状的数量，只需在 for 循环外部定义一个整数，并在探索过程中逐个递增即可。

2、TopOpeBRepTool_ShapeExplorer

下一种方法是使用 TopOpeBRepTool_ShapeExplorer 而不是 TopExp_Explorer，并在其中使用 Index函数。

3、TopoDS_Iterator

TopoDS_Iterator 用于探索形状直到下一个形状类型。例如，如果你正在使用 TopoDS_Iterator 探索一个面，将获得该形状的线。如果你正在探索一条线，将获得该形状的边。

我们可以在此 API 中定义另外两个变量。要迭代所有子形状，你必须使用递归函数或任何其他形式的使用。

TopoDS_Iterator可以像 TopoDS_Explorer一样使用。示例如下：

4、TopTools_IndexedMapOfShape

如果你想要使用索引映射子形状，您可以简单地使用此 API。在这里，子形状使用索引进行映射。

这里的主要优点是每个形状只计算一次。如果我们用 TopTools_IndexedMapOfShape探索一个框以获取边，将获得 12 条边。

5、TopTools_IndexedDataMapOfShapeListOfShape

当需要获取形状和子形状连接时，可以使用此方法。例如，当需要检查连接到特定形状的每个边的面是什么时，可以按如下方式使用此 API。在此映射中，键是边，值是面列表。

你可以按照给定的示例从形状映射和形状列表中提取数据。

6、ShapeAnalysis_ShapeContents

如果只想获取形状的数量，可以直接使用此 API。在这里，你可以根据需要获取不同的子形状数量。仔细选择要获取的参数。

从下面的列表中选择要获取的参数。

你可能会想为什么有不同的方法来获取边数。让我描述一个子形状；边。

• NbEdges — 此参数将返回与我们可以从“TopExp_Explorer”中获得的边数相同的边数。这里将返回所有重复的边。
• NbSharedEdges — 此参数将返回与我们可以从 TopTools_IndexedMapOfShape中获得的边数相同的边数。这里省略了公共边数。
• NbFreeEdges — 此参数将返回给定形状中的自由边。自由边是指不属于任何面或线的边。
• NbFreeSharedEdges — 此参数将返回不属于任何面的边数。 NbFreeEdges 和 NbFreeSharedEdges 都相同。

我们遗漏了什么？

我们需要从给定形状中获取其他形状计数，但 ShapeAnalysis_ShapeContents 中未包含这些计数。其中一些是非流形边的数量和退化边的数量。

需要新版本！

为了填补这一空白，我创建了一个名为 geom_ShapeContent的新类，它基于 ShapeAnalysis_ShapeContenets。在这里，我包含了获取非流形边和退化边数量的函数。

你可以查看此 github 存储库，并欢迎就此API 提出建议。

原文链接：Explore your shape using OPEN CASCADE

BimAnt翻译整理，转载请标明出处