BimAnt

下一代UI：元宇宙 vs. AI

admin — Thu, 23 Apr 2026 17:34:10 GMT

高科技行业一直被各种风潮困扰，几乎每年都有新事物被炒作到天上去：

电子商务和整个互联网泡沫（1995-2001年）
VR/AR和"元宇宙"（马克·扎克伯格偏离主营业务的一次弯路）
NFT（非同质化代币，2022年的宠儿）
AI工具（2023年的"大事"）

我们如何辨别什么是炒作，什么是真实的？NFT已经明确破产，而电子商务则是明确的赢家（截至2023年5月，占美国零售销售额的15.1%，约合每年一万亿美元——每当涉及到万亿这个大数字时，它就不可能是风潮）。在两者都处于炒作巅峰时，仅凭新闻报道你很难分辨它们的区别。

我建议区分真伪的方法是看用户测试中对客户有效的是什么。被炒作的想法是否帮助真实用户更高效或更愉悦地完成有用的任务？如果是，现实中的采用就是可能的。它是否在演示中看起来很棒，但却无法帮助人们完成任务？如果是，那它可能就是炒作，将在年内遭到应有的消亡。

在我列出的四个被炒作的项目中，两个已经接受了历史的审判，我也可以说在当时就很清楚电子商务是有用的，而NFT是无用的风潮。（关于2000年前后的电子商务，问题不在于在线购物是否对消费者有益，而在于是否能构建高效的供应链来盈利地运送像狗粮这样的商品。）

那么元宇宙和AI呢？两者都在向天际冲刺，但其中一枚火箭正在发射台上爆炸。

先说结论：AI工具是真实的，元宇宙是炒作。让我们看看为什么。

1、元宇宙的诱惑

前4代主流用户界面风格是：

批处理：整个工作流在单一时间点一次性提交，构成一个零维UI。1945-1964年。
命令行（如Unix、DOS）：逐行输入文本命令，构成一个一维UI。1964-1980年。
全屏终端（如IBM大型机）：仍然是纯文本，但一次显示一屏内容，用户可以在屏幕上移动光标，例如填写表单字段。这是一个二维UI。1971-1984年。（注意第2代和第3代有重叠，两者曾并行使用。）
图形用户界面（GUI，如Mac和Windows），同样使用二维电脑屏幕，但具有重叠窗口，增加了一些Z轴维度，构成一个二点五维UI。1984-2024年。

（关于这些UI世代的更多信息，请参阅我关于用户界面3个范式的文章。）

鉴于这种0 -> 1 -> 2 -> 2.5维度的历史演进，很多人认为第5代UI将完成计数，变为三维——以虚拟现实或被炒作的"元宇宙"为代表。

我从不这么认为：参见我1998年的文章 2D优于3D。

3D之所以无法超越2D，是因为我们在电脑上操作的大部分信息是N维的，其中N远大于3。例如，考虑财务规划和投资管理。不同的投资策略和不同工具有多少维度？再加上每个投资者的情况和偏好的额外维度。无论你将这些维度压缩到2还是3，其实差别不大：可用性将取决于你的可视化技能，而不是2D和3D之间的差异。但3D UI通常会更差，因为它比同一数据和功能的2D表示更难操作和视觉扫描。

下一代UI不会是3D，而是基于意图的结果规范（由AI驱动）与基于可视化的图形用户界面（结合传统命令驱动的交互设计，主要是2D）的混合体。我们不会进入更多几何维度，而是进入更多概念维度，结合多种界面风格。

当然，3D在某些应用中是有用的：医学手术规划、修理飞机引擎等复杂设备，以及电脑游戏。所以我们会看到一些3D界面来补充占主导地位的2D/AI混合设计。

但即使是像选择酒店房间这样似乎能从3D可视化中受益的用例，主要方式可能仍是非3D的，更多地依赖大量照片和一些视频，而不是VR。大多数网站通过投资更好的摄影将比部署VR赚更多钱。毕竟，赚更多钱是商业中UX的目标。你的工作不是发布实现成本更高却带来更少收入的炫酷设计。

苹果的"Vision Pro"AR头显拥有卓越的硬件，分辨率更高且无延迟。据报道，它还有一个出色的用于控制3D环境的用户界面。（不过我要等到看到独立用户测试的结果后再做最终判断，而不是记者报道的精心安排的演示。）它对实际使用来说太贵太重了，但下一版会更便宜更轻。第3版可能对富裕国家的富裕消费者来说足够好，可以用来观看3D电影。我怀疑更多用例是否足够有吸引力：发布演示令人惊讶地缺乏吸引力。即使是3D电影，如果我们以这一类型的经验来看，也可能只是一个小众用例：除了新奇效应外，人们很少观看3D电影，甚至一些好莱坞最优秀的创作者在尝试制作3D电影时也失败了。（我所说的"失败"，是指故事在2D中观看同样引人入胜，你戴上护目镜或头显并没有任何溢价。）

（顺便说一句，我们过去常说微软的产品应该等到3.0版本再购买。今天，我对苹果也是这样说。相比之下，微软最近发布了几个在v.1就足以投入生产使用的产品，包括Bing Create和Bing Chat。不过，由于后者由ChatGPT第4版驱动，如果我们取前端UI和后端大语言模型的平均值，版本号可能接近3。）

每次将3D用于一般商业应用或非游戏消费者应用时，它都失败了。

马克·扎克伯格怎么会犯这么大的错误？所有报道都表明他智商很高，技术背景扎实。虽然在两方面可能都不如比尔·盖茨，但比Bill智商低并不丢人（我很确定自己也属于IQ<billg俱乐部）。

我没有来自Facebook/Meta的任何内幕信息。（如果有，我不会写出来。）但我认为有两个解释：一个追溯到童年，一个更贴近当下。

3D之所以诱人，是因为它是许多科幻电影和电视节目中的主导UI，最突出的是《星际迷航》和《星球大战》。我们这些书呆子，包括扎克，都是在大量诱人的3D产品陪伴下长大的。当然，它们并不是真正的产品（有真正的客户和实际用例），而只是推动剧情发展的虚构设备。我不能否认3D UI在银幕上看起来很棒。然而，科幻设计不是用户界面；而是观众界面。它们的存在不是为了支持任务完成，而是为了支持叙事目标。非常诱人。但对于在地球上的企业（而非星际飞船企业号上）什么能奏效来说，非常误导。

3D之所以诱人，是因为它在演示中确实有说服力。看别人操作3D UI并解释可视化的工作原理，你会很容易被说服这是一个伟大的设计。看起来很酷。肯定很好。请停止那种僵尸思维，做一些批判性分析吧！

基于数十年UX经验的批判性分析告诉我们，演示对于判断可用性和实用性是无关紧要的。重要的是代表性用户在执行真实商业任务时的实际使用。观察用户，而不是演示。这正是元宇宙一次又一次失败的地方。人们拿到头显，体验了几次有趣的内容，然后它就搁在架子上积灰，而他们则在平面屏幕上处理业务。

2、AI工具确实有效

与元宇宙形成对比，AI工具在真正的商业用例中是有效的。我最近调研了3项关于AI工具用于商业的研究：客户支持代理回答客户咨询、商业专业人士撰写标准商业文档、以及程序员实现真实代码。在所有3个案例中，AI工具都带来了巨大的、统计上显著的用户生产力提升。在这3个案例研究中，使用AI工具时生产力提高了66%。这正是区分炒作与现实的标准：巨大的商业收益使AI成为现实。

这66%的生产力提升是基于ChatGPT 3.5的上一代AI工具实现的。当前版本（v.4）已经好了很多，我们应该预期下一版本会有更好的表现。此外，在3个案例研究中的2个里，用户只在他们首次接触AI工具时被测量。用户界面受益于学习曲线，人们随着经验的积累变得更有生产力。总之，66%的生产力增长是对我们明年将看到的一个非常低的估计：许多商业实施的AI工具很可能使员工生产力翻倍。（又名，成本减半。**

能否赚钱是你判断AI不再是炒作的标准（尽管在过去几十年里它曾经是）。任何没有AI战略的公司几年后都将完蛋。这对你也一样，亲爱的读者。赶紧行动，学会在你自己的工作中利用AI来让你的工作绩效翻倍。

3、结束语：生产力提升赢得胜利

实际使用是区分炒作与现实的标准。

能够改善广泛行业盈利能力的用例表明了什么是真实的。代表性用户在可用性测试中执行有用任务的能力也是如此。

相比之下，花哨的演示不能预测实际使用。事实上，如果你只看到某项技术被用于演示，那它很可能是炒作。

想象一下给地球上任何地方的高管打一个Zoom电话：美国、中国、德国，哪里都行。你告诉他或她："我们有一个面向你们行业的AI工具，可以将你的成本减半。"这位高管会接听这个销售电话吗？更重要的是，会听你的推销吗？那当然。

再想象给少数几个特定行业的几位高管打另一个Zoom电话："我们有一个面向你们行业的XR工具，可以让你的维护工程师效率提高20%。"这些高管会接听电话吗？可能会，如果你的VR/AR确实比他们现有的好20%，他们甚至可能会购买。

这两个场景之间的两个差异：

你可以向全球任何公司进行AI销售推销——至少从现在起10年后，当专业化应用被开发出来时。而你的元宇宙销售员只能打给少数几个行业的潜在客户。
你的推销是100%对20%——更大的节省能促成更多的销售。

以下是你区分现实与炒作的指南：

你是否有在真实企业中盈利使用的现实用例？
这些用例是否具有广泛的适用性，还是会一直很狭窄？
该技术在演示中表现更好，还是在用户研究中表现更好？
根据实际任务的测量研究，你能推动多大的变化？

将这些指南应用于元宇宙和AI驱动应用，可以得出一个直截了当的结论：要保持领先，忘记元宇宙，拥抱AI的力量。元宇宙是炒作。AI是真实的。你在这里听到了。

原文链接: AI vs. Metaverse: Which Is the 5th Generation UI?

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

3D感知管线开发环境搭建

admin — Thu, 23 Apr 2026 10:51:07 GMT

我们正在构建一个统一系统，融合3D LiDAR和ZED2立体相机数据，使用YOLO进行目标检测，使用Open3D进行点云处理。所有内容均通过Pixi管理，使环境在不同系统上可复现。

这些模块化课程共同构成了一个完整的端到端项目。你可以按照循序渐进的路线图学习，也可以根据需要直接跳到特定的传感器逻辑部分。

在融合传感器或运行AI模型之前，我们需要一个坚实的基础。搭建机器人开发环境传统上是开发中最令人沮丧的环节之一——往往会导致"依赖地狱"，即一个库的更新会破坏整个系统。

在本课中，我们使用Pixi——一个下一代包管理器。Pixi确保你所需版本的ROS 2、PyTorch和Open3D被安装到一个隔离的"气泡"（本地环境）中。这保持了你的主操作系统的整洁，并确保在我的机器上能运行的代码在你的机器上也能运行。

0、学习目标

完成本节后，你将能够：

配置Linux开发环境： 为ROS 2开发安装必要的底层构建工具和Git。
管理多仓库工作空间： 正确地克隆和组织主项目仓库以及如vision_msgs等外部依赖。
使用现代包管理： 学习Pixi工作流，包括环境初始化（pixi install）和激活（pixi shell）。
解析pixi.toml： 了解如何在单个配置文件中定义通道、多平台支持和复杂依赖（AI + 机器人）。
验证感知栈： 使用colcon执行完整的工作空间构建，并启动预配置的感知管线，使用ROS 2 bag和RViz验证系统完整性。

1、系统要求

虽然我们构建的环境是跨平台的，但本课程在Ubuntu（22.04或24.04）上进行了官方测试和验证。

首先，你需要在系统上安装基本的开发工具和Git。打开终端并运行：

# Update your package list
sudo apt update

# Install essential build tools and Git
sudo apt install -y build-essential git curl

# Install the LTTng libraries
sudo apt-get install liblttng-ust-dev

关于跨平台支持的说明： 我们使用的配置在技术上支持Windows和macOS（Intel和Apple Silicon）。然而，这些平台通常需要额外的步骤——例如为GUI工具配置X11或在Windows中管理路径长度——这些内容不在本课程范围内。如果你在非Linux系统上尝试时遇到问题，请寻求私人支持。

2、克隆项目仓库

本项目的仓库包含一个ROS 2工作空间，其中包含所有代码，以及用于设置工作环境的Pixi配置文件。

要克隆仓库，请使用以下命令：

git clone https://github.com/carlos-argueta/rse-3d-perception-pipeline.git

3、克隆Vision Messages仓库

Vision Messages仓库包含用于发布感知相关数据的ROS 2接口和用于可视化的RViz插件。要克隆并随后构建这些包，请导航到ROS 2工作空间的源文件夹并克隆vision_msgs仓库。

# Navigate to the src folder
cd rse-3d-perception-pipeline/ros2_ws/src/

# Make sure to checkout the jazzy branch
git clone -b jazzy https://github.com/ros-perception/vision_msgs.git

4、使用Pixi设置项目环境

在传统的机器人开发中，安装ROS 2是一个"系统级"操作，经常会破坏计算机上的其他Python项目。Pixi是一个现代包管理器（基于Conda生态系统构建），它解决了三个主要问题：

隔离性： 它为这个项目创建了一个"气泡"。所有内容——从ROS 2 Jazzy到PyTorch——都存放在项目目录中的*.pixi*文件夹内。它不会触及你的系统文件。
可复现性： 它使用锁定文件来确保本课程中的每位学生都使用完全相同版本的每个库。
单工具工作流： 它用单一工具替代了apt、pip和rosdep。

4.1 pixi.toml的结构

pixi.toml文件是你项目的"大脑"。它精确定义了你的环境。让我们看看本课程提供的文件：

[workspace]： 定义项目名称和通道（Pixi查找软件的位置）。我们使用robostack-jazzy获取ROS 2，使用conda-forge获取通用库。
platforms： 这告诉Pixi确保环境在Linux、Windows和Mac上可解。
[dependencies]： 这是你的购物清单。
ROS包： 注意我们包含了ros-jazzy-desktop和特定消息类型如sensor-msgs。
构建工具： 包含了colcon-ros以便编译我们的工作空间。
AI栈： 我们在一个地方定义了ultralytics（用于YOLO）、open3d（用于点云）和pytorch。

[workspace]
name = "rse-3d-perception-pipeline"
channels = ["robostack-jazzy", "conda-forge"]
# Added support for Lunux, Windows, macOS (Intel), and macOS (Apple Silicon)
platforms = ["linux-64", "win-64", "osx-64", "osx-arm64"]

[dependencies]
ros-jazzy-desktop = "*"
ros-jazzy-sensor-msgs = "*"
ros-jazzy-sensor-msgs-py = "*"
ros-jazzy-cv-bridge = "*"
ros-jazzy-tf2-ros = "*"
ros-jazzy-tf2-geometry-msgs = "*"
ros-jazzy-robot-state-publisher = "*"
ros-jazzy-xacro = "*"

colcon-ros = ">=0.5.0,<0.6"
colcon-common-extensions = ">=0.3.0,<0.4"

ultralytics = "*"
open3d = "*"
numpy = "*"
opencv = ">=4.12.0,<5"

pytorch = ">=2.0"
torchvision = ">=0.15"

4.2 安装Pixi环境

现在，让我们实际构建这个"气泡"。

在你的机器上安装Pixi（如果还没有安装）：

curl -fsSL https://pixi.sh/install.sh | sh
# Restart your terminal after installation

通过导航到项目文件夹并运行安装命令来初始化项目：

# Go to the project's root folder
cd rse-3d-perception-pipeline

# Install the pixi environment as per the pixi.toml specifications
pixi install

首次运行会需要几分钟。Pixi正在为这个项目下载完整的ROS 2发行版和AI库。

当你想学习本课程时，通过以下命令进入环境：

pixi shell

你的终端提示符会改变，表示你现在已经进入隔离的ROS 2环境。

4.3 下载ROS 2 Bag

本项目使用预录制的机器人数据。下一步是下载并解压本项目的ROS 2 bag文件。

# Download the data
wget -O linkou.zip "https://www.dropbox.com/scl/fi/tdxin6bzw01siucdv3kgv/linkou-2023-12-27-2-med.zip?rlkey=rcz93bhozjsdymcpn5dqz6rly&st=do015oqz&dl=0"
# Extract the data
unzip linkou.zip

5、构建和加载工作空间

我们现在准备构建和加载工作空间。这将使我们能够测试设置是否就绪。确保Pixi shell已激活。

# Navigate to the ROS 2 workspace
cd rse-3d-perception-pipeline/ros2_ws

# Build the workspace
colcon build

# Source the workspace
source install/setup.bash

6、测试设置

最后一步是运行整个3D管线并直观地确认它能正常工作。

ros2 launch s1s2_r1_perception perception.launch.py

你应该会看到类似下面的输出：

RViz窗口将打开，它应该看起来像下面的截图：

最后，在另一个终端中，让我们回放ROS bag中的数据来查看管线的实际运行效果：

# Open a new terminal 
# Navigate to where you downloaded and unzipped the bag, then play it with:
ros2 bag play linkou-2023-12-27-2-med/ --clock

7、⚠ 关于硬件和性能的说明

虽然这个感知管线旨在易于使用并且可以完全在CPU上运行，但它是一个计算密集型过程。管线同时管理：

深度学习推理： 运行YOLO进行目标检测。
点云处理： 通过Open3D对数千个LiDAR点进行滤波和聚类。
投影计算： 实时计算2D和3D帧之间的变换。

如果你的CPU性能不足，你会注意到延迟差距。特别是在鸟瞰图（BEV）中，3D边界框可能会"滞后"于实际的点云簇，因为机器人在移动。这是因为CPU无法足够快地完成AI推理和融合计算来跟上输入的传感器数据。如果你看到这种延迟且无法使用其他机器，请尝试关闭其他资源密集型应用程序。

恭喜！你已成功跨越了机器人技术中最困难的障碍：环境搭建。

在本课中，你已经：

配置了专业工作空间： 使用Pixi搭建了干净、隔离的开发环境。
管理了依赖： 克隆并配置了必要的ROS 2消息接口（vision_msgs）。
验证了软件栈： 成功构建了工作空间并使用录制的传感器数据启动了实时感知管线。

"管道"问题解决了，你的机器现在是一个功能完备的机器人工作站。我们已正式准备好开始探索这个3D感知管线的不同组件。

原文链接: 3D Perception: a LiDAR-Camera Pipeline — Setting Up Your Development Environment

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

Spline Omma：从提示词到3D网站

admin — Thu, 23 Apr 2026 10:39:29 GMT

Spline是第一家将易于创建的3D体验带入浏览器的公司，其学习曲线远小于Blender或Cinema4D。这个工具让像我这样的新手也能进行3D设计和交互。

今天，它发布了Omma——一个极其简单的AI工具，允许你描述你的想象，并通过一个Web友好的界面将其变为现实。

1、用3D交互让你的现有设计焕发生机

Omma的仪表板以"导入网站"选项开始，该功能可以将当前项目的内容和UI导入，并添加3D资产、滚动动画、光标交互等。

对于复杂的动画和对象，Omma团队建议与AI进行对话，并进行深入的编辑。

2、为PDF和其他文档添加3D视觉效果

当我看到可以将PDF导入Omma时，确实让我感到困惑。

但随后我看到了这样的示例：

带有3D交互的文字环绕效果

3、将实时数据转化为3D交互

得益于Omma导入文档和Excel表格的能力及其Vibe编码组件，你可以将数据点以3D交互的形式可视化在网页上。

带有鼠标交互的3D饼图

你还可以利用此功能构建类似流程图的"树"结构，帮助人们更好地理解网站上的数据。

使用Omma制作的3D思维导图

虽然这并非Omma的独有功能，但仅需一个简单的提示词就能实现，这才是真正让我兴奋的地方。

4、Spline有游戏功能，Omma让这些游戏栩栩如生

Spline最初是一个基于Web的3D工具，后来发展出更多功能，包括构建关卡和利用输入的能力。

在Omma中制作的纪念碑谷风格3D解谜游戏

它提供了完整的光标和键盘输入支持，因此你可以构建更复杂的内容——比如在开放世界环境中的汽车探索游戏。

支持物理效果的快速汽车游戏

这也展示了Omma为我们的工作流带来的逼真物理引擎。你可以让物体破碎、添加或移除重力、为元素增加重量等等。

5、为下一代体验打造的逼真模拟

这个实验完美展示了模拟效果

粒子效果和3D模拟是为设计增添深度和真实感的绝佳方式，而Omma只需一个提示词就能实现。

此功能使用WebGPU和自定义参数来提升性能，例如你可以更改粒子数量、细节、阴影等，使动画更加流畅。

6、其他在3D Web体验领域掀起波澜的替代工具

还有一系列设计工具可以为网站和UI设计创建快速简便的3D体验，它们可能更容易上手，同时也能产生酷炫的效果。

6.1 Unicorn Studio

这本质上是一个"特效"应用。你可以添加图片或应用界面，然后在上面叠加特效层。可以是酷炫的灯光层、位移遮罩，或者将图片转换为视差光标效果。

这些特效能流畅地响应鼠标移动和交互，并通过代码集成轻松导出，可添加到任何网站或设计工具中。

6.2 Framer Effects & Shaders

通过一些全新更新，Framer现在允许你为网页添加酷炫的背景和3D玻璃效果。在这里体验。

Framer中的色差效果

原文链接: Prompt to 3D Website Magic is Finally Here!

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

LiDAR、IMU和深度摄像机

admin — Tue, 21 Apr 2026 13:19:58 GMT

在机器人学中，传感器是感知的基础。它们通过将物理信号转换为可测量的数据，使机器人能够理解其环境。今天，我将简要介绍机器人学中使用的三种关键传感器——LiDAR、IMU和深度摄像头——以及它们如何与ROS 2集成以实现实际应用。

1、什么是LiDAR？

LiDAR = 光探测与测距（Light Detection And Ranging）。 它是一种主动传感器——发射自己的光（红外激光脉冲）并测量光子返回所需的时间。根据这个时间，它计算到周围物体的精确距离，构建一个称为点云的精确空间地图。

与摄像头（被动——仅捕获环境光）不同，LiDAR可以在完全黑暗中工作，穿透灰尘和雾气（范围会减小），并给出直接的度量距离，无需任何推理或估算。

1.1 飞行时间公式

d = (c × t) / 2

d = 距离（米），c = 光速（3×10⁸ m/s），t = 往返时间（秒）

t = 2d / c

重新排列：光传播到物体并返回所需的时间

示例：d=5m → t = (2×5) / (3×10⁸) = 33.3 ns

分辨率：1ps TDC → Δd = (3×10⁸ × 1×10⁻¹²) / 2 = 0.15 mm

这就是LiDAR能够实现毫米级精度的原因！

LiDAR硬件流程

1.2 LiDAR有分类吗？

是的，LiDAR的分类与RADAR一样根据维度区分，分为1D、2D和3D。"D"对应维度（Dimensions）。

1D LiDAR 由静止的激光束组成，在一个轴上计算障碍物与扫描器之间的距离，即一个维度。
2D LiDAR 由一束激光组成，带有旋转机制，收集到目标的水平距离数据，获取X和Y轴上的数据。
3D LiDAR 的原理相同，但多束激光垂直堆叠发射，获取X、Y和Z轴上的数据。每束激光与其它激光束之间有一个角度差。

1.3 架构

1.4 数据类型 — 原始硬件 → ROS 2消息

1.5 TF2变换树 — 坐标系

TF2是ROS 2的坐标变换系统。每个传感器和链接都有一个命名的坐标系（frame）。TF2知道每个坐标系的相对位置，可以自动将任何点从任何坐标系变换到任何其他坐标系——例如，摄像头坐标系中的检测结果 → 世界地图坐标系。

ROS 2 LiDAR命令

# ─── Essential ROS 2 LiDAR CLI commands ─────────────────────
# Start RPLIDAR driver
ros2 run rplidar_ros rplidar_composition \
  --ros-args -p serial_port:=/dev/ttyUSB0 \
             -p serial_baudrate:=256000
# See what's being published
ros2 topic list

# → /scan    (sensor_msgs/LaserScan)

# See actual scan data (ctrl+c to stop)
ros2 topic echo /scan --once

# Check publish rate (should be ~10 Hz)
ros2 topic hz /scan

# Visualize in RViz2 (best tool for LiDAR!)
rviz2

# Add → LaserScan → topic: /scan → style: Points → size: 0.02
# Record a bag file (save data for offline work)
ros2 bag record /scan /tf /odom -o my_lidar_session

# Replay bag file (test SLAM without physical robot)
ros2 bag play my_lidar_session --loop

# Run SLAM Toolbox (easiest 2D SLAM in ROS 2)
sudo apt install ros-humble-slam-toolbox
ros2 launch slam_toolbox online_async_launch.py

# Save the map when done exploring
ros2 service call /slam_toolbox/save_map \
  slam_toolbox/srv/SaveMap "{name: {data: 'my_map'}}"

# Load saved map for navigation (no re-mapping needed)
ros2 launch nav2_bringup bringup_launch.py \
  map:=my_map.yaml use_sim_time:=false

2、深度摄像头传感器

深度摄像头，也称为RGB-D（红-绿-蓝-深度）传感器，同时捕获彩色图像和逐像素深度信息，实现对环境的三维感知。与仅捕获3D世界的2D投影的传统摄像头不同，深度摄像头添加了关键的第三维度，使机器人能够理解到物体的距离、安全导航并构建周围环境的3D地图。

2.1 深度测量技术

2.2 飞行时间（ToF）

飞行时间摄像头通过计算发射光传播到物体并反射回传感器所需的时间来测量深度。这可以使用脉冲光（测量实际传播时间）或连续波调制（测量相位差）来实现。ToF摄像头在户外和变化的光照条件下特别有用，因为它们主动控制照明源。

2.3 立体视觉

立体视觉使用两个或多个相隔已知基线距离的摄像头来模拟人类双眼视觉。通过在左右图像中找到对应点并测量它们的视差（水平偏移），可以通过三角测量计算深度。立体视觉是被动的（不需要红外发射器）并在户外效果良好，但需要有纹理的表面才能进行可靠的匹配。

深度处理流程

点云生成：

点云生成将2D深度图转换为空间中的一组3D点。深度图像中的每个像素使用摄像头内参转换为3D坐标（X, Y, Z）。当与RGB数据结合时，每个点还有颜色信息（R, G, B），创建场景的彩色3D表示。

深度摄像头的ROS 2集成

深度摄像头主题结构

深度摄像头驱动代码

import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image, CameraInfo, PointCloud2, PointField
from std_msgs.msg import Header
import numpy as np
import struct
class DepthCameraPublisher(Node):
 def __init__(self):
 super().__init__('depth_camera_publisher')
 self.declare_parameter('camera_name', 'camera')
 self.declare_parameter('frame_id', 'camera_depth_optical_frame')

 self.camera_name = self.get_parameter('camera_name').value
 self.frame_id = self.get_parameter('frame_id').value

 self.rgb_pub = self.create_publisher(Image, f'/{self.camera_name}/rgb/image_raw', 10)
 self.depth_pub = self.create_publisher(Image, f'/{self.camera_name}/depth/image_raw', 10)
 self.pc_pub = self.create_publisher(PointCloud2, f'/{self.camera_name}/depth/points', 10)

 # Camera intrinsics
 self.fx, self.fy = 614.5, 614.5
 self.cx, self.cy = 319.5, 239.5
 self.depth_scale = 0.001

 self.timer = self.create_timer(0.033, self.publish_frames)

 def publish_frames(self):
 stamp = self.get_clock().now().to_msg()
 header = Header(stamp=stamp, frame_id=self.frame_id)

 # Capture from sensor (placeholder)
 rgb_image = self.capture_rgb()
 depth_image = self.capture_depth()

 # Publish RGB
 rgb_msg = self.create_image_msg(rgb_image, 'rgb8', header)
 self.rgb_pub.publish(rgb_msg)

 # Publish Depth
 depth_msg = self.create_image_msg(depth_image, '16UC1', header)
 self.depth_pub.publish(depth_msg)

 # Publish Point Cloud
 pc_msg = self.create_pointcloud(depth_image, rgb_image, header)
 self.pc_pub.publish(pc_msg)

 def create_image_msg(self, image, encoding, header):
 msg = Image()
 msg.header = header
 msg.height, msg.width = image.shape[:2]
 msg.encoding = encoding
 msg.is_bigendian = False
 msg.step = image.nbytes // msg.height
 msg.data = image.tobytes()
 return msg

 def create_pointcloud(self, depth, rgb, header):
 fields = [
 PointField(name='x', offset=0, datatype=PointField.FLOAT32, count=1),
 PointField(name='y', offset=4, datatype=PointField.FLOAT32, count=1),
 PointField(name='z', offset=8, datatype=PointField.FLOAT32, count=1),
 PointField(name='rgb', offset=12, datatype=PointField.FLOAT32, count=1)
 ]

 points = []
 for v in range(depth.shape[0]):
 for u in range(depth.shape[1]):
 z = depth[v, u] * self.depth_scale
 if z <= 0 or z > 10.0:
 continue
 x = (u - self.cx) * z / self.fx
 y = (v - self.cy) * z / self.fy
 r, g, b = rgb[v, u, 2], rgb[v, u, 1], rgb[v, u, 0]
 rgb_val = struct.unpack('f', struct.pack('I', (r<<16)|(g<<8)|b))[0]
 points.append(struct.pack('ffff', x, y, z, rgb_val))

 msg = PointCloud2()
 msg.header = header
 msg.height, msg.width = 1, len(points)
 msg.fields = fields
 msg.point_step = 16
 msg.row_step = 16 * len(points)
 msg.data = b''.join(points)
 return msg

 def capture_rgb(self):
 return np.zeros((480, 640, 3), dtype=np.uint8)

 def capture_depth(self):
 return np.zeros((480, 640), dtype=np.uint16)
def main(args=None):
 rclpy.init(args=args)
 node = DepthCameraPublisher()
 rclpy.spin(node)
 node.destroy_node()
 rclpy.shutdown()
if __name__ == '__main__':
 main()

3、结束语

总之，LiDAR提供精确的距离测量，IMU提供运动和姿态数据，深度摄像头提供密集的3D场景理解。当在ROS 2中使用TF2和适当的消息结构将它们融合在一起时，它们能够在机器人系统中实现强大的感知、SLAM和自主导航。

原文链接: About Sensors: Lidar, Depth Camera etc..

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

用 Gazebo 学习 ROS 2

admin — Tue, 21 Apr 2026 12:35:55 GMT

本文基于约翰霍普金斯大学"机器人学导论"课程中教授的机器人学之避障主题。我们将自定义一个ROS 2机器人并在Gazebo Ionic仿真环境中运行这个机器人。

1、基础（设置与启动）

在我们能够传递传感器数据或驱动机器人之前，我们需要让ROS 2和Gazebo Ionic无缝地一起启动。

两个不同的世界

ROS 2和Gazebo是完全独立的软件生态系统。

ROS 2使用一种名为DDS（数据分发服务）的中间件协议进行通信。
Gazebo Ionic使用自己的内部消息系统Gazebo Transport进行通信。

因为它们使用不同的语言，我们使用一个名为ros_gz的元包。这个包包含从ROS终端启动Gazebo的启动文件，以及在两者之间转换消息所需的桥接器。

以下是我们构建第一个集成启动文件的实践练习。

步骤1：安装集成包

首先，确保你已为特定的ROS 2发行版（例如Jazzy、Humble或Rolling）安装了ros_gz包。打开终端并运行：

sudo apt update
sudo apt install ros-jazzy-ros-gz

步骤2：创建启动文件

专业的ROS开发者不会从桌面手动打开Gazebo，而是直接从ROS 2 Python启动文件启动模拟器。

首先创建ROS 2包。

ros2 pkg create --build-type ament_python gazebo_control

创建一个名为gazebo_launch.py的新文件，并将以下代码粘贴到其中：

# launch/gazebo_launch.py
import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource

def generate_launch_description():
    # 1. Find the official ros_gz_sim package on your computer
    pkg_ros_gz_sim = get_package_share_directory('ros_gz_sim')
    # 2. Setup the IncludeLaunchDescription to trigger Gazebo
    gz_sim = IncludeLaunchDescription(
        PythonLaunchDescriptionSource(
            os.path.join(pkg_ros_gz_sim, 'launch', 'gz_sim.launch.py')
        ),
        # 3. Pass arguments to Gazebo: load an empty world and run immediately (-r)
        launch_arguments={'gz_args': 'empty.sdf -r'}.items(),
    )
    # 4. Return the LaunchDescription
    return LaunchDescription([
        gz_sim
    ])

步骤3：理解代码

让我们分解一下你刚才写的内容：

get_package_share_directory('ros_gz_sim')：动态查找官方ros_gz集成包在你硬盘上的位置。
IncludeLaunchDescription：这就像一个"盗梦空间"命令。它告诉你的自定义启动文件去触发一个完全不同的启动文件（Gazebo提供的gz_sim.launch.py）。
gz_args: 'empty.sdf -r'：这是传递给Gazebo的命令行参数。empty.sdf告诉它加载一个空白世界。-r标志至关重要——它告诉Gazebo按下"播放"并立即启动物理引擎。没有它，模拟会以暂停状态启动。

步骤4：执行启动

要测试我们的基础，打开终端，导航到保存文件的文件夹，并运行：

colcon build --packages-select gazebo_control
source install/setup.bash
ros2 launch gazebo_control gazebo_launch.py

如果一切配置正确，Gazebo Ionic GUI应该会弹出一个空白的3D世界，完全从ROS 2生态系统内部启动！

2、ros_gz_bridge和管理多个机器人

通用翻译器

目前，ROS 2和Gazebo就像两个坐在同一个房间里但说着完全不同语言的人。如果ROS 2使用geometry_msgs/msg/Twist消息大喊"向前开！"，Gazebo会忽略它，因为它只理解gz.msgs.Twist消息。

ros_gz_bridge就是我们的翻译器。要使用它，我们必须准确定义我们想要翻译的主题、消息类型是什么，以及翻译应该沿哪个方向进行。

标准语法如下：

/topic_name@ROS_2_Type[Direction]Gazebo_Type

方向括号：

]：从ROS 2翻译到Gazebo。
[：从Gazebo翻译到ROS 2。
==：双向翻译。

让我们亲自动手驱动机器人。

步骤1：启动机器人世界

首先，我们需要一个可以驾驶的机器人。Gazebo附带了一个默认的差速驱动车辆可以使用。关闭之前的Gazebo窗口（在该终端中使用Ctrl+C），改为运行：

ros2 launch ros_gz_sim gz_sim.launch.py gz_args:="diff_drive.sdf -r"

当Gazebo打开时，你会注意到一个有趣的事情： 有两个机器人！一个蓝色的和一个绿色的。

因为有两个独立的车辆，我们不能只向/cmd_vel主题发送一个通用的速度命令——Gazebo不知道哪个机器人应该移动。相反，Gazebo根据实体树中的模型名称为每个机器人分配一个特定的命名空间（例如，/model/vehicle_green/cmd_vel）。

步骤2：启动桥接器（ROS 2 -> Gazebo）

我们想从ROS 2向Gazebo中的机器人发送速度命令。机器人在/cmd_vel主题上监听。

打开第二个终端，source你的ROS 2环境，并使用蓝色车辆的特定命名空间运行桥接命令：

ros2 run ros_gz_bridge parameter_bridge \
  /model/vehicle_blue/cmd_vel@geometry_msgs/msg/Twist]gz.msgs.Twist

/model/vehicle_blue/cmd_vel：这是蓝色机器人的特定命名空间主题。
@geometry_msgs/msg/Twist：我们正在发送的标准ROS 2消息类型。
]：告诉桥接器将数据从ROS 2发送到Gazebo的方向括号。
gz.msgs.Twist：需要翻译成的Gazebo特定消息类型。

步骤3：驱动机器人！

现在是有趣的部分。打开第三个终端，source你的ROS 2环境，手动发布一个ROS 2 Twist消息告诉机器人向前行驶并转弯绕圈：

ros2 topic pub /model/vehicle_blue/cmd_vel \
  geometry_msgs/msg/Twist "{linear: {x: 1.0}, angular: {z: 0.5}}"

看看你的Gazebo窗口——蓝色车辆应该立即开始绕圈行驶！

步骤4：桥接数据回传（Gazebo -> ROS 2）

驾驶很好，但我们也需要从模拟器获取数据。最基本的数据是模拟时钟（它确保ROS 2算法与Gazebo的物理时间保持同步）。

在第二个终端中停止桥接器（Ctrl+C），让我们运行一个同时处理/model/vehicle_blue/cmd_vel（发送到Gazebo）和/clock（返回ROS 2）的新桥接器：

ros2 run ros_gz_bridge parameter_bridge \
/model/vehicle_blue/cmd_vel@geometry_msgs/msg/Twist]gz.msgs.Twist \
/clock@rosgraph_msgs/msg/Clock[gz.msgs.Clock

注意时钟的[括号，表示Gazebo正在向ROS 2发送数据。

为了证明它正在工作，转到你的第三个终端（用Ctrl+C停止发布命令）并回显时钟主题：

ros2 topic echo /clock

你应该看到连续的时间数据流从Gazebo物理引擎直接涌入你的ROS 2终端。

clock:
  sec: 527
  nanosec: 401000000
---
clock:
  sec: 527
  nanosec: 402000000
---
clock:
  sec: 527
  nanosec: 403000000

3、生成URDF（让机器人活起来）

在第2章中，我们学习了如何通过驾驶一些默认的预构建方块来与Gazebo通信。但模拟的目标不是驾驶通用形状——而是测试你特定的机器人设计。

在这里，我们遇到了一个经典的语言障碍。Gazebo原生使用SDF（仿真描述格式）文件构建其世界和机器人。然而，整个ROS 2生态系统依赖于URDF（统一机器人描述格式）文件。

ros_gz_sim包提供了一个出色的工具——create节点——而不是强迫你手动将URDF重写为SDF。它可以读取你的ROS 2 URDF并将其动态注入到运行中的Gazebo世界中。

让我们使用以下URDF文件进行此测试。

让我们编写一个启动文件来完成这个任务。

步骤1：启动文件架构

我们将创建一个名为spawn_robot.launch.py的新启动文件。这个文件需要同时完成三件事：

启动带空白世界的Gazebo。
启动ROS 2 robot_state_publisher（它读取你的basic_robot.urdf并将其物理结构广播到ROS网络）。
运行Gazebo的create节点来获取广播的结构并将其生成到3D物理引擎中。

步骤2：编写代码

在你的gazebo_control包中创建spawn_robot.launch.py文件并粘贴以下内容：

# launch/spawn_robot.launch.py
import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch_ros.actions import Node

def generate_launch_description():
    # 1. Paths to your package and the URDF file
    pkg_gazebo_control = get_package_share_directory('gazebo_control')
    pkg_ros_gz_sim = get_package_share_directory('ros_gz_sim')

    urdf_file = os.path.join(pkg_gazebo_control, 'urdf', 'basic_robot.urdf')
    with open(urdf_file, 'r') as infp:
        robot_desc = infp.read()

    # 2. Start Gazebo with an empty world
    gz_sim = IncludeLaunchDescription(
        PythonLaunchDescriptionSource(
            os.path.join(pkg_ros_gz_sim, 'launch', 'gz_sim.launch.py')
        ),
        launch_arguments={'gz_args': 'empty.sdf -r'}.items(),
    )

    # 3. Start the Robot State Publisher
    robot_state_publisher = Node(
        package='robot_state_publisher',
        executable='robot_state_publisher',
        name='robot_state_publisher',
        output='screen',
        parameters=[{
            'robot_description': robot_desc,
            'use_sim_time': True  # CRITICAL: Tells ROS to use Gazebo's clock!
        }]
    )

    # 4. The Spawner Node: Bridges URDF into Gazebo
    spawn_robot = Node(
        package='ros_gz_sim',
        executable='create',
        arguments=[
            '-topic', 'robot_description', 
            '-name', 'my_custom_diffdrive',
            '-z', '0.5'  # Drop it slightly above the ground
        ],
        output='screen'
    )
    return LaunchDescription([
        gz_sim,
        robot_state_publisher,
        spawn_robot
    ])

步骤3：理解`create`节点

仔细看上面代码的第4部分。来自ros_gz_sim的create可执行文件在这里承担了主要工作。让我们看看传递给它的参数：

-topic robot_description：告诉Gazebo，"嘿，不要在硬盘上找文件了。相反，监听ROS 2的/robot_description主题并构建你听到的内容。"
-name my_custom_diffdrive：为我们的机器人在Gazebo实体树中设置特定的命名空间。
-z 0.5：这是物理引擎的一个专业技巧。我们将机器人在空中生成0.1米，让它落到地面上。如果你正好在0.0处生成，车轮可能会穿入地面，导致物理引擎将你的机器人猛烈弹射到天空中！

步骤4：启动并验证

构建你的工作空间（colcon build），source你的终端，并运行新的启动文件：

colcon build --packages-select gazebo_control
source install/setup.bash
ros2 launch gazebo_control spawn_robot.launch.py

Gazebo应该会弹出。你应该能看到你的自定义差速驱动机器人——带有平坦底盘、蓝色左轮、红色右轮和绿色激光雷达穹顶——完美地坐在物理模拟器中！

4、传感器集成与RViz2可视化（给机器人眼睛）

在第3章中，我们成功将你的自定义URDF机器人放入了Gazebo物理引擎。它存在于世界中，但目前完全看不见。

机器人需要外感受传感器（如LiDAR或摄像头）来绘制环境地图并避障。在Gazebo中，我们通过将Gazebo插件附加到现有URDF链接来创建传感器。然后，我们使用ros_gz_bridge将丰富的传感器数据从物理引擎传输到ROS 2进行可视化和处理。

让我们把机器人上那个绿色的lidar_dome变成一个全功能的360度激光扫描器。

步骤1：在URDF中添加传感器插件

打开你的basic_robot.urdf文件。在文件最底部（紧邻最后的标签上方），粘贴这个块：

这做了什么：

reference="lidar_dome"：将虚拟传感器精确地附加到绿色球体所在的位置。
type="gpu_lidar"：告诉Gazebo使用计算机显卡计算激光射线，这比使用CPU快得多。
visualize="true"：将在Gazebo窗口内绘制蓝色激光射线，让你看到它们击中物体。
min/max_angle：-3.14到3.14弧度提供完整的360度扫描。

步骤2：添加仿真描述文件（SDF）

仿真描述格式（SDF）文件定义了你的机器人在Gazebo中模拟的环境（"世界"）。

虽然URDF（统一机器人描述格式）用于描述机器人本身（其链接、关节和传感器），但SDF用于描述模拟中其他所有内容。

以下是我的my_world.sdf供参考。



  
    
      0.001
      1.0
    
    
    
    
    
    
    
    
      ogre2
    

    
      
        
          3D View
          false
          docked
        
        ogre2
        scene
        0.4 0.4 0.4
        0.8 0.8 0.8
        -6 0 6 0 0.5 0
      

      
        
          floating
          5
          5
          false
        
      
      
        
          false
          5
          5
          floating
          false
        
      
      
        
          false
          5
          5
          floating
          false
        
      
      
        
          false
          5
          5
          floating
          false
        
      

      
      
    

    
      true
      0 0 10 0 0 0
      0.8 0.8 0.8 1
      0.2 0.2 0.2 1
      
        1000
        0.9
        0.01
        0.001
      
      -0.5 0.1 -0.9
    

    
      true
      
        
          
            
              0 0 1
              100 100
            
          
        
        
          
            
              0 0 1
              100 100
            
          
          
            0.8 0.8 0.8 1
            0.8 0.8 0.8 1
            0.8 0.8 0.8 1

以下是我们创建的my_world.sdf文件的详细解析：

1. 物理和核心系统

物理引擎：设置物理步长和实时因子，告诉Gazebo运行模拟的速度以及计算碰撞和重力的频率。
核心插件：加载必要的Gazebo插件，如gz-sim-physics-system（处理重力和碰撞）和gz-sim-scene-broadcaster-system（将3D数据发送到GUI供查看）。

2. 传感器系统（LiDAR修复）


 ogre2

Gazebo中默认的empty.sdf世界默认不加载传感器插件。没有这个插件，Gazebo会忽略你URDF中的标签，这就是为什么你的激光雷达最初没有发射射线的原因。这个块告诉Gazebo主动模拟摄像头和激光雷达等传感器。

3. GUI插件

定义Gazebo用户界面。加载3D视图、实体树和相机控制。关键的是，它包含了块，强制Gazebo GUI自动加载激光雷达可视化工具。

4. 环境（太阳和地面）

light（太阳）：创建一个方向光源，使世界不会漆黑一片并让物体投射阴影。
ground_plane模型：创建你的机器人行驶的平坦灰色网格地板。它包括visual（让你可以看到它）和collision（让机器人不会掉入虚空）。

总之，my_world.sdf是舞台、灯光和物理引擎，而你的basic_robot.urdf是在那个舞台上表演的演员！

步骤3：启动世界并添加障碍物

保存你的URDF并运行我们在第3章中构建的启动文件：

ros2 launch en613_control spawn_robot.launch.py

当Gazebo打开时，你现在应该能看到一个淡淡的蓝色激光环从你的机器人穹顶射出！

为了让数据更有趣，使用Gazebo顶部菜单栏（3D形状图标）在激光路径中直接投放几个方块或球体。

步骤4：桥接传感器数据（Gazebo -> ROS 2）

激光正在Gazebo中发射，但ROS 2毫不知情。我们需要桥接/scan主题。

打开第二个终端，source你的环境，运行桥接命令。注意我们使用的是[括号，因为数据从Gazebo流向ROS 2。

ros2 run ros_gz_bridge parameter_bridge /scan@sensor_msgs/msg/LaserScan[gz.msgs.LaserScan

步骤5：在RViz2中可视化

在Gazebo中看到蓝色线条很好，但自主算法不看Gazebo——它们看ROS 2数据。让我们使用RViz2证明数据已经成功通过桥接。

打开第三个终端并启动可视化器：

rviz2

配置RViz2查看激光：

在左侧的"Displays"面板中，将Fixed Frame更改为lidar_dome。
点击左下角的**"Add"**按钮。
选择**"By topic"**并双击/scan主题添加LaserScan显示。
在LaserScan显示设置中将"Size"参数增加到0.05，使点更容易看到。

你现在应该在RViz2中看到明亮的红点，形成了你放入Gazebo世界中的方块的精确轮廓！当你在Gazebo中移动方块时，RViz2中的红点将实时更新。

5、变换树（TF2）与让机器人动起来

在第4章中，我们通过添加LiDAR传感器给自定义机器人装上了"眼睛"。然而，它目前只是一个花哨的高科技雕像。它没有电机，更重要的是，ROS 2不知道机器人的物理部件如何运动。

Gazebo完美地处理物理，但RViz2（以及你的自主算法）依赖于TF2（变换）树。TF2是ROS 2的神经系统。它精确追踪chassis相对于世界（odom）的位置，以及车轮相对于chassis的精确位置。

让我们添加虚拟电机并连接这个神经系统！

步骤1：添加"肌肉"（差速驱动插件）

要让你的自定义URDF行驶，我们需要将差速驱动控制器附加到车轮上。

打开你的basic_robot.urdf文件。在底部，紧接LiDAR 块下方，添加这个新插件来定义电机：


    
      left_wheel_joint
      right_wheel_joint
      0.875
      0.4
      30
      cmd_vel
      odom
      odom
      chassis

这做了什么： 告诉Gazebo监听/cmd_vel主题并对left_wheel_joint和right_wheel_joint施加物理扭矩。它还自动计算机器人的里程计并发布连接世界（odom）和机器人（chassis）的主要TF（变换）。

步骤2：发布车轮角度（关节状态）

差速驱动插件移动机器人，但RViz2不会动画显示车轮旋转，除非它知道它们的确切角度。我们在差速驱动插件下方再添加一个快速插件：


    
      joint_states
      left_wheel_joint
      right_wheel_joint

这做了什么： 每当车轮在物理引擎中转动一度的几分之一时，这个插件都会将该关节角度广播到/joint_states主题。

步骤3：终极桥接

我们需要桥接三个关键内容：速度命令（进入）、关节状态（输出）和TF树（输出）。我们可以将ros_gz_bridge直接添加到我们的spawn_robot.launch.py文件中！

bridge = Node(
        package='ros_gz_bridge',
        executable='parameter_bridge',
        arguments=[
            '/cmd_vel@geometry_msgs/msg/Twist]gz.msgs.Twist',
            '/joint_states@sensor_msgs/msg/JointState[gz.msgs.Model',
            '/model/my_custom_diffdrive/tf@tf2_msgs/msg/TFMessage[gz.msgs.Pose_V',
            '/scan@sensor_msgs/msg/LaserScan[gz.msgs.LaserScan'
        ],
        remappings=[
            ('/model/my_custom_diffdrive/tf', '/tf')
        ],
        output='screen'
    )

这更加方便，因为现在单个启动命令将启动Gazebo、生成机器人、启动机器人状态发布器，并为所有主题（cmd_vel、joint_states、tf和scan）启动桥接器。

注意：我们还需要正确的重映射，以便Gazebo的/model/my_custom_diffdrive/tf被转换为RViz期望的标准ROS 2 /tf主题。

关闭所有正在运行的终端，重新构建并启动你的世界：

ros2 launch gazebo_control spawn_robot.launch.py

步骤4：驾驶和可视化！

打开第二个终端并启动RViz2：

rviz2

配置RViz2：

更改Fixed Frame

将Fixed Frame更改为odom（现在我们有了TF桥接器运行，这将完美运行！）。

添加RobotModel显示

默认情况下，RViz尝试从参数读取机器人描述，但我们的启动文件将其发布到主题。以下是在RViz中修复的方法：

展开左侧面板中的RobotModel显示。
找到名为Description Source的属性。
将其从Topic更改为Topic（如果还不是的话）。
找到名为Description Topic的属性。
点击旁边的空框并输入/robot_description（或从下拉菜单中选择）。

添加LaserScan

添加一个LaserScan显示（主题/scan）。

你将在RViz中看到机器人。

最后，打开第三个终端并发布驾驶命令：

ros2 topic pub /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 1.0}, angular: {z: 0.5}}"

注意：要停止机器人，运行以下命令。

ros2 topic pub /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.0}, angular: {z: 0.0}}"

看看RViz2。你不仅应该看到LiDAR数据在更新，而且你还会看到URDF上的车轮在odom坐标系中精确地旋转，同时机器人绕圈行驶，完美地镜像了Gazebo物理窗口中发生的事情！

你将在Gazebo中看到以下内容，即机器人将会移动。

步骤5：使用TeleopTwistKeyboard控制机器人

teleop_twist_keyboard是在ROS 2中使用键盘控制机器人的标准且最简单的方法。

由于我们已经在使用/cmd_vel主题，它将开箱即用，因为teleop_twist_keyboard默认发布到/cmd_vel。

使用方法：

1. 运行Teleop节点打开一个新终端（确保已source你的ROS 2安装）并运行：

ros2 run teleop_twist_keyboard teleop_twist_keyboard

如果需要安装此包：

sudo apt install ros-jazzy-teleop-twist-keyboard

2. 如何控制机器人节点运行后，确保你的终端窗口处于聚焦/活动状态。你可以使用以下按键移动机器人：

i：前进
,：后退
j：左转
l：右转
k：停止

调整速度：

q / z：增加/减少最大速度10%
w / x：仅增加/减少线速度10%
e / c：仅增加/减少角速度10%

6、优化（组合与YAML桥接）

如果你跟着第5章操作，你可能注意到了一个明显的问题：终端疲劳。

要让我们的机器人完全运行，有时我们需要打开几个独立的终端——一个启动模拟、一个桥接传感器、另一个桥接速度和TF数据，还有一个用于RViz2。在专业的机器人环境中，依赖人类输入大量多行终端命令而不出拼写错误是灾难的根源。

生产系统通过使用YAML配置文件并将所有内容打包到单个自动化启动文件来解决这个问题。我们在第5章中已经应用了一些清理，让我们进一步改进。

步骤1：YAML配置文件

与其在终端中使用神秘的括号（]、[），ros_gz_bridge可以读取一个干净、易读的YAML文件来精确定义数据应该如何在两个生态系统之间流动。

在你的gazebo_control包中，创建一个名为config的新文件夹。在该文件夹中，创建一个名为bridge_config.yaml的文件并粘贴以下内容：

# bridge_config.yaml
# 1. Drive Commands (ROS 2 to Gazebo)
- ros_topic_name: "/cmd_vel"
  gz_topic_name: "/cmd_vel"
  ros_type_name: "geometry_msgs/msg/Twist"
  gz_type_name: "gz.msgs.Twist"
  direction: ROS_TO_GZ
# 2. LiDAR Sensor Data (Gazebo to ROS 2)
- ros_topic_name: "/scan"
  gz_topic_name: "/scan"
  ros_type_name: "sensor_msgs/msg/LaserScan"
  gz_type_name: "gz.msgs.LaserScan"
  direction: GZ_TO_ROS
# 3. Joint States for Wheels (Gazebo to ROS 2)
- ros_topic_name: "/joint_states"
  gz_topic_name: "/joint_states"
  ros_type_name: "sensor_msgs/msg/JointState"
  gz_type_name: "gz.msgs.Model"
  direction: GZ_TO_ROS
# 4. Transform Tree / TF2 (Gazebo to ROS 2)
- ros_topic_name: "/tf"
  gz_topic_name: "/model/my_custom_diffdrive/tf"
  ros_type_name: "tf2_msgs/msg/TFMessage"
  gz_type_name: "gz.msgs.Pose_V"
  direction: GZ_TO_ROS
# 5. Simulation Clock (Gazebo to ROS 2)
- ros_topic_name: "/clock"
  gz_topic_name: "/clock"
  ros_type_name: "rosgraph_msgs/msg/Clock"
  gz_type_name: "gz.msgs.Clock"
  direction: GZ_TO_ROS

看这有多容易阅读！如果你以后添加新传感器（比如摄像头），只需在这个文件中追加一个新块。

步骤2："一键"启动文件

现在，让我们更新spawn_robot.launch.py来自动加载这个YAML文件并为我们启动桥接节点。

我们需要在现有Python启动文件中添加两样东西：YAML文件的路径和桥接节点本身。以下是直接在spawn_robot节点下方添加的代码：

# Find the config file path
    bridge_params = os.path.join(
        pkg_en613_control,
        'config',
        'bridge_config.yaml'
    )
# 5. Start the Bridge Node using the YAML file
    gz_bridge = Node(
        package='ros_gz_bridge',
        executable='parameter_bridge',
        parameters=[{
            'config_file': bridge_params,
            'use_sim_time': True
        }],
        output='screen'
    )

（不要忘记将gz_bridge添加到文件底部的LaunchDescription数组中！）

步骤3：测试优化后的系统

因为我们添加了新的config文件夹，你需要更新CMakeLists.txt或setup.py以确保config文件夹在构建时被安装，然后运行colcon build。

现在，见证真相的时刻。打开一个终端并运行：

ros2 launch en613_control spawn_robot.launch.py

会发生什么？ 只需一个命令，你的计算机就会启动Gazebo物理引擎、读取你的自定义URDF、将机器人生成到3D世界中、使用YAML配置建立五个不同数据流的双向桥接，并开始主动将TF树和传感器数据广播到ROS 2网络的其余部分。

打开RViz2，在机器人前面放一个方块，并发布/cmd_vel消息。一切都会完美运行，你不再有充满终端窗口的杂乱桌面！

7、命令机器人前往在RVIZ中选择的目标点

让我们添加PID控制器节点

import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist, PoseStamped
from tf2_ros import Buffer, TransformListener
import math

class DiffDrivePID(Node):
    def __init__(self):
        super().__init__('diffdrive_pid')

        self.tf_buffer = Buffer()
        self.tf_listener = TransformListener(self.tf_buffer, self)

        self.goal_sub = self.create_subscription(
            PoseStamped,
            '/goal_pose',
            self.goal_callback,
            10
        )

        self.cmd_vel_pub = self.create_publisher(
            Twist,
            '/cmd_vel',
            10
        )

        self.timer = self.create_timer(1.0 / 30.0, self.timer_callback)

        self.goal_x = None
        self.goal_y = None
        self.goal_theta = None

        self.prev_x = None
        self.prev_y = None
        self.prev_theta = None
        self.prev_time = None

        # PD Gains
        self.kp_v = 1.0
        self.kd_v = 0.2
        self.kp_omega = 2.0
        self.kd_omega = 0.2

        self.get_logger().info('DiffDrive PID Controller Node started.')

    def goal_callback(self, msg):
        self.goal_x = msg.pose.position.x
        self.goal_y = msg.pose.position.y

        q = msg.pose.orientation
        siny_cosp = 2 * (q.w * q.z + q.x * q.y)
        cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z)
        self.goal_theta = math.atan2(siny_cosp, cosy_cosp)

        self.get_logger().info(f'New goal received: x={self.goal_x:.2f}, y={self.goal_y:.2f}, theta={self.goal_theta:.2f}')

    def timer_callback(self):
        if self.goal_x is None:
            return

        try:
            t = self.tf_buffer.lookup_transform('odom', 'chassis', rclpy.time.Time())
        except Exception as e:
            return

        current_time = self.get_clock().now()

        current_x = t.transform.translation.x
        current_y = t.transform.translation.y
        q = t.transform.rotation

        siny_cosp = 2 * (q.w * q.z + q.x * q.y)
        cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z)
        current_theta = math.atan2(siny_cosp, cosy_cosp)

        if self.prev_time is None:
            self.prev_x = current_x
            self.prev_y = current_y
            self.prev_theta = current_theta
            self.prev_time = current_time
            return

        dt = (current_time - self.prev_time).nanoseconds / 1e9
        if dt <= 0:
            return

        dx_robot = current_x - self.prev_x
        dy_robot = current_y - self.prev_y
        dtheta_robot = current_theta - self.prev_theta
        dtheta_robot = math.atan2(math.sin(dtheta_robot), math.cos(dtheta_robot))

        current_v = (dx_robot * math.cos(current_theta) + dy_robot * math.sin(current_theta)) / dt
        current_omega = dtheta_robot / dt

        dx_goal = self.goal_x - current_x
        dy_goal = self.goal_y - current_y
        distance_error = math.sqrt(dx_goal**2 + dy_goal**2)

        angle_to_goal = math.atan2(dy_goal, dx_goal)
        heading_error = angle_to_goal - current_theta
        heading_error = math.atan2(math.sin(heading_error), math.cos(heading_error))

        if distance_error < 0.05:
            distance_error = 0.0
            heading_error = self.goal_theta - current_theta
            heading_error = math.atan2(math.sin(heading_error), math.cos(heading_error))

        v_cmd = self.kp_v * distance_error - self.kd_v * current_v
        omega_cmd = self.kp_omega * heading_error - self.kd_omega * current_omega

        v_cmd = max(min(v_cmd, 1.0), -1.0)
        omega_cmd = max(min(omega_cmd, 2.0), -2.0)

        if distance_error < 0.05 and abs(heading_error) < 0.05:
            v_cmd = 0.0
            omega_cmd = 0.0
            self.goal_x = None
            self.get_logger().info('Goal reached!')

        twist = Twist()
        twist.linear.x = float(v_cmd)
        twist.angular.z = float(omega_cmd)
        self.cmd_vel_pub.publish(twist)

        self.prev_x = current_x
        self.prev_y = current_y
        self.prev_theta = current_theta
        self.prev_time = current_time

def main(args=None):
    rclpy.init(args=args)
    node = DiffDrivePID()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

使用PID控制器的步骤：

1. 启动模拟在我们的第一个终端中，像之前一样启动Gazebo模拟和RViz：

ros2 launch gazebo_control spawn_robot.launch.py

2. 运行PID控制器打开一个新终端，source你的工作空间，运行PID节点：

source /opt/ros/jazzy/setup.bash
source /home/ubuntu/gazebo/install/setup.bash
ros2 run gazebo_control diffdrive_pid

3. 在RViz中命令机器人

转到你的RViz窗口。
在顶部工具栏中，点击"2D Goal Pose"按钮（看起来像一个绿色箭头）。
在RViz中的网格上点击任意位置并拖动以设置机器人的目标位置和方向（航向）。
观察机器人在Gazebo中移动到目标位置！PID控制器会自动计算必要的速度并在机器人到达目的地时停止。

如何避免在单独的终端中运行PID节点？

bridge_config.yaml文件专门用于在Gazebo和ROS 2之间桥接数据，所以我们不能把PID控制器放在里面。

然而，我们有更好的解决方案！我们可以直接将PID控制器添加到spawn_robot.launch.py文件中并重新构建包。

现在，当我们运行：

ros2 launch gazebo_control spawn_robot.launch.py

它将自动同时在一个终端中启动Gazebo、RViz、bridge和PID控制器！

为什么Gazebo中的机器人与RViz中的最终位置不完全一致？

是的，这完全正常！你所看到的是机器人学中一个叫做里程计漂移的基本概念。

以下是Gazebo中的机器人（"真实"世界）最终位置与RViz（"机器人大脑"）认为的位置略有不同的确切原因：

1. PID控制器如何工作当我们在RViz中点击"2D Goal Pose"时，我们告诉PID控制器："移动到相对于起始点（odom）的坐标(X, Y)。"PID控制器然后查看机器人在odom坐标系中的当前位置并计算车轮需要多快旋转才能到达目标。

2. 问题：车轮打滑Gazebo是一个物理模拟器。当机器人转弯或加速时，车轮可能会在地面上轻微打滑。然而，odom坐标系（RViz用来绘制机器人的）纯粹通过计算车轮旋转了多少次来计算。

Gazebo："车轮转了10圈，但打滑了一点，所以机器人移动了9.5米。"
里程计（odom）："车轮转了10圈，所以机器人一定精确移动了10.0米。"

3. 结果由于这种打滑，机器人对自己位置的认知（RViz）慢慢偏离了其实际物理位置（Gazebo）。PID控制器成功地将机器人驱动到它认为目标所在的位置（在RViz中），但由于其内部地图略有偏移，Gazebo中的物理机器人最终位置略有偏差。

真正的机器人如何解决这个问题？为了解决这个问题，真正的机器人使用LiDAR或摄像头等传感器观察环境并纠正其里程计漂移。这被称为定位（如AMCL算法）。

当机器人使用定位时，它会创建一个名为map的新坐标系。map坐标系代表世界的真实绝对位置，机器人不断纠正odom坐标系以与之对齐。

由于我们的机器人目前仅依赖车轮编码器（odom）且还没有运行定位算法，两个窗口之间的轻微漂移是完全正常的，并证明了我们的物理模拟运行得很逼真！

为什么Gazebo中的机器人方向与RViz中的相反？

是的，这也是正常的，原因在于两个不同工具中坐标系的视觉表示方式！

ROS 2标准（右手定则）Gazebo和RViz都使用完全相同的数学坐标系（标准ROS 2右手定则）：

X轴（红色）：前方
Y轴（绿色）：左方
Z轴（蓝色）：上方

视觉差异混淆来自于我们首次打开窗口时的默认相机角度：

RViz（俯视图）：默认情况下，RViz从天空直视下方。

X轴（红色）指向屏幕的右侧。
Y轴（绿色）指向屏幕的顶部。
所以，如果我们告诉机器人"向下"移动，我们是在告诉它沿负Y方向移动。

Gazebo（3D透视图）：Gazebo通常以一个角度打开。根据生成时相机的旋转方式：

X轴（红色）可能指向屏幕的"上方"或"远离你"。
Y轴（绿色）可能指向"左方"或"右方"。

如何证明它们实际上是匹配的：要看到它们实际上在做完全相同的事情，我们需要对齐我们的相机：

查看RViz中的网格。找到红线（X轴）和绿线（Y轴）。
转到Gazebo并旋转你的相机，使你从正上方俯视机器人。
旋转Gazebo相机，直到地面上的红线和绿线与RViz中的方向完全一致（红色指向右，绿色指向上）。

现在，如果你在RViz中点击"向下"，你会看到机器人在Gazebo中也"向下"移动！机器人并不是反向移动；你只是从两个不同的角度在观察它。

8、结束语

你已经成功将自定义ROS 2机器人迁移到Gazebo Ionic仿真环境中。你学会了如何建模物理属性、转换原生数据流、配置虚拟传感器、映射运动学变换树以及编写生产级启动系统。完整代码请参考这里。

仿真世界现在就是你的游乐场。祝你构建愉快！

原文链接: Robotics# Gazebo with Ros2

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

LiDAR 工作原理解读

admin — Tue, 21 Apr 2026 07:32:32 GMT

LiDAR，全称为光探测与测距（Light Detection and Ranging），是一种利用激光测量距离的遥感技术。其基本原理是向目标发射激光脉冲，然后测量光从目标表面反射后返回所需的时间。这一过程使LiDAR能够创建高精度的三维环境地图。

这项技术非常多功能，自1960年代就已经存在，尽管近年来其应用范围已大幅扩展。 LiDAR系统被广泛应用于地理、林业、自动驾驶和考古等多个行业。

在深入本指南之前—— 你脑海中一定有这样一个问题——LiDAR和激光扫描是同一种技术吗？ 这是很多人问的问题，大多数人认为它们是相同的，但信不信由你，它们并不一样。本文将指导你了解LiDAR和激光之间的区别

LiDAR系统收集的数据可用于详细分析、地图制作和建模，使其成为理解和与物理世界交互的关键工具。

1、LiDAR的工作原理

要充分理解LiDAR，了解其工作原理至关重要。 LiDAR系统的核心由激光器、扫描器和专用GPS接收器组成。

以下是LiDAR工作流程的逐步解析：

激光脉冲发射：LiDAR设备向目标区域快速发射激光脉冲。这些脉冲通常位于电磁波谱的近红外范围内，每秒可发射数千到数百万个脉冲。
激光脉冲反射：当这些激光脉冲击中物体或表面（如地面、树木或建筑物）时，它们会反射回LiDAR传感器。系统会记录脉冲返回所需的时间。
距离测量：LiDAR系统根据激光脉冲返回所需的时间计算自身与目标之间的距离。此计算利用光速进行，使系统能够以惊人的精度测量距离。
数据点生成：每个反射的激光脉冲代表三维空间中的一个数据点，也称为"点云"。当数百万个这样的点组合在一起时，它们就形成了被测区域的高精度地图或3D模型。
数据处理与分析：收集点云数据后，专用软件会对信息进行处理和分析，以创建精确的地形图、模型或模拟。

2、LiDAR的类型

LiDAR技术可根据其平台、应用和操作模式分为多种类型。最常见的分类包括：

2.1 机载LiDAR

机载LiDAR安装在飞行器上，如直升机或无人机，主要用于大面积区域测量。它可以进一步分为两个子类型：

地形LiDAR：这种类型用于测绘地表。它使用近红外激光，非常适合地形建模、城市规划和洪涝区域测绘等应用。
水深LiDAR：专为水下应用设计，水深LiDAR使用可以穿透水体的绿色激光束，适用于测绘河床、沿海地区和水下环境。

2.2 地面LiDAR

来源：space.fmi.fi

地面LiDAR系统是基于地面的，用于收集详细的近距离数据。主要有两种类型：

移动LiDAR：安装在车辆上，移动LiDAR系统用于测绘道路、基础设施和城市环境。它们在创建高分辨率3D模型方面特别有价值，可用于交通规划、建筑和自动驾驶导航。
静态LiDAR：这些系统是固定的，用于对特定区域或物体进行详细扫描。静态LiDAR常用于建筑、考古和法医学，以创建建筑物、结构或考古遗址的精确3D模型。

2.3 星载LiDAR

来源：researchgate.net

星载LiDAR安装在卫星上，用于大规模地球观测。 这种类型的LiDAR由于在太空部署此类系统面临挑战而较为罕见，但在全球测绘、气候监测和环境研究方面具有不可替代的价值。

3、LiDAR的应用

凭借其提供准确、高分辨率数据的能力，LiDAR技术在多个行业有着广泛的应用。主要应用包括：

3.1 环境监测与管理

LiDAR被广泛用于环境科学中的植被监测、森林结构分析和土地利用变化追踪。它有助于评估森林生物量、测绘沿海区域以及追踪地球表面随时间的变化，使其成为环境保护和管理的重要工具。

3.2 城市规划与基础设施发展

在城市区域，LiDAR用于城市规划、基础设施开发和建筑。它提供详细的地形图，帮助规划者设计高效的排水系统、交通网络和可持续的城市景观。

LiDAR还用于监测和维护基础设施，如桥梁和道路，通过检测变形或结构薄弱点。

3.3 自动驾驶汽车

LiDAR最引人注目的应用之一是在自动驾驶汽车的开发中。LiDAR传感器用于创建车辆周围环境的3D地图，使汽车能够检测和避开障碍物、行人和其他车辆。

这种实时建图能力对于自动驾驶汽车的安全高效运行至关重要。

3.4 考古与文化遗产

来源：nationalgeographic.org

考古学家使用LiDAR来发现肉眼看不见的古代建筑和景观。通过扫描茂密的森林或其他植被覆盖区域，LiDAR可以揭示隐藏的废墟、古代道路网络和其他考古遗址，为了解过去的文明提供宝贵的见解。

3.5 农业

在农业中，LiDAR 用于精准农业，提供作物健康状况、土壤条件和地形数据。 农民可以利用这些信息优化灌溉、施肥和收割，从而提高产量并实现更可持续的农业实践。

4、LiDAR的未来

随着技术的不断进步不断扩展其能力和应用，LiDAR技术的未来充满前景。以下是一些值得关注的发展趋势：

1. 与其他技术的融合

LiDAR正越来越多地与人工智能（AI）、机器学习和摄影测量等其他技术融合。这些融合使更复杂的数据分析和增强的自动化成为可能，在机器人、智慧城市和灾害管理等领域开辟了新的可能性。

2. 小型化和成本降低

随着技术的进步，LiDAR系统正变得更小、更实惠、更易于部署。这种小型化和成本降低可能会推动其在消费电子、移动设备和个人无人机中的更广泛应用，使LiDAR技术更加普及。

3. 更高的分辨率和精度

未来的LiDAR系统预计将提供更高的分辨率和精度，实现更详细和精确的测绘和建模。这一改进将在需要精细数据的应用中特别有益，如生物医学研究、城市规划和环境监测。

4. 太空探索的扩展

航天机构和研究机构正在探索将LiDAR用于太空探索。LiDAR可以在测绘其他行星表面、引导自主探测车，甚至帮助确定未来载人任务的潜在着陆点方面发挥关键作用。

5、结束语

LiDAR是一项强大的技术，已经改变了我们理解和与周围世界互动的方式。从测绘地形到导航自动驾驶汽车，其应用广泛而多样。随着技术的不断发展，我们可以期待更多创新用途和进步，进一步巩固LiDAR在塑造我们未来中的作用。

6、常见问题

1. LiDAR代表什么？

LiDAR代表光探测与测距（Light Detection and Ranging）。它是一种利用激光测量距离并创建详细三维地图的遥感方法。

2. LiDAR与雷达有什么区别？

虽然LiDAR和雷达都是遥感技术，但LiDAR使用激光测量距离，而雷达使用无线电波。LiDAR提供更高分辨率的数据，使其适合详细的地图制作和建模。

3. LiDAR能穿透物体吗？

LiDAR不能穿透固体物体，但可以穿透一些半透明材料，如水或树叶，具体取决于所用激光的波长。

4. LiDAR对人体安全吗？

是的，LiDAR通常对人体安全。大多数LiDAR系统中使用的激光功率较低，工作在不对人眼或皮肤有害的波长范围内。

5. LiDAR有多精确？

LiDAR可以提供高度精确的测量，精度通常可达几厘米或更高，具体取决于系统和应用。这种精度使其非常适合需要详细空间数据的应用，如工程、测量和自动驾驶汽车。

原文链接: What is LiDAR | Types, Application & How it Work?

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

10个Nano Banana资产生成技巧

admin — Sat, 18 Apr 2026 11:32:01 GMT

如果你最近在X（前Twitter）或Reddit上活跃过，你可能看到过 "Nano Banana"这个术语。这个最初作为谷歌隐藏图像生成测试的病毒式昵称（官方名称为Gemini 2.5 Flash Image，现称Gemini 3 Pro Image），已经演变为专业创作者的强大工具。

与经常在"扭曲的手指"或乱码文字上挣扎的旧扩散模型不同，Nano Banana模型——特别是 Pro（Thinking）版本——有着本质的区别。它们不只是喷涂像素，而是对你的提示词进行推理。

无论你是需要一致的等距精灵图的游戏开发者、制作演示文稿的营销人员，还是寻求快速构思的设计师，这里有10个专业技巧帮助你掌握Nano Banana高质量资产生成。

1. "品牌圣经"参考技巧

AI资产生产中最困难的事情之一就是保持"调性"一致。Nano Banana Pro允许你上传最多14张参考图片。不要只是上传随机灵感——上传一套"品牌圣经"。

与其每次都描述"极简蓝色矢量艺术"，不如截取你的配色方案、排版规则和三张目标艺术风格的示例。将这些作为你的参考集上传。

提示词策略：

"将上传的参考图片作为严格的风格指南，生成一个新的'设置'菜单图标。遵循图片1的配色方案和图片2的线宽风格。"

为什么有效： 模型有效地利用"视觉上下文"，将你的上传视为约束条件而非仅仅是建议。

2. 掌握"文本优先"构图

大多数AI模型将文本视为事后补充。Nano Banana Pro在这方面表现出色，但前提是你需要正确排列提示词顺序。要获得干净、可编辑的文本资产（如UI按钮或海报），请先提示文本布局，再描述视觉元素。

试试这个结构：

画布： "一张16:9营销横幅。"
排版： "居中大号粗体无衬线文字，内容为'SUMMER SALE'。"
视觉： "周围环绕3D渲染的热带水果，柔和灯光，4K分辨率。"

专业技巧： 如果文字稍有偏差，不要重新生成整张图片。使用局部重绘编辑器只框选文字区域，然后输入："修正拼写为'SUMMER SALE'。"

3. 用于产品资产的"Knolling"技巧

"Knolling"是将物体以90度角排列的艺术。这是创建游戏库存物品或电商情绪板的作弊代码。

Nano Banana对空间关系有很高的理解能力。通过要求"Knolling布局"，你可以获得清晰分离的资产，之后很容易单独裁剪。

提示词：

"赛博朋克生存套件的knolling摄影布局。包括：未来风格医疗包、霓虹能量饮料和数字指南针。白色背景，影棚灯光，俯视图。物体之间高度分离。"

4. 用真实世界数据为资产奠定基础

Nano Banana架构的独特之处在于它连接了Google搜索。你可以利用这一点生成在事实或文化上准确的资产，而无需描述每个细节。

如果你正在为设定在1920年代东京的游戏创建环境资产，你不需要猜测建筑风格。

提示词：

"为设定在1920年代东京（大正时代）的视觉小说生成街道纹理背景。搜索该年份准确的时期建筑细节、招牌风格和服装。动漫背景风格，新海诚光影。"

模型会在生成之前"研究"视觉元素，为你节省数小时的参考资料搜索时间。

5. 锁定角色一致性

"Nano Banana"热潮始于3D手办，但它真正的力量在于身份锁定。要生成在每张图中都看起来相同的游戏角色或吉祥物，你需要定义它们的"锚定特征"。

分步操作：

在中性背景上生成你的基础角色。
在对话上下文中给它起个名字（例如，"这是Agent K"）。
要求生成"角色设定表"："为Agent K生成一个显示正面、侧面和背面视图的角色设定表。"
后续资产中，引用名字："展示Agent K在雨巷中奔跑的场景。"

优化方法： 如果面部出现偏差，将原始生成图作为新提示词的参考图片上传。

6. 用于3D原型制作的"手办"风格

即使你不是在做玩具，那个走红的"3D手办"提示词在创建3D建模参考方面也非常出色。它迫使AI比标准"插画"提示词更好地理解体积、材质和光照。

黄金提示词：

"一个[你的角色]的1/7比例商业手办。塑料质感，逼真的影棚灯光，中性灰色背景。手办放置在转盘底座上。"

将这些结果交给3D建模师，作为几何形状和纹理的完美参考。

7. 零样本等距游戏资产

Nano Banana在等距几何方面出人意料地擅长，使其非常适合策略游戏或城市建造游戏。关键是指定投影角度，以确保它们能在瓦片地图上无缝拼接。

提示词：

"一个科幻发电站的等距瓦片。30度等距投影。透明背景。矢量游戏美术风格。清晰的边缘，无模糊。"

8. 用"Fast"迭代 -> 用"Thinking"定稿

谷歌提供两个版本的模型：Nano Banana（Fast）和Nano Banana Pro（Thinking）。不要把每日的Pro额度浪费在头脑风暴上。

工作流程：

使用Fast模型快速生成20种不同的构图方案。它快速且成本低。
选出最佳方案。
切换到**Thinking（Pro）**模型。
将"Fast"结果作为参考上传，并提示："以高保真纹理、4K分辨率和光线追踪光照重新演绎这个构图。"

这为你节省了额度和时间，同时确保最终资产达到生产级质量。

9. 创建"Alpha就绪"纹理

对于3D艺术家来说，创建无缝纹理是一件痛苦的事。如果你明确要求平铺的数学属性，Nano Banana可以生成"可平铺"的纹理。

提示词：

"一张无缝、可平铺的苔藓鹅卵石纹理。俯视图，平面光照（反照率贴图），无阴影，高频细节。2048x2048分辨率。"

专业技巧： 虽然它比大多数模型更好地处理"无缝"请求，但始终要在Photoshop中使用"位移"滤镜检查边缘，以确保完美循环。

10. "UI模型"反馈循环

最后，使用Nano Banana来原型化整个用户界面。因为它理解文本和布局，你可以描述一个仪表板并获得可用的线框图。

提示词：

"一个植物浇水追踪器的移动应用UI设计。现代、简洁、绿白配色方案。屏幕1：带图表的仪表板。屏幕2：相机扫描模式。高保真模型。"

生成后，你可以在Figma中切割这些图片，为客户快速创建情绪板，然后再投入编码。

11、结束语：它是工具，不是魔法棒

"Nano Banana"生态系统已经快速成熟。它不再只是一个用于搞笑自拍的表情包生成器；它是资产生产流程中的合法组成部分。获胜的创作者不会是那些输入单词提示词的人，而是那些像对待初级设计师一样对待AI的人——给它清晰的需求简报、参考图片和具体的约束条件。

今天就开始尝试Thinking模型，让你的资产生产工作流程提速10倍。

原文链接: 10 Pro Nano Banana Tips for High-Quality Asset Production

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

Nano Banana如何制作重复图案

admin — Sat, 18 Apr 2026 11:22:27 GMT

我的爱好之一是参加按需印刷网站Spoonflower上发布的设计挑战赛。每两周会有一个新的主题和提示。参赛艺术家需要提交与主题对应的重复图案（即表面图案）。获胜者可以获得曝光和现金奖励。但比潜在奖品更重要的是，这些挑战赛创造了截止日期和结构，帮助我真正去练习创作。和所有按需印刷网站一样，Spoonflower上充斥着大量设计。如果你已经有一个可以引导到店铺的受众群体，你在Spoonflower上获得收入的可能性会大得多。虽然我还没有认真尝试将这个爱好变现（我可能也不应该这样做），但我一直在努力维持一个Instagram账号来分享我的作品。然而，我发现在完成一个设计之后，额外的内容创作、文案撰写、发布等步骤显得极其繁琐。我感到很沮丧，因为我在一遍又一遍地创建同样的帖子——一张带有我账号的静态设计图片。这正是效果图的用途所在——一种无需购买几码布料并缝制裙子就能让你的设计生动呈现的方式。Spoonflower也制作效果图，但它们风格重复、不可下载，而且非常容易被认出是"Spoonflower效果图"。我目前也没有时间和材料来制作自己的效果图模板。

与此同时，我也在学习更多关于AI代理的知识。我从图书馆借了Ben Auffarth和Leonid Kuligin的《Generative AI with LangChain》（老派做法），这变成了一个小项目！当我开始这个项目时，Gemini的免费版包含对Nano Banana的API访问。遗憾的是现在已不再如此。

我期望的输出：

三种不同的效果图供选择（壁纸、服装和家居装饰）
每张效果图配一段适合Instagram的文案

最初，我还想实现内容的自动发布。这是在我研究Instagram API之前（哎）。所以目前我们只是将内容保存到Google Drive。

我的输入：

图案的基本单元块
设计挑战赛的主题和提示，提供有用的上下文
我之前写的一些Instagram文案，帮助确定语调

在编写任何代码之前，我在Nano Banana和ChatGPT的UI中尝试了不同的提示词和输入。

当我把单个瓦片给LLM并让它重复时，效果图画得不太好。LLM在保持图案的细节和准确性方面有很大的困难，即使我尝试通过提示词来保持图案的一致性。Nano Banana的照片编辑能力在发布时受到了赞誉，所以我认为它可能配备了某种编辑工具来处理像重复图案这样简单的任务。因此，我不是传入单个瓦片，而是先用PIL将其重复多次生成一张图片，然后将它作为LLM的输入。比较Gemini和ChatGPT的输出，我确实更喜欢ChatGPT的图片，因为它们看起来更逼真。

左：Nano Banana尝试平铺我的基本图案（还行，不算太糟）。右：使用PIL预先平铺重复图案后Nano Banana生成的效果图。

1、开始吧！

安装langchain_google_genai库。在Colab中运行，我挂载了Google Drive用于存储，并使用Colab的密钥管理器传入Google API密钥。

pip install langchain_google_genai
from google.colab import userdata
from google.colab import drive
from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
from langchain.schema.runnable import RunnablePassthrough, RunnableLambda
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.output_parsers import StrOutputParser
import base64
import IPython
from io import BytesIO
import os
from PIL import Image, ImageDraw, ImageFont
import shutil
import time

# This is a helpful function from the LangChain Docs to decode generated images.
def _get_image_base64(response: AIMessage) -> str:
    """Extracts the base64 image data from an AIMessage response."""
    image_block = next(
        (block for block in response.content if isinstance(block, dict) and block.get("image_url")),
        None
    )
    if image_block:
        return image_block["image_url"].get("url").split(",")[-1]
    return None

GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')
input_path = '/content/drive/My Drive/Design/Spoonflower/0_input'
output_path = '/content/drive/My Drive/Design/Spoonflower/0_output'

以下是我使用的所有提示词。设计挑战赛的主题用于为效果图提供额外的上下文（例如，如果挑战赛是关于制作温馨的设计，效果图也应该感觉温馨）。我还传入了之前的一些Instagram文案作为写作样本，鼓励Nano Banana以类似的风格生成文案。

mockup_system_message = "You are an experienced surface pattern designer and interior designer, knowledgeable about repeating surface patterns, how to make mock-ups of those patterns in photoshop so that they appear realistically on clothes, furniture, wallpaper, and other household items. You have a good sense for interior design, fashion, color theory, and how light interacts with different surfaces."

# get the theme for the challenge
image_context =  open(f"{challenge_path}/challenge_info.txt", "r").read().replace("\n", " ")
mockup_prompts = {
                "wallpaper" : f"Here is an image. Here is some context around the image: {image_context}.\nI want you to take this image and create a mock-up image where the image appears as wallpaper in a setting that corresponds to the context of the image and goes well with the theme and colors. Try not to alter the pattern itself, but rather just adjust the lighting and perspective to make a realistic mockup.",
                "home_fabric" :  f"Here is an image. Here is some context around the image: {image_context}.\nI want you to take this image and create a mock-up image where the image appears as either a pillow case, bedding, tablecloth, or curtain in a setting that corresponds to the context of the image and goes well with the theme and colors. Try not to alter the pattern itself, but rather just adjust the lighting and perspective to make a realistic mockup.",
                "clothing" : f"Here is an image. Here is some context around the image: {image_context}.\nI want you to take this image and create a mock-up image where the image appears as a clothing item (shirt, skirt, dress) on a person in a setting that corresponds to the context of the image and goes well with the theme and colors. Try not to alter the pattern itself, but rather just adjust the lighting and perspective to make a realistic mockup."
                }

instagram_text_samples = open(f"{input_path}/instagram_samples.txt", "r").read().replace("\n", " ")
instagram_system_message = f"""
You are the social media manager for a surface pattern designer, Ella Frieda, who sells her designs on
the print-on-demand site Spoonflower on a range of textiles, wallpapers, tea towels, and more. You will receive an image that will be used as an Instagram post. It is your task to create an engaging caption for the image,
including emojis, a call to action, and tags for discoverability. When you
draft the content, think about SEO and optimizing for the Instagram algorithm. Try to find hashtags
that have been successful for similar creators. Here is some
writing from a previous Instagram account, that encapsulates Ella Fieda's writing style. As you are
executing the prompt, try to stick to a similar style (friendly, witty): {instagram_text_samples}.

The image will be related to a so-called Spoonflower challenge, meaning that
the surface pattern within the image will follow a certain theme and respond to a certain prompt. The title and details for
this challenge were: {image_context}.

Please do not take phrases or word groups directly from the prompt, but you may use the title in some form or another.
"""
instagram_post_prompt = f"""
Write an Instagram caption based on the attached image.
"""

如前所述，LLM在平铺方面有困难。理想情况下，我希望能让LLM无缝地平铺然后缩放设计（根据图像的分辨率和打印设置），以便效果图能准确呈现图案在现实世界中的样子。但目前，我接受设计的缩放可能与Spoonflower上的实际产品不完全对应。效果图在将设计情境化和激发想象力方面仍然具有价值。

第一步是使用PIL进行一些图像处理，创建一个填满图案的较大图像，Nano Banana随后可以将其用于效果图制作。此时，我还会保存一份带有我账号的图案填充图像副本，因为这总是很适合作为轮播图的最后一页。

# Load the image
img = Image.open(img_path)

# Get info
width, height = img.size

# set contrast color for handle
average_color = tuple([int(sum(x) / len(x)) for x in zip(*img.getdata())])
opposite_color = tuple([255 - c for c in average_color])

# Resize the image
new_width = 200
new_height = int(height * (new_width / width))
resized_img = img.resize((new_width, new_height))
resized_width, resized_height = resized_img.size

# Create a new image for the tile pattern
tile_img = Image.new('RGB', (1024, 1024))

# Tile the resized image
for x in range(0, 1024, resized_width):
    for y in range(0, 1024, resized_height):
        tile_img.paste(resized_img, (x, y))

draw = ImageDraw.Draw(tile_img)

# Create a copy of the tiled image before adding the handle
tile_img_no_watermark = tile_img.copy()
byte_stream = BytesIO()

tile_img_no_watermark.save(byte_stream, format='PNG')
image_bytes = byte_stream.getvalue()
encoded_image = base64.b64encode(image_bytes).decode("utf-8")

接下来是LangChain的部分。我创建了两个链，一个用于生成效果图，另一个用于生成Instagram文案。我使用ChatPromptTemplate来构建提示词。在创建chat实例时，我必须显式传入API密钥以避免认证错误，但我认为通常不需要这样做。

第一个链mockup_chain的最后一个元素是一个从多模态AIMessage中提取图像的函数，这样它就可以作为下一个链的输入。我尝试过一个将RunnableLambda(_get_image_base64)作为独立链的迭代版本，但那样没有奏效（尽管Gemini推荐了这种做法）。这个版本看起来也更优雅。full_chain然后将这两个链串联在一起，使用Auffarth和Kuligin建议的语法来捕获和保存两个链的输出。

# initialize chat
chat = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash-image-preview",
    temperature=0.4,
    google_api_key=GOOGLE_API_KEY, # for some reason, I had to pass the API key in explicitly at this stage (not in the config of the chain invocation) to not get errors
)

mockup_chat_prompt = ChatPromptTemplate.from_messages([
    ("system", mockup_system_message),
    ("user",[{"type": "text", "text": "{prompt}"},{"type": "image_url", "image_url": {"url": f"data:image/png;base64,{encoded_image}"}},])])

insta_chat_prompt = ChatPromptTemplate.from_messages([
    ("system", instagram_system_message),
    ("user",[{"type": "text", "text": instagram_post_prompt},{"type": "image_url", "image_url": {"url": "data:image/png;base64,{mockup_image}"}},])])

mockup_chain = mockup_chat_prompt | chat | RunnableLambda(_get_image_base64)

insta_chain = insta_chat_prompt | chat | StrOutputParser()

# I am using this syntax here to capture the mockup image as an output even though it is inside the chain
full_chain = mockup_chain | {
    "mockup_image": RunnablePassthrough(),
    "instagram_post": insta_chain
}

因为我想要三种不同类型的效果图（壁纸、服装和家居面料），我使用一个简单的循环调用了三次链。也可以使用batch()代替，但考虑到我需要保存每个输出，我最终还是需要使用循环。

for mockup_type in mockup_prompts.keys(): # wallpaper, clothing, home_fabric

  response = full_chain.invoke(
      {"prompt": mockup_prompts[mockup_type]},
      generation_config=dict(response_modalities=["TEXT", "IMAGE"]),
  )

  image_base64 = response["mockup_image"]
  display(IPython.display.Image(data=base64.b64decode(image_base64), width=300))

  # Display
  print("Instagram post:")
  print(response["instagram_post"])

  mockup_output_dir = os.path.join(image_output_path, mockup_type)
  os.makedirs(mockup_output_dir, exist_ok=True)

  # Save the Instagram caption to a text file
  output_filename_insta = f"{img_name.replace(' ','_')}_{mockup_type}_insta.txt"
  output_filepath_insta = os.path.join(mockup_output_dir, output_filename_insta)

  with open(output_filepath_insta, "w") as f:
      f.write(response["instagram_post"])

  print(f"Instagram post saved to: {output_filepath_insta}")

  # Save the image as JPEG
  image_bytes = base64.b64decode(image_base64)
  image_to_save = Image.open(BytesIO(image_bytes))
  output_filename_mockup = f"{img_name.replace(' ','_')}_{mockup_type}.jpeg"
  output_filepath_mockup = os.path.join(mockup_output_dir, output_filename_mockup)
  image_to_save.save(output_filepath_mockup, format='JPEG')

  print(f"Mockup image saved to: {output_filepath_mockup}")

以下是一些结果。Nano Banana在展示图案和将其置于适当的场景中方面做得非常出色。虽然这些图片明显是AI生成的，但它们为原本会相当无聊的帖子增添了视觉趣味。

原文链接: Nano Banana can't make repeat patterns, but the mockups are pretty good.

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

GenAI驱动的建筑可视化

admin — Sat, 18 Apr 2026 08:40:39 GMT

我丢掉了一个800美元的项目，因为我的竞争对手在2天内交付了，而我报价是5天。同样的质量，同样的风格，却只用了一半的时间。

那是我最后一次让缓慢的交付让我失去客户。从那以后，我重新构建了围绕AI的整个建筑可视化工作流程，过去需要五天完成的工作现在只需要一天半。同样的质量，在关键环节绝不偷工减料。

这篇文章正是我希望在那次谈话之前有人能递给我的东西。

1、你把时间花在了错误的地方

以下是大多数自由建筑师和建筑可视化艺术家在一个典型项目上实际花费时间的诚实分解：

参考素材收集与情绪板制作： 3–5小时
初始概念体量与体块推敲： 4–6小时
材料选型与贴图制作： 3–4小时
灯光设置与测试渲染： 4–8小时
与客户的修改迭代： 3–6小时
最终渲染与后期处理： 2–4小时

单个项目总共需要19到33个小时。而残酷的真相是？至少60%的时间花在了AI完全可以处理或可以大幅缩减的任务上。

剩下的40%——创意方向、空间直觉、理解客户说"让它感觉温暖但现代"时真正想要什么——这些是你的。这是没人能自动化的部分。正是你的建筑学教育让你拥有了游戏背景的3D艺术家永远无法企及的优势。

问题不在于你的技能，而在于你把最好的时间花在了精心编写提示词的AI几分钟就能完成的工作上。

让我们来解决这个问题。

2、AI建筑可视化工作流程

2.1 概念与情绪板（原需时间：4小时 → 新时间：30分钟）

在打开Revit、SketchUp或AutoCAD之前，你需要视觉方向。大多数建筑师花几个小时在Pinterest、Archdaily和Houzz上滚动浏览，收集参考素材。别再这样做了。

替代方案：

使用 Midjourney 配合结构化的提示词，在几分钟内生成情绪板和概念方向。关键在于使用具有建筑专业性的提示词——这是游戏3D艺术家永远不会知道的。

一个有效的提示词：

"Exterior residential architecture, warm contemporary style, Nigerian tropical climate, wide overhangs, local stone cladding, golden hour lighting, photorealistic, 8K, architectural visualization — ar 16:9 — v 6"

在不到10分钟内生成4–8个变体。选定方向。在你还没有建一堵墙之前就向客户展示。你刚刚用30分钟的创意对话替代了4小时的参考素材搜索，而客户从第一天起就感受到了参与感。

工具： Midjourney（$10/月）

2.2 早期设计探索（原需时间：5小时 → 新时间：1.5小时）

方向一旦确认，大多数建筑师就直奔建模软件开始构建。这就是时间消失在修改兔子洞里的地方。

替代方案：

使用 Veras by Evolve Lab（或用于体量推敲的 Finch3D）直接在现有模型上探索设计变体。Veras允许你将AI生成的渲染风格应用到粗糙的SketchUp或Revit模型上，这样你就可以在甚至还没完成建模之前向客户展示逼真的概念效果。

这有两个好处：它极大地压缩了设计探索阶段，并且防止了客户在看到最终渲染后改变主意这种代价高昂的情况发生。

工具： Veras by Evolve Lab（有免费版）

2.3 材料与贴图（原需时间：3小时 → 新时间：20分钟）

寻找合适的纹理、下载、调整尺寸并在渲染引擎中调整，是建筑可视化中最繁琐的环节之一。

替代方案：

Poly.pizza 和 Polyhaven 现在都有了AI辅助搜索功能。但更强大的是，Adobe Firefly 可以让你通过文本描述——"带有轻微骨料纹理的风化清水混凝土"——在60秒内生成自定义无缝纹理。你得到了一个在任何网站上都找不到的、专为你的设计量身定制的纹理。

在渲染引擎内的材质应用方面，Enscape 的资产库已经大幅扩展，并与SketchUp和Revit直接集成，消除了导入导出的循环。

工具： Adobe Firefly（Creative Cloud上$5/月）、Enscape、Polyhaven（免费）

2.4 灯光与测试渲染（原需时间：6小时 → 新时间：1小时）

这是大多数建筑可视化艺术家浪费整个下午的地方——调整太阳角度、HDRI强度，运行20分钟的测试渲染就为了看看阴影是否感觉对。

替代方案：

使用 Lumion 的AI辅助灯光系统，通过一个滑块就能设置时间和大气条件。其实时渲染引擎意味着你在视口中看到的基本就是最终输出——不再需要测试渲染循环。根据Lumion官方2024发布说明，最新版本在同等质量下视频渲染速度提升了5倍以上，光栅化性能比之前的版本提升了高达46%。

如果你的预算更紧张，D5 Render 是一个强有力的替代方案，它有慷慨的免费版和实时光线追踪功能，让你可以在实时预览中做出灯光决策。

规则：在你对构图90%确定之前，永远不要运行完整渲染。AI辅助的实时渲染引擎使这成为可能。

工具： Lumion（需许可证）或 D5 Render（有免费版）

2.5 客户修改（原需时间：5小时 → 新时间：1.5小时）

修改是项目走向死亡的地方。客户要求"改变立面材料"，听起来像是10分钟的调整，结果变成了3小时的渲染循环。

替代方案：

这里有两件事。

第一，使用 Midjourney的img2img功能（或 Adobe Firefly的生成式填充）在修改模型之前对渲染图像进行快速视觉编辑。客户想看白色而不是石材的立面效果。在2分钟内生成，获得批准，然后再修改模型。你刚刚完全消除了"让我先看看效果"的修改循环。

第二，这是一个系统层面的修复，而不是工具修复——使用一个 结构化的客户审批流程，在每个阶段强制要求签字确认后再继续。我会在下面分享我使用的Notion模板。

工具： Adobe Firefly生成式填充、Midjourney img2img

2.6 后期处理与交付（原需时间：3小时 → 新时间：45分钟）

最终调色、天空替换、配景（人物、汽车、植物）和导出过去意味着要在Photoshop中花好几个小时。

替代方案：

Luminar Neo 可以在几分钟内完成天空替换和AI驱动的大气增强，比手动Photoshop工作快得多。至于配景，Lumion 的人物和植被库是AI智能放置的，意味着树木和人物是上下文感知放置的，而不是手动放置的。

对于最终导出，批量处理一切。一次性设置好交付规格（分辨率、格式、命名规则），然后让它在后台运行，同时你去做别的事情。

工具： Luminar Neo（$79/年）

3、证据：这实际上改变了什么

以下是完整工作流程前后的对比：

从概念提示词到逼真渲染的AI辅助建筑可视化工作流程，仅需通常时间的一小部分。

这不是一个小改进。这是每周交付一个项目和每周交付三个项目之间的区别，而且不需要多工作一个小时。

这在经济上意味着： 如果你每个项目收费500美元，你原来每周赚500美元。有了这个工作流程，你每周赚1,500美元。同样的技能，同样的时间，只是一个更智能的系统。

率先掌握这一点的建筑师和建筑可视化自由职业者不仅仅是在节省时间——他们正在创造客户能够感受到的定价和交付优势。速度意味着能力。快速高质量地交付告诉客户你清楚地知道自己在做什么。

4、这不能替代什么

我想说清楚一件事，因为建筑界对AI取代设计师有很多恐惧。

AI不知道你的客户所说的"温暖而现代"在拉各斯和伦敦意味着完全不同的东西。它不理解建筑位于热带气候中需要特定的遮阳挑檐。它不能阅读场地分析、在字里行间解读设计任务书，或者在客户的美学偏好与被动式制冷原则冲突时提出异议。

你的建筑学教育是让每一个AI工具在你的手中产生比在任何人手中更好输出的关键。你没有被取代。如果你选择的话，你正在被升级。

那些将会挣扎的自由职业者是那些要么完全忽视AI、要么在没有设计智能来正确引导AI的情况下使用它的人。你不属于任何一个阵营。

5、结束语

上面的工作流程将立即为你节省数小时。但工具只是一半。

另一半是拥有一个项目管理系统，让你的客户保持知情、修改有条理、交付流程严丝合缝，这样你用AI节省的时间就不会被混乱的客户沟通所吞噬。

原文链接: How to Use AI to Deliver ArchViz Projects 3x Faster Without Sacrificing Quality

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

AI时代的3D动画流水线

admin — Wed, 13 Nov 2024 11:59:18 GMT

随着生成 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建模

admin — Mon, 11 Nov 2024 02:37:36 GMT

本文介绍了一种使用扫描网格数据生成精确的平面图和建筑内部 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 左所示。耳机将三角形叠加在用户对建筑物内部的视图上。虽然耳机捕捉到了大部分墙壁、地板和天花板，但某些区域的数据可能缺失，如图所示。

图 1. 左图：HoloLens 正在计算三角形网格。右图：黄色块标记传感器位置。粗黄线（称为探针）显示传感器或其他注释的建议位置和方向

注释网格为了捕获传感器、恒温器、窗户和门等物体的位置，我们开发了一个增强现实 (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) 等。对于单层建筑，我们搜索两个大桶对，分别代表地板（靠近底部）和天花板（靠近顶部）。

图 2. 地板最初不平整的模型

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

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

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

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

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

图 3. 左图：球坐标系中三角形朝向方向的热图。横轴是围绕 y 轴的角度 θ。纵轴是从南极到北极的角度 ϕ。颜色越暖，表示每个方向桶中的三角形越多。右图：六个聚类中心分别显示天花板（顶部红点）、地板（底部红点）和四个主要墙壁方向（中等高度从左到右的点）的方向。

图 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 的示例结果。

图 4. 最初未对齐的建筑物 B1（左）的网格模型以及对齐墙壁后的网格模型（右）

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

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

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

图 5。左：使用几乎垂直向上或垂直向下的三角形，绘制质心高度的直方图，按三角形表面积加权。直方图峰值可能是地板和天花板的高度。中间：一栋两层楼的建筑。右：该建筑的两层。

3.2 平面图计算

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

图 6。左：3D 模型。中间：通过 k=6 的球面 k 均值获得的平面图。右：来自支持更多墙面方向的改进 DBSCAN 的平面图

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

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

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

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

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

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

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

图 7. 在多个高度切片的建筑物网格

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

图 8. 左：建筑物部分的定向网格。中间：DBSCAN 的结果。每种颜色代表不同的墙段。右：计算出的平墙。

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

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

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

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

图 9. 图 8 模型中的钢笔和墨水平面图（左）和绘图平面图（右）

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

4、实验

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

图 10。（a）：建筑物测量。（b）：建筑物的扫描 S1。（c）：扫描 S2

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

图 11。第一张：B3 号建筑的 3D 模型。第二张：计算出的平墙。第三张：绘图式平面图。第四张：钢笔画式平面图

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

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

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

图 12. Matterport3D 的三层模型（左上）及其三角形高度直方图（右上）。下图显示了建筑物的层数

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

图 13。第一张：B2 号楼的 DBSCAN 聚类结果。第二张：平面贴合的平墙。第三张：绘图式平面图。第四张：钢笔画式平面图

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

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

图 14。第一：B2 的 DBSCAN 聚类结果。第二：平面贴合的平墙。第三：绘图式平面图。第四：（c）钢笔画式平面图

图 15。第一：Matterport3D 模型的 DBSCAN 聚类结果。第二：平面贴合的平墙。第三：绘图式平面图。第四：钢笔画平面图。

5、结论和未来工作

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

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

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

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

VR/AR：已走进死胡同

admin — Mon, 11 Nov 2024 02:17:53 GMT

如果这个市场的主要参与者继续以现在的方式发展，我们不妨猜猜 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翻译整理，转载请标明出处

扩散模型和重新照明的未来

admin — Tue, 05 Nov 2024 06:59:58 GMT

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

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

1、解决重新照明问题

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

渲染方程。来源

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

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

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

2、扩散模型

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

潜在扩散模型来源

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

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

ControlNet

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

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

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

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

3、DiLightNet

DiLightNet：基于扩散的图像生成的细粒度照明控制

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

3.1 方法

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

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

ControlNet

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

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

3.2 实现

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

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

3.3 结果

DiLightNet 结果

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

DiLightNet 结果

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

DiLightNet 结果

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

DiLightNet 结果

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

3.4 局限性

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

4、神经 Gaffer

神经 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）的比较。

Neural Gaffer 结果

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

Neural Gaffer 结果

此图比较了他们的方法与另一种基于 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 结果

Relightful Harmonization 结果

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

Relightful Harmonization 结果

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

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 实现

2D 重新照明模块的推理图

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

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

6.3 结果

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

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

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

6.3 局限性

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

7、LightIt

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翻译整理，转载请标明出处

海量点云的可视化

admin — Tue, 05 Nov 2024 02:16:39 GMT

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

本文处理和可视化无人机 3D 点云。你将在实时可视化和创建动画的同时学习特征提取、交互式和自动分割

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

你可以注意到，左侧（Open3D）与右侧（PPTK）相比速度有多慢，PPTK 使用八叉树结构来加速可视化。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 在我们的大学校园里飞行，收集一些图像并运行摄影测量重建，如此处所述。

以下链接提供的 3D 点云来自 DJI Phantom 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)

在 PPTK 中可视化的点云

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

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

v.attributes(colors/65535)

PPTK 查看器中带有颜色信息的 3D 点云

🤓 注意：我们的颜色值是从 .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 中可视化的 3D 点云。请注意如何很好地使用法线来增强几何图形的视觉效果

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

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

使用 Python 在 open3D 中将点云转换为体素

点云的 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）。

3D 多点云分割。从点云中创建多个选择

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

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

7、实现自动分割

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

selection=v.get('selected')

步骤 1：我们从初始 3D 点云中选择点

然后我计算每个点的法线。为此，我想说明使用 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)

自动法线过滤器后的 3D 点云片段。看看车顶和整个汽车结构上的一些点是如何被丢弃的

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

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)

过滤垂直法线接近初始段最低 Z 值的点的 3D 点云

这很棒！现在，你可以探索这种强大的思维方式，并结合任何过滤（例如，在 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')

点云的 PPTK 中 4 个关键帧之间的线性插值

9、结束语

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

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

原文链接：Visualise Massive point cloud in Python

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

计算几何算法的应用

admin — Fri, 01 Nov 2024 01:13:33 GMT

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

它是计算机科学的一个分支，具有广泛的应用范围。计算几何在模式识别、计算机图形学、运筹学、制造和计算机辅助设计等领域面临着多项挑战。计算机图形学和 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翻译整理，转载请标明出处

BimAnt

下一代UI：元宇宙 vs. AI

1、元宇宙的诱惑

2、AI工具确实有效

3、结束语：生产力提升赢得胜利

3D感知管线开发环境搭建

0、学习目标

1、系统要求

2、克隆项目仓库

3、克隆Vision Messages仓库

4、使用Pixi设置项目环境

4.1 pixi.toml的结构

4.2 安装Pixi环境

4.3 下载ROS 2 Bag

5、构建和加载工作空间

6、测试设置

7、⚠ 关于硬件和性能的说明

Spline Omma：从提示词到3D网站

1、用3D交互让你的现有设计焕发生机

2、为PDF和其他文档添加3D视觉效果

3、将实时数据转化为3D交互

4、Spline有游戏功能，Omma让这些游戏栩栩如生

5、为下一代体验打造的逼真模拟

6、其他在3D Web体验领域掀起波澜的替代工具

6.1 Unicorn Studio

6.2 Framer Effects & Shaders

LiDAR、IMU和深度摄像机

1、什么是LiDAR？

1.1 飞行时间公式

1.2 LiDAR有分类吗？

1.3 架构

1.4 数据类型 — 原始硬件 → ROS 2消息

1.5 TF2变换树 — 坐标系

2、深度摄像头传感器

2.1 深度测量技术

2.2 飞行时间（ToF）

2.3 立体视觉

3、结束语

用 Gazebo 学习 ROS 2

1、基础（设置与启动）

两个不同的世界

步骤1：安装集成包

步骤2：创建启动文件

步骤3：理解代码

步骤4：执行启动

2、ros_gz_bridge和管理多个机器人

通用翻译器

步骤1：启动机器人世界

步骤2：启动桥接器（ROS 2 -> Gazebo）

步骤3：驱动机器人！

步骤4：桥接数据回传（Gazebo -> ROS 2）

3、生成URDF（让机器人活起来）

步骤1：启动文件架构

步骤2：编写代码

步骤3：理解create节点

步骤4：启动并验证

4、传感器集成与RViz2可视化（给机器人眼睛）

步骤1：在URDF中添加传感器插件

步骤2：添加仿真描述文件（SDF）

步骤3：启动世界并添加障碍物

步骤4：桥接传感器数据（Gazebo -> ROS 2）

步骤5：在RViz2中可视化

5、变换树（TF2）与让机器人动起来

步骤1：添加"肌肉"（差速驱动插件）

步骤2：发布车轮角度（关节状态）

步骤3：终极桥接

步骤4：驾驶和可视化！

步骤5：使用TeleopTwistKeyboard控制机器人

6、优化（组合与YAML桥接）

步骤1：YAML配置文件

步骤2："一键"启动文件

步骤3：测试优化后的系统

7、命令机器人前往在RVIZ中选择的目标点

8、结束语

LiDAR 工作原理解读

1、LiDAR的工作原理

2、LiDAR的类型

2.1 机载LiDAR

2.2 地面LiDAR

2.3 星载LiDAR

步骤3：理解`create`节点