Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
本入门包含由 Mode Lab 开发的章节。这些章节重点介绍使用 Dynamo 开始和运行自己的可视化程序所需的基本技能,以及有关如何进一步使用 Dynamo 的关键信息。
本手册旨在满足不同背景和技能水平的读者的需求。有关 Dynamo 设置、用户界面和关键概念的一般简介位于以下各部分中,建议新用户浏览以下主题:
对于希望更深入地了解每个元素(例如,特定节点及其背后的概念)的用户,我们会在各自相应章节中介绍基础知识。
如果您想要查看 Dynamo 工作流的演示,我们已在“示例工作流”部分中包含了一些图形。按照随附的说明创建您自己的 Dynamo 图形。
我们会介绍有关 Dynamo 的不同主题,因此可以在后面的章节中找到更多特定于主题的练习。“练习” 通常位于每个页面的最后一部分。
如果没有众多热衷的用户和积极贡献者,Dynamo 就不能成为现在的样子。通过关注博客、将作品添加到库或在论坛中讨论 Dynamo,来与社区进行交流。
Dynamo 被设计为一款面向设计师的可视化编程工具,可帮助我们创建使用外部库或任何具有 API 的 Autodesk 产品的工具。借助 Dynamo 沙箱,我们可以在“沙箱”样式的应用程序中开发程序,但 Dynamo 生态系统会持续增长。
项目的源代码是开源的,使我们能够尽情地扩展其功能。在 GitHub 上检出项目,并浏览用户自定义 Dynamo 的工作进度。
浏览、分叉并开始扩展 Dynamo 以满足您的需求
Dynamo 工作空间由四个主要元素组成。
所有活动选项卡。
预览模式
缩放/平移控件
工作空间中的节点
打开新文件时,将默认打开新的主工作空间。
可以创建一个自定义节点,然后在自定义节点工作空间中将其打开。
每个 Dynamo 窗口中仅允许有一个主工作空间,但可能在选项卡中打开多个自定义节点工作空间。
有 3 种方法可在不同预览之间切换:
a.使用右上角图标
b.在工作空间中单击鼠标右键
从三维预览切换到图形预览
从图形预览切换到三维预览
c.使用键盘快捷键 (Ctrl+B)
可以使用图标或鼠标在任一工作空间中导航。
a.在 “图形预览” 模式下
使用图标:
使用鼠标:
单击鼠标左键 - 选择
单击鼠标左键并拖动 - 选择框用于选择多个节点
鼠标中键向上/向下滚动 - 放大/缩小
单击鼠标中键并拖动 - 平移
在画布上的任意位置单击鼠标右键 - 打开画布内搜索
b.在 “三维预览” 模式下
使用图标:
使用鼠标:
鼠标中键向上/向下滚动 - 放大/缩小
单击鼠标中键并拖动 - 平移
单击鼠标右键并拖动 - 动态观察
单击鼠标左键以选择任意节点。
要选择多个节点,请单击并拖动以创建选择框。
Dynamo 是一个活动的开源开发项目。查看。
Dynamo 会随 “Revit3D”、“FormIt”、“Civil3D” 等软件一起预安装。
有关将 Dynamo 与特定软件配合使用的更多指导,建议您参见以下部分:
如果您想将 Dynamo 用作单机版应用程序。继续阅读以获取有关下载 Sandbox 的指导。
如果要查找以前或“前沿”开发版本,则可以在同一页面的下半部分找到所有版本。
“前沿”开发可能包括一些尚未经过完全测试的新功能和实验性功能,因此可能不稳定。使用这一版本时,您可能会遇到错误或问题,请通过向我们的团队报告问题来帮助我们改进应用程序。
建议初学者下载稳定的正式版。
启动已下载的任何版本之前,您需要将内容解压缩到选定文件夹。
在压缩文件上单击鼠标右键,然后选择 “全部解压缩”...
选择一个目标位置来解压缩所有文件。
在目标文件夹中,双击 “DynamoSandbox.exe” 可启动它
您将看到 DynamoSandbox 启动屏幕,如下所示。
恭喜您,现在已完成设置 DynamoSandbox,可立即使用!
“几何图形” 是 Dynamo Sandbox 中的一项附加功能,仅适用于拥有以下 Autodesk 软件的当前固定期限的许可或许可的用户:Revit、Robot Structural Analysis、FormIt 和 Civil 3D。“几何图形” 允许用户从 Dynamo Sandbox 输入、创建、编辑和输出几何图形。
Dynamo 是面向设计师的开源可视化编程平台。
您刚打开了 Dynamo Primer,它是 Autodesk Dynamo 中可视化编程的全面指南。本 Primer 是一个持续的项目,旨在分享编程基础知识。主题包括使用计算几何体、基于规则的设计最佳实践、跨领域编程应用程序以及与 Dynamo 平台相关的更多信息。
Dynamo 的强大功能可在多种与设计相关的活动中找到。Dynamo 带有可立即访问的扩展列表,可供您快速开始:
首次探索可视化编程
连接各种软件中的工作流
参与由用户、贡献者和开发人员组成的活跃社区
开发一个开源平台以持续改进
在此活动中以及使用 Dynamo 的令人兴奋的机会中,我们需要一个具有相同水准的文档 - Dynamo Primer。
我们不断地改进 Dynamo,因此某些功能看起来可能与本 Primer 中所介绍的功能不同。但是,所有功能更改都会正确介绍。
Dynamo Primer 项目是开源的!我们致力于提供高质量内容,并感谢您提供的任何反馈。如果您要报告任何方面的问题,请将其发布到我们的 GitHub 问题页面:https://github.com/DynamoDS/DynamoPrimer/issues
如果您要为此项目创建新的部分、进行编辑或任何其他操作,请查看 GitHub 库以便开始:https://github.com/DynamoDS/DynamoPrimer。
Dynamo Primer 是一个开源项目,由 Matt Jezyk 和 Autodesk 的 Dynamo 开发团队发起。
已委派 Mode Lab 编写本 Primer 的第一版。我们感谢他们在建立这一宝贵资源方面付出的努力。
已委派 Parallax 团队的 John Pierson 更新本 Primer 以,反映 Dynamo 2.0 修订版。
已委派 Matterlab 更新本 Primer,以反映 Dynamo 2.13 修订版。
已委派 Archilizer 更新本 Primer,以反映 Dynamo 2.17 修订版。
已委派 Wood Rodgers 使用 Dynamo for Civil 3D 的内容更新本 Primer。
尤其感谢 Ian Keough 启动和引导 Dynamo 项目。
感谢 Matt Jezyk、Ian Keough、Zach Kron、Racel Amour 和 Colin McCrone 的热情协作,让大家有机会参与各种 Dynamo 项目。
Dynamo 如需最新稳定版 Dynamo,请访问以下站点。
http://dynamobim.com/download/ 或 http://dynamobuilds.com
DynamoBIM 获取其他信息、学习内容和论坛的最佳来源是 DynamoBIM 网站。
http://dynamobim.org
Dynamo GitHub Dynamo 是 GitHub 上的开源开发项目。要做出贡献,请查看 DynamoDS。
https://github.com/DynamoDS/Dynamo
联系 请告知我们有关本文档中任何问题的信息。
Dynamo@autodesk.com
Copyright 2023 Autodesk
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.See the License for the specific language governing permissions and limitations under the License.
Dynamo 的用户界面 (UI) 分为五个主要区域。我们将在此简要介绍概述,然后在以下各部分中进一步介绍工作空间和库。
菜单
工具栏
库
工作空间
执行栏
以下是 Dynamo 应用程序基本功能的菜单。与大多数 Windows 软件一样,前两个菜单涉及文件管理、选择操作和内容编辑。其余菜单则更加特定于 Dynamo。
常规信息和设置位于 “Dynamo” 下拉菜单中。
关于 - 了解计算机上安装的 Dynamo 版本。
同意收集可用性数据 - 这允许您选择加入或退出共享您的用户数据以改进 Dynamo。
首选项 - 包括定义应用程序的小数点精度和几何图形渲染质量等设置。
退出 Dynamo
如果遇到问题,请查看 “帮助” 菜单。可以通过 Internet 浏览器访问其中一个 Dynamo 参考网站。
快速入门 - 简要介绍如何使用 Dynamo。
互动指南 -
样例 - 参考示例文件。
Dynamo 词典 - 包含所有节点文档的资源。
Dynamo 网站 - 在 GitHub 上查看 Dynamo 项目。
Dynamo Project Wiki - 访问 Wiki 以了解如何使用 Dynamo API、支持库和工具进行开发。
显示开始页面 - 在文档内时返回 Dynamo 开始页面。
报告错误 - 在 GitHub 上打开问题。
Dynamo 工具栏包含一系列按钮,可快速处理文件以及访问“Undo [Ctrl + Z]”和“Redo [Ctrl + Y]”命令。最右侧是另一个按钮,它将输出工作空间快照,这对于文档编制和共享非常重要。
从此处运行 Dynamo 脚本。单击“执行”按钮上的下拉图标,可在不同模式之间切换。
自动:自动运行脚本。更改会实时更新。
手动:仅当单击“运行”按钮时,脚本才会运行。对更改复杂且“繁重”的脚本很有用。
周期:默认情况下,此选项灰显。仅当使用 DateTime.Now 节点时可用。可以将图形设置为按指定的间隔自动运行。
在 Dynamo 中,节点是您连接其以构建可视化程序的对象。每个节点都执行一项操作 - 有时这可能与存储数字一样简单,或者可能是更复杂的操作,例如创建或查询几何图形。
Dynamo 中的大多数节点由五个部分组成。虽然存在例外(如输入节点),但每个节点的剖析可描述如下:
名称 - 采用
Category.Name
命名约定的节点名称主体 - 节点的主体 - 在此处单击鼠标右键可显示整个节点级别的选项
端口(输入和输出)- 导线的接受器,它们向节点提供输入数据以及节点操作的结果
默认值 - 在输入端口上单击鼠标右键 - 某些节点有可以使用也可以不使用的默认值。
节点的输入和输出称为端口,并充当导线的接受器。数据通过左侧的端口进入节点,并在节点执行右侧的操作后流出节点。
端口希望接收特定类型的数据。例如,将数字(如 2.75)连接到“Point By Coordinates”(坐标点)节点上的端口将成功创建点;但是,如果我们向同一端口提供 “Red” ,则会导致错误。
提示:将光标悬停在端口上,可查看包含预期数据类型的工具提示。
端口标签
工具提示
数据类型
默认值
Dynamo 通过基于每个节点的状态使用不同颜色方案渲染节点,来提供执行可视化程序的状态的指示。状态层次结构遵循以下顺序:“错误”>“警告”>“信息”>“预览”。
将光标悬停在名称或端口上或在其上单击鼠标右键,会显示其他信息和选项。
满意的输入 - 输入端口上有蓝色竖线的节点连接良好,并且其所有输入都已成功连接。
不满意的输入 - 一个或多个输入端口上有红色竖线的节点需要连接这些输入。
函数 – 输出函数并在输出端口上有灰色竖线的节点是函数节点。
已选定 - 当前选定的节点在其边界周围会浅绿色亮显。
已冻结 - 半透明蓝色节点已冻结,暂停执行该节点。
警告 - 节点下方的黄色状态栏指示“警告”状态,这意味着节点缺少输入数据,也可能数据类型不正确。
错误 - 节点下方的红色状态栏指示节点处于“错误”状态。
信息 - 节点下方的蓝色状态栏指示“信息”状态,它标记有关节点的有用信息。当接近节点支持的最大值时,可能会触发此状态,从而以可能影响性能的方式使用节点等。
提示:掌握此工具提示信息后,检查上游节点以查看所需的数据类型或数据结构是否出错。
警告工具提示 -“空”或无数据不能理解为双精度,即数字
使用“Watch”节点检查输入数据
上游“Number”节点存储的是“Red”而非数字
在某些情况下,您可能希望阻止在可视化程序中执行特定节点。为此,可以“冻结”节点,该节点是节点右键单击菜单下的一个选项。
冻结节点还会冻结其下游的节点。换言之,依赖于冻结节点输出的所有节点也将冻结。
导线连接节点以创建关系并建立可视化程序的流。我们可以按照字面意思将其视为电线,用于将数据脉冲从一个对象传送到下一个对象。
导线将一个节点的输出端口连接到另一个节点的输入端口。此方向性会在可视化程序中建立数据流。
输入端口位于左侧,输出端口位于节点的右侧;因此,我们通常可以说程序流从左向右移动。
通过在一个端口上单击鼠标左键以创建导线,然后在另一个节点的端口上单击鼠标左键以创建连接。在建立连接的过程中,导线将显示为虚线,并在成功连接后进行捕捉以成为实线。
数据将始终通过此导线从输出流到输入;但是,我们可以按照单击连接端口的顺序沿任意方向创建导线。
通常,我们要通过编辑导线表示的连接来调整可视化程序中的程序流。要编辑导线,请在已连接节点的输入端口上单击。现在有两种选择:
要更改到输入端口的连接,请在另一个输入端口上单击鼠标左键
要删除导线,请将导线移离,然后在工作空间上单击鼠标左键
使用 Shift+单击鼠标左键可重新连接多条导线
使用 Ctrl+单击鼠标左键可复制导线
默认情况下,导线将通过灰色笔划进行预览。选择某个节点后,将使用与该节点相同的浅绿色亮显来渲染任何连接导线。
亮显的导线
默认导线
默认隐藏导线
如果您希望在图形中隐藏导线,可以在“视图”>“连接器”中找到此选项 > 取消勾选“显示连接器”。
使用此设置,只有选定的节点及其连接线将以淡绿色亮显。
还可以仅通过在节点输出上单击鼠标右键 > 选择“隐藏导线”来隐藏选定的导线
图形预览
三维预览
缩放匹配
放大
缩小
平移
缩放匹配
放大
缩小
平移
动态观察
要开始使用,请从工具栏面板启动它。根据您使用的软件,通常可以从“菜单”> “管理” 选项卡找到启动图标。单击 Dynamo 图标 以启动它。
Dynamo 应用程序可从 获得。正式版本、过去版本或预发布版本均可从下载页面获得。访问页面,然后单击下载以获取正式发布的版本。
要执行此步骤,请下载并将其安装到您的计算机上。
请参见 ,以了解您可通过本 Primer 学到的内容。
*注意:从 Revit 2020 开始,Dynamo 与 Revit 版本捆绑在一起,因此无需手动安装。有关详细信息,请访问此。
节点和导线是 Dynamo 中支持过程的关键组件。它有助于在设计的各个部分之间建立强大的视觉和系统关系。在开发和优化设计工作流时,使用简单的鼠标单击即可轻松连接节点。
新建 - 创建新的 .dyn 文件
打开 - 打开现有 .dyn(工作空间)或 .dyf(自定义节点)文件
保存/另存为 - 保存活动的 .dyn 或 .dyf 文件
撤消 - 撤消上一个操作
重做 - 重做下一个操作
将工作空间输出为图像 - 将可见工作空间输出为 PNG 文件
Dynamo 库是功能库的集合,每个库都包含按类别分组的节点。它包含在默认安装 Dynamo 期间添加的基本库,随着我们继续介绍其用法,我们将演示如何通过自定义节点和其他软件包扩展基本功能。部分将介绍有关如何使用它的更详细指导。
在工作空间中,我们可以编写可视化程序,您还可以更改其“预览”设置以从此处查看三维几何图形。有关更多详细信息,请参见 。
连缀图标 - 表示为匹配列表输入指定的(稍后再做详细介绍)
预览关闭 - 节点下方的灰色状态栏和眼睛图标 表示节点的几何图形预览已关闭。
如果可视化程序包含警告或错误,Dynamo 将提供有关该问题的其他信息。任何黄色节点在名称上方也会有工具提示。将鼠标光标悬停在警告 或错误 工具提示图标上可将其展开。
在本部分中,我们将介绍 Dynamo 库中提供的基本节点,这些节点将帮助您像专业人员一样创建自己的可视化程序。
计算设计的几何图形:如何在 Dynamo 中使用几何图元?探索基于基本体创建简单或复杂几何图形的多种方法。
程序的构建块:“数据”是什么,我可以在程序中开始使用哪些基本类型?此外,还要了解有关在设计工作流中结合数学和逻辑运算的更多信息。
使用列表进行设计:如何管理和协调数据结构?详细了解“列表”的概念,并使用它来高效管理设计数据。
Dynamo 中的词典:什么是词典?了解如何使用词典查找现有结果中的特定数据和值。
“几何图形” 是设计语言。当编程语言或环境的核心有几何图形内核时,我们可以针对以下目标开启各种可能性:设计精确而稳健的模型、自动执行设计例程以及使用算法生成设计迭代。
了解几何图形类型及其之间的关系,将使我们能够浏览库中可用的 “几何图形节点” 的集合。几何图形节点按字母顺序组织,而不是按层次组织 - 它们在此处的显示类似于其在 Dynamo 界面中的布局。
此外,随着时间的流逝,在 Dynamo 中制作模型并将在“背景预览”中所看到内容的预览连接到图形中的数据流应会变得更加直观。
请注意,假定坐标系由栅格和彩色轴渲染
“选定节点”将在背景中以亮显颜色渲染相应的几何图形(如果节点创建几何图形)
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
传统上定义的几何图形是对形状、大小、图形的相对位置和空间特性的研究。这一领域悠久历史,可以追溯到数千年前。随着计算机的出现和普及,我们在定义、浏览和生成几何图形方面获得了强大的工具。现在,可以非常轻松地计算复杂几何交互的结果;实际上,我们所做的几乎是透明的。
如果您想知道如何利用计算机的强大功能来获得多样化和复杂的几何图形,请通过 Web 快速搜索“斯坦福兔”(即,一种用于测试算法的规范模型)。
在算法、计算和复杂性的环境中了解几何图形可能会令人望而生畏;但有一些关键和相对简单的原则,我们可以将这些原则确立为基础来开始构建更高级的应用程序:
几何图形是 “数据” - 对计算机和 Dynamo 而言,兔子与数字没有什么不同之处。
几何图形依赖 “抽象” - 从根本上来说,几何图元由给定空间坐标系中的数字、关系和公式进行描述
几何图形具有 “层次” - 点汇聚生成线、线汇聚生成面,以此类推
几何图形同时描述 “零件和整体” - 如果有曲线,则它既包括形状,也包括沿其的所有可能点
实际上,这些原则意味着我们需要知道我们正在处理的内容(几何图形的类型、如何创建等);因此,我们在开发更复杂的模型时,可以顺畅地构建、分解和重新构建不同的几何图形。
让我们花点时间了解一下几何图形的“抽象”说明和“层次”说明之间的关系。由于这两个概念是相关的,但起初并不总是很明显,因此一旦我们开始开发更深的工作流或模型,我们可能会快速遇到概念上的障碍。首先,我们使用维数作为所建模“素材”的简单描述符。描述形状所需的维数为我们提供了一个窗口,让我们可以了解几何图形是如何按层次组织的。
“点”(由坐标定义)没有任何维数 - 它只是描述每个坐标的数字
“线”(由两个点定义)现在有 一 个维数 - 我们可以向前(正方向)或向后(负方向)“漫游”直线
“平面”(由两条直线定义)有 两 个维数 - 现在可以向左或向右更多漫游
“方框”(由两个平面定义)有 三 个维数 - 我们可以定义相对于上或下的位置
维数是一种开始对几何图形进行分类的便捷方法,但它不一定是最佳方法。毕竟,我们不仅使用“点”、“线”、“平面”和“方框”建模 - 如果我想要弯曲,该怎么办?此外,还有另一类完全抽象的几何类型,即它们定义诸如方向、体积或各部件之间关系之类的特性。我们无法真正抓住向量,那么如何相对于空间中的显示内容定义向量?几何层次的更详细分类应适应“抽象类型”或“辅助对象”之间的差异,我们可以根据它们的帮助内容和有助于描述模型图元形状的类型对它们进行分组。
在 Dynamo 中创建模型并不局限于我们可以通过节点所生成的内容。以下是进一步处理几何图形的一些关键方法:
Dynamo 允许您输入文件 - 尝试将 CSV 用于点云,或将 SAT 用于引入曲面
使用 Revit 时,我们可以参照要在 Dynamo 中使用的 Revit 图元
Dynamo Package Manager 为扩展几何图形类型和操作提供了附加功能 - 查看 Mesh Toolkit 软件包
向量由大小和方向表示,可以将其视为以给定速度朝特定方向加速的箭头。在 Dynamo 中,它是模型的关键组件。请注意,由于它们属于“辅助对象”的“抽象”类别,因此当我们创建向量时,不希望在背景预览中看到任何内容。
我们可以使用一条线作为向量预览的替代对象。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
平面是一个二维曲面,可以将其视为无限延伸的平面。每个平面都有一个原点、X 方向、Y 方向和 Z(向上)方向。
尽管它们是抽象的,但平面确实具有原点位置,以便我们可以在空间中定位它们。
在 Dynamo 中,平面在背景预览中渲染。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
坐标系是一个用于确定点或其他几何图元位置的系统。下图介绍了它在 Dynamo 中的外观以及每种颜色所表示的含义。
尽管它们是抽象的,但坐标系也具有原点位置,以便我们可以在空间中定位它们。
在 Dynamo 中,坐标系在背景预览中渲染为一个点(原点)和定义轴(X 为红色、Y 为绿色以及 Z 为蓝色,遵循约定)的线。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
向量、平面和坐标系构成了抽象几何图形类型的主组。它们帮助我们为描述形状的其他几何图形定义位置、方向和空间环境。如果我说我在纽约市第 42 街的百老汇(坐标系)、站在街道上(平面)、面朝北(向量),我刚刚使用这些“辅助对象”来定义我所在的位置。这同样适用于手机壳产品或摩天大楼 - 我们需要此环境来开发模型。
向量是描述方向和幅值的几何量。向量是抽象的;即它们表示量,而不表示几何图元。向量可能容易与“点”混淆,因为它们都是由一列值组成。不过,有一个关键区别:“点”描述给定坐标系中的位置,而“向量”描述位置中的相对差异(这就是所谓的“方向”)。
如果相对差异的概念令人困惑,请将“向量 AB”想象为“我站在点 A,面朝点 B”。 从这里 (A) 到那里 (B) 的方向就是我们所谓的向量。
使用相同 AB 符号将向量详解为其各组成部分:
向量的 “起点” 称为 “基底”。
向量的 “终点” 称为 “尖端” 或 “指向”。
“向量 AB”与“向量 BA”不同 - 它们指向相反的方向。
如果您需要关于向量(及其抽象定义)的喜剧效果,请观看经典喜剧《飞机》,聆听时常引用的半开玩笑台词:
Roger, Roger.What's our vector, Victor?
平面是二维抽象“辅助对象”。 更具体地说,平面在概念上是“平”的,在两个方向上无限延伸。通常,它们在其原点附近被渲染为较小的矩形。
您可能会想:“等等!原点?这听起来像是一个坐标系...就像我在 CAD 软件中建模所使用的坐标系!”
您是对的!大多数建模软件都利用构造平面或“标高”来定义要拔模的本地二维环境。XY、XZ、YZ 或北、东南、平面图听起来可能更加熟悉。这些都是“平面”,用于定义无限的“平”环境。平面没有深度,但也有助于我们描述方向 -
如果我们对平面感到满意,那么我们只需一小步就能理解坐标系。平面与坐标系一样具有相同的各部分,前提是它是标准的“欧几里德”或“XYZ”坐标系。
但是,还有其他可选坐标系,如圆柱坐标系或球形坐标系。如我们在后续各部分中所见,坐标系也可应用于其他几何图形类型,以定义该几何图形上的位置。
添加可选坐标系 - 圆柱坐标系、球形坐标系
点仅由一个或多个称为坐标的值定义。定义点所需的坐标值数量取决于该点所在的坐标系或环境。
Dynamo 中最常用的点类型存在于三维世界坐标系中,具有三个坐标 [X,Y,Z](Dynamo 中的三维点)。
Dynamo 中的二维点有两个坐标 [X,Y]。
曲线和曲面的参数是连续的,并且延伸到给定几何图元的边缘之外。由于定义“参数空间”的形状存在于三维世界坐标系中,因此我们始终可以将“参数化坐标”转换为“世界”坐标。例如,曲面上的点 [0.2, 0.5] 与世界坐标中的点 [1.8, 2.0, 4.1] 相同。
假定的世界 XYZ 坐标中的点
相对于给定坐标系(圆柱)的点
曲面上 UV 坐标形式的点
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
如果“几何图形”是模型的语言,则“点”是字母。点是创建所有其他几何图形的基础 - 我们需要至少两个点来创建曲线、我们需要至少三个点来生成一个多边形或网格面,依此类推。通过定义点之间的位置、顺序和关系(尝试使用正弦函数),我们可以定义更高阶的几何图形,例如我们识别为“圆”或“曲线”的图形。
使用函数
x=r*cos(t)
和y=r*sin(t)
的圆使用函数
x=(t)
和y=r*sin(t)
的正弦曲线
点也可以存在于二维坐标系中。根据我们所使用的空间类型,约定的字母表示法有所不同 - 我们可能在平面上使用 [X,Y] 或在曲面上使用 [U,V]。
欧几里得坐标系中的点:[X,Y,Z]
曲线参数坐标系中的点:[t]
曲面参数坐标系中的点:[U,V]
该库中包含所有已加载的节点,包括安装时附带的 10 个默认类别节点以及任何额外加载的自定义节点或软件包。该库中的节点在库、类别和子类别(如果适用)中按层次进行组织。
基本节点:默认安装时随附。
自定义节点:将常用例程或特殊图形存储为自定义节点。还可以与社区共享自定义节点
软件包管理器中的节点:已发布自定义节点的集合。
我们将浏览节点层次结构类别、介绍如何从库中快速搜索,以及了解其中一些常用节点。
浏览这些类别是了解我们可以向“工作空间”添加的内容层次的最快方法,也是查找之前尚未使用的新节点的最佳方式。
通过单击菜单展开每个类别及其子类别来浏览库
“几何图形”是开始探索的最佳菜单,因为它们包含最多数量的节点。
库
种类
子类别
节点
这些选项会根据节点是 “创建” 数据、执行 “操作” 还是 “查询” 数据,来对同一子类别中的节点进一步分类。
将鼠标光标悬停在节点上,即可显示除其名称和图标以外的更多详细信息。这使我们可以快速了解节点的作用、所需输入内容以及输出内容。
描述 - 节点的纯语言描述
图标 - 库菜单中图标的较大版本
输入 - 名称、数据类型和数据结构
输出 - 数据类型和结构
如果您相对具体地了解要添加到工作空间的节点,请在 “搜索” 字段中键入内容以查找所有匹配的节点。
通过单击要添加的节点进行选择,或按 Enter 键将亮显的节点添加到工作空间的中心。
除了使用关键字尝试查找节点之外,我们还可以在“搜索”字段或代码块中键入以句点分隔的层次结构(这使用 Dynamo 文本语言)。
每个库的层次结构都会反映在添加到工作空间的节点名称中。
以 library.category.nodeName
格式键入“库”层次结构中节点位置的不同部分会返回不同结果
library.category.nodeName
category.nodeName
nodeName
或 keyword
通常,工作空间中的节点名称将以 category.nodeName
格式进行呈现,但存在一些明显例外,尤其是在“输入”和“视图”类别中。
小心类似的命名节点,并注意类别差异:
大多数库中的节点将包括类别格式
Point.ByCoordinates
和 UV.ByCoordinates
有相同名称,但来自不同类别
值得注意的例外情况包括内置函数、Core.Input、Core.View 和运算符
Dynamo 的基本安装中包含数百个节点,哪些节点对于开发可视化程序至关重要?我们将重点介绍以下节点:定义程序的参数(“Input”)、查看节点操作的结果(“Watch”)以及通过快捷方式定义输入或功能(“Code Block”)。
“Input”节点是可视化程序的用户(无论是自己还是他人)与关键参数交互的主要手段。以下是核心库中提供的一些节点:
“Watch”节点对于管理流经可视化程序的数据至关重要。将鼠标光标悬停在节点上,可通过节点数据预览查看节点的结果。
它有助于在 “Watch” 节点中保持其显示
或者,通过 “Watch3D” 节点查看几何图形结果。
这两个节点均位于核心库的“视图”类别中。
提示:如果可视化程序中包含许多节点,则三维预览有时可能会分散注意力。请考虑取消选中“设置”菜单中的“显示背景预览”选项,然后使用“Watch3D”节点预览几何图形。
Code Block 节点可用于定义代码块,其中各行用分号隔开。这可以像 X/Y
一样简单。
我们还可以将“代码块”用作定义“数字输入”或调用另一个节点功能的快捷方式。执行此类操作的语法遵循 Dynamo 文本语言(即 DesignScript)的命名约定。
下面是有关在脚本中使用“代码块”的简单演示(带有说明)。
双击以创建“Code Block”节点
Circle.ByCenterPointRadius(x,y);
Type
在工作空间上单击以清除选择内容,应会自动添加 x
和 y
输入。
创建“Point.ByCoordinates”节点和“数字滑块”,然后将它们连接到“代码块”的输入。
执行可视化程序的结果在三维预览中会显示为圆
曲线是我们介绍的第一个几何数据类型,有一组更熟悉的形状描述特性 - 弯曲度或笔直度如何?多长或多短?请记住,点仍然是我们的构建块,用于定义从直线到样条曲线以及它们之间的所有曲线类型。
线
多段线
圆弧
圆
椭圆
NURBS 曲线
复合线
NURBS 是一个用于精确表示曲线和曲面的模型。在 Dynamo 中使用两种不同方法制作正弦曲线,以创建 NURBS 曲线来比较结果。
“NurbsCurve.ByControlPoints” 使用一列点作为控制点
“NurbsCurve.ByPoints” 通过一列点绘制曲线
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
术语 “曲线” 通常是所有不同类型弯曲(即使是笔直)形状的全部捕捉。大写字母“C”(即“Curve”)是所有这些形状类型(直线、圆、样条曲线等)的父分类。从技术上讲,“曲线”描述了通过将“t”输入到函数集合中可以找到的所有可能点,范围可能从简单形式 (x = -1.26*t, y = t
) 到涉及微积分的函数。不论我们使用何种类型的曲线,这一名为“t”的 “参数” 都是我们可以计算的特性。此外,不论形状的外观如何,所有曲线也都具有起点和终点,它们与用于创建曲线的最小和最大 t 值一致符合。这也有助于我们了解其方向性。
请务必注意,Dynamo 假定曲线的“t”值域可理解为 0.0 到 1.0。
所有曲线还拥有许多可用于描述或分析它们的特性或特征。如果起点和终点之间的距离为零,则曲线为“闭合”。 此外,每条曲线都有多个控制点,如果所有这些点都位于同一平面中,则该曲线为“平面”的。 某些特性整体上适用于曲线,而其他特性仅适用于沿曲线的特定点。例如,平面性是全局特性,而给定 t 值处的切线向量是局部特性。
“线” 是最简单的曲线形式。它们看起来可能不弯曲,但它们实际上是曲线 - 只是没有任何曲率。创建直线的方法有几种,最直观的形式是从点 A 到点 B。在这两个点之间绘制“直线 AB”的形状,但在数学上它在两个方向上无限延伸。
将两条直线连接在一起时,我们得到了 “多段线”。在此处,我们可以直接了解什么是“控制点”。编辑其中任何点位置都将更改多段线的形状。如果多段线是闭合的,则会得到一个多边形。如果多边形的边长全部相等,则将其描述为常规边。
随着我们为定义形状的参数化函数增加了更多复杂性,我们可以从直线进一步创建 “圆弧” 、“圆” 、“椭圆圆弧” 或 “椭圆”,方法是描述一个或两个半径。“圆弧”版本与“圆”或“椭圆”之间的差异仅在于形状是否是闭合的。
NURBS(非均匀有理基本样条曲线)是数学表示形式,可以对任何形状进行精确建模(从简单的二维直线、圆、圆弧或矩形到最复杂的三维自由形式有机曲线)。由于其灵活性(相对较少的控制点,但基于“阶数”设置的平滑插值)和精度(受强大的数学约束),NURBS 模型可用于从插图、动画到制造的任何过程。
阶数:曲线的阶数确定了控制点对曲线的影响范围;阶数越高,范围越大。“阶数”为正整数。此数字通常为 1、2、3 或 5,但可以是任意正整数。NURBS 直线和多段线通常为 1 阶,并且大多数自由形式曲线为 3 阶或 5 阶。
控制点:控制点是一列至少包含 Degree+1 的点。更改 NURBS 曲线形状的最简单方法之一是移动其控制点。
权重:控制点具有一个称为“权重”的关联数字。权重通常为正数。当曲线的控制点全都具有相同的权重(通常为 1)时,曲线称为“非有理性曲线”,否则曲线称为“有理曲线”。大多数 NURBS 曲线是非有理性曲线。
结:结是一列 (Degree+N-1) 数字,其中 N 是控制点的数量。结与权重一起使用,以控制控制点对生成的曲线的影响。结的一个用途是在曲线中的某些点处创建扭折。
阶数 = 1
阶数 = 2
阶数 = 3
请注意,阶数值越高,则用于对生成的曲线进行插值的控制点越多。
作为可视化编程环境,Dynamo 使您可以构思数据的处理方式。数据是数字或文本,但几何体也是数据。根据计算机的理解方式,几何体(有时也称为计算几何体)是我们可以用来创建精美、复杂或性能驱动的模型的数据。为此,我们需要了解我们可以使用的各种几何图形的详细内容。
在我们准备好深入探讨开发可视化程序后,我们将需要深入了解我们将使用的构建块。本章介绍有关数据的基本概念 - 介绍通过 Dynamo 程序的“导线”的内容。
逻辑,或更确切地说是条件逻辑,允许我们基于测试指定一个操作或操作集。在评估测试后,我们将得到一个布尔值,该值表示 True
或 False
,我们可以使用它来控制程序流。
数字变量可以存储整个范围的不同数字。布尔变量只能存储两个名为“True”或“False”、“Yes”或“No”、“1”或“0”的值。由于布尔范围有限,我们很少使用布尔来执行计算。
“If”语句是编程中的关键概念:如果 this 为 true,则 that 发生;否则 something else 发生。语句的结果操作由布尔值驱动。在 Dynamo 中,有多种方法可定义“If”语句:
图标 | 名称(语法) | 输入(Inputs) | 输出 (Outputs) |
---|
接下来,我们来看一个简短示例,分别介绍这三个节点在使用“If”条件语句时的行为。
在本图中,“boolean”设置为“true”,这意味着结果是字符串读取:“this is the result if true”。在此处,创建 “If” 语句的三个节点的工作方式相同。
同样,该节点的工作方式也相同。如果 “boolean” 更改为 “false”,则结果是 “Pi” 数字,如原始 “If” 语句中所定义。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
我们使用逻辑将一列数字分隔为一列偶数和一列奇数。
a.Number Range - 向画布添加一个数字范围。
b.Numbers - 向画布添加三个数字节点。每个数字节点的值应为:“start”为“0.0”、“end”为“10.0”以及“step”为“1.0”。
c.Output - 输出是一列 11 个数字(范围从 0 到 10)。
d.求模(%) - “Number Range” 连接到 “x” , “2.0” 连接到 “y”。这将计算列表中每个数字除以 2 的余数。此列表的输出将给出一列介于 0 和 1 之间的交替值。
e.相等测试 (==) - 向画布添加相等测试。将 “modulo” 输出连接到 “x” 输入,将 “0.0” 输入连接到 “y” 输入。
f.Watch - 相等测试的输出是一列介于 true 和 false 之间的交替值。这些值用于分隔列表中的项目。0(或 true)表示偶数,1(或 false)表示奇数。
g.List.FilterByBoolMask - 此节点会根据输入布尔值将值过滤为两个不同的列表。将原始 “number range” 连接到 “list” 输入,将 “equality test” 输出连接到 “mask” 输入。“in” 输出表示 true 值,而 “out” 输出表示 false 值。
h.Watch - 结果,我们现在得到了一列偶数和一列奇数。我们已使用逻辑运算符将列表分成各图案!
在第一个练习中建立的逻辑基础上,我们将此设置应用于建模操作。
2.我们将从上一个具有相同节点的练习跳转。唯一的例外(除了更改格式外):
a.使用具有这些输入值的 “Sequence” 节点。
b.我们已取消将列表输入连接到 “List.FilterByBoolMask”。现在,我们将这些节点放在旁边,但稍后在练习中,它们会派上用场。
3.首先,我们创建一组单独的图形,如上图所示。该组节点表示参数方程,用于定义曲线。几点注意事项:
a.第一个 “数字滑块” 表示波浪的频率,其最小值应为 1,最大值应为 4,步长应为 0.01。
b.第二个 “数字滑块” 表示波浪的振幅,其最小值应为 0,最大值应为 1,步长应为 0.01。
c.PolyCurve.ByPoints - 如果复制上述节点图表,则在 Dynamo 预览视口中结果为正弦曲线。
此处的输入方法:使用数字节点可获得更多静态特性,使用数字滑块可获得更多灵活特性。我们希望保留在此步骤开头定义的原始数字范围。但是,我们在此处创建的正弦曲线应该具有一定的灵活性。我们可以移动这些滑块,来观察曲线更新的频率和振幅。
4.我们在定义中跳过一点,从而看一下最终结果,以便我们可以参照所得到的内容。前两个步骤是分别进行的,我们现在要将这两个步骤连接起来。我们将使用基础正弦曲线来驱动拉链组件的位置,我们将使用 true/false 逻辑以在小框和大框之间交替。
a.Math.RemapRange - 使用在步骤 02 中创建的数字序列,我们通过重新映射范围来创建一系列新数字。原始数字来自步骤 01,范围为 0-100。这些数字介于 0 到 1,分别通过 “newMin” 和 “newMax” 输入。
5.创建 “Curve.PointAtParameter” 节点,然后将步骤 04 中的 “Math.RemapRange” 输出连接为其 “param” 输入。
此步骤将沿曲线创建点。我们将数字重新映射为 0 到 1,因为 “param” 的输入将查找此范围中的值。值为 “0” 表示开始点,值为 “1” 表示结束点。介于两者之间的所有数字均在 “[0,1]” 范围内求值。
6.将 “Curve.PointAtParameter” 的输出连接到 “List.FilterByBoolMask”,以分隔奇数和偶数索引列表。
a.List.FilterByBoolMask - 将上一步的**“Curve.PointAtParameter”**连接到_“list”_输入。
b.Watch -_“in”的观察节点和“out”_的观察节点表明,我们有表示偶数索引和奇数索引的两个列表。这些点在曲线上的排序方式相同,我们将在下一步中进行演示。
7.接下来,我们将在步骤 05 中使用 “List.FilterByBoolMask” 的输出结果,以根据其索引生成具有大小的几何图形。
Cuboid.ByLengths - 重新创建在上图中所见到的连接,以沿正弦曲线获得拉链。立方体在此处就是一个框,我们将基于框中心的曲线点定义其大小。现在,偶数/奇数分割的逻辑在模型中应该一清二楚。
a.偶数索引处的立方体列表。
b.奇数索引处的立方体列表。
大功告成!您刚刚编写了一个根据本练习中演示的逻辑操作定义几何图形尺寸的过程。
如果我们要构建无法基于单个曲面创建的更复杂模型,或者要定义明确的体积,我们现在必须进入到(和多边形曲面)领域。即使简单的立方体也足够复杂,需要六个曲面,每个面一个。实体可用于访问曲面所没有的两个关键概念 - 更加优化的拓扑描述(面、边、顶点)和布尔操作。
可以使用修改实体。让我们使用几个布尔操作来创建一个尖球。
Sphere.ByCenterPointRadius:创建基本体。
Topology.Faces、Face.SurfaceGeometry:查询实体的面并转换为曲面几何图形(在本例中,球体仅有一个面)。
Cone.ByPointsRadii:使用曲面上的点构造圆锥体。
Solid.UnionAll:使圆锥体和球体合并。
Topology.Edges:查询新实体的边
Solid.Fillet:对尖球的边进行圆角处理
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
布尔运算很复杂,计算速度可能很慢。使用“冻结”功能可暂停选定节点和受影响的下游节点的执行。
1.使用快捷上下文菜单可冻结“实体并集”操作
2.选定节点和所有下游节点将以浅灰色重影模式预览,并且受影响的线将显示为虚线。受影响的几何体预览也将生成重影。现在,可以在上游修改值,而无需计算布尔并集。
3.要解冻节点,请单击鼠标右键,然后取消选中“冻结”。
4.所有受影响的节点和关联的几何图形预览将更新并还原为标准预览模式。
您可以在[4_nodes_and_wiresmentiontitle部分,阅读有关冻结节点的详细信息。
实体由一个或多个曲面组成,这些曲面包含通过定义“内”或“外”的闭合边界进行定义的体积。 无论这些曲面有多少,它们都必须形成“无间隙”体积才能视为实体。可以通过将曲面或多边形曲面连接在一起,或者使用放样、扫掠和旋转等操作来创建实体。球体、立方体、圆锥体和圆柱体基本体也是实体。至少删除了一个面的立方体视为多边形曲面,它具有一些类似的属性,但它不是实体。
平面由单个曲面组成,而且不是实体。
球体由一个曲面组成,但_是_实体。
圆锥体由两个连接在一起以形成实体的曲面组成。
圆柱体由三个连接在一起以形成实体的曲面组成。
立方体由六个连接在一起以形成实体的曲面组成。
实体由三种类型的元素组成:顶点、边和面。面是组成实体的曲面。边是定义相邻面之间的连接的曲线,顶点是这些曲线的起点和终点。可以使用拓扑节点查询这些图元。
面
边
顶点
可以通过对实体的边进行圆角或倒角操作来修改实体,以消除锐角和角度。倒角操作可在两个面之间创建规则曲面,而圆角可在面之间过渡以保持相切。
实体立方体
倒角立方体
圆角立方体
实体布尔运算是用于合并两个或两个以上实体的方法。单个布尔操作实际上意味着执行四项操作:
与两个或多个对象相交。
在交点处分割它们。
删除几何图形中不需要的部分。
重新连接所有内容。
并集:删除实体的重叠部分,并将它们合并为单个实体。
差集:从一个实体中减去另一个实体。要减去的实体称为工具。请注意,可以切换哪个实体是保留反向体积的工具。
交集:仅保留两个实体的相交体积。
UnionAll:使用球体和朝外的圆锥体进行并集操作
DifferenceAll:使用球体和朝内圆锥体时的差集运算
在计算建模领域,是表示三维几何图形的最普遍形式之一。网格几何图形通常由一组四边形或三角形组成,它可以是使用 NURBS 的轻量级和灵活的替代方案,并且网格用于从渲染和可视化到数字制造和三维打印的所有领域。
Dynamo 使用“面-顶点”数据结构定义网格。在最基本的层次上,此结构只是分组为多边形的点集。网格的点称为“顶点”,而类似曲面的多边形称为“面”。
要创建网格,我们需要一列顶点和将这些顶点分组为面的系统(称为“索引组”)。
顶点列表
用于定义面的索引组列表
该库还提供了一些工具,可用于修改网格、修复网格或提取水平切片以在制造中使用。
网格是表示曲面或实体几何图形的四边形和三角形的集合。像实体一样,网格对象的结构包括顶点、边和面。还有一些使网络独一无二的特性,例如法线。
网格顶点
网格边 *仅具有一个邻接面的边称为“裸边”。 所有其他边均为“装饰边”
网格面
网格的顶点只是一列点。在构建网格或获取网格结构的相关信息时,顶点的索引非常重要。对于每个顶点,还有一个相应的顶点法线(向量),它描述了附加面的平均方向,并帮助我们了解网格的“入”和“出”方向。
顶点
顶点法线
面是由三个或四个顶点组成的有序列表。因此,根据要建立索引的顶点位置,网格面的“曲面”表示处于隐含状态。我们已经拥有构成网格的顶点列表,因此无需提供单独的点来定义面,只需使用顶点的索引即可。这样,我们还可以在多个面中使用同一顶点。
使用索引 0、1、2 和 3 创建的四边形面
使用索引 1、4 和 2 创建的三角形面 请注意,索引组可以按其顺序移动 - 只要该顺序按逆时针顺序排序,相应面将正确定义
网格几何图形与 NURBS 几何图形有何不同?何时可能要使用其中一个而不是另一个?
在前一章中,我们看到 NURBS 曲面由一系列沿两个方向的 NURBS 曲线进行定义。这些方向标有 U
和 V
,并允许根据二维曲面域对 NURBS 曲面进行参数化。曲线本身作为方程存储在计算机中,从而允许将生成的曲面计算为任意小的精度。但是,将多个 NURBS 曲面组合在一起可能会非常困难。连接两个 NURBS 曲面将生成多重曲面,其中几何图形的不同部分将具有不同的 UV 参数和曲线定义。
曲面
等参(等参线)曲线
曲面控制点
曲面控制多边形
等参点
曲面框架
网格
裸边
网格网络
网格边
顶点法线
网格面/网格面法线
另一方面,网格由许多离散的精确定义的顶点和面组成。顶点网络通常无法通过简单的 UV
坐标进行定义;由于面是离散的,因此精度量内置到网格中,并只能通过优化网格和添加更多面来进行更改。由于缺少数学描述,因此网格可以更灵活地处理单个网格内的复杂几何图形。
另一个重要区别是网格或 NURBS 几何图形中的局部更改影响整个形状的程度。移动网格的一个顶点只会影响与该顶点相邻的面。在 NURBS 曲面中,影响范围更加复杂,具体取决于曲面的阶数以及控制点的权重和结。但通常,在 NURBS 曲面中移动单个控制点会在几何图形中产生更平滑、更广泛的更改。
NURBS 曲面 - 移动控制点具有延伸到形状上的影响
网格几何图形 - 移动顶点仅对相邻图元有影响
一个可能有用的类比是将向量图像(由直线和曲线组成)与光栅图像(由各个像素组成)进行比较。如果放大向量图像,曲线将保持清晰明了,而放大光栅图像的结果是看到各个像素变大。在此类比中,可以将 NURBS 曲面与向量图像进行比较,因为存在平滑的数学关系,而网格的行为与具有设定分辨率的光栅图像类似。
数据是我们程序的内容。它穿过连线,为节点提供输入,在这些节点中处理为新形式的输出数据。让我们回顾一下数据的定义、数据的结构,然后开始在 Dynamo 中使用它。
数据是一组定性变量或定量变量的值。最简单形式的数据是数字,如 0
、3.14
或 17
。但数据也可以是多种不同的类型:表示变化数字的变量 (height
);字符 (myName
);几何图形 (Circle
);或一列数据项 (1,2,3,5,8,13,...
)。
在 Dynamo 中,我们会向节点的输入端口添加/提供数据 - 我们可以具有无需操作的数据,但我们需要数据来处理节点表示的操作。将某个节点添加到工作空间后,如果未提供任何输入,则结果将为函数,而不是操作本身的结果。
简单数据
数据和操作(A 节点)成功执行
没有数据输入的操作(A 节点)返回通用函数
注意空值,'null'
类型表示缺少数据。尽管这是一个抽象概念,但在使用可视化编程时,您可能会遇到这种情况。如果某个操作未创建有效结果,则节点会返回空值。
测试空值并从数据结构中删除空值是创建健壮程序的关键部分。
在进行可视化编程时,我们可以非常快速地生成大量数据,并需要一种方式来管理其层次结构。这是数据结构的作用,也是我们存储数据的组织方案。数据结构的具体内容及其使用方法具体取决于编程语言。
在 Dynamo 中,我们通过列表向数据添加层次结构。我们将在后续章节中深入探讨这一点,但先让我们简单介绍一下:
列表表示放置在一个数据结构中的项目集合:
我手(列表)上有五根手指(项目)。
我的街道(列表)上有十座房屋(项目)。
“Number Sequence” 节点使用 “start” 、 “amount” 和 “step” 输入来定义一列数字。使用这些节点,我们创建了两个包含十个数字的单独列表,一个列表的范围为 100-109,另一列表的范围为 0-9。
“List.GetItemAtIndex” 节点会选择列表中特定索引处的项目。选择 “0” 时,我们会得到列表中的第一项(在本例中为 “100” )。
通过将相同过程应用于第二个列表,得到的值为 “0”,即列表中的第一项。
现在,我们使用 “List.Create” 节点将这两个列表合并为一个列表。请注意,该节点将创建_一列列表_。这会更改数据的结构。
再次使用 “List.GetItemAtIndex” 时,如果索引设置为 “0”,则我们将获得该列列表中的第一个列表。这就是将列表视为项目的含义,这与其他脚本编写语言略有不同。在后面的章节中,我们将通过列表操作和数据结构获得更高级的功能。
在 Dynamo 中了解数据层次结构的关键概念:在数据结构方面,列表被视为项目。换句话说,Dynamo 通过自上而下的过程来了解数据结构。这意味着什么?我们通过一个示例来介绍它。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在此第一个示例中,我们装配了一个带壳圆柱体,该圆柱体遍历本节中讨论的几何图像层次结构。
1.添加 “Point.ByCoordinates” - 向画布添加节点后,我们会在 Dynamo 预览栅格的原点处看到一个点。“x,y”和“z”输入的默认值为“0.0”,从而在此位置处向我们提供一个点。
2.Plane.ByOriginNormal - 几何图形层次结构中的下一步是平面。有几种构建平面的方法,我们使用原点和法线作为输入。原点是在上一步中创建的点节点。
Vector.ZAxis - 这是 Z 方向上单位化的向量。请注意,没有输入,仅有值为 [0,0,1] 的向量。我们将此项用作 “Plane.ByOriginNormal” 节点的 “normal” 输入。这样,我们在 Dynamo 预览中就得到了一个矩形平面。
3.Circle.ByPlaneRadius - 逐步扩展层次结构,我们现在基于上一步中的平面创建曲线。在连接到节点后,我们会在原点处得到一个圆。节点上的默认半径值为 “1”。
4.Curve.Extrude - 现在,我们通过增加其深度并进入第三维,使该内容弹出。该节点基于曲线创建曲面,方法是拉伸该曲线。节点上的默认距离为 “1”,应该可以在视口中看到一个圆柱体。
5.Surface.Thicken - 此节点通过将曲面偏移给定距离并闭合形状,从而为我们提供一个闭合实体。默认厚度值为 “1”,我们会在视口中看到一个与这些值对应的带壳圆柱体。
6.数字滑块 - 我们不使用所有这些输入的默认值,而是向模型添加一些参数化控件。
域编辑 - 在向画布添加数字滑块后,单击左上角的插入符号可显示域选项。
最大值/最小值/步长 - 将 “min” 、 “max” 和 “step” 值分别更改为 “0” 、 “2” 和 “0.01”。我们这样做的目的是控制整个几何图形的大小。
7.数字滑块 - 在所有默认输入中,我们复制并粘贴此数字滑块(选择滑块、按 Ctrl+C,然后按 Ctrl+V)多次,直到具有默认值的所有输入都有滑块为止。某些滑块值必须大于零,才能使定义生效(即:需要拉伸深度才能加厚曲面)。
8.现在,我们已使用这些滑块创建参数化带壳圆柱体。尝试调整其中一些参数,然后在 Dynamo 视口中动态查看几何图形更新。
数字滑块 - 更进一步对此进行介绍,我们已向画布添加了很多滑块,并且需要清理刚刚创建的工具的界面。在一个滑块上单击鼠标右键、选择“重命名...”,然后将每个滑块更改为其参数的相应名称(厚度、半径、高度等)。
9.此时,我们创建了一个令人惊叹的加厚圆柱体。目前,这是一个对象,让我们来看看如何创建一个圆柱体阵列,其中圆柱体保持动态链接。为此,我们将创建一列圆柱体,而不是使用单个项。
加(+) - 我们的目的是在创建的圆柱体旁边添加一排圆柱体。如果要添加一个与当前圆柱体相邻的圆柱体,我们需要考虑圆柱体的半径及其壳厚度。通过添加滑块的两个值,可得到此数字。
10.该步骤更加复杂,因此让我们缓慢地逐步介绍:最终目的是创建一列数字,用于定义每个圆柱体在一排中的位置。
a.相乘 - 首先,我们要将上一步中的值乘以 2。上一步中的值表示半径,我们希望将圆柱体移动整个直径。
b.数字序列 - 使用此节点创建数字数组。第一个输入是上一步中的 “multiplication” 节点到 “step” 值。可以使用 “number” 节点将 “start” 值设置为 “0.0”。
c.整数滑块 - 对于 “amount” 值,我们会连接整数滑块。这将定义创建多少个圆柱体。
d.输出 - 此列表显示阵列中每个圆柱体移动的距离,并由原始滑块以参数化方式驱动。
11.此步骤足够简单 - 将上一步中定义的序列连接到原始 “Point.ByCoordinates” 的 “x” 输入。这将替换可以删除的滑块 “pointX”。现在,在视口中可以看到圆柱体阵列(确保整数滑块大于 0)。
12.圆柱体链仍与所有滑块动态链接。调整每个滑块以观察定义更新!
我们在模型中使用来表示在三维世界中所看到的对象。虽然曲线并非始终是平面的(即它们是三维的),但它们定义的空间始终绑定到一个维度。曲面为我们提供了另一个维度和一组附加特性,我们可以在其他建模操作中使用它们。
在 Dynamo 中输入和评估“参数处的曲面”,以查看我们可以提取的信息类型。
“Surface.PointAtParameter” 返回给定 UV 坐标处的点
“Surface.NormalAtParameter” 返回给定 UV 坐标处的法线向量
“Surface.GetIsoline” 返回 U 或 V 坐标处的等参曲线 - 请注意“isoDirection”输入。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
曲面是由函数和两个参数定义的数学形状,我们使用 U
和 V
(而不是曲线的 t
)来描述相应的参数空间。这意味着,在处理此类型的几何体时,我们需要从中绘制更多的几何数据。例如,曲线具有切线向量和法线平面(可以沿曲线的长度旋转或扭曲),而曲面具有在其方向上保持一致的法线向量和切线平面。
曲面
U 向等参曲线
V 向等参曲线
UV 坐标
垂直平面
法线向量
曲面域:曲面域定义为“(U,V)”参数的范围,这些参数评估为该曲面上的三维点。每个维度中的域(U 或 V)通常描述为两个数字(U 最小值到 U 最大值)和(V 最小值到 V 最大值)。
尽管曲面的形状看起来不是“矩形”,但是局部可能有更紧或更松的等参曲线集,由其域定义的“空间”始终是二维的。在 Dynamo 中,始终可以将曲面理解为使域在 U 和 V 方向上最小为 0.0 且最大为 1.0。平面曲面或修剪曲面可能具有不同的域。
Isocurve(等参曲线):由曲面上的恒定 U 或 V 值定义的曲线,以及相应其他 U 或 V 方向的值域。
UV 坐标:UV 参数空间中的点由 U、V(有时为 W)定义。
垂直平面:在给定 UV 坐标处与 U 向和 V 向等位曲线垂直的平面。
法线向量:定义相对于垂直平面的“向上”方向向量。
NURBS 曲面与 NURBS 曲线非常相似。可以将 NURBS 曲面视为位于两个方向上的 NURBS 曲线的栅格。NURBS 曲面的形状由多个控制点以及该曲面在 U 和 V 方向的阶数定义。相同的算法用于通过控制点、权重和阶数来计算形状、法线、切线、曲率和其他特性。
对于 NURBS 曲面,几何图形会隐含两个方向,因为无论我们看到的是什么形状,NURBS 曲面都是矩形控制点栅格。尽管这些方向通常与世界坐标系任意相关,但我们将经常使用它们来分析模型或基于曲面生成其他几何图形。
阶数 (U,V) = (3,3)
阶数 (U,V) = (3,1)
阶数 (U,V) = (1,2)
阶数 (U,V) = (1,1)
多边形曲面由跨边连接的曲面组成。多边形曲面提供了超过二维的 UV 定义,现在我们可以通过其拓扑在连接的形状中移动。
“拓扑”通常描述了有关零件连接方式的概念和/或 Dynamo 中的相关拓扑也是一种几何体类型。特别是,它是“曲面”、“多边形曲面”和“实体”的父类别。
有时称为“面片”,以这种方式连接曲面可以创建更加复杂的形状,并定义跨接缝的细节。我们可以方便地将圆角或倒角操作应用到多边形曲面的边。
如果最简单的数据形式是数字,则将这些数字关联起来的最简单方法是通过数学。从除法等简单的运算符到三角函数,再到更复杂的公式,Math 是开始探索数值关系和模式的好方法。
运算符是一组组件,这些组件使用具有两个数字输入值的代数函数,这些结果产生一个输出值(加、减、乘、除等)。这些可在“运算符”>“操作”下找到。
图标 | 名称(语法) | 输入(Inputs) | 输出 |
---|
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
通过公式将运算符和变量组合在一起以形成更复杂的关系。使用滑块来创建可由输入参数控制的公式。
1.创建表示参数方程中“t”的数字序列,因此我们要使用足够大的列表来定义螺旋。
Number Sequence:基于以下三个输入定义数字序列:start、amount 和 step。
2.上述步骤已创建一列数字,来定义参数化域。接下来,创建表示黄金螺旋方程的节点组。
黄金螺旋定义为以下方程:
下图以可视化编程形式呈现了黄金螺旋。在逐步查看节点组时,请尝试注意可视化程序和编写方程之间的平行性。
a.Number Slider:向画布添加两个数字滑块。这些滑块将表示参数方程的 “a” 和 “b” 变量。这些表示灵活的常量,或我们可以根据所需结果调整的参数。
b.相乘 (*):乘法节点由星号表示。我们将反复使用它来连接乘法变量
c.Math.RadiansToDegrees:“t”值需要转换为度数,以便在三角函数中进行求值。请记住,Dynamo 默认使用度数来对这些函数求值。
d.Math.Pow:作为“t”和数字“e”的函数,这将创建 Fibonacci 数列。
e.Math.Cos 和 Math.Sin:这两个三角函数将分别区分每个参数点的 x 坐标和 y 坐标。
f.Watch:现在,我们看到输出为两个列表,它们将是用于生成螺旋的点的 x 和 y 坐标。
Point.ByCoordinates:将上乘法节点连接到 “x” 输入,将下乘法节点连接到 “y” 输入。现在,我们在屏幕上会看到点的参数化螺旋。
Polycurve.ByPoints:将上一步的 “Point.ByCoordinates” 连接到 “points”。我们可以不输入而保留 “connectLastToFirst”,因为我们不会绘制闭合曲线。这将创建穿过上一步中定义的每个点的螺旋。
我们现在已完成 Fibonacci 螺旋!让我们从此处开始进一步研究两个独立的练习,我们称之为 Nautilus 和 Sunflower。这些是自然系统的抽象表示,但 Fibonacci 螺旋的两种不同应用将得到充分体现。
Circle.ByCenterPointRadius:我们将在此处使用“Circle”节点,其输入与上一步相同。半径值默认为 “1.0”,因此可以看到圆即时输出。这些点与原点之间的分离程度立即清晰可辩。
Number Sequence:这是 “t” 的原始数组。通过将其连接到 “Circle.ByCenterPointRadius” 的半径值,圆心仍会与原点进一步偏离,但圆的半径不断增大,从而创建一个时髦的 Fibonacci 圆图形。
如果使其成为三维形式,可获得奖励积分!
作为一个跳跃点,我们从上一练习的相同步骤开始:使用 “Point.ByCoordinates” 节点创建点的螺旋阵列。
![](../images/5-3/2/math-part IV-01.jpg)
接下来,按照这些小步骤操作以生成一系列不同旋转的螺旋。
a.Geometry.Rotate:有多个 “Geometry.Rotate” 选项;请务必选择将 “geometry” 、 “basePlane” 和 “degrees” 作为其输入的节点。将 “Point.ByCoordinates” 连接到几何图形输入。在该节点上单击鼠标右键,并确保将连缀设置为“叉积”
b.Plane.XY:连接到 “basePlane” 输入。我们将绕原点旋转,该原点与螺旋的底部位置相同。
c.Number Range:对于度数输入,我们要创建多个旋转。我们可以使用 “Number Range” 组件快速完成此操作。将其连接到 “degrees” 输入。
d.Number:要定义数字范围,请按垂直顺序将三个数字节点添加到画布。从上到下,分别指定值 “0.0,360.0,” 和 “120.0”。这些驱动螺旋的旋转。将三个数字节点连接到相应节点后,请注意 “Number Range” 节点的输出结果。
我们的输出开始类似于旋涡。我们调整一些 “Number Range” 参数,看一看结果如何变化。
将 “Number Range” 节点的步长从 “120.0” 更改为 “36.0”。请注意,这将创建更多旋转,因此会为我们提供更密集的栅格。
将 “Number Range” 节点的步长从 “36.0” 更改为 “3.6”。现在,我们得到更密集的栅格,但螺旋的方向性尚不清楚。女士们,先生们:我们创建了一颗向日葵。
列表是我们组织数据的方式。在计算机的操作系统上,有文件和文件夹。在 Dynamo 中,我们可以分别将它们视为项目和列表。与操作系统一样,可通过多种方法创建、修改和查询数据。在本章中,我们将分析如何在 Dynamo 中管理列表。
创建:从头开始创建或构建几何图形。例如,圆。
操作:对对象执行操作。例如,缩放圆。
查询:获取已存在对象的特性。例如,获取圆的半径。
节点 | 节点 | ||
---|---|---|---|
直线由一组点组成,每条直线至少有 2 个点。在 Dynamo 中创建直线的最常见方法之一是使用 Line.ByStartPointEndPoint
在 Dynamo 中创建直线。
这使实体布尔成为一个强大的省时过程。有三种实体布尔运算,它们可区分保留几何图形的哪些部分。
除了这三项操作,Dynamo 还具有 “Solid.DifferenceAll” 和 “Solid.UnionAll” 节点,用于对多个实体执行差集和并集操作。
Dynamo 的网格功能可通过安装软件包进行扩展。Dynamo Mesh Toolkit 包提供了多种工具,可从外部文件格式输入网格、从 Dynamo 几何图形对象创建网格,以及按顶点和索引手动构建网格。
例如,有关使用此软件包的信息,请访问 。
图标 | 名称/语法 | 输入(Inputs) | 输出 (Outputs) |
---|
现在,上一步中的大部分节点都可以正常工作,但这种工作量很大。要创建更高效的工作流,请查看,以将 Dynamo 表达式的字符串定义到一个节点中。在接下来的一系列步骤中,我们将了解如何使用参数方程绘制 Fibonacci 螺旋。
现在的情况是,我们已创建一个圆形 Nautilus 壳,接下来我们转到参数化栅格。我们将在 Fibonacci 螺旋上使用基本旋转来创建 Fibonacci 栅格,然后在后对结果进行建模。
Boolean
Number
String
Number Slider
Directory Path
Integer Slider
File Path
创建 |
Color.ByARGB 按 Alpha、红色、绿色和蓝色分量构造颜色。 |
颜色范围 基于起点颜色和终点颜色之间的颜色渐变获取颜色。 |
操作 |
Color.Brightness 获取该颜色的亮度值。 |
Color.Components 按以下顺序列出颜色分量:Alpha、红、绿、蓝。 |
Color.Saturation 获取该颜色的饱和度值 |
Color.Hue 获取该颜色的色调值。 |
查询 |
Color.Alpha 查找颜色的 Alpha 分量:0 到 255。 |
Color.Blue 查找颜色的蓝色分量:0 到 255。 |
Color.Green 查找颜色的绿色分量:0 到 255。 |
Color.Red 查找颜色的红色分量:0 到 255。 |
创建 |
GeometryColor.ByGeometryColor 使用一种颜色显示几何图形。 |
操作 |
View.Watch 将节点输出内容可视化。 |
View.Watch 3D 显示几何图形的动态预览。 |
操作 |
布尔 在“True”和“False”之间选择。 |
代码块 允许直接编写 DesignScript 代码。 |
目录路径 允许您选择系统上的目录以获取其路径 |
文件路径 允许您选择系统上的文件以获取其文件名 |
整数滑块 用于生成整数值的滑块。 |
编号 创建数字。 |
数字滑块 用于生成数字值的滑块。 |
字符串 创建字符串。 |
Object.IsNull 确定给定对象是否为 Null。 |
创建 |
List.Create 基于给定输入创建一个新列表。 |
List.Combine 将组合器应用于两个序列中的每个元素 |
数字范围 按指定范围创建一系列数字 |
数字序列 创建一系列数字。 |
操作 |
List.Chop 将某个列表切成一组列表,其中每个列表包含给定数量的项目。 |
List.Count 返回存储于给定列表中的项数。 |
List.Flatten 按一定数量展平一列嵌套列表。 |
List.FilterByBoolMask 通过在单独布尔列表中查找相应索引过滤序列。 |
List.GetItemAtIndex 获取位于指定索引处给定列表中的项目。 |
List.Map 将函数应用于列表的所有元素,从而基于结果生成一个新列表。 |
List.Reverse 以相反顺序创建包含给定列表各项的新列表。 |
List.ReplaceItemAtIndex 替换位于指定索引处给定列表中的项目。 |
List.ShiftIndices 将列表中的索引右移给定数量 |
List.TakeEveryNthItem 在给定偏移后是给定值倍数的索引处提取给定列表的项。 |
List.Transpose 交换一列列表中的行和列。如果一些行长短不一,则 Null 值将作为占位符插入结果数组中,使其始终为矩形 |
操作 |
If 条件语句。检查测试输入的布尔值。如果测试输入为 True,则结果将输出 True 输入,否则结果将输出 False 输入。 |
操作 |
Math.Cos 查找角度的余弦。 |
Math.DegreesToRadians 将以度为单位的角度换算为以弧度为单位的角度。 |
Math.Pow 求数字的指定次幂。 |
Math.RadiansToDegrees 将以弧度为单位的角度换算为以度为单位的角度。 |
Math.RemapRange 调整数字列表的范围,同时保留分布率。 |
Math.Sin 查找角度的正弦。 |
公式 计算数学公式。使用 NCalc 进行评估。请参见 http://ncalc.codeplex.com |
映射 将值映射到输入范围 |
操作 |
String.Concat 将多个字符串合并为单个字符串。 |
String.Contains 确定给定字符串是否包含给定子字符串。 |
String.Join 将多个字符串合并为单个字符串,在每个连接的字符串之间插入给定分隔符。 |
String.Split 使用由给定分隔符字符串确定的分段,将单个字符串拆分为字符串列表。 |
String.ToNumber 将字符串转换为整数或双精度数。 |
创建 |
Circle.ByCenterPointRadius 以世界坐标系 Z 轴为法线,通过在世界坐标系 XY 平面输入圆心和半径创建圆。 |
Circle.ByPlaneRadius 在输入平面内以输入平面原点(根)为圆心,按给定半径创建圆。 |
创建 |
CoordinateSystem.ByOrigin 创建坐标系,方法是使其原点位于输入点,X 和 Y 轴设置为 WCS 的 X 和 Y 轴 |
CoordinateSystem.ByCyclindricalCoordinates 在指定柱面坐标参数处相对于指定坐标系创建坐标系 |
创建 |
Cuboid.ByLengths 以 WCS 原点为中心,使用宽度、长度和高度创建立方体。 |
Cuboid.ByLengths(原点) 以输入点为中心,使用特定宽度、长度和高度创建立方体。 |
Cuboid.ByLengths(坐标系) 以 WCS 原点为中心,使用宽度、长度和高度创建立方体。 |
Cuboid.ByCorners 通过从低点到高点延伸创建立方体。 |
Cuboid.Length 返回立方体的输入尺寸标注,而不是实际的世界空间尺寸标注。** |
Cuboid.Width 返回立方体的输入尺寸标注,而不是实际的世界空间尺寸标注。** |
Cuboid.Height 返回立方体的输入尺寸标注,而不是实际的世界空间尺寸标注。** |
BoundingBox.ToCuboid 获取边界框作为实心长方体 |
操作 |
Curve.Extrude(距离) 朝法向量方向拉伸曲线。 |
Curve.PointAtParameter 获取 StartParameter() 和 EndParameter() 之间指定参数处曲线上的点。 |
操作 |
Geometry.DistanceTo 获取从该几何图形到另一个几何图形的距离。 |
Geometry.Explode 将复合或非单独图元拆分为其构件 |
Geometry.ImportFromSAT 输入几何图形的列表 |
Geometry.Rotate(基准面) 绕平面原点和法线将对象旋转指定度数。 |
Geometry.Translate 将任意几何图形类型按给定距离朝给定方向平移。 |
创建 |
Line.ByBestFitThroughPoints 创建最逼近点散布图的直线。 |
Line.ByStartPointDirectionLength 从某个点开始创建直线,朝向量方向延伸指定长度。 |
Line.ByStartPointEndPoint 在两个输入点之间创建一条直线。 |
Line.ByTangency 创建与输入曲线相切的直线,定位于输入曲线的参数点处。 |
查询 |
Line.Direction 曲线的方向。 |
创建 |
NurbsCurve.ByControlPoints 使用显式控制点创建 BSplineCurve。 |
NurbsCurve.ByPoints 通过在各点之间插值创建 BSplineCurve |
创建 |
NurbsSurface.ByControlPoints 通过使用具有指定 U 和 V 度数的显式控制点创建 NurbsSurface。 |
NurbsSurface.ByPoints 使用指定插值点以及 U 和 V 度数创建 NurbsSurface。生成的曲面将通过所有点。 |
创建 |
Plane.ByOriginNormal 以原点为中心,通过输入法向量创建平面。 |
Plane.XY 在世界坐标 XY 平面中创建平面 |
创建 |
Point.ByCartesianCoordinates 在给定坐标系中通过 3 个笛卡尔坐标形成一个点 |
Point.ByCoordinates(二维) 在 XY 平面中通过 2 个笛卡尔坐标形成一个点。Z 分量为 0。 |
Point.ByCoordinates(三维) 通过给定的 3 个笛卡尔坐标形成一个点。 |
Point.Origin 获取原点 (0,0,0) |
操作 |
Point.Add 将向量添加到点。相当于平移(向量)。 |
查询 |
Point.X 获取点的 X 分量 |
Point.Y 获取点的 Y 分量 |
Point.Z 获取点的 Z 分量 |
创建 |
Polycurve.ByPoints 由连接点的直线序列生成 PolyCurve。对于闭合曲线,最后一个点应与起点位于同一位置。 |
创建 |
Rectangle.ByWidthLength(平面) 以输入平面原点为中心,按输入宽度(平面 X 轴长度)和长度(平面 Y 轴长度)创建矩形。 |
创建 |
Sphere.ByCenterPointRadius 以输入点为球心,按给定半径创建实心球体。 |
创建 |
Surface.ByLoft 通过在输入横截面曲线之间放样来创建实体 |
Surface.ByPatch 通过在由输入曲线确定的闭合边界内填充来创建曲面。 |
操作 |
Surface.Offset 在曲面法线方向上,按指定距离偏移曲面 |
Surface.PointAtParameter 返回指定 U 和 V 参数处的点。 |
Surface.Thicken 将曲面加厚为实体,以朝曲面法线方向在曲面两侧进行拉伸。 |
创建 |
UV.ByCoordinates 由两个双精度数创建 UV。 |
创建 |
Vector.ByCoordinates 由 3 个欧几里得坐标形成一个向量 |
Vector.XAxis 获取规范 X 轴向量 (1,0,0) |
Vector.YAxis 获取规范 Y 轴向量 (0,1,0) |
Vector.ZAxis 获取规范 Z 轴向量 (0,0,1) |
操作 |
Vector.Normalized 获取向量的规范版本 |
创建 |
CoordinateSystem.ByOrigin 创建坐标系,方法是使其原点位于输入点,X 和 Y 轴设置为 WCS 的 X 和 Y 轴 |
CoordinateSystem.ByCyclindricalCoordinates 在指定柱面坐标参数处相对于指定坐标系创建坐标系 |
+ 加 |
- 减 |
* 乘 |
/ 除 |
% 模块除法会查找在除以第二个输入后得到的第一个输入的余数 |
< 小于 |
> 大于 |
== 两个值之间的相等测试。 |
Object.IsNull | obj | bool |
如果 (If) | test, true, false | 结果 |
公式 (IF(x,y,z)) | x, y, z | 结果 |
代码块 ((x?y:z);) | x? y, z | 结果 |
相加 (+) | var[]...[], var[]...[] | var[]...[] |
相减 (-) | var[]...[], var[]...[] | var[]...[] |
相乘 (*) | var[]...[], var[]...[] | var[]...[] |
相除 (/) | var[]...[], var[]...[] | var[]...[] |
颜色是用于在可视化程序中创建引入注目的视觉效果以及渲染输出差异的绝佳数据类型。处理抽象数据和改变数字时,有时难以了解变化内容以及变化程度。这是颜色的绝佳应用。
Dynamo 中的颜色是使用 ARGB 输入创建的。这对应于 Alpha、红、绿和蓝通道。Alpha 表示颜色的 透明度,而其他三种颜色用作原色来协调生成整个色谱。
图标 | 名称(语法) | 输入 | 输出 |
---|---|---|---|
下表中的颜色查询用于定义相应颜色的特性:Alpha、红、绿和蓝。请注意,Color.Components 节点给出全部四个不同输出,这使得该节点更适合查询颜色的特性。
图标 | 名称(语法) | 输入 | 输出 |
---|---|---|---|
下表中的颜色对应于 HSB 颜色空间。对于我们如何解释颜色,将颜色分为色调、饱和度和亮度无疑更加直观:应该是什么颜色?应该如何呈现多彩?颜色应该如何变亮或变暗?这分别是色调、饱和度和亮度的细分。
图标 | 名称(语法) | 输入 | 输出 |
---|---|---|---|
颜色范围类似于 #part-ii-from-logic-to-geometry练习中的 “Remap Range” 节点:它将数字列表重新映射到其他域。但它不会映射到 “数字” 域,而是基于 0 到 1 范围的输入数字映射到 “颜色渐变”。
当前节点运作良好,但第一次就使一切正常工作可能会有点勉强。熟悉颜色渐变的最佳方法是以交互方式对其进行测试。让我们快速练习,了解如何使用与数字对应的输出颜色设置渐变。
定义三种颜色:使用 “Code Block” 节点,通过插入相应的 “0” 和 “255” 组合来定义 红色、绿色 和 蓝色。
创建列表:将三种颜色合并到一个列表中。
定义索引:创建列表以定义每种颜色的夹点位置(范围从 0 到 1)。请注意,值 0.75 表示绿色。这会将绿颜色 3/4 置于颜色范围滑块中水平渐变的位置。
代码块:输入值(介于 0 和 1 之间)以转换为颜色。
“Display.ByGeometry” 节点使我们能够在 Dynamo 视口中为几何图形着色。这有助于分离不同类型的几何图形、演示参数化概念或定义用于模拟的分析图例。输入很简单:几何图形和颜色。要创建与上图类似的渐变,请将颜色输入连接到 “Color Range” 节点。
“Display.BySurfaceColors” 节点使我们能够使用颜色在整个曲面上映射数据!此功能为可视化通过离散分析(例如日光、能量和接近度)获得的数据引入了一些令人兴奋的可能性。在 Dynamo 中将颜色应用于曲面类似于在其他 CAD 环境中将纹理应用于材质。在下面的简短练习中,我们来演示如何使用此工具。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
本练习重点介绍如何以参数方式控制与几何图形平行的颜色。该几何图形是基本螺旋线,我们在下面使用 “代码块” 对其进行定义。这是一种用于创建参数化函数的快速而简单的方法;由于我们的重点是颜色(而不是几何图形),因此我们使用代码块来有效地创建螺旋线,而不会使画布变得混乱。随着底漆迁移到更高级的材质,我们会更频繁地使用代码块。
代码块:使用上述公式定义两个代码块。这是用于创建螺旋的快速参数化方法。
Point.ByCoordinates:将代码块的三个输出连接到该节点的坐标。
现在,我们会看到创建螺旋线的一组点。下一步是通过这些点创建曲线,以便我们可以可视化螺旋线。
PolyCurve.ByPoints:将 “Point.ByCoordinates” 输出连接到节点的 “points” 输入。我们会得到螺旋曲线。
Curve.PointAtParameter:将 “PolyCurve.ByPoints” 输出连接到 “curve” 输入。此步骤的目的是创建一个沿曲线滑动的参数化吸引器点。由于曲线将计算参数处的点,因此我们需要输入一个介于 0 和 1 之间的 参数 值。
数字滑块:添加到画布后,将_最小_值更改为 0.0、将 最大 值更改为 1.0、将 步长 值更改为 .01。将滑块输出插入 “Curve.PointAtParameter” 的 “param” 输入。现在,我们会沿螺旋线长度看到一个点,由滑块的百分比表示(起点处为 0,终点处为 1)。
创建参照点后,我们现在将比较参照点与定义螺旋线的原始点之间的距离。此距离值将驱动几何图形以及颜色。
Geometry.DistanceTo:将 “Curve.PointAtParameter” 输出连接到 “input”。将 “Point.ByCoordinates” 连接到几何图形输入。
Watch:结果输出会显示沿曲线从每个螺旋点到参照点的距离列表。
下一步是通过从螺旋点到参照点的距离列表来驱动参数。我们使用这些距离值来沿曲线定义一系列球体的半径。为了使球体保持合适大小,我们需要 重映射 距离值。
Math.RemapRange:将 “Geometry.DistanceTo” 输出连接到数字输入。
代码块:将值为 0.01 的代码块连接到 “newMin” 输入,将值为 1 的代码块连接到 “newMax” 输入。
Watch:将 “Math.RemapRange” 输出连接到一个节点,并将 “Geometry.DistanceTo” 输出连接到另一个节点。比较结果。
此步骤已将距离列表重新映射为较小的范围。我们可以编辑 “newMin” 和 “newMax” 值,但我们认为合适。这些值将重新映射并在整个域中具有相同的 分布率。
Sphere.ByCenterPointRadius:将 “Math.RemapRange” 输出连接到 “radius” 输入,将原始 “Point.ByCoordinates” 输出连接到 “centerPoint” 输入。
更改数字滑块的值,并观察球体更新的大小。现在,我们有了一个参数化夹具
球体的大小演示了由沿曲线的参照点定义的参数化阵列。让我们对球体半径使用相同的概念来驱动其颜色。
Color Range:在画布顶部添加。将光标悬停在 “value” 输入上时,我们注意到请求的数字介于 0 和 1 之间。我们需要重新映射 “Geometry.DistanceTo” 输出中的数字,以便它们与此域兼容。
Sphere.ByCenterPointRadius:目前,我们禁用此节点上的预览(单击鼠标右键 >“预览”)
Math.RemapRange:此过程看起来很熟悉。将 “Geometry.DistanceTo” 输出连接到数字输入。
Code Block:与之前的步骤类似,为 “newMin” 输入创建值 0,为 “newMax” 输入创建值 1。注意,在这种情况下,我们能够在一个代码块中定义两个输出。
Color Range:将 “Math.RemapRange” 输出连接到 “value” 输入。
Color.ByARGB:这是我们要为创建两种颜色所执行的操作。尽管此过程看起来可能有些古怪,但它与其他软件中的 RGB 颜色相同,我们只需使用可视化编程即可实现。
Code Block:创建由 0 和 255 组成的两个值。将两个输出连接到与上图一致的两个 “Color.ByARGB” 输入(或创建您最喜欢的两种颜色)。
Color Range: “colors” 输入要求一列颜色。我们需要基于上一步中创建的两种颜色创建此列表。
List.Create:将两种颜色合并到一个列表中。将输出连接到 “Color Range” 的 “colors” 输入。
Display.ByGeometryColor:将 “Sphere.ByCenterPointRadius” 连接到 “geometry” 输入,将 “Color Range” 连接到 “color” 输入。现在,我们在曲线域上具有平滑渐变。
如果我们之前在定义中更改了 “Number Slider” 的值,则颜色和尺寸会更新。在这种情况下,颜色和半径大小直接相关:我们现在在两个参数之间有视觉链接!
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
首先,我们需要创建(或引用)一个曲面以用作 “Display.BySurfaceColors” 节点的输入。在此示例中,我们将在正弦和余弦曲线之间放样。
该组节点将沿 Z 轴创建点,然后基于正弦和余弦函数置换它们。然后,使用这两个点列表生成 NURBS 曲线。
Surface.ByLoft:在 NURBS 曲线列表之间生成插值曲面。
File Path:选择要取样的图像文件以获取下游像素数据
使用 “File.FromPath” 将文件路径转化为某个文件,然后传递给 “Image.ReadFromFile” 以输出图像进行采样
Image.Pixels:输入某个图像并提供要沿图像的 X 和 Y 标注使用的样例值。
Slider:为 “Image.Pixels” 提供样例值
Display.BySurfaceColors:在整个曲面上分别沿 X 和 Y 映射颜色值数组
输出曲面的特写预览,分辨率为 400x300 样例
词典表示与另一数据(称为主键)相关的数据集合。词典可以搜索、删除数据并将数据插入到集合中。
我们基本上可以将词典看作真正智能的查找内容的方式。
虽然在 Dynamo 中提供词典功能有一段时间了,但 Dynamo 2.0 引入了管理此数据类型的新方式。
原始图片来源:sixtysecondrevit.com
Dynamo 2.0 带有各种词典节点供我们使用。这包括 创建、操作和查询 节点。
Dictionary.ByKeysValues
会使用提供的值和键创建词典。(条目数将是最短列表输入内容)
Dictionary.Components
会生成输入词典的组件。(这与创建节点相反。)
Dictionary.RemoveKeys
会生成一个新的词典对象,其中输入键已删除。
Dictionary.SetValueAtKeys
会根据输入键和值生成新词典,以替换相应键处的当前值。
Dictionary.ValueAtKey
会返回输入键处的值。
Dictionary.Count
会告诉您词典中有多少键值对。
Dictionary.Keys
会返回当前存储在词典中的键。
Dictionary.Values
会返回当前存储在词典中的值。
与词典建立整体关联数据是对使用索引和列表的旧方法的重大替代。
正式地,字符串是代表文字常量或某种类型变量的字符序列。非正式,字符串是文本编程术语。我们已使用数字(整数和小数)来驱动参数,可以对文本执行相同操作。
字符串可用于各种应用,包括定义自定义参数、注释文档集以及解析基于文本的数据集。字符串节点位于“核心”>“输入类别”中。
上面的示例节点都是字符串。数字可以表示为字符串、字母或整个文本数组。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
通过查询字符串,即可快速解析大量数据。我们将介绍一些基本操作,这些操作可以加快工作流并帮助实现软件互操作性。
下图考虑了来自外部电子表格的数据字符串。该字符串表示矩形在 XY 平面中的顶点。让我们在微型练习中分解一些字符串拆分操作:
“;”分隔符分割矩形的每个顶点。这将为每个顶点创建一个包含 3 个项目的列表。
点击节点中间的“+”,可创建新的分隔符。
向画布添加“,”字符串,然后连接到新的分隔符输入。
现在,我们得到了包含十个项目的列表。节点先基于 “separator0” 进行分割,然后基于 “separator1” 进行分割。
虽然上述项目列表看起来像数字,但在 Dynamo 中仍将它们视为单独的字符串。要创建点,需要将点的数据类型从“字符串”转换为“数字”。使用 “String.ToNumber” 节点可执行此操作
此节点简单明了。将 “String.Split” 结果连接到输入。输出看起来没有什么不同,但数据类型现在是 “number” ,而不是 “string”。
使用其他一些基本操作,我们现在在原点处基于原始字符串输入绘制了一个三角形。
由于字符串是通用文本对象,因此它们承载了各种应用。让我们来了解一下 Dynamo 的“核心”>“字符串类别”中的一些主要操作:
这是一个将两个字符串按顺序合并到一起的方法。这将提取列表中的每个文字字符串,并创建一个合并字符串。
以下内容表示三个字符串的串联:
通过单击节点中心的“+/-”按钮,可在串联中添加或减少字符串。
输出会提供一个串联的字符串,其中包含空格和标点符号。
合并方法与连接方法非常相似,只是它增加了标点图层。
如果您使用过 Excel,则可能遇到过 CSV 文件。这代表逗号分隔值。可以使用逗号(或在本例中,使用两个短划线)作为 “String.Join” 节点的分隔符,以创建类似的数据结构。
下图表示两个字符串的合并:
分隔符输入允许一个分隔符创建一个字符串,该字符串会分割已合并的字符串。
在本练习中,我们将使用查询和操作字符串的方法来解构 Robert Frost 的“Stopping By Woods on a Snowy Evening”诗的最后一小节。这并非最实用的应用,但在我们将概念性的字符串操作应用于节奏和韵律的清晰各行时,它将有助于我们掌握此类操作。
我们先从该诗小节的基本字符串拆分开始。首先,我们注意到书写格式基于逗号设置。我们将使用此格式来将每行分隔为单独的项目。
基础字符串将粘贴到 “String” 节点中。
另一个 “String” 节点用于表示分隔符。在本例中,我们使用的是逗号。
“String.Split” 节点将添加到画布并连接到两个字符串。
输出表明,我们现在已将各行分成各个元素。
现在,让我们了解这首诗的优美部分:最后两行。原始诗小节是一项数据。在第一步中,我们已将该数据分为各个项目。现在,我们需要搜索所需的文字。尽管我们 可以 通过选择列表的最后两项来完成此操作,但如果这是一本书,我们不希望通读所有内容并手动隔离各元素。
我们使用 “String.Contains” 节点来搜索一组字符,而不是手动搜索。这类似于在文字处理器中执行“查找”命令。在本例中,如果在项目中找到相应子字符串,则返回“true”或“false”。
在 “searchFor” 输入中,我们定义了要在诗小节中查找的子字符串。我们使用一个带有文字“And miles”的 “String” 节点。
输出结果为一列 false 或 true。我们将在下一步中使用此布尔逻辑过滤各元素。
“List.FilterByBoolMask” 是我们要用来剔除 false 和 true 的节点。“in”输出返回“mask”输入为“true”的语句,而“out”输出返回“mask”输入为“false”的语句。
“in”的输出与预期一样,为我们提供了诗小节的最后两行。
现在,我们要通过合并这两行,来再现该诗小节。查看上一步的输出时,我们注意到列表中有两个项目:
使用两个 “List.GetItemAtIndex” 节点,我们可以使用值 0 和 1 作为索引输入来隔离项目。
每个节点的输出按顺序为我们提供最后两行。
要将这两个项目合并为一个项目,我们将使用 “String.Join” 节点:
在添加 “String.Join” 节点后,我们注意到需要分隔符。
要创建分隔符,我们向画布中添加一个 “String” 节点,然后键入逗号。
最终输出已将最后两个项目合并为一个项目。
隔离最后两行看起来可能需要大量工作;确实,字符串操作通常需要一些前期工作。但它们具有可伸缩性,可以相对轻松地应用于大型数据集。如果您以参数方式使用电子表格和互操作性,请务必记住字符串操作。
既然我们已经建立了列表,那么让我们来介绍如何对它执行操作。将一个列表想象为一副纸牌。一副纸牌即是列表,每张纸牌表示一个项目。
照片由 Christian Gidlöf 提供
我们可以在列表中进行哪些查询?这将访问现有特性。
一副纸牌中纸牌的张数?52.
玩家人数?4.
材料?纸。
长度?3.5" 或 89mm。
宽度?2.5" 或 64mm。
我们可以对列表执行哪些操作?这将基于给定操作更改列表。
我们可以洗牌。
我们可以按值对一副纸牌进行排序。
我们可以按玩家对一副纸牌进行排序。
我们可以拆分一副纸牌。
我们可以通过发牌来划分一副纸牌。
我们可以选择一副纸牌中某张特定纸牌。
上面列出的所有操作都有类似 Dynamo 节点来用于处理常规数据列表。下面的课程将演示可以对列表执行的一些基本操作。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
下图是我们在两个圆之间绘制直线以表示基本列表操作的基础图形。我们将探讨如何管理列表中的数据,并通过下面的列表操作演示可视结果。
从 “代码块” 开始,其中值为
500;
连接到 “Point.ByCoordinates” 节点的 x 输入。
将上一步中的节点连接到 “Plane.ByOriginNormal” 节点的原点输入。
使用 “Circle.ByPlaneRadius” 节点,将上一步中的节点连接到平面输入。
使用 “代码块” ,为半径指定值
50;
。这是我们将创建的第一个圆。使用 “Geometry.Translate” 节点,将圆沿 Z 方向向上移动 100 个单位。
使用 “Code Block” 节点,通过以下一行代码定义一系列 10 个介于 0 和 1 之间的数字:
0..1..#10;
将上一步中的代码块连接到两个 “Curve.PointAtParameter” 节点的 “param” 输入。将 “Circle.ByPlaneRadius” 插入到顶部节点的曲线输入,并将 “Geometry.Translate” 连接到其下节点的曲线输入。
使用 “Line.ByStartPointEndPoint” ,连接两个 “Curve.PointAtParameter” 节点。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.Count” 节点简单明了:它计算列表中值的数量,并返回该数量。随着我们使用列表的列表,此节点会变得更加微妙,但我们会在接下来的各部分中进行演示。
“List.Count”**** 节点会返回 “Line.ByStartPointEndPoint” 节点中线的数量。在本例中,该值为 10,表示与从原始 “Code Block” 节点创建的点数一致。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.GetItemAtIndex” 是用于查询列表中项的基本方法。
首先,在 “Line.ByStartPointEndPoint” 节点上单击鼠标右键以关闭其预览。
使用 “List.GetItemAtIndex” 节点,我们选择索引 “0” 或线列表中的第一项。
将滑块值更改为介于 0 和 9 之间,以使用 “List.GetItemAtIndex” 选择其他项目。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.Reverse” 可反转列表中所有项的顺序。
要正确显示反转的线列表,请通过将 “代码块” 更改为
0..1..#50;
来创建更多线复制 “Line.ByStartPointEndPoint” 节点,在 “Curve.PointAtParameter” 和第二个 “Line.ByStartPointEndPoint” 之间插入“List.Reverse”节点
使用 “Watch3D” 节点预览两个不同的结果。第一个显示没有反向列表的结果。这些线垂直连接到相邻点。但是,反转列表会将所有点以相反顺序连接到其他列表。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.ShiftIndices” 是适用于创建扭曲或螺旋图案或者任何其他类似数据操作的工具。此节点会将列表中的项目移动给定数量的索引。
在与反转列表相同的过程中,将 “List.ShiftIndices” 插入到 “Curve.PointAtParameter” 和 “Line.ByStartPointEndPoint” 中。
使用 “代码块”,指定值为“1”以将列表移动一个索引。
请注意,更改很细微,但在连接到另一组点时,较低 “Watch3D” 节点中的所有线都已移动一个索引。
例如,通过将 “代码块” 更改为较大值(“30”),我们注意到对角线存在明显差异。在本例中,该移动类似于照相机的光圈,从而以原始圆柱形式创建扭曲。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.FilterByBooleanMask” 将基于布尔值列表移除某些项目,或通过读取“true”或“false”值来移除某些项目。
为了创建读取“true”或“false”的值列表,我们需要做更多的工作...
使用 “代码块”,通过以下语法定义一个表达式:
0..List.Count(list);
。将 “Curve.PointAtParameter” 节点连接到 “list” 输入。我们将在代码块章节中详细介绍此设置,但本例中的该行代码会为我们提供一个列表,该列表表示 ”Curve.PointAtParameter” 节点的每个索引。使用 “%” **(求模)**节点,将 代码块 的输出连接到 x 输入,将值 4 连接到 y 输入。当将索引列表除以 4 时,这将为我们提供余数。求模节点对于创建图案而言确实非常有用。所有值将读取为 4 的可能余数:0、1、2、3。
在 “%” (求模) 节点中,我们知道值为 0 意味着索引是 4 的倍数(0、4、8,依此类推)。通过使用 “==” 节点,我们可以针对值 “0” 对其进行测试,以测试其可除性。
“Watch” 节点仅显示以下情况:我们有一个“true/false”模式,其读取:true,false,false,false...。
使用此 true/false 模式,连接到两个 “List.FilterByBooleanMask” 节点的遮罩输入。
将 “Curve.PointAtParameter” 节点连接到 “List.FilterByBooleanMask” 的每个列表输入。
“Filter.ByBooleanMask” 的输出读取 “in” 和 “out”。“in” 表示遮罩值为 “true” 的值,而 “out” 表示值为 “false” 的值。通过将 “in” 输出连接到 “Line.ByStartPointEndPoint” 节点的 “startPoint” 和 “endPoint” 输入,我们创建了过滤后的线列表。
“Watch3D” 节点显示线数少于点数。通过仅过滤 true 值,我们仅选择了 25% 的节点!
列表是元素或项目的集合。以一串香蕉为例。每个香蕉都是列表(或串)中的一个项目。拾取一串香蕉比单独拾取每个香蕉要容易得多,同样适用于通过数据结构中的参数化关系对元素进行分组。
照片由 Augustus Binu 提供。
当我们购买生活用品时,我们会将所有购买物品放入一个袋子中。这个袋子也是一个列表。如果我们要制作香蕉面包,需要 3 束香蕉(我们要制作 许多 香蕉面包)。袋子表示一列香蕉串,每串表示一列香蕉。袋子是一列列表(二维),香蕉串是一个列表(一维)。
在 Dynamo 中,会对列表数据进行排序,并且每个列表中第一项的索引均为“0”。下面,我们将讨论如何在 Dynamo 中定义列表以及如何将多个列表相互关联。
乍看起来可能有些奇怪的是,列表的第一个索引始终为 0,而不是 1。因此,当我们谈论列表的第一项时,实际上是指对应于索引 0 的项。
例如,如果要计算我们右手的手指数,则很有可能您的计数是 1 到 5。但是,如果要将手指放入列表,Dynamo 会为其指定索引 0 到 4。尽管这对于编程初学者来说似乎有些奇怪,但是从零开始的索引是大多数计算系统中的标准做法。
请注意,列表中仍有 5 个项目;只是列表使用的是基于零的计数系统。而且,列表中存储的项目并不仅限于数字。它们可以是 Dynamo 支持的任何数据类型,例如点、曲线、曲面、族等。
a.索引
b.点
c.项目
通常,查看列表中存储的数据类型的最简单方法是将“Watch”节点连接到另一个节点的输出。默认情况下,观察节点自动将所有索引显示在列表的左侧,并在右侧显示数据项。
这些索引是使用列表时的关键元素。
与列表相关,输入和输出因使用的 Dynamo 节点而异。例如,我们使用一列 5 个点,并将该输出连接到两个不同的 Dynamo 节点:”PolyCurve.ByPoints”和“Circle.ByCenterPointRadius”:
“PolyCurve.ByPoints” 的 “points” 输入正在查找 “Point[]”。这表示一列点
“PolyCurve.ByPoints” 的输出是基于一列五个点所创建的一条复合线。
“Circle.ByCenterPointRadius” 的 “centerPoint” 输入要求提供 “Point”。
“Circle.ByCenterPointRadius” 的输出是一列五个圆,其中心与点的原始列表相对应。
“PolyCurve.ByPoints” 和 “Circle.ByCenterPointRadius” 的输入数据相同,但 “Polycurve.ByPoints” 节点会提供一条复合线,而 “Circle.ByCenterPointRadius” 节点会提供 5 个圆(中心位于每个点处)。直观地讲,这很有意义:将复合线绘制为连接 5 个点的曲线,而圆在每个点处创建不同的圆。数据发生了什么变化?
通过将光标悬停在 “Polycurve.ByPoints” 的 “points” 输入上,我们会看到该输入正在查找 “Point[]”。请注意末端的括号。这表示一列点,并且要创建复合线,输入需要每个复合线是一个列表。因此,该节点会将每个列表压缩为一个复合线。
另一方面,“Circle.ByCenterPointRadius” 的 “centerPoint” 输入要求提供 “Point”。此节点会查找一个点作为项目,以定义圆的圆心。这就是我们基于输入数据获得五个圆的原因。在 Dynamo 中识别输入的这些差异有助于在管理数据时更好地了解节点的运行方式。
在没有清晰解决方案的情况下,数据匹配会是一个问题。当节点有权访问不同大小的输入时,就会发生这种情况。更改数据匹配算法可能会导致结果差异极大。
假定在各点之间创建线段的节点(“Line.ByStartPointEndPoint”)。它将有两个输入参数,两个输入参数均提供点坐标:
最简单的方法是逐一连接输入,直到其中一个流运行干。这称为“最短列表”算法。这是 Dynamo 节点的默认行为:
“最长列表”算法会一直连接输入、重用元素,直到所有流都流干为止:
最后,“笛卡尔积”方法可以建立所有可能的连接:
如您所见,我们可以通过不同的方式在这些点集之间绘制直线。通过在某个节点的中心上单击鼠标右键并选择“连缀”菜单,即可找到连缀选项。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
为了演示下面的连缀操作,我们将使用此基础文件定义最短列表、最长列表和笛卡尔积。
我们将更改 “Point.ByCoordinates” 上的连缀,但不会更改有关上图的其他任何内容。
通过选择 “最短列表” 作为连缀选项(也是默认选项),我们会得到一条由五个点组成的基本对角线。五个点是较小列表的长度,因此最短列表连缀在到达一个列表的末尾后即停止。
通过将连缀更改为 “最长列表”,我们得到一条垂直延伸的对角线。采用与概念图相同的方法,将重复该列表的 5 个项目中的最后一项,以达到较长列表的长度。
通过将连缀更改为 “笛卡尔积”,我们得到每个列表之间的每个组合,从而获得 5x10 点栅格。这是与上述概念图中所示的笛卡尔积等效的数据结构,但数据现在是一列列表。通过连接复合线,我们可以看到每个列表均由其 X 值定义,从而得到一行垂直线。
Dynamo 2.0 不仅引入之前针对词典讨论的节点,还在代码块中提供了新功能!
可以使用如下所示的语法或基于 DesignScript 的节点表示。
由于词典是 Dynamo 中的对象类型,因此我们可以对其执行以下操作。
在将 Revit 数据与字符串相关联时,保持这些交互类型尤其有用。接下来,我们将了解一些 Revit 使用案例。
Dynamo 2.0 引入了将词典数据类型与列表数据类型进行分隔的概念。此更改可能会对您在工作流中创建和使用数据的方式作出一些重大改变。在 2.0 之前,词典和列表已组合为一种数据类型。简而言之,列表实际上是带有整数键的词典。
词典是由一组键值对组成的数据类型,其中每个键在每个集合中是唯一的。词典没有顺序,基本上可以使用键而不是类似列表的索引值来“查找”内容。在 Dynamo 2.0 中,键只能是字符串。
列表是由有序值集合组成的数据类型。在 Dynamo 中,列表使用整数作为索引值。
词典与列表之间的分离会使词典成为“一等公民”,可以使用词典快速、轻松地存储和查找值,无需记住索引值或在整个工作流中保持严格的列表结构。在用户测试期间,当使用词典而不是多个 GetItemAtIndex
节点时,我们看到图形大小显著减小。
语法 已发生更改,改变了初始化以及使用代码块中的词典和列表的方式。
词典使用以下语法:{key:value}
列表使用以下语法:[value,value,value]
库中引入了 新节点,以帮助您创建、修改和查询词典。
加载脚本时,v1.x 代码块中创建的列表会自动迁移为使用方括号 [ ]
(而不是大括号 { }
)的新列表语法 \
在计算机科学中,词典(如列表)是对象集合。虽然列表按特定顺序排列,但词典是 无序 集合。它们并不依赖于顺序编号(索引),而是使用 键。
在下图中,我们演示了词典的潜在使用案例。通常,词典用于关联两个可能没有直接相关性的数据。在本例中,我们将单词的西班牙语版本连接到英文版本,供以后查找。
构建词典来关联两条数据。
获取给定键的值。
Dynamo 为各种可视化编程任务提供了许多核心节点。有时,更快速、更简洁或更轻松共享的解决方案是构建自己的节点。这些节点可以在不同项目中重用,使图形更清晰、更简洁,并且可以将它们推送到软件包管理器,并与全球 Dynamo 社区共享。
我们刚创建了一个自定义节点,并将它应用到 Dynamo 图形中的特定流程。我们非常喜欢这个节点,我们想将它保留在 Dynamo 库中,以便在其他图形中引用。为此,我们将本地发布节点。这与发布软件包的过程类似,我们将在下一章中详细介绍。
通过本地发布节点,可以在打开新会话时在 Dynamo 库中访问该节点。如果不发布节点,则引用自定义节点的 Dynamo 图形也必须在其文件夹中具有该自定义节点(或必须使用 “文件”>“输入库” 将自定义节点输入到 Dynamo 中)。
只要 Dynamo Sandbox 2.17 及更高版本中的自定义节点和软件包没有宿主 API 依存关系,就可以发布它们。在早期版本中,只能在 Dynamo for Revit 和 Dynamo for Civil 3D 中发布自定义节点和软件包。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
让我们继续处理上一节中创建的自定义节点。打开“PointsToSurface”自定义节点后,我们会在 Dynamo 自定义节点编辑器中看到该图形。还可以在 Dynamo 图形编辑器中双击自定义节点来打开它。
要在本地发布自定义节点,只需在画布上单击鼠标右键,然后选择 “发布此自定义节点...” 。
填写与上图类似的相关信息,然后选择 “本地发布” 。请注意,“组”字段定义可从 Dynamo 菜单访问的主图元。
选择一个文件夹以容纳计划在本地发布的所有自定义节点。Dynamo 每次加载时都会检查该文件夹,因此请确保该文件夹处于永久位置。导航到此文件夹,然后选择 “选择文件夹” 。现在,Dynamo 节点在本地发布,每次加载程序时都会保留在 Dynamo 库中!
要检查自定义节点文件夹位置,请转到 “Dynamo”>“首选项”>“软件包设置”>“节点和软件包路径” 。
在此窗口中,我们会看到路径列表。
“Documents\DynamoCustomNodes...” 是指我们已本地发布的自定义节点的位置。
“AppData\Roaming\Dynamo...” 是指联机安装的 Dynamo 软件包的默认位置。
您可能希望按照列表顺序将本地文件夹路径下移(通过单击路径名左侧的向下箭头)。顶层文件夹是安装软件包的默认路径。因此,通过保留默认的 Dynamo 软件包安装路径作为默认文件夹,联机软件包将与本地发布的节点分离。
我们切换了路径名称的顺序,以便让 Dynamo 的默认路径作为软件包安装位置。
导航到此本地文件夹,我们可以在 “.dyf” 文件夹中找到原始自定义节点,该文件夹是 Dynamo 自定义节点文件的扩展名。我们可以编辑此文件夹中的文件,并且节点将在 UI 中更新。我们还可以向 “DynamoCustomNode” 主文件夹添加更多节点,Dynamo 会在重新启动时将它们添加到您的库中!
现在,每次使用 Dynamo 库的“DynamoPrimer”组中的“PointsToSurface”时,Dynamo 都会载入。
您是否曾想过使用 Revit 中包含的数据查找内容?
如果您已经完成了类似以下示例的操作,则有可能出现这种情况。
在下图中,我们会收集 Revit 模型中的所有房间、获取所需房间的索引(按房间编号),最后在索引处抓取房间。
收集模型中的所有房间。
要查找的房间编号。
获取房间编号并查找它所在的索引。
获取索引处的房间。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
现在,让我们使用词典重建这个想法。首先,我们需要收集 Revit 模型中的所有房间。
我们选择要处理的 Revit 类别(在本例中,我们处理的是房间)。
我们告诉 Dynamo 收集所有这些元素
接下来,我们需要决定要使用哪些键来查找此数据。(键的相关信息位于“什么是词典?”部分中。)
我们将使用的数据是房间编号。
现在,我们将使用给定的键和元素创建词典。
节点 “Dictionary.ByKeysValues” 将根据相应的输入创建词典。
Keys
需要是字符串,而values
可以是多种对象类型。
最后,我们现在可以使用房间编号从词典中检索房间。
String
将是用于从词典中查找对象的键。现在,“Dictionary.ValueAtKey” 将从词典中获取对象。
使用相同的词典逻辑,我们还可以使用分组对象创建词典。如果我们要查找给定级别的所有房间,可以按如下所示修改上图。
我们现在可以使用参数值(在本例中,我们将使用标高),而不是将房间编号用作键。
现在,我们可以按房间所在的标高对房间进行分组。
按标高对图元进行分组后,我们现在可以使用共享键(唯一键)作为词典的键,以及将房间列表作为元素。
最后,使用 Revit 模型中的标高,我们可以在词典中查找位于该标高的房间。
Dictionary.ValueAtKey
将获取标高名称并返回该标高处的房间对象。
使用词典的机会确实是无限的。在 Revit 中将 BIM 数据与元素本身关联的功能可用于各种使用案例。
Dynamo 提供了几种不同方法来创建自定义节点。可以从头开始构建自定义节点、从现有图形构建自定义节点,也可以在 C# 中显式构建自定义节点。在本节中,我们将介绍如何在 Dynamo UI 中基于现有图形构建自定义节点。此方法非常适用于清理工作空间,以及打包一系列节点以在其他位置重用。
在下图中,我们使用 UV 坐标将某个点从一个曲面映射到另一个曲面。我们将利用此概念创建镶板曲面,该曲面参照 XY 平面中的曲线。我们将在此处创建四边形嵌板以进行镶板,但是使用相同的逻辑,我们可以使用 UV 映射创建各种嵌板。这是开发自定义节点的绝佳机会,因为我们将能够在此图形或其他 Dynamo 工作流中更轻松地重复类似过程。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
首先,我们创建一个要嵌套到自定义节点的图形。在本示例中,我们将使用 UV 坐标创建一个图形,该图形会将多边形从基础曲面映射到目标曲面。我们经常使用此 UV 映射过程,使其成为用于自定义节点的理想候选过程。有关曲面和 UV 空间的详细信息,请参见曲面页面。完整图形是来自上面下载的 .zip 文件中的 “UVmapping_Custom-Node.dyn”。
代码块:使用以下代码行可创建一系列介于 -45 和 45 之间的 10 个数字:
45..45..#10;
Point.ByCoordinates:将 “代码块” 的输出连接到“x”和“y”输入,并将连缀设置为“交互参照”。现在,您应该有了点栅格。
Plane.ByOriginNormal:将 “Point” 输出连接到 “origin” 输入,以在每个点处创建一个平面。将使用默认法向向量 (0,0,1)。
Rectangle.ByWidthLength:将上一步中的平面连接到 “plane” 输入,并使用值为 “10” 的 “代码块” 指定宽度和长度。
现在,您应该会看到矩形栅格。让我们使用 UV 坐标将这些矩形映射到目标曲面。
Polygon.Points:将上一步中的 “Rectangle.ByWidthLength” 输出连接到 “polygon” 输入以提取每个矩形的角点。这些点是我们要映射到目标曲面的点。
Rectangle.ByWidthLength:使用值为 “100” 的 “代码块” 指定矩形的宽度和长度。这将是基础曲面的边界。
Surface.ByPatch:将上一步中的 “Rectangle.ByWidthLength” 连接到 “closedCurve” 输入以创建基础曲面。
Surface.UVParameterAtPoint:连接 “Polygon.Points” 节点的 “Point” 输出和 “Surface.ByPatch” 节点的 “Surface” 输出,以返回每个点处的 UV 参数。
现在,我们已拥有一个基础曲面和一组 UV 坐标,可以输入目标曲面并在曲面之间映射点。
文件路径:选择要输入的曲面的文件路径。文件类型应为“.SAT”。单击 “浏览...” 按钮,然后导航到来自上面下载的 .zip 文件中的 “UVmapping_srf.sat” 文件。
Geometry.ImportFromSAT:连接文件路径以输入曲面。您应该会在几何图形预览中看到输入的曲面。
UV:将 UV 参数输出连接到 “UV.U” 和 “UV.V” 节点。
Surface.PointAtParameter:连接输入的曲面以及 u 和 v 坐标。现在,您应该会在目标曲面上看到三维点栅格。
最后一步是使用三维点来构造矩形曲面修补。
PolyCurve.ByPoints:连接曲面上的点,以通过这些点构造复合线。
Boolean:将 “Boolean” 添加到工作空间,然后将其连接到 “connectLastToFirst” 输入并切换到 True 以关闭复合线。现在,您应该会看到映射到曲面的矩形。
Surface.ByPatch:将复合线连接到 “closedCurve” 输入以构建曲面修补。
现在,我们选择要嵌套到自定义节点中的节点,以考虑我们希望哪些内容作为节点的输入和输出。我们希望自定义节点尽可能灵活,以便它应该能够映射任何多边形,而不仅仅是矩形。
选择以下节点(从“Polygon.Points”开始),在工作空间上单击鼠标右键,然后选择“创建自定义节点”。
在“自定义节点特性”对话框中,为“自定义节点”指定名称、描述和类别。
名称:MapPolygonsToSurface
描述:将多边形从基础曲面映射到目标曲面
附加模块类别:Geometry.Curve
“自定义节点”已显着清理工作空间。请注意,已基于原始节点命名输入和输出。让我们编辑“自定义节点”,以使名称更具描述性。
双击“自定义节点”以对其进行编辑。这将打开一个工作空间,该工作空间有表示节点内部的黄色背景。
输入:将输入名称更改为 “baseSurface” 和 “targetSurface”。
输出:为映射的多边形添加附加输出。
保存自定义节点,然后返回到主工作空间。请注意,“MapPolygonsToSurface” 节点反映了我们刚才所做的更改。
我们还可以通过添加 “自定义注释” 来增加“自定义节点”的稳定性。注释有助于提示输入和输出类型或解释节点的功能。用户将光标悬停在“自定义节点”的输入或输出上时,将显示注释。
双击“自定义节点”以对其进行编辑。这将重新打开黄色背景的工作空间。
开始编辑输入 “代码块”。要开始注释,请键入“//”,后跟注释文字。键入可能有助于阐明节点的任何内容 - 在此处,我们将介绍 “targetSurface”。
我们还将通过设置输入类型等于某个值,来设置 “inputSurface” 的默认值。在此处,我们会将默认值设置为原始 “Surface.ByPatch” 集。
注释也可以应用于输出。
编辑输出“代码块”中的文字。键入“//”,后跟注释文字。在此处,我们将通过添加更深入的描述来阐明 “Polygons” 和 “surfacePatches” 输出。
将光标悬停在“自定义节点输入”上可查看注释。
在对 “inputSurface” 设置默认值后,我们还可以运行定义,无需输入曲面。
Dynamo 提供了大量现成功能,还维护了一个丰富的软件包库,可显著扩展 Dynamo 的功能。软件包是自定义节点或附加功能的集合。Dynamo Package Manager 是一个社区门户,用于下载已在线发布的任何软件包。这些工具集由第三方开发,用于扩展 Dynamo 的核心功能、可供所有人访问,只需单击相应按钮即可下载。
诸如 Dynamo 之类的开源项目通过此类社区参与有了蓬勃发展。借助专门的第三方开发人员,Dynamo 能够将其应用范围扩展到各行各业的工作流。因此,Dynamo 团队已共同努力来简化软件包的开发和发布(将在以下各节中详细讨论)。
安装软件包的最简单方法是使用 Dynamo 界面中的“软件包”菜单选项。现在,让我们直接跳转到该菜单选项并安装软件包。在本快速示例中,我们将安装一个常用软件包,用于在栅格上创建四边形嵌板。
在 Dynamo 中,转到 “软件包”>“软件包管理器...”。
在搜索栏中,让我们搜索“quads from rectangular grid”。片刻之后,您应该会看到与此搜索查询匹配的所有软件包。我们想要选择具有匹配名称的第一个软件包。
单击“安装”以将此软件包添加到库,然后接受确认。完成!
请注意,现在 Dynamo 库中有另一个名为“buildz”的组。该名称指代软件包的开发人员,并且自定义节点将放置在此组中。我们可以立即开始使用此组。
使用 “代码块” 以快速定义矩形栅格、将结果输出到 “Polygon.ByPoints” 节点,然后输出到 “Surface.ByPatch” 节点以查看刚创建的矩形嵌板列表。
上述示例重点介绍内含一个自定义节点的软件包,但相同过程可用于下载内含多个自定义节点的软件包以及支持数据文件。现在,我们通过一个更全面的软件包来进行演示:Dynamo Unfold。
如上例中所示,首先选择 “软件包”>“软件包管理器...”。
这次,我们将搜索 “DynamoUnfold” 一词。当我们看到该软件包时,请通过单击“安装”下载,以将“Dynamo Unfold”添加到 Dynamo 库中。
在 Dynamo 库中,我们有一个 “DynamoUnfold” 组,其中包含多个类别和自定义节点。
现在,让我们来看一下软件包的文件结构。
首先,转到“软件包”>“软件包管理器”>“已安装的软件包”。
然后,单击“显示根目录”以打开此软件包的根文件夹。
这会转到该软件包的根目录。请注意,我们有 3 个文件夹和一个文件。
“bin” 文件夹中存储了 .dll 文件。此 Dynamo 软件包使用 Zero-Touch 开发,因此自定义节点保存在此文件夹中。
“dyf” 文件夹中存储了自定义节点。此软件包不是使用 Dynamo 自定义节点开发的,因此此软件包的该文件夹为空。
“extra”文件夹中存储了所有附加文件,包括我们的示例文件。
pkg 文件是一个基本文本文件,用于定义软件包设置。我们现在可以忽略该文件。
打开“extra”文件夹,我们会在其中看到随安装下载的一系列示例文件。并非所有软件包中都有示例文件,如果示例文件是软件包的一部分,那么就可以在该位置找到它们。
让我们打开“SphereUnfold”。
在打开该文件并点击求解器上的“运行”后,我们会得到一个展开的球体!此类示例文件有助于了解如何使用新的 Dynamo 软件包。
在软件包管理器中,可以在“搜索软件包”选项卡中使用排序和过滤选项浏览软件包。有若干过滤器可用于查找宿主程序、状态(新的、已弃用或未弃用),以及软件包是否具有依存关系。
通过对软件包进行排序,可以识别评分较高或下载次数最多的软件包,也可以查找包含最新更新的软件包。
还可以通过单击“查看详细信息”,来访问每个软件包的更多详细信息。这将在“软件包管理器”中打开一个侧面板,在其中可以查找版本控制和依存关系、网站或存储库 URL、许可信息等信息。
了解 Dynamo 软件包的另一种方法是浏览 Dynamo Package Manager 网站。在此处,可以查找软件包和作者排行榜的统计信息。还可以从 Dynamo Package Manager 下载软件包文件,但直接在 Dynamo 中进行下载是一个更无缝的过程。
如果要查看软件包文件的保存位置,请在顶部导航中,依次单击“Dynamo”>“首选项”>“软件包设置”>“节点和软件包文件位置”,可以在此处查找当前根文件夹目录。
默认情况下,软件包安装在与以下文件夹路径类似的位置:C:/Users/[用户名]/AppData/Roaming/Dynamo/[Dynamo 版本]。
Dynamo 社区不断发展壮大。通过不时浏览 Dynamo Package Manager,您会发现一些令人兴奋的新进展。在以下各部分中,我们将更深入地探索软件包,从最终用户角度到您自己的 Dynamo 软件包制作。
再往下钻,让我们为层次结构添加更多层。数据结构可以扩展到远超二维列表的列表。由于列表是 Dynamo 中的项目,而且它们本身也是项目,因此我们可以创建尽可能多维的数据。
我们将在此处使用的类比是俄罗斯套娃。每个列表可视为一个包含多个项的容器。每个列表都有自己的特性,也被视为自己的对象。
一组俄罗斯套娃(照片由 Zeta 提供)是 n 维列表的类比。每个层表示一个列表,每个列表在其中包含项目。在 Dynamo 的情况下,每个容器内可以有多个容器(表示每个列表的项目)。
n 维列表很难用直观的方式进行解释,但是我们在本章中设置了一些练习,这些练习着重于处理超出二维范围的列表。
映射无疑是 Dynamo 中数据管理最复杂的部分,并且在处理列表的复杂层次结构时尤其重要。在下面的一系列练习中,我们将演示在数据变为多维时何时使用映射和组合。
在上一节中,可以找到 “List.Map” 和 “List.Combine” 的初步介绍。在下面的最后一个练习中,我们将对复杂数据结构使用这些节点。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
本练习是三个练习中的第一个,侧重于阐述输入的几何图形。本系列练习中的每个部分都将增加数据结构的复杂性。
让我们从练习文件文件夹中的“.sat”文件开始。我们可以使用 “File Path” 节点抓取此文件。
使用 “Geometry.ImportFromSAT”,该几何图形将作为两个曲面输入到 Dynamo 预览中。
在本练习中,我们希望保持简单并处理其中一个曲面。
让我们选择索引 1,以抓取上方曲面。我们使用 “List.GetItemAtIndex” 节点来执行此操作。
关闭 “Geometry.ImportFromSAT” 预览中的几何图形预览。
下一步是将曲面分割为点栅格。
1.使用 “代码块”,插入以下两行代码:
0..1..#10;
0..1..#5;
2.使用 “Surface.PointAtParameter”,将两个代码块值连接到 u 和 v。将此节点的 “连缀” 更改为 “叉积”。
3.输出显示数据结构,这在 Dynamo 预览中也可见。
接下来,使用上一步中的点以沿曲面生成十条曲线。
要了解数据结构的组织方式,我们将 “NurbsCurve.ByPoints” 连接到 “Surface.PointAtParameter” 的输出。
现在,可以关闭 “List.GetItemAtIndex” 节点的预览,以获得更清晰的结果。
基本 “List.Transpose” 将翻转一列列表的列和行。
通过将 “List.Transpose” 的输出连接到 “NurbsCurve.ByPoints”,我们现在得到五条曲线在整个曲面上水平延伸。
可以在上一步中关闭 “NurbsCurve.ByPoints” 节点的预览,以在图像中获得相同的结果。
让我们增加复杂性。假定我们要对上一个练习中创建的曲线执行操作。也许,我们希望将这些曲线与其他曲面相关联,并在它们之间进行放样。这需要更加注意数据结构,但基本逻辑是相同的。
从上一练习的步骤开始,使用 “List.GetItemAtIndex” 节点隔离已输入几何图形的上曲面。
使用 “Surface.Offset”,将曲面偏移值 “10”。
按照与上一练习相同的方式,使用以下两行代码定义 “代码块”:
0..1..#10;
0..1..#5;
将这些输出连接到两个 “Surface.PointAtParameter” 节点,每个节点的 “连缀” 设置为 “叉积”。其中一个节点连接到原始曲面,而另一个节点连接到偏移曲面。
关闭这些曲面的预览。
与上一练习中一样,将输出连接到两个 “NurbsCurve.ByPoints” 节点。结果显示与两个曲面对应的曲线。
通过使用 “List.Create”,我们可以将两组曲线合并为一列列表。
在输出中注意到,我们有两个列表,其中每个列表都包含十个项目,分别表示每个 NURBS 曲线的连接集。
通过执行 “Surface.ByLoft”,我们可以直观地了解此数据结构。该节点将放样每个子列表中的所有曲线。
在上一步中,关闭 “Surface.ByLoft” 节点的预览。
通过使用 “List.Transpose”,请记住,我们将翻转所有列和行。此节点会将两列(每个列表十条曲线)转换为十列(每个列表两条曲线)。现在,我们得到与另一个曲面上的相邻曲线相关的每条 NURBS 曲线。
使用 “Surface.ByLoft”,我们得到一个带肋的结构。
接下来,我们将演示实现此结果的替代流程
在开始之前,请在上一步中关闭 “Surface.ByLoft” 预览以避免混淆。
除 “List.Transpose” 之外,还可以使用 “List.Combine”。这将对每个子列表运算 “连结符”。
在本例中,我们使用 “List.Create” 作为 “连结符”,这将在子列表中创建每个项目的列表。
使用 “Surface.ByLoft” 节点,我们得到与上一步中相同的曲面。在这种情况下,转置更容易使用,但当数据结构变得更加复杂时,“List.Combine” 更加可靠。
如果要切换带肋结构中曲线的方向,请后退几步,我们需要先使用 “List.Transpose”,然后再连接到 “NurbsCurve.ByPoints”。这将翻转列和行,从而得到 5 个水平加强筋。
现在,我们将更进一步。在本练习中,我们将使用两个输入的曲面,从而创建复杂的数据层次结构。尽管如此,我们的目标是使用相同的基础逻辑来完成相同的操作。
从上一练习中输入的文件开始。
与上一练习中一样,使用 “Surface.Offset” 节点按值 “10” 进行偏移。
在输出中注意到,我们创建了两个具有偏移节点的曲面。
按照与上一练习相同的方式,使用以下两行代码定义 “代码块”:
0..1..#20;
0..1..#20;
将这些输出连接到两个 “Surface.PointAtParameter” 节点,每个节点的连缀设置为 “叉积”。其中一个节点连接到原始曲面,而另一个节点连接到偏移曲面。
与上一练习中一样,将输出连接到两个 “NurbsCurve.ByPoints” 节点。
查看 “NurbsCurve.ByPoints” 的输出,注意到这是一列两个列表,比上一练习更复杂。数据按基础曲面分类,因此我们为结构化数据添加了另一个层级。
请注意,“Surface.PointAtParameter” 节点中的对象变得更加复杂。在本例中,我们会看到一列列表。
在继续操作之前,请关闭现有曲面的预览。
使用 “List.Create” 节点,我们将 NURBS 曲线合并为一个数据结构,从而创建一列列表(其中每个元素也是一个列表)。
通过连接 “Surface.ByLoft” 节点,我们得到原始曲面的版本,因为它们各自保留在由原始数据结构创建的自己列表中。
在上一练习中,我们能够使用 “List.Transpose” 创建带肋结构。这在此处不起作用。对二维列表应使用转置,但由于我们有三维列表,因此“翻转列和行”操作不会像之一样轻松。请记住,列表是对象,因此 “List.Transpose” 将翻转包含子列表的列表,但不会将 NURBS 曲线在层次结构中进一步向下翻转一个列表。
“List.Combine” 在此处将更加适用。当访问更复杂的数据结构时,我们要使用 “List.Map” 和 “List.Combine” 节点。
使用 “List.Create” 作为 “连结符”,我们可以创建一个数据结构,使其更加适用。
数据结构仍需要在层次结构上向下转置一步。为此,我们将使用 “List.Map”。除了使用一个输入列表(而不是两个或更多)之外,这类似于使用 “List.Combine”。
我们将应用于 “List.Map” 的函数是 “List.Transpose”,这将翻转主列表中子列表的列和行。
最后,我们可以结合使用正确的数据层次结构放样 NURBS 曲线,从而提供带肋结构。
我们使用 “Surface.Thicken” 节点和输入设置为几何图形添加一些深度,如图所示。
最好添加一个曲面来支撑这两个结构,因此请添加另一个 “Surface.ByLoft” 节点,并使用上一步中 “NurbsCurve.ByPoints” 的第一个输出作为输入。
随着预览变得混乱,请通过在每个节点上单击鼠标右键并取消选中“预览”以关闭这些节点的预览,以便更好地查看结果。
加厚这些选定曲面,完成连接。
这不是有史以来最舒适的摇椅,但还会进行大量数据处理。
最后一步,我们反转带条纹成员的方向。如在上一练习中使用转置一样,我们将在此处执行类似操作。
由于我们的层次结构中还有一层级,因此我们需要将 “List.Map” 与 “List.Tranpose” 函数一起使用来更改 NURBS 曲线的方向。
我们可能希望增加踏板数,因此可以将 “代码块” 更改为
0..1..#20;
0..1..#30;
摇椅的第一个版本很流畅,因此我们的第二个模型提供了越野、运动多功能版本的靠背。
让我们再为层次结构添加一个层级。如果我们从原始示例中获取数据卡组并创建包含多个数据卡组的框,则该框现在表示一列数据卡组,每个数据卡组表示一列数据卡。这是一列列表。在本节的类比中,下图包含一列硬币卷,每个卷包含一列便士。
照片由 Dori 拍摄。
我们可以在该列列表中进行哪些查询?这将访问现有特性。
硬币类型的数量?2.
硬币类型值?$0.01 和 $0.25。
两角五分的材料?75% 铜和 25% 镍。
便士材料?97.5% 锌和 2.5% 铜。
我们可以对该列列表执行哪些操作?这会根据给定的操作更改该列列表。
选择一叠特定的两角五分或便士。
选择一个特定的两角五分或便士。
重新排列各叠两角五分和便士。
将各叠堆叠在一起。
同样,Dynamo 为上述每项操作都提供了一个分析节点。由于我们处理的是抽象数据而不是物理对象,因此我们需要一组规则来控制如何上下移动数据层次结构。
在处理列表的列表时,数据是分层且复杂的,但这使得有机会执行一些很棒的参数化操作。让我们来分解基础知识,并在下面的课程中再讨论几项操作。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
要从本部分中了解的基本概念:Dynamo 将列表视为自身内部和自身的对象。这种自上而下层次结构是在考虑面向对象编程的情况下开发的。Dynamo 会选择数据结构中主列表的索引,而不是使用诸如 “List.GetItemAtIndex” 之类的命令选择子元素。该项可以是另一个列表。让我们用示例图像进行分解:
使用 “代码块”,我们已定义两个范围:
0..2; 0..3;
这些范围连接到 “Point.ByCoordinates” 节点,其中连缀设置为 “叉积”。这将创建点栅格,并且还会返回一列列表作为输出。
请注意,“Watch” 节点提供 3 个列表,其中每个列表中有 4 个项目。
使用 “List.GetItemAtIndex” 时,在索引为 0 的情况下,Dynamo 会选择第一个列表及其所有内容。其他程序可能会选择数据结构中每个列表的第一个项目,但 Dynamo 在处理数据时采用自上而下层次结构。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“展平”会从数据结构中删除所有层级的数据。这在操作不需要数据层次结构时非常有用,但由于它会删除信息,因此可能存在风险。下面的示例显示了展平一列数据的结果。
在 “代码块” 中插入一行代码以定义一个范围:
-250..-150..#4;
通过将 “代码块” 插入到 “Point.ByCoordinates” 节点的 “x” 和 “y” 输入,我们会将连缀设置为 “叉积” 以获取点栅格。
“Watch” 节点显示我们有一列列表。
“PolyCurve.ByPoints” 节点将引用每个列表并创建相应的复合线。请注意,在 Dynamo 预览中,我们有四条复合线分别表示栅格中的每一行。
通过在复合线节点之前插入 “展平”,我们为所有点创建了一个列表。“PolyCurve.ByPoints” 节点引用列表来创建一条曲线,并且由于所有点都在一个列表中,因此我们得到了一条锯齿形复合线,该复合线贯穿整个点列表。
还有用于展平孤立层级数据的选项。使用 “List.Flatten” 节点,可以定义一定数量的数据层级,以从层次结构的顶部展平。如果要处理的复杂数据结构不一定与工作流相关,那么这是一个非常有用的工具。另一个选择是在 “List.Map” 中将展平节点用作函数。我们将在下面详细介绍 “List.Map”。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
使用参数化建模时,有时您还希望将修改现有列表的数据结构。此外,还有许多节点可用于此操作,其中最基本的版本是“切除”。使用“切除”,我们可以将一个列表划分为具有一定数量项目的子列表。
“切除”命令会根据给定的列表长度来分割列表。在某些方面,切除与展平相反:它不是删除数据结构,而是向其中添加新的层级。这是一个有助于执行几何操作(如以下示例)的工具。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“List.Map/Combine” 会将设置的函数应用于输入列表,但在层次结构中向下一步。组合与贴图相同,但组合可以具有与给定函数的输入相对应的多个输入。
注意:此练习是使用 Dynamo 的先前版本创建的。通过添加“List@Level”功能,“List.Map”的大部分功能已经解决。有关详细信息,请参见 下面 的“List@Level”。
通过简单介绍一下,我们来回顾上一节中的 “List.Count” 节点。
“List.Count” 节点对列表中的所有项目进行计数。我们将使用此节点来演示 “List.Map” 如何工作。
将两行代码插入到 “代码块”:
-50..50..#Nx; -50..50..#Ny;
在键入此代码后,代码块将为 Nx 和 Ny 创建两个输入。
使用两个 整数滑块,通过将它们连接到 “代码块” 来定义 “Nx” 和 “Ny” 值。
将代码块的每行连接到 “Point.ByCoordinates” 节点的相应 “X” 和 “Y” 输入。在节点上单击鼠标右键,选择“连缀”,然后选择 “叉积”。这将创建点栅格。因为我们定义的范围是 -50 到 50,所以我们跨越了默认的 Dynamo 栅格。
“Watch” 节点显示所创建的点。请注意数据结构。我们已创建一列列表。每个列表都表示栅格的一行点。
将上一步中的 “List.Count” 节点附加到“Watch”节点的输出。
将 “Watch” 节点连接到 “List.Count” 输出。
请注意,“List.Count”节点提供的值为“5”。这等于代码块中所定义的“Nx”变量。这是为什么呢?
首先,“Point.ByCoordinates” 节点使用“x”输入作为用于创建列表的主输入。当 Nx 为 5 且 Ny 为 3 时,我们得到一列 5 个列表,每个列表都包含 3 个项目。
由于 Dynamo 将列表视为自身内部和自身的对象,因此 “List.Count” 节点会应用于层次结构中的主列表。结果为值 5 或主列表中列表的数量。
通过使用 “List.Map” 节点,我们在层次结构中向下一步,然后在此级别上执行 “函数”。
请注意,“List.Count” 节点没有输入。它将用作一个函数,因此 “List.Count” 节点将应用于层次结构中向下一步的每个单独列表。“List.Count” 的空白输入对应于 “List.Map” 的列表输入。
“List.Count” 的结果现在提供一列 5 个项目,每个项目的值为 3。这表示每个子列表的长度。
注意:此练习是使用 Dynamo 的先前版本创建的。通过添加“List@Level”功能,“List.Combine”的大部分功能已经解决。有关详细信息,请参见下面的“List@Level”。
在本练习中,我们将使用 “List.Combine” 演示如何使用它来在单独的对象列表中应用函数。
首先,设置两个点列表。
使用 “Sequence” 节点生成 10 个值,每个值都有 10 步增量。
将结果连接到 “Point.ByCoordinates” 节点的 x 输入。这将在 Dynamo 中创建点列表。
将第二个 “Point.ByCoordinates” 节点添加到工作空间、使用相同的 “Sequence” 输出作为其 x 输入,但使用 “Interger Slider” 作为其 y 输入并将其值设置为 31(它可以是任何值,只要它们不与第一组点重叠),这样 2 组点就不会相互重叠。
接下来,我们将使用 “List.Combine” 对 2 个单独列表中的对象应用函数。在本例中,它将是一个简单的绘制线函数。
将 “List.Combine” 添加到工作空间,并连接 2 组点作为其 list0 和 list1 输入。
使用 “Line.ByStartPointEndPoint” 作为 “List.Combine” 的输入函数。
完成后,通过 “Line.ByStartPointEndPoint” 函数将 2 组点压缩/成对组合在一起,并在 Dynamo 中返回 10 行。
请参见 n 维列表中的练习,以查看使用“List.Combine”的另一个示例。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
相较于 “List.Map”,“List@Level” 功能允许直接选择要在节点的输入端口上使用的列表级别。此功能可应用于节点的任何传入输入,并让您可以更快、更容易地访问列表的各级别(相较于其他方法)。只需告诉节点要使用列表的哪个级别作为输入,然后让节点执行其余操作即可。
在本练习中,我们将使用 “List@Level” 功能隔离特定级别的数据。
我们将从一个简单的三维点栅格开始。
该栅格使用 X、Y 和 Z 范围构建,因此我们知道数据结构由 3 个层级组成:X 列表、Y 列表和 Z 列表。
这些层级存在于不同的级别上。级别显示在预览气泡的底部。“列表级别”列与上述列表数据相对应,以帮助确定要在哪个级别工作。
“列表级别”按相反顺序进行组织,以便最低级别数据始终位于“L1”。这将有助于确保图形按计划工作,即使上游发生任何更改也是如此。
要使用 “List@Level” 函数,请单击“>”。在此菜单中,您会看到两个复选框。
使用级别 - 这会启用 “List@Level” 功能。单击此选项后,将能够点进,然后选择希望节点使用的输入列表级别。使用此菜单,可以通过单击上下箭头来快速试用不同的级别选项。
保持列表结构 - 如果已启用,则可以选择保持该输入的级别结构。有时,您可能会有目的地将数据组织到子列表中。选中此选项,即可使列表组织保持完整,而不会丢失任何信息。
使用简单的三维栅格,我们可以通过切换“列表级别”来访问和可视化列表结构。每个列表级别和索引组合将从原始三维集中返回一组不同的点。
DesignScript 中的“@L2”允许我们仅选择级别 2 的列表。级别 2 列表(索引为 0)仅包含第一组 Y 点,从而仅返回 XZ 栅格。
如果将级别过滤器更改为“L1”,则我们将能够看到第一列表级别中的所有内容。级别 1 列表(索引 0)将所有三维点都包括在一个展平列表中。
如果我们尝试对“L3”执行相同操作,则我们仅会看到第三列表级别点。级别 3 列表(索引为 0)仅包含第一组 Z 点,从而仅返回 XY 栅格。
如果我们尝试对“L4”执行相同操作,则我们仅会看到第三列表级别点。级别 4 列表(索引为 0)仅包含第一组 X 点,从而仅返回 YZ 栅格。
尽管也可以使用 “List.Map” 创建此特定示例,但 “List@Level” 会极大地简化交互,从而可以轻松访问节点数据。请在下面查看 “List.Map” 和 “List@Level” 方法的比较:
尽管这两种方法都将允许我们访问相同的点,但 “List@Level” 方法允许我们轻松地在一个节点内的数据层之间切换。
要使用 “List.Map” 访问点栅格,我们需要使用 “List.GetItemAtIndex” 节点以及 “List.Map”。对于我们要向下步进的每个列表级别,我们需要使用额外的 “List.Map” 节点。根据列表的复杂程度,这可能需要将大量 “List.Map” 节点添加到图形中,才能访问正确级别的信息。
在此示例中,“List.GetItemAtIndex” 节点与 “List.Map” 节点结合使用会返回列表结构与 “List.GetItemAtIndex”(在选择“@L3”的情况下)相同的一组相同点。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
“Transpose”是一个处理列表的列表时的基本函数。与在电子表格程序中一样,转置会翻转数据结构的列和行。我们将在下面的基本矩阵中对此进行演示,并且在以下部分中我们将演示如何使用转置来创建几何关系。
让我们从上一个练习中删除 “List.Count” 节点,然后转到一些几何图形以查看数据的结构。
从 “Point.ByCoordinates” 将 “PolyCurve.ByPoints” 连接到“Watch”节点的输出。
输出会显示 5 条复合线,我们可以在 Dynamo 预览中看到这些曲线。Dynamo 节点将查找一列点(或在本例中为一列点列表)并基于它们创建一条复合线。实际上,每个列表已转换为数据结构中的曲线。
“List.Transpose” 节点将切换一列列表中所有列表的所有项目。这听起来很复杂,但其逻辑与 Microsoft Excel 中的“转置”相同:在数据结构中切换列和行。
请注意抽象结果:“转置”将列表结构从 5 列(每列 3 个项目)更改为 3 列(每列 5 个项目)。
请注意几何结果:使用 “PolyCurve.ByPoints”,我们在与原始曲线的垂直方向上获得 3 条复合线。
代码块简写使用“[]”来定义列表。与 “List.Create” 节点相比,这种方法可更快、更流畅地创建列表。代码块会在 “代码块和 DesignScript” 中进行更详细的介绍。请参照下图,以注意如何使用代码块定义具有多个表达式的列表。
代码块简写使用“[]”作为要从复杂数据结构中选择所需特定项目的快速简便方法。代码块会在“代码块和 DesignScript”一章中进行更详细的介绍。请参照下图,以注意如何使用代码块查询具有多个数据类型的列表。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
本练习使用在上一个练习中建立的某些逻辑来编辑曲面。我们在此处的目标一目了然,但将更多涉及数据结构导航。我们希望通过移动控制点来接合曲面。
从上述节点字符串开始。我们将创建一个跨越默认 Dynamo 栅格的基本曲面。
使用 “代码块”,插入以下两行代码并分别连接到 “Surface.PointAtParameter” 的 “u” 和 “v” 输入:
-50..50..#3;
-50..50..#5;
确保将 “Surface.PointAtParameter” 的“连缀”设置为 “叉积”。
“Watch” 节点显示我们有一列 3 个列表(每个列表都含有 5 个项目)。
在此步骤中,我们要在已创建的栅格中查询中心点。为此,我们将选择中间列表中的中间点。有道理,对吧?
要确认这一点是正确的,我们还可以单击“Watch”节点项目来确认我们面向的目标是正确的。
使用 “代码块”,我们将编写一行基本代码,用于查询一列列表:
points[1][2];
使用 “Geometry.Translate”,我们会将选定点在 Z 方向上上移 20 个单位。
我们还要使用 “List.GetItemAtIndex” 节点选择中间行的点。注意:与上一步类似,我们还可以使用 “代码块”,通过一行代码
points[1];
查询列表
到目前为止,我们已成功查询中心点并将其向上移动。现在,我们需要将此移动的点插回原始数据结构。
首先,我们要替换在上一步中隔离的列表项。
使用 “List.ReplaceItemAtIndex”,我们会将使用且索引为 “2” 的中间项替换为与移动的点( “Geometry.Translate” )相连的替换项。
输出显示我们已将移动的点输入到列表的中间项。
现在,我们已经修改了列表,我们需要将此列表插回原始数据结构:列表的列表。
遵循相同的逻辑,使用 “List.ReplaceItemAtIndex” 将中间列表替换为我们修改的列表。
请注意,为这两个节点定义索引的 “代码块” 为 1 和 2,这与 “代码块” (points[1][2]) 中的原始查询匹配。
通过选择 “索引 1” 处的列表,我们会看到数据结构在 Dynamo 预览中亮显。我们已成功将移动的点合并到原始数据结构中。
基于这组点生成曲面的方法有多种。在本例中,我们将通过一起放样曲线来创建曲面。
创建 “NurbsCurve.ByPoints” 节点并连接新的数据结构,来创建三条 NURBS 曲线。
将 “Surface.ByLoft” 连接到 “NurbsCurve.ByPoints” 的输出。现在,我们得到了一个修改的曲面。我们可以更改几何图形的原始 Z 值。平移并观察几何图形更新!
Dynamo 提供了多种方法来创建软件包,以供个人使用或与 Dynamo 社区共享。在下面的案例研究中,我们将通过解构现有软件包来逐步介绍如何创建一个软件包。本案例研究基于上一章的课程构建,提供一组自定义节点用于按 UV 坐标映射几何图形(从一个 Dynamo 曲面到另一个 Dynamo 曲面)。
我们将使用一个示例包,演示点从一个曲面到另一个曲面的 UV 映射。我们已在本 Primer 的部分中构建了该工具的基础知识。下面的文件演示了如何理解 UV 映射的概念,并为可发布库开发一组工具。
在此图像中,我们使用 UV 坐标将点从一个曲面映射到另一个曲面。软件包基于此概念,但有更加复杂的几何图形。
在前一章中,我们探讨了在 Dynamo 中基于在 XY 平面中定义的曲线为曲面镶板的方法。本案例研究扩展了这些概念,以获得更多几何图形尺寸。我们将以内置方式安装此软件包,以演示其开发方式。在下一节中,我们将演示如何发布此软件包。
在 Dynamo 中,依次单击“软件包”>“软件包管理器”,然后搜索软件包“MapToSurface”(全部写为一个单词)。单击“安装”以开始下载,并将软件包添加到库。
完成安装后,自定义节点应位于“附加模块”>“DynamoPrimer”部分下。
现在,软件包已完成安装,我们来介绍其设置方式。
我们正在创建的软件包使用我们为参照而构建的五个自定义节点。下面,我们来介绍每个节点的作用。某些自定义节点基于其他自定义节点构建,图表具有布局,供其他用户直接理解。
这是一个包含五个自定义节点的简单软件包。在下面的步骤中,我们将简要介绍每个自定义节点的设置。
这是一个基本自定义节点,所有其他映射节点均基于该节点。只需放置,该节点会将某个点从源曲面 UV 坐标映射到目标曲面 UV 坐标的位置。由于点是最基本的几何图形,基于它可构建更复杂的几何图形,因此我们可以使用此逻辑将二维几何图形(甚至三维几何图形)从一个曲面映射到另一个曲面。
仅使用此处的多边形,可演示将映射点从一维几何图形扩展到二维几何图形的逻辑。请注意,我们已将 “PointsToSurface” 节点嵌套到此自定义节点中。这样,我们就可以将每个多边形的点映射到曲面,然后基于这些映射点重新生成多边形。通过保持正确的数据结构(一列点列表),我们可以在多边形简化为一组点后,使多边形保持分离。
此处应用的逻辑与 “PolygonsToSurface” 节点中的逻辑相同。但是,我们不是映射多边形点,而是映射 NURBS 曲线的控制点。
OffsetPointsToSurface
此节点变得更加复杂,但概念非常简单:与 “PointsToSurface” 节点类似,此节点会将点从一个曲面映射到另一个曲面。但是,它还会考虑不在原始源曲面上的点,获取其与最近 UV 参数的距离,并将此距离映射到相应 UV 坐标处的目标曲面法线。在查看示例文件时,这会更有意义。
这是一个简单节点,用于创建参数化曲面以从源栅格映射到示例文件中的波状曲面。
示例文件位于软件包的根文件夹中。依次单击“软件包管理器”>“已安装的软件包”选项卡。
在“MapToSurface”的旁边,依次单击垂直点菜单 >“显示根目录”。
接着,打开 “extra” 文件夹,该文件夹存储软件包中所有非自定义节点的文件。这是存储 Dynamo 软件包示例文件(如果存在)的位置。下面的屏幕截图介绍每个示例文件中演示的概念。
使用类似的工作流,本练习文件显示用于将圆(或表示圆的多边形)从一个曲面映射到另一个曲面的设置。这将使用 “PolygonsToSurface” 节点。
此示例文件通过使用“NurbsCrvToSurface”节点增加了一些复杂性。目标曲面偏移给定距离,且 NURBS 曲线映射到原始目标曲面和偏移曲面。从这里,将放样两条映射曲线以创建曲面,然后加厚该曲面。此结果实体有表示目标曲面法线的波动。
此示例文件演示如何将褶皱多重曲面从源曲面映射到目标曲面。源曲面和目标曲面是分别跨栅格和旋转曲面的矩形曲面。
源多重曲面从源曲面映射到目标曲面。
由于自定义节点能够映射不同类型的曲线,因此最后这个文件会引用从 Illustrator 输出的 SVG 文件,并将输入的曲线映射到目标曲面。
通过解析 .svg 文件的语法,曲线将从 .xml 格式转换为 Dynamo 复合线。
输入的曲线将映射到目标曲面。这样,我们可以在 Illustrator 中显式(点击)设计镶板、输入 Dynamo,然后应用于目标曲面。
Dynamo 的节点库中存储了许多即时可用的功能。对于那些常用例程或要与社区共享的特殊图形,自定义节点和软件包是进一步扩展 Dynamo 的好方法。
创建几个自定义节点后,下一步就是通过软件包开始组织和发布它们 - 这是一种存储节点并与 Dynamo 社区共享节点的便捷方式。
在前面的各部分中,我们详细介绍了如何使用自定义节点和示例文件构建 “MapToSurface” 软件包。但是,我们如何发布本地开发的软件包?本案例研究演示了如何发布由本地文件夹中的一组文件构成的软件包。
有多个方法可以发布软件包。下面是我们建议的流程:本地发布、本地开发,然后联机发布。我们首先从包含软件包中所有文件的文件夹开始。
在开始发布 MapToSurface 软件包之前,如果您安装了上一课中的软件包,请将其卸载,以免使用相同的软件包。
首先,转到“软件包”>“软件包管理器”>“已安装的软件包”选项卡 >“MapToSurface”的旁边,依次单击垂直点菜单 >“删除”。
然后,重新启动 Dynamo。重新打开后,选中 “管理软件包” 窗口时,“MapToSurface” 应不再存在。现在,我们已准备好从头开始!
只要 Dynamo Sandbox 2.17 及更高版本中的自定义节点和软件包没有宿主 API 依存关系,就可以发布它们。在早期版本中,只能在 Dynamo for Revit 和 Dynamo for Civil 3D 中发布自定义节点和软件包。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
这是软件包的首次提交,我们已将所有示例文件和自定义节点放入一个文件夹中。准备好此文件夹后,我们便可以上传到 Dynamo 软件包管理器。
此文件夹中包含五个自定义节点 (.dyf)。
此文件夹中还包含五个示例文件 (.dyn) 和一个输入的矢量文件 (.svg)。这些文件将用作介绍性练习,以向用户介绍如何使用自定义节点。
在 Dynamo 中,首先依次单击 “软件包”>“软件包管理器”>“发布新软件包” 选项卡。
在 “发布软件包” 选项卡中,填写窗口左侧的相关字段。
接下来,我们将添加软件包文件。可以逐个添加文件,也可以通过选择“添加目录” (1) 来添加整个文件夹。要添加并非 .dyf 文件的文件,请确保在浏览器窗口中将文件类型更改为 “所有文件(.)”。请注意,我们将随意添加每个文件、自定义节点 (.dyf) 或示例文件 (.dyn)。当我们发布软件包时,Dynamo 会对这些项目进行分类。
选择“MapToSurface”文件夹后,“软件包管理器”会显示文件夹内容。如果您正在上传具有复杂文件夹结构的软件包,并且不希望 Dynamo 对文件夹结构进行更改,可以启用“保留文件夹结构”开关。此选项适用于高级用户,如果您的软件包并非以特定方式有意设置,则最好使此开关保持处于关闭状态,允许 Dynamo 根据需要组织文件。单击“下一步”以继续操作。
在此处,您有机会在发布之前预览 Dynamo 将如何组织软件包文件。单击“完成”以继续。
单击“本地发布” (1) 即可发布。如果您遵照执行,请务必单击 “本地发布” (而 不是 “联机发布” )以避免在“软件包管理器”中出现一系列重复的软件包。
发布后,应该会在“DynamoPrimer”组或 Dynamo 库下提供自定义节点。
现在,我们来查看根目录,以了解 Dynamo 如何设置刚刚创建的软件包的格式。要执行此操作,请转到“已安装的软件包”选项卡 >“MapToSurface”的旁边,单击垂直点菜单 > 选择“显示根目录”。
请注意,根目录位于软件包的本地位置(请记住,我们已“本地”发布了软件包)。Dynamo 当前正在引用此文件夹来读取自定义节点。因此,请务必将目录本地发布到永久文件夹位置(即:不是桌面)。以下内容详细介绍了 Dynamo 软件包文件夹。
“bin” 文件夹中存储了使用 C# 或 Zero-Touch 库创建的 .dll 文件。我们没有任何此软件包的内容,因此在本例中,此文件夹为空。
“dyf” 文件夹中存储了自定义节点。打开此文件夹将显示该软件包的所有自定义节点(.dyf 文件)。
附加文件夹中存储了所有附加文件。这些文件可能是 Dynamo 文件 (.dyn),也可能是所需的任何其他文件(.svg、.xls、.jpeg、.sat 等)。
pkg 文件是一个基本文本文件,用于定义软件包设置。这是在 Dynamo 中自动生成的,但如果您想要了解详细信息,可以对其进行编辑。
注意:除非您实际上发布自己的软件包,否则请勿遵循此步骤!
准备好发布后,在“软件包”>“软件包管理器”>“已安装的软件包”窗口中,选择要发布的软件包右侧的按钮,然后选择“发布”。
如果要更新已发布的软件包,请选择“发布版本”,然后 Dynamo 会根据该软件包的根目录中的新文件联机更新软件包。就这么简单!
当更新已发布软件包的根文件夹中的文件时,还可以通过在 “我的软件包” 选项卡中选择 “发布版本...” 来发布该软件包的新版本。这是对内容进行必要更新并与社区共享的无缝方式。仅当您是该软件包的维护人员时,“发布版本” 才起作用。
Dynamo Mesh Toolkit 包提供了多种工具,可从外部文件格式输入网格、从 Dynamo 几何体对象创建网格,以及按顶点和索引手动构建网格。该库还提供了一些工具,可用于修改网格、修复网格或提取水平切片以在制造中使用。
Dynamo Mesh Toolkit 是 Autodesk 持续网格研究的一部分,因此在未来几年内将继续增长。希望新方法经常出现在工具包中,您可以随时与 Dynamo 团队联系并提供评论、错误和新功能建议。
在 Dynamo 中,转到顶部菜单栏中的“软件包”>“软件包管理器...”。在搜索字段中,键入“MeshToolkit”,全部写为一个单词。单击“安装”并接受确认以开始下载。就这么简单!
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在此示例中,我们将查看网格工具包中的“相交”节点。我们将导入网格并与一系列输入平面相交以创建切片。这是准备模型以在激光刀具、水射流刀具或 CNC 铣削上进行加工的起点。
首先,在 Dynamo 中打开 “Mesh-Toolkit_Intersect-Mesh.dyn”。
File Path:找到要输入的网格文件(“stanford_bunny_tri.obj”)。支持的文件类型包括 .mix 和 .obj
Mesh.ImportFile:连接文件路径以输入网格
Point.ByCoordinates:构造点 - 这将是圆弧的中心。
Arc.ByCenterPointRadiusAngle:围绕点构造圆弧。此曲线将用于定位一系列平面。设置如下所示:
radius: 40, startAngle: -90, endAngle:0
创建一系列沿圆弧定向的平面。
代码块:创建 25 个介于 0 和 1 之间的数字。
Curve.PointAtParameter:将圆弧连接到 “curve” 输入,将代码块输出连接到 “param” 输入以沿曲线提取一系列点。
Curve.TangentAtParameter:连接与上一个节点相同的输入。
Plane.ByOriginNormal:将点连接到 “origin” 输入并将向量连接到 “normal” 输入,以在每个点处创建一系列平面。
接下来,我们将使用这些平面来与网格相交。
Mesh.Intersect:使平面与输入的网格相交,从而创建一系列复合线轮廓。在节点上单击鼠标右键并将连缀设置为最长
PolyCurve.Curves:将复合线断开为其曲线片段。
Curve.EndPoint:提取每条曲线的端点。
NurbsCurve.ByPoints:使用点来构建 NURBS 曲线。使用设定为 True 的布尔节点闭合曲线。
在继续操作之前,请关闭某些节点(例如:Mesh.ImportFile、Curve.EndPoint、Plane.ByOriginNormal 和 Arc.ByCenterPointRadiusAngle)的预览,以便更好地查看结果。
Surface.ByPatch:为每个轮廓构造曲面面片以创建网格的“切片”。
为一个格子/卵形木箱效果添加第二组切片。
您可能已注意到,相交操作通过网格与类似实体进行更快的计算。此练习中演示的工作流适合于与网格结合使用。
自定义节点通过在“Dynamo 自定义节点”内嵌套其他节点和自定义节点来构建,我们可以从概念上将其看作容器。在图形中执行该容器节点时,将执行其中的所有内容,以允许您重用和共享有用的节点组合。
如果图形中有自定义节点的多个副本,可以通过编辑基础自定义节点更新所有副本。这样,您可以通过适应工作流或设计中可能发生的任何更改来无缝更新图形。
可以说,自定义节点的最佳功能是其工作共享功能。如果“超级用户”创建复杂的 Dynamo 图形,并将其交给 Dynamo 的新手设计师,则他/她可以将图形压缩为用于设计交互的基本要素。可以打开自定义节点来编辑内部图形,但“容器”可以保持简单。借助此过程,自定义节点可让 Dynamo 用户设计清晰且直观的图形。
我们跳到自定义节点环境,并创建一个简单节点来计算百分比。自定义节点环境与 Dynamo 图形环境不同,但交互基本相同。说到这里,让我们创建第一个自定义节点!
要从头开始创建自定义节点,请启动 Dynamo 并选择“自定义节点”,或者从画布键入 Ctrl + Shift + N。
在“自定义节点特性”对话框中指定名称、说明和类别。
名称:百分比
说明:计算一个值相对于另一个值的百分比。
类别:Math.Functions
这将打开一个带黄色背景的画布,表示您正在自定义节点内部工作。在此画布中,您可以访问所有核心 Dynamo 节点,以及“输入”和“输出”节点,这些节点标记自定义节点的数据流入和流出。它们位于“输入”>“基本”中。
输入:输入节点在自定义节点上创建输入端口。输入节点的语法为 “input_name : datatype = default_value(optional)”。
可以将此自定义节点另存为“.dyf”(与标准“.dyn”相反)文件,并且该文件将自动添加到您的会话和将来的会话中。您会在库的“附加模块”部分中找到自定义节点。
现在,我们已创建了第一个自定义节点,接下来的部分将更深入地介绍自定义节点功能以及如何发布常规工作流。在以下部分中,我们将介绍如何开发将几何体从一个曲面传输到另一个曲面的自定义节点。
“Zero-Touch 输入”是指用于输入 C# 库的简单点击方法。Dynamo 将读取 .dll 文件的公有方法,并将这些方法转换为 Dynamo 节点。可以将 Zero-Touch 用于开发您自己的自定义节点和软件包,以及将外部库输入到 Dynamo 环境。
.dll 文件
Dynamo 节点
使用 Zero-Touch,实际上可以输入不一定为 Dynamo 开发的库,以及创建一组新节点。当前的 Zero-Touch 功能演示了 Dynamo 项目的跨平台思维。
在 Dynamo 中,创建一个新文件,然后依次选择 “文件”>“导入库...”
接下来,找到 dll 文件。
在弹出窗口中,导航到安装有 AForge 的相应版本文件夹。该文件夹可能类似于以下文件夹:C:\Program Files (x86)\AForge.NET\Framework\Release。
AForge.Imaging.dll:我们只想要将 AForge 库中的此文件用于本案例研究。选择此 .dll,然后点击 “打开”。
返回 Dynamo,您应该会看到已添加到库的 “AForge” 节点组。现在,我们可从可视化程序访问 AForge 图像处理库!
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
现在,库已输入,我们将开始此第一个简单练习 (01-EdgeDetection.dyn)。我们将对样例图像进行一些基本图像处理,以显示 AForge 图像如何过滤。我们将使用 “Watch Image” 节点来显示结果,并在 Dynamo 中应用过滤器(与 Photoshop 中的过滤器类似)
“File Path”节点仅提供指向选定图像的路径字符串。接下来,我们需要在 Dynamo 中将其转换为可用的图像文件。
使用 “File From Path” 将文件路径项目转换为 Dynamo 环境中的图像。
将 “File Path” 节点连接到 “File.FromPath” 节点。
要将此文件转换为图像,我们将使用 “Image.ReadFromFile” 节点。
最后,我们来看一看结果!将 “Watch Image” 节点拖动到画布上,然后连接到 “Image.ReadFromFile”。我们尚未使用 AForge,但我们已成功将图像输入 Dynamo。
在“AForge.Imaging.AForge.Imaging.Filters”(导航菜单中)下,您会注意到有许多可用过滤器。现在,我们将使用其中一个过滤器来基于阈值降低图像饱和度。
将这三个滑块拖动到画布上,将它们的范围更改为 0 到 1,将其步长值更改为 0.01。
将 “Grayscale.Grayscale” 节点添加到画布。这是一个“AForge”过滤器,可将“灰度”过滤器应用于图像。将步骤 1 中的三个滑块连接到 cr、cg 和 cb。将顶部和底部滑块的值更改为 1,将中间滑块的值更改为 0。
为了应用“灰度”过滤器,我们需要对图像执行一个操作。为此,我们使用 “BaseFilter.Apply”。将图像连接到图像输入,然后将 “Grayscale.Grayscale” 连接到“baseFilter”输入。
通过连接到 “Watch Image” 节点,我们会得到饱和度降低的图像。
我们可以控制如何根据红、绿和蓝的阈值来降低该图像的饱和度。这些值由 “Grayscale.Grayscale” 节点的输入定义。请注意,图像看起来很暗,这是因为滑块中的绿色值设置为 0。
将顶部和底部滑块的值更改为 0,将中间滑块的值更改为 1。这样,我们获得饱和度明显降低的图像。
让我们使用饱和度降低的图像,然后基于它应用另一个过滤器。饱和度降低的图像有一定的对比度,因此我们将测试一些边缘检测。
将 “SobelEdgeDetector.SobelEdgeDetector” 节点添加到画布。
将其连接到 “BaseUsingCopyPartialFilter.Apply”,然后将饱和度降低的图像连接到此节点的图像输入。
“Sobel Edge Detector”已在新图像中亮显边缘。
放大时,边缘检测器使用像素标注出气泡的轮廓。AForge 库提供的工具可用于获取类似结果以及创建 Dynamo 几何图形。我们将在下一练习中进行探索。
现在,我们已经介绍了一些基本图像处理,让我们使用图像来驱动 Dynamo 几何图形!从根本上讲,在本练习中我们旨在使用 AForge 和 Dynamo 对图像进行 “实时跟踪”。我们将遵循简单原则,从参照图像中提取矩形,但在 AForge 中提供一些工具来执行更复杂的操作。我们将从下载的练习文件中使用 “02-RectangleCreation.dyn”。
使用“File Path”节点,导航到练习文件夹中的“grid.jpg”。
连接上述其余一系列节点,以显示路线参数化网格。
将“BlobCounter”添加到画布,然后我们需要一种方法来处理图像(类似于上一个练习中的 “BaseFilter.Apply” 工具)。
遗憾的是,“Process Image”节点在 Dynamo 库中不会立即显示。这是因为该函数在 AForge 源代码中可能不可见。为了解决此问题,我们需要找到解决方法。
将“Python”节点添加到画布,并将以下代码添加到“Python”节点。此代号将输入 AForge 库,然后处理输入的图像。
将图像输出连接到“Python”节点输入,我们可从“Python”节点获得“AForge.Imaging.BlobCounter”结果。
将 Python 脚本的输出连接到“BlobCounterBase.GetObjectRectangles”。这将基于阈值读取图像中的对象,并从像素空间中提取量化矩形。
通过将另一个“Python”节点添加到画布,从而连接到“GetObjectRectangles”,然后输入以下代码。这将创建 Dynamo 对象的有组织列表。
调换上一步中“Python”节点的输出。这将创建 4 个列表,每个列表表示每个矩形的 X、Y、宽度和高度。
通过使用代码块,我们将数据组织为可容纳 Rectangle.ByCornerPoints 节点的结构(代码如下)。
我们得到一个矩形阵列,代表图像中的白色方块。通过编程,我们(大致)完成了与 Illustrator 中实时跟踪类似的操作!
但是,我们仍需要进行一些清理。放大后,可以看到我们有一堆小的不需要的矩形。
接下来,我们将编写代码以消除不需要的矩形。
在“GetObjectRectangles”节点和另一个“Python”节点之间插入一个“Python”节点。节点代码位于下方,并删除小于指定大小的所有矩形。
在删除多余的矩形后,只需单击几下即可基于这些矩形创建一个曲面,然后根据它们的面积拉伸一段距离。
最后,将“both_sides”输入更改为“false”,我们将在一个方向上得到拉伸。将此婴儿浸入树脂中,您便拥有一张超级书呆子桌子。
尽管 Dynamo 是一个灵活的环境,旨在将其导入各种程序,但最初创建该环境是为了与 Revit 配合使用。可视化程序为建筑信息模型 (BIM) 带来了强大的选择。Dynamo 提供了专为 Revit 设计的一整套节点,以及来自蓬勃发展的 AEC 社区的第三方库。本章着重介绍在 Revit 中使用 Dynamo 的基础知识。
在“DynamoUnfold”的旁边,选择菜单菜单 。
此示例文件演示了如何使用 “PointsToSurface” 来根据矩形栅格为曲面镶板。这应该看起来很熟悉,如我们在中演示的类似工作流。
以下练习演示了使用 Mesh Toolkit 的一些基本网格操作。在该练习中,我们将网格与一系列平面相交,这可能需要使用实体进行大量的计算。与实体不同,网格有设置的“分辨率”,且不是以数学方式而是以拓扑方式定义,我们可以基于手头的任务定义此分辨率。有关网格与实体关系的详细信息,可参考本 Primer 中的一章。要更全面的了解 Mesh Toolkit,可以参见 。接下来,我们跳至下面练习中的软件包。
在 Dynamo 中,有多种方法可构建自定义节点。在本章的示例中,我们将直接从 Dynamo 用户界面创建自定义节点。如果您是程序员并且对 C# 或 Zero-Touch 格式感兴趣,可以参见 Dynamo Wiki 上的进行更深入的了解。
输出:与输入类似,这些输出将在自定义节点上创建和命名输出端口。考虑将 “自定义注释” 添加到输入和输出端口,以提示输入和输出类型。这将在部分中详细介绍。
本部分演示如何使用 Zero-Touch 输入第三方库。有关开发您自己的 Zero-Touch 库的信息,请参考 。
Zero-Touch 软件包是对用户定义的自定义节点的良好补充。下表列出了使用 C# 库的一些软件包。有关软件包的更多详细信息,请访问“附录”中的。
在本案例研究中,我们将介绍如何输入 外部 .dll 库。AForge 是一个功能强大的库,提供了从图像处理到人工智能的一系列功能。我们将引用 AForge 中的图像处理类,以在下面进行一些图像处理练习。
首先,我们下载 AForge。在 上,选择 “[下载安装程序]”,然后在下载完成后进行安装。
要输入图像,请将 “File Path” 节点添加到画布,然后从练习文件夹中选择“soapbubbles.jpg”(照片来源:)。
在下一步中,我们要参照图像中的白色方块,并将它们转换为实际的 Dynamo 几何图形。AForge 具有许多功能强大的计算机视觉工具,我们将在此处针对名为的库使用一个特别重要的工具。
接下来将进行一些技巧操作,以展示对的熟悉程度。对于使用 Dynamo 而言,无需了解所有这些技巧。这更多是在 Dynamo 环境的灵活性内使用外部库的演示。
这些是基本示例,但此处概述的概念可以传递给令人兴奋的真实应用程序。计算机视觉可用于各种流程。仅举几例:条形码读取器、透视匹配、和。有关与本练习相关的 AForge 的更多高级主题,请通读。
虽然 Dynamo 最初是在考虑与 Revit 结合使用的情况下构建的,但 Dynamo 作为一款可视化编程工具的多功能性超越了 Revit。Dynamo 还集成到 Civil 3D 中,使用户能够为土木基础设施项目创建功能强大的自动化例程。它是一款非常有用的工具,用于处理从常见任务到最复杂设计工作流的所有事务,从而最终帮助您节省时间、优化设计并做出更好的设计决策。Dynamo 提供了专为 Civil 3D 设计的一整套节点,以及来自繁荣社区的第三方库。
Primer 的本章将重点介绍 Dynamo for Civil 3D,从基础知识开始,然后介绍更高级的主题。
随着时间的推移,您可能会发现自己需要超越基础知识,深入了解 Dynamo 的内部运作。本部分中的页面将为您提供一个用于解锁 Dynamo for Civil 3D 中高级功能的蓝图,以便您可以将图形处理提升到更高级别。
ARGB 颜色 (Color.ByARGB)
A,R,G,B
颜色
Alpha (Color.Alpha)
颜色
A
红色 (Color.Red)
颜色
R
绿色 (Color.Green)
颜色
G
蓝色 (Color.Blue)
颜色
B
组件 (Color.Components)
颜色
A,R,G,B
色调 (Color.Hue)
颜色
色调
饱和度 (Color.Saturation)
颜色
饱和度
亮度 (Color.Brightness)
颜色
亮度
徽标/图像 | 名称 |
适用于 Revit 的 Dynamo 使用图形算法编辑器的数据和逻辑环境扩展建筑信息模型。它的灵活性与强大的 Revit 数据库相结合,可以提供全新的 BIM 视角。
本章着重介绍适用于 BIM 的 Dynamo 工作流。各部分主要基于练习,因为直接进入项目是熟悉 BIM 图形算法编辑器的最佳方式。首先,我们来谈谈程序的开头部分。
由于 Revit 和 Dynamo 都在不断发展,您可能会注意到,您使用的 Revit 版本与您计算机上安装的适用于 Revit 的 Dynamo 版本不兼容。下面概述了哪些适用于 Revit 的 Dynamo 版本与 Revit 兼容。
该项目最初非常简单,但凭借专门的开发者团队和充满激情的社区,已经发生了很大变化。
最初,Dynamo 旨在简化 Revit 中的 AEC 工作流。尽管 Revit 为每个项目创建了一个强大的数据库,但普通用户可能难以在界面约束之外访问此信息。Revit 托管全面的 API(应用程序程序界面),使第三方开发者可以创建自定义工具。程序员多年来一直在使用此 API,但并非所有人都可以访问基于文本的脚本。Dynamo 希望通过易得到的图形算法编辑器使 Revit 数据大众化。
使用核心 Dynamo 节点与自定义 Revit 节点,用户可以显著扩展参数化工作流以实现互操作性、文档编制、分析和生成。使用 Dynamo,可以自动执行繁琐的工作流,同时设计探索可以蓬勃发展。
在 Revit 项目或族编辑器中,导航到“附加模块”,然后单击 Dynamo。*
*Dynamo 仅在已打开的文件中运行。
在 Revit 中打开 Dynamo 时,有一个名为“Revit”的新类别。这是对用户界面完全新增的功能,可提供专门针对 Revit 工作流的节点。*
*通过使用 Revit 特定的节点族,Dynamo 图形将仅在适用于 Revit 的 Dynamo 中打开时可用。例如,如果在 Dynamo 沙盒中打开适用于 Revit 的 Dynamo 图形,Revit 节点将丢失。
由于 Revit 是一个提供强大项目管理的平台,因此 Dynamo 中的参数化操作可能非常复杂且计算速度缓慢。如果 Dynamo 计算节点需要较长时间,可能需要使用“冻结”节点功能,以便在开发图形时暂停执行 Revit 操作。
您可以在节点和导线部分,阅读有关冻结节点的详细信息。
由于 Dynamo 最初是为 AEC 开发的,因此其庞大且不断壮大的社区是一个绝佳资源,可供从业内专家处学习并与之联系。Dynamo 的社区由那些热衷于分享和创作的建筑师、工程师、程序员以及设计师组成。
Dynamo 是一个不断发展的开源项目,而且许多开发与 Revit 相关。如果您对于该游戏是新手,请访问论坛并开始发布问题!如果您是程序员并想参与 Dynamo 开发,请查看 GitHub 库。此外,Dynamo 软件包管理器是第三方库的绝佳资源。其中许多软件包都是由 AEC 制作的,我们将在本章中查看用于镶板的第三方软件包。
Dynamo 还维护着一个活跃的博客。阅读最近的帖子,了解最新进展!
Revit 是一个数据丰富的环境。这为我们提供了一系列选择功能,使其远超“点击”范围。我们可以查询 Revit 数据库,以及在执行参数化操作的同时将 Revit 图元动态链接到 Dynamo 几何图形。
UI 中的 Revit 库提供了“选择”类别,该类别允许通过多种方式选择几何图形。
要正确选择 Revit 图元,请务必全面了解 Revit 图元层次结构。要选择项目中的所有墙?选择“按类别”。要选择您中世纪风格大厅中的每把埃姆斯椅?选择“按族”。
我们快速回顾一下 Revit 层次结构。
还记得生物学的分类法吗?界、门类、类别、等级、族、属、种?Revit 图元以类似方式分类。在基本级别上,Revit 层次结构可以分解为“类别”、“族”、“类型*”和“实例”。实例是一个模型图元(具有唯一 ID),而类别则定义常规组(如“墙”或“楼板”)。通过这种方式组织 Revit 数据库,我们可以选择一个图元,并根据层次结构中的指定级别选择所有相似图元。
*Revit 中的类型定义与编程中的类型不同。在 Revit 中,类型是指层次结构的分支,而不是“数据类型”。
下面的三幅图像对 Dynamo 中 Revit 图元选择的主要类别进行了细分。这些是可结合使用的优秀工具,我们将在以下练习中介绍其中一些工具。
“点击” 是直接选择 Revit 图元的最简单方法。可以选择完整的模型图元或其一部分拓扑(如面或边)。这会保持与该 Revit 对象的动态链接,因此,当 Revit 文件更新其位置或参数时,参照的 Dynamo 图元将在图形中更新。
“下拉”菜单 在 Revit 项目中创建所有可访问图元的列表。可以使用此选项来参照在视图中不一定可见的 Revit 图元。这是一款优秀的工具,可用于查询现有图元或者在 Revit 项目或族编辑器中创建新图元。
![](../.gitbook/assets/selecting _database_navigation_with_dynamo_nodes_02.png)
还可以在 Revit 层次结构 中按特定层级选择 Revit 图元。这是一个功能强大的选项,可用于自定义大型数据阵列,以准备文档或衍生式实例化和自定义。
在上述三幅图中,我们将深入探讨一个练习,该练习从基本 Revit 项目中选择图元,为我们将在本章的其余部分创建的参数化应用程序做好准备。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在此 Revit 文件示例中,我们有三种图元类型的简单建筑。我们将以此为例,在 Revit 层次结构的上下文中选择 Revit 图元。
建筑体量
梁(结构框架)
桁架(自适应构件)
基于 Revit 项目视图中当前的图元,我们可以得出哪些结论?我们需要在层次结构中向下行进多远来选择相应图元?当然,在处理大型项目时,这将成为一项更为复杂的任务。有许多可用选项:我们可以按“类别”、“标高”、“族”、“实例”等选择图元。
由于我们使用的是基本设置,因此我们选择“Categories”下拉节点中的 “Mass” 来选择建筑体量。这可在“Revit”>“选择”选项卡中找到。
“Mass”类别的输出只是类别本身。我们需要选择相应图元。为此,我们使用 “All Elements of Category” 节点。
请注意,此时我们在 Dynamo 中看不到任何几何图形。我们已选择 Revit 图元,但尚未将该图元转换为 Dynamo 几何图形。这是非常重要的差异。如果要选择大量图元,您不会希望在 Dynamo 中预览所有这些图元,因为这会降低所有操作的速度。Dynamo 是一款用于管理 Revit 项目的工具(无需执行几何图形操作),我们将在本章的下一部分中进行介绍。
在本例中,我们使用的是简单几何图形,因此我们希望将几何图形输入 Dynamo 预览。上述“Watch”节点中的“BldgMass”旁边有一个绿色数字。这表示该图元的 ID,指示处理的是 Revit 图元,而不是 Dynamo 几何图形。下一步是在 Dynamo 中将此 Revit 图元转换为几何图形。
使用 “Element.Faces” 节点,我们会得到一个包含曲面的列表,表示 Revit 体量的每个面。现在,我们可以在 Dynamo 视口中看到几何图形,然后开始参照相应面进行参数化操作。
以下是另一种方法。在这种情况下,我们将不会通过 Revit 层次结构 (“All Elements of Category”) 进行选择,而是改为在 Revit 中明确选择几何图形。
使用 “Select Model Element” 节点,单击*“select”*(或 “change” )按钮。在 Revit 视口中,选择所需的图元。在本例中,我们选择的是建筑体量。
我们可以使用 “Element.Geometry” 将完整体量作为一个实体几何图形进行选择,而不是使用 “Element.Faces”。这将选择该体量中包含的所有几何图形。
使用 “Geometry.Explode” ,我们可以再次获得包含曲面的列表。这两个节点的工作方式与 “Element.Faces” 相同,但提供了用于深入到 Revit 图元的几何图形的替代选项。
使用一些基本列表操作,我们可以查询关注的面。
首先,将之前选定的图元输出到“Element.Faces”节点。
接着,“List.Count” 节点会显示我们正在处理体量中的 23 个曲面。
参照此数字,我们将整数滑块的最大值更改为 “22”。
使用 “List.GetItemAtIndex”,我们为 “index” 输入列表和整数滑块。在选定内容之间滑动,当到达 “索引 9” 并隔离将桁架用作主要外立面时,便会停止。
上一步有点麻烦。我们可以使用 “Select Face” 节点更快地完成此操作。这样,我们便可以隔离 Revit 项目中本身不是图元的面。除了我们选择曲面而非完整图元之外,与 “Select Model Element” 相同的交互也适用。
假定我们要隔离建筑的主要外立面墙。我们可以使用 “Select Faces” 节点来执行此操作。单击“Select”按钮,然后在 Revit 中选择四个主要外立面。
选择四面墙后,确保在 Revit 中单击“完成”按钮。
现在,面作为曲面输入到 Dynamo 中。
现在,我们看一下横跨中庭的梁。
使用 “Select Model Element” 节点,选择其中一个梁。
将梁图元连接到 “Element.Geometry” 节点,现在在 Dynamo 视口中便有了梁。
我们可以使用 “Watch3D” 节点放大几何图形(如果在“Watch 3D”中看不到梁,请单击鼠标右键,然后点击“zoom to fit”)。
Revit/Dynamo 工作流中可能经常遇到的问题:如何选择一个图元并获取所有相似图元?由于选定的 Revit 图元中包含其所有层次结构信息,因此我们可以查询其族类型并选择该类型的所有图元。
将梁图元连接到 “Element.ElementType” 节点。
“Watch” 节点显示,输出现在是族符号,而不是 Revit 图元。
“Element.ElementType” 是一个简单查询,因此我们可以在代码块中执行此操作(就像使用
x.ElementType;
一样简单)并获得相同的结果。
要选择其余梁,我们使用 “All Elements of Family Type” (所有族类型的图元)节点。
“Watch”节点显示我们已选择了五个 Revit 图元。
我们也可以将所有这五个图元都转换为 Dynamo 几何图形。
如果我们有 500 个梁,该怎样办?将所有这些图元都转换为 Dynamo 几何图形会非常慢。如果 Dynamo 计算节点需要较长时间,可能需要使用“冻结”节点功能,以便在开发图形时暂停执行 Revit 操作。有关冻结节点的详细信息,请查看“实体”章节中的“冻结”部分。
在任何情况下,如果要输入 500 个梁,我们是否需要将所有曲面都用来执行所需的参数化操作?或者,我们是否可以从梁中提取基本信息,并使用基本几何图元执行衍生式任务?在学习本章时,我们要牢记这个问题。例如,接下来让我们看一下桁架系统。
使用相同的节点图,选择桁架图元而不是梁图元。在执行此操作之前,请在上一步中删除“Element.Geometry”。
接下来,我们准备从桁架族类型中提取一些基本信息。
在 “Watch” 节点中,我们可以看到从 Revit 中选择的自适应构件列表。我们要提取基本信息,因此我们从自适应点开始操作。
将 “All Elements of Family Type” (所有族类型的图元)节点连接到 “AdaptiveComponent.Location” 节点。这样,我们就得到了一个包含列表的列表,每个列表都有三个点,这三个点代表自适应点的位置。
连接 “Polygon.ByPoints” 节点会返回一条复合线。我们可以在 Dynamo 视口中看到这一结果。通过此方法,我们已可视化了一个图元的几何图形,并对其余图元阵列的几何图形进行了抽象处理(其数量可能大于本示例)。
提示:如果在 Dynamo 中单击 Revit 图元的绿色数字,则 Revit 视口将缩放到该图元。
编辑文档记录的参数时遵循前面几节课程中学到的经验教训。在本节中,我们将查看编辑参数,这些参数不会影响图元的几何特性,而是为文档记录准备 Revit 文件。
在下面的练习中,我们将使用与平面节点的基本偏差,来为文档记录创建 Revit 图纸。参数化定义的屋顶结构上的每个嵌板都有不同的偏差值,我们希望使用颜色来突出值的范围,并通过安排自适应点来移交给外立面顾问、工程师或承包商。
“与平面的偏差”节点将计算四个点集与它们之间的最佳拟合平面之间的距离。这是一种研究可施工性快速而简便的方法。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
从本部分的 Revit 文件开始(或从上一部分继续)。此文件中具有屋顶上 ETFE 嵌板的阵列。在本练习中,我们将参照这些嵌板。
向画布添加 “Family Types” 节点,然后选择 “ROOF-PANEL-4PT”。
将此节点连接到“Select All Elements of Family Type”节点,以将所有图元从 Revit 输入到 Dynamo。
使用 “AdaptiveComponent.Locations” 节点查询每个图元的自适应点位置。
使用 “Polygon.ByPoints” 节点基于这四个点创建多边形。请注意,我们现在在 Dynamo 中拥有镶板系统的抽象版本,无需输入 Revit 图元的完整几何图形。
使用 “Polygon.PlaneDeviation” 节点计算平面偏差。
接下来,与上一练习一样,我们会根据每个嵌板的平面偏差设置其孔径比。
将 “Element.SetParameterByName” 节点添加到画布,然后将自适应构件连接到 “element” 输入。将读取 “Aperture Ratio” 的 “代码块” 连接到 “parameterName” 输入。
我们无法直接将偏差结果连接到值输入,因为我们需要将这些值重新映射到参数范围。
使用 “Math.RemapRange”,通过在 “代码块” 中输入
0.15; 0.45;
,将偏差值重新映射到介于 0.15 和 0.45 之间的域。将这些结果连接到 “Element.SetParameterByName” 的值输入。
返回 Revit,我们可以 稍微 了解曲面上孔径的变化。
放大后,可以更清楚地看到闭合的嵌板在曲面的各个角落上都具有权重。开口角点朝向顶部。角点表示偏差较大的区域,而凸度具有最小曲率,因此这很有意义。
设置“Aperture Ratio”并不能清楚地显示屋顶上嵌板的偏差,而且我们还要修改实际图元的几何图形。假定我们只想研究制造可行性的偏差。根据我们文档的偏差范围对嵌板进行着色会很有帮助。我们可以通过以下一系列步骤实现,并且过程与上述步骤非常相似。
删除 “Element.SetParameterByName” 及其输入节点,然后添加 “Element.OverrideColorInView”。
将 “Color Range” 节点添加到画布,然后连接到 “Element.OverrideColorInView” 的颜色输入。为了创建渐变,我们仍需将偏差值连接到颜色范围。
将光标悬停在 “value” 输入上时,我们可以看到输入值必须介于 0 和 1 之间,以便将颜色映射到每个值。我们需要将偏差值重新映射到此范围。
使用 “Math.RemapRange”,将平面偏差值重新映射到介于 0 和 1 之间的范围(注意:也可以使用 “MapTo” 节点定义源域)。
将结果连接到 “Color Range” 节点。
请注意,我们的输出是颜色范围,而不是数字范围。
如果设置为“手动”,请点击 “运行” 。此时,应该能够无需再设置为“自动”。
返回 Revit,我们看到了更清晰的渐变,它代表了基于我们颜色范围的平面偏差。如果我们要自定义颜色,该怎么办?请注意,最小偏差值以红色表示,这似乎与我们的预期相反。我们希望最大偏差以红色表示,最小偏差以较柔和的颜色表示。我们返回 Dynamo,然后修复此问题。
使用 “代码块”,在两个不同代码行上添加两个数字:
0;
和255;
。通过将相应值连接到两个 “Color.ByARGB” 节点,即可创建红色和蓝色。
以这两种颜色创建列表。
将此列表连接到 “Color Range” 的 “colors” 输入,然后观察自定义颜色范围更新。
返回 Revit,我们现在可以更好地了解角点中偏差最大的区域。请记住,此节点用于替代视图中的颜色,因此如果我们在专注于特定分析类型的图形集中有特定图纸,这将非常有用。
在 Revit 中选择一个 ETFE 嵌板,我们会看到有四个实例参数:XYZ1、XYZ2、XYZ3 和 XYZ4。创建这些参数后,它们的内容都为空。这些是基于文字的参数,都需要值。我们会使用 Dynamo 将自适应点位置写入每个参数。如果需要将几何图形发送给外立面顾问工程师,这有助于实现互操作性。
在样例图纸中,我们有一个大的空明细表。XYZ 参数是 Revit 文件中的共享参数,这样我们便可将它们添加到明细表中。
放大后,XYZ 参数尚未填充。前两个参数由 Revit 处理。
为了写入这些值,我们将执行复杂的列表操作。该图形本身很简单,但这些概念主要基于列表一章中讨论的列表映射进行构建。
选择所有具有两个节点的自适应构件。
使用 “AdaptiveComponent.Locations” 提取每个点的位置。
将这些点转换为字符串。请记住,参数基于文字,因此我们需要输入正确的数据类型。
创建包含四个字符串的列表,该列表定义要更改的参数:XYZ1、XYZ2、XYZ3 和 XYZ4。
将此列表连接到 “Element.SetParameterByName” 的 “parameterName” 输入。
将 “Element.SetParameterByName” 连接到 “List.Combine” 的 “combinator” 输入。将 自适应构件 连接到 “list1”。将 Object 的 “String” 连接到 “list2”。
我们在此处进行列表映射,因为我们要为每个图元编写四个值,从而创建一个复杂的数据结构。“List.Combine” 节点在数据层次结构中定义一个向下步骤的操作。这就是 “Element.SetParameterByName” 的图元和值输入保留为空的原因。根据 “Element.SetParameterByName” 的空输入的连接顺序, “List.Combine” 会将其输入的子列表连接到这些空输入。
在 Revit 中选择一个嵌板后,现在会看到每个参数都有字符串值。实际上,我们将创建更简单的格式来写入点 (X,Y,Z)。这可以在 Dynamo 中使用字符串操作完成,但我们会绕过此处以停留在本章的范围内。
样例明细表的视图,其中已填充参数。
现在,每个 ETFE 嵌板都为每个自适应点写入了 XYZ 坐标,从而表示要预制的每个嵌板的角点。
Dynamo for Civil 3D 为从事土木基础设施项目的工程师和设计师提供了 可视化编程 范例。可以将 Dynamo 视为一种面向 Civil 3D 用户的数字多功能工具 - 无论任务如何,它都有适合该工作的合适工具。Dynamo 的直观界面使您无需编写一行代码即可创建强大且可自定义的例程。您不需要 成为 一名程序员就可以使用 Dynamo,但您确实需要能够以程序员的逻辑 思考。结合该 Primer 中的其他章,本章将帮助您培养逻辑技能,以便您能够以计算设计思维模式来处理任何任务。
Dynamo 是在 Civil 3D 2020 中首次引入的,自此以后不断发展。它最初是通过软件更新单独安装的,现在随所有版本的 Civil 3D 一起提供。根据您正在使用的 Civil 3D 的版本,您可能会注意到 Dynamo 界面看起来与您在本章中所见的示例略有不同。这是因为在 Civil 3D 2023 中对界面进行了重大改进。
建议您查看 Dynamo 博客,以了解有关 Dynamo 开发的最新信息。下表汇总了 Dynamo for Civil 3D 生命期中的关键里程碑。
可以在 Dynamo 中使用完全参数化控制创建 Revit 图元阵列。Dynamo 中的 Revit 节点支持将常规几何图形中的图元输入到特定类别类型(如墙和楼板)。在本部分中,我们将重点介绍如何以参数化方式输入具有自适应构件的灵活图元。
自适应构件是一种灵活的族类别,非常适用于衍生应用程序。实例化后,即可创建复杂的几何图元,该图元由自适应点的基本位置驱动。
下面是族编辑器中三点自适应构件的示例。这将生成一个桁架,该桁架由每个自适应点的位置定义。在下面的练习中,我们将使用此构件在外墙上生成一系列桁架。
自适应构件是实现互操作性最佳实践的一个很好示例。我们可以通过定义基本自适应点来创建自适应构件阵列。在将该数据传输到其他程序时,我们能够将几何图形简化为简单数据。使用类似 Excel 的程序输入和输出遵循类似的逻辑。
假定外墙顾问想要知道桁架图元的位置,而无需通过完全铰接的几何图形进行解析。在准备制造时,顾问可以参照自适应点的位置,以在类似 Inventor 的程序中重新生成几何图形。
我们将在下面练习中设置的工作流允许我们在创建 Revit 图元时创建定义的同时访问所有这些数据。通过此流程,我们可以将概念化、文档编制和制造合并为一个无缝工作流。这将为互操作性创造更智能、更高效的流程。
下面的第一个练习将分步介绍 Dynamo 如何参照数据以创建 Revit 图元。为了生成多个自适应构件,我们会定义一个包含列表的列表,其中每个列表中都有表示自适应构件的每个点的三个点。在 Dynamo 中管理数据结构时,我们要记住这一点。
将参数化 Dynamo 几何图形输入 Revit 的另一种方法是使用 DirectShape。总之,DirectShape 图元和相关类支持将外部创建的几何形状存储在 Revit 文档中。几何图形可以包含闭合实体或网格。DirectShape 主要用于从 IFC 或 STEP 等其他数据格式输入形状,这些格式中没有足够信息可用于创建“真实”的 Revit 图元。与 IFC 和 STEP 工作流一样,DirectShape 功能非常适用于将 Dynamo 创建的几何图形作为真实图元输入到 Revit 项目。
让我们通过第二个练习来分步介绍如何将 Dynamo 几何图形作为 DirectShape 输入到 Revit 项目中。使用此方法,我们可以指定输入的几何图形的类别、材质和名称,同时保留指向 Dynamo 图形的参数化链接。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
从本部分的示例文件开始(或从上一任务中的 Revit 文件继续操作),我们会看到相同的 Revit 体量。
这是已打开的文件。
这是我们使用 Dynamo 创建的桁架系统,与 Revit 体量智能链接。
我们已使用 “Select Model Element” (选择模型图元)和 “Select Face” (选择面)节点,现在我们在几何图形层次结构中向下进一步,并使用 “Select Edge” (选择边)。将 Dynamo 求解器设置为 “自动” 运行后,图形将不断更新到 Revit 文件中的更改。我们选择的边与 Revit 图元拓扑动态关联。只要拓扑*不改变,Revit 和 Dynamo 之间的连接就会保持链接。
选择玻璃外墙的最顶部曲线。这将跨越建筑的整个长度。如果在选择边时遇到问题,请记得在 Revit 中进行选择,方法是将光标悬停在相应边上,然后点击 “Tab” ,直到所需边亮显。
使用两个 “Select Edge” (选择边)节点,选择表示外墙中间的斜面处的每条边。
在 Revit 中,对外墙的底边执行相同的操作。
“Watch”(观察)节点显示我们现在在 Dynamo 中有线。这会自动转换为 Dynamo 几何图形,因为边本身不是 Revit 图元。这些曲线是我们将用于实例化整个外墙的自适应桁架的参照。
*为了保持拓扑一致,我们所引用的模型没有添加额外面或边。尽管参数可以更改其形状,但构建方式仍保持一致。
首先,我们需要连接曲线并将它们合并到一个列表中。这样,我们就可以对曲线 “分组” 以执行几何图形操作。
为外墙中间的两条曲线创建一个列表。
通过将 “List.Create” 组件插入到 “Polycurve.ByJoinedCurves” 节点,从而将两条曲线连接到复合线。
为外墙底部的两条曲线创建一个列表。
通过将 “List.Create” 组件插入到 “Polycurve.ByJoinedCurves” 节点,从而将两条曲线连接到复合线。
最后,将三条主要曲线(一条线和两条复合线)合并到一个列表中。
我们要利用顶部曲线(即一条线),它表示外墙的整个跨度。我们将沿这条线创建平面,以与我们在列表中分组在一起的一组曲线相交。
借助 “代码块”,使用以下语法定义一个范围:
0..1..#numberOfTrusses;
将整数滑块连接到代码块的输入。如您所料,这将表示桁架数。请注意,滑块控制在 0 至 1 所定义范围内的项目数。
将 “代码块” 插入到 “Curve.PlaneAtParameter” 节点的 “param” 输入,并将顶边插入到 “curve” 输入。这样,我们将获得十个平面,这些平面均匀分布在外墙的跨度上。
平面是几何图形的抽象部分,表示无限的二维空间。由于我们在此步骤中进行设置,因此平面非常适合轮廓和相交。
使用 “Geometry.Intersect” 节点(将连缀选项设置为叉积),将 “Curve.PlaneAtParameter” 连接到 “Geometry.Intersect” 节点的 “entity” 输入。将主 “List.Create” 节点插入到 “geometry” 输入。现在,我们在 Dynamo 视口中会看到代表每个曲线与定义平面相交的点。
请注意,输出是一列包含列表的列表。对于我们的目的而言,列表过多。我们想在这里进行部分展平。我们需要在列表中向下一步,然后展平结果。为此,我们使用 “List.Map” 操作,如 Primer 的列表章节中所述。
将 “Geometry.Intersect” 节点插入到 “List.Map” 的列表输入。
将 “Flatten” (展平)节点插入到 “List.Map” 的 f(x) 输入。结果给出 3 个列表,每个列表的计数等于桁架数。
我们需要更改此数据。如果要实例化桁架,我们需要使用在族中定义的相同数量的自适应点。这是一个三点自适应构件,因此我们想要的不是三个列表(每个列表 10 个项目 (numberOfTrusses)),而是 10 个列表(每个列表三个项目)。这样,我们就可以创建 10 个自适应构件。
将 “List.Map” 插入到 “List.Transpose” 节点。现在,我们得到了所需的数据输出。
要确认数据正确无误,请将 “Polygon.ByPoints” 节点添加到画布,然后使用 Dynamo 预览仔细检查。
采用创建多边形的相同方式,我们对自适应构件进行排列。
将 “AdaptiveComponent.ByPoints” 节点添加到画布,将 “List.Transpose” 节点插入到 “points” 输入。
使用 “Family Types” 节点,选择 “自适应桁架” 族,然后将其连接到 “AdaptiveComponent.ByPoints” 节点的 “FamilyType” 输入。
在 Revit 中,我们现在有十个桁架均匀分布在外立面上!
“调整”图形,我们通过更改滑块将“numberOfTrusses”调大为“30”。许多桁架,不太真实,但参数化链接仍起作用。验证后,将“numberOfTrusses”设置为“15”。
在最后一次测试中,通过在 Revit 中选择体量并编辑实例参数,我们可以修改建筑的形状,并观察桁架的跟随效果。请记住,必须打开此 Dynamo 图形才能看到此更新,并且链接会在该图形关闭后立即断开。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
首先,打开本课程的示例文件“ARCH-DirectShape-BaseFile.rvt”。
在三维视图中,我们可以看到上一课程中的建筑体量。
沿着中庭的边是一条参照曲线,我们将此曲线用作 Dynamo 中的参照曲线。
沿着中庭的相对边是另一条参照曲线,我们也将在 Dynamo 中参照该曲线。
为了在 Dynamo 中参照我们的几何图形,我们将为 Revit 中的每个构件使用 “Select Model Element”。在 Revit 中选择体量,然后使用 “Element.Faces” 将几何图形输入到 Dynamo - 体量现在应该在 Dynamo 预览中可见。
使用 “Select Model Element” 和 “CurveElement.Curve” 将一条参照曲线输入到 Dynamo。
使用 “Select Model Element” 和 “CurveElement.Curve” 将其他参照曲线输入到 Dynamo。
缩小并平移到示例图的右侧,我们会看到一组大节点 - 这些是几何操作,可生成在 Dynamo 预览中可见的格子架屋顶结构。这些节点使用 “节点到代码” 功能生成,如 Primer 的 “代码块”部分 中所述。
结构由三个主要参数(对角偏移、拱形和半径)驱动。
缩放此图形的参数特写。我们可以进行调整,以获得不同的几何图形输出。
将 “DirectShape.ByGeometry” 节点拖放到画布上,我们会看到它有四个输入:“geometry”、“category”、“material” 和 “name”。
几何图形将是从图形的几何图形创建部分创建的实体
使用下拉 “Categories” (类别)节点选择类别输入。在本例中,我们将使用“Structural Framing”(结构框架)。
通过上述节点阵列选择材质输入 - 尽管在这种情况下,可以更加简单地将其定义为“默认”。
运行 Dynamo 后,返回 Revit,我们将输入的几何图形放置在项目的屋顶上。这是结构框架图元,而不是常规模型。指向 Dynamo 的参数化链接保持不变。
Dynamo 的一个强大功能是,可以在参数化级别上编辑参数。例如,衍生式算法或模拟结果可用于驱动图元阵列的参数。这样,同一族中的一组实例可以在 Revit 项目中具有自定义特性。
实例参数定义屋顶表面上嵌板的孔径,Aperture Ratio 的范围介于 0.1 到 0.4 之间。
基于类型的参数将应用于表面上的每个图元,因为它们的族类型相同。例如,每个嵌板的材质都可以由基于类型的参数驱动。
如果之前已设置过 Revit 族,请记住,需要指定参数类型(字符串、数字、尺寸标注等)。 在 Dynamo 中指定参数时,请务必使用正确的数据类型。
还可以将 Dynamo 与在 Revit 族的特性中定义的参数化约束结合使用。
在 Revit 中快速查看参数时,我们要记得有类型参数和实例参数。这两个参数在 Dynamo 中都可以进行编辑,但我们在下面的练习中使用的是实例参数。
在发现了编辑参数的广泛应用后,您可能想要在 Revit 中使用 Dynamo 编辑大量图元。这可能是_计算成本高昂_的操作,这意味着它的速度可能会很慢。如果要编辑大量图元,可能需要使用“冻结”节点功能,以便在开发图形时暂停执行 Revit 操作。有关冻结节点的详细信息,请查看“实体”章节中的“冻结”部分。
从版本 0.8 开始,Dynamo 基本上是无单位的。这样,Dynamo 便可保持抽象的可视化编程环境。与 Revit 尺寸标注交互的 Dynamo 节点将参照 Revit 项目的单位。例如,如果在 Revit 中设置 Dynamo 的长度参数,则 Dynamo 中的数值将对应 Revit 项目中的默认单位。下面的练习以“米”为单位。
要快速转换单位,请使用 “Convert Between Units” 节点。这是一个方便工具,可用于即时转换长度、面积和体积单位。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
下面的练习以“米”为单位。
本练习重点介绍如何编辑 Revit 图元,而无需在 Dynamo 中执行几何操作。我们在此处不会输入 Dynamo 几何图形,只需在 Revit 项目中编辑参数即可。本练习是基本练习,对于更高级的 Revit 用户,请注意这些是体量的实例参数,但可以将相同逻辑应用于图元阵列以进行大规模自定义。这全部是通过“Element.SetParameterByName”节点完成的。
从本部分的 Revit 示例文件开始。我们已从上一部分中删除了结构图元和自适应桁架。在本练习中,我们将重点介绍 Revit 中的参数化装备,以及 Dynamo 中的操作。
在 Revit 中,选择体量中的建筑,我们可以在“特性”面板中看到实例参数的阵列。
在 Dynamo 中,我们可以通过选择目标图元来检索参数。
使用 “Select Model Element” 节点选择建筑体量。
我们可以使用 “Element.Parameters” 节点查询此体量的所有参数。这包括类型和实例参数。
参照 “Element.Parameters” 节点以查找目标参数。或者,我们可以查看上一步中的“特性”面板,以选择要编辑的参数名称。在本例中,我们将查找影响建筑体量上较大几何移动的参数。
我们将使用 “Element.SetParameterByName” 节点对 Revit 图元进行更改
使用“代码块”定义参数列表,其中用引号括起来每个项目以表示字符串。我们还可以将“List.Create”节点与一系列连接到多个输入的 “string” 节点一起使用,但代码块更便捷。在 Revit 中,确保字符串与精确名称匹配,具体情况如下:
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};
我们还要为每个参数指定值。向画布添加六个 “整数滑块” ,然后重命名为列表中相应的参数。此外,根据上图设置每个滑块的值。按从上到下的顺序:62、92、25、22、8、12
定义另一个 “代码块” ,其中列表与参数名称的长度相同。在本例中,我们命名变量(不带引号),这将为 “代码块” 创建输入。将 “滑块” 连接到各自的输入:
{bw,bl,bh,ao,io,lu};
将“代码块”连接到 “Element.SetParameterByName”* 值输入。在选中“自动运行”后,我们会自动看到结果。
*此演示使用的是实例参数,而不是类型参数。
就像在 Revit 中一样,其中许多参数相互依赖。当然,在这些组合中几何图形可能会中断。我们可以在参数特性中定义公式来解决这个问题,也可以在 Dynamo 中使用数学运算设置类似逻辑(如果您想扩展练习,这也是一项额外的挑战)。
此组合为建筑体量提供了功能强大的新设计:100、92、100、25、13、51
接下来,我们来了解一下如何使用类似过程编辑外立面。
复制图形,然后专注于将容纳桁架系统的外立面玻璃。在本例中,我们将隔离四个参数:
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
此外,我们还会创建 “数字滑块” ,然后重命名为相应的参数。前三个滑块(从上到下)应重新映射到 [0,10] 的域,而最后一个滑块( “外立面弯曲位置” )应重新映射到 [0,1] 的域。这些值(从上到下)应从以下这些值开始(尽管它们是任意值):2.68、2.64、2.29、0.5
定义新的代码块并连接滑块:
{so,mo,no,fbl};
通过更改图形此部分中的 “滑块”,我们可以使外立面玻璃更加实质:9.98、10.0、9.71、0.31
尽管我们之前介绍了如何编辑基本建筑体量,但我们希望一次编辑大量图元,以便深入了解 Dynamo/Revit 链接。由于数据结构需要更高级的列表操作,因此大比例自定义会变得更加复杂。但是,其执行背后的基本原则在根本上是相同的。让我们基于一组自适应构件来研究一些可能的分析。
假定我们创建了一系列自适应构件,并希望根据其点位置编辑参数。例如,这些点可以驱动与图元面积相关的厚度参数。或者,它们可以驱动一年内与日光曝晒相关的不透明度参数。Dynamo 支持通过几个简单步骤将分析与参数相连接,我们将在下面的练习中探讨基本版本。
使用 “AdaptiveComponent.Locations” 节点查询选定自适应构件的自适应点。这样,我们便可以使用 Revit 图元的抽象版本进行分析。
通过提取自适应构件的点位置,我们可以针对该图元运行一系列分析。例如,通过四点自适应构件可以研究与给定嵌板的平面之间的偏差。
使用“重映射”将一组数据映射到参数范围。这是参数化模型中所使用的基本工具,我们将在下面的练习中进行演示。
使用 Dynamo,自适应构件的点位置可用于创建每个图元的最佳拟合平面。我们还可以在 Revit 文件中查询太阳位置,并研究该平面与太阳的相对方向与其他自适应构件的比较。让我们在下面的练习中通过创建算法屋顶图来进行设置。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
本练习将进一步介绍上一节中演示的技术。在本例中,我们将基于 Revit 图元定义参数化曲面、实例化四点自适应构件,然后根据太阳的方向对其进行编辑。
首先,使用 “Select Edge” 节点选择两条边。这两条边是中庭的长跨度。
使用 “List.Create” 节点将两条边合并为一个列表。
使用 “Surface.ByLoft” 在两条边之间创建曲面。
使用 “代码块”,定义介于 0 到 1 之间的一个范围(包含 10 个等间距值):
0..1..#10;
将 “代码块” 连接到 “Surface.PointAtParameter” 节点的*“u”*和 “v” 输入,并将 “Surface.ByLoft” 节点连接到 “surface” 输入。在节点上单击鼠标右键,并将 “连缀” 更改为 “笛卡尔积”。这将在曲面上提供点栅格。
该点栅格用作参数化定义的曲面的控制点。我们要提取其中每个点的 u 和 v 位置,以便可以将它们连接到参数化公式并保持相同的数据结构。可以通过查询刚才创建的点的参数位置来执行此操作。
将 “Surface.ParameterAtPoint” 节点添加到画布,连接输入,如上所示。
使用“UV.U”节点查询这些参数的 “u” 值。
使用“UV.V”节点查询这些参数的 “v” 值。
输出显示曲面每个点对应的 “u” 和 “v” 值。现在,在正确的数据结构中,每个值的范围介于 0 到 1 之间,因此我们准备好应用参数算法。
将 “代码块” 添加到画布,然后输入代码:
Math.Sin(u*180)*Math.Sin(v*180)*w;
。这是一个参数化函数,可从平面创建正弦平滑。将 “UV.U” 连接到 “u” 输入,并将“UV.V”连接到 “v” 输入。
“w” 输入表示形状的 “振幅”,因此我们向其附加 “数字滑块”。
现在,我们得到了由算法定义的一列值。让我们使用该列值在 “+Z” 方向上上移点。使用 “Geometry.Translate”,将*“代码块”*连接到 “zTranslation”,并将 “Surface.PointAtParameter” 连接到 “geometry” 输入。您应该会看到新点显示在 Dynamo 预览中。
最后,我们使用 “NurbsSurface.ByPoints” 节点创建曲面,从而将上一步中的节点连接到点输入。我们自己有一个参数化曲面。可以随意拖动滑块来观察多边形收缩和扩展。
使用参数化曲面,我们需要定义一种方法来进行镶板,以便布置四点自适应构件。Dynamo 没有现成的功能来进行曲面镶板,因此我们可以向社区寻求有用的 Dynamo 软件包。
转到 “软件包”>“搜索软件包...”
搜索 “LunchBox”,然后安装 “LunchBox for Dynamo”。对于此种情况,这是一组非常有用的几何图形操作工具。
完成下载后,现在可以完全访问 LunchBox 套件。搜索 “四边形栅格”,然后选择 “LunchBox 四边形栅格(按面)”。将参数化曲面连接到 “surface” 输入,并分别将 “U” 和 “V” 设置为 “15”。您应该会在 Dynamo 预览中看到四分面板的曲面。
如果您对其设置很满意,可以双击 “Lunch Box” 节点,查看其设置。
返回 Revit,让我们快速看一下在此处使用的自适应构件。无需再继续,但这是我们要实例化的屋顶嵌板。它是四点自适应构件,是 ETFE 系统的粗略表示。中心空心的光圈位于名为 “ApertureRatio” 的参数上。
我们要在 Revit 中实例化许多几何图形,因此请确保将 Dynamo 解算器设置为 “手动”。
向画布添加 “Family Types” 节点,然后选择 “ROOF-PANEL-4PT”。
将 “AdaptiveComponent.ByPoints” 节点添加到画布,将 “LunchBox 四边形栅格(按面)” 输出中的 “Panel Pts” 连接到 “points” 输入。将 “Family Types” 节点连接到 “familySymbol” 输入。
点击 “运行”。当创建几何图形时,Revit 必定会 考虑 一下。如果需要太长时间,请将 代码块的“15” 减少到较小数字。这将减少屋顶上嵌板的数量。
注意:如果 Dynamo 计算节点需要较长时间,可能需要使用“冻结”节点功能,以便在开发图形时暂停执行 Revit 操作。有关冻结节点的详细信息,请参见“实体”章节中的“冻结”部分。
返回 Revit,我们在屋顶上有一组嵌板。
放大后,可以更仔细地查看其曲面质量。
从上一步继续操作,我们进一步根据每个嵌板到太阳的曝光来驱动其光圈。放大 Revit 并选择一个嵌板,我们在特性栏中可以看到有一个名为 “Aperture Ratio” 的参数。设置族,以便使光圈范围大致介于 “0.05” 到 “0.45” 之间。
如果打开日光路径,可以在 Revit 中看到当前的太阳位置。
我们可以使用 “SunSettings.Current” 节点来参照此太阳的位置。
将“日光设置”连接到 “Sunsetting.SunDirection” 以获得太阳向量。
从用于创建自适应构件的 “Panel Pts”,使用 “Plane.ByBestFitThroughPoints” 以近似计算构件的平面。
查询此平面的 “法线”。
使用 “点积” 计算太阳方向。点积是一个用于确定两个向量的平行度或反平行度的公式。我们采用每个自适应构件的平面法线,并将其与太阳向量进行比较以粗略模拟太阳方向。
获取结果的 “绝对值”。这可确保点积在平面法线朝向反转方向时是准确的。
点击 “运行”。
我们看一下 “点积”,这里有很多数字。我们想要使用它们的相对分布,但我们需要将数字压缩到计划编辑的 “Aperture Ratio” 参数的适当范围。
“Math.RemapRange” 是一个适用于此种情况的优秀工具。它采用输入列表并将其边界重新映射到两个目标值。
在 “代码块” 中,将目标值定义为 “0.15” 和 “0.45”。
点击 “运行”。
将重映射的值连接到 “Element.SetParameterByName” 节点。
将字符串 “Aperture Ratio” 连接到 “parameterName” 输入。
将 “自适应构件” 连接到 “element” 输入。
点击 “运行”。
返回 Revit,从远处我们可以看出太阳方向对 ETFE 嵌板光圈的影响。
放大,我们看到 ETFE 嵌板在面对太阳时更加闭合。此处,我们的目标是减少因日光曝晒而导致的过热情况。如果我们要根据日光曝晒让更多光线进入,只需切换 “Math.RemapRange” 上的域即可。
当将管道和结构添加到管网时,Civil 3D 会使用模板自动指定名称。通常,这在初始放置期间已够用;但随着设计的展开,这些名称在将来不可避免地需要更改。此外,可能还需要许多不同的命名模式;例如,从最远的下游结构开始按顺序命名管道管路中的结构,或遵循与本地机构的数据模式保持一致的命名模式。本例将演示如何使用 Dynamo 来定义任何类型的一贯应用的命名策略。
使用边界框
使用 List.FilterByBoolMask 节点过滤数据
使用 List.SortByKey 节点对数据排序
生成和修改文字字符串
此图形将在 Civil 3D 2020 及更高版本上运行。
首先下载下面的样例文件,然后打开 DWG 文件和 Dynamo 图形。
下面概述了此图形中的逻辑。
按图层选择结构
获取结构位置
按偏移过滤结构,然后按桩号对结构排序
生成新名称
重命名结构
开始吧!
首先,我们需要选择要处理的所有结构。为此,我们只需选择特定图层上的所有对象,这意味着我们可以选择不同管网中的结构(假定它们共享同一图层)。
此节点确保我们不会意外检索到任何可能与结构共享同一图层的并不需要的对象类型。
现在,我们已有这些结构,我们需要确定它们在空间中的位置,以便可以根据它们的位置对它们进行排序。为此,我们将利用每个对象的边界框。对象的边界框是完全包含该对象几何范围的最小大小的框。通过计算边界框的中心,我们会获取结构插入点的较佳近似值。
我们将使用这些点,来获取结构相对于选定路线的桩号和偏移。
以下是事情开始变得有点棘手的地方。在此阶段,我们已有一个包含指定图层上所有结构的大列表,然后选择我们要对沿其的结构排序的路线。问题是列表中可能有我们不想要重命名的结构。例如,它们可能不是我们感兴趣的特定管路的一部分。
选定的路线
要重命名的结构
应忽略的结构
因此,我们需要过滤结构列表,以便我们不必考虑大于与路线的特定偏移量的结构。最好使用 List.FilterByBoolMask 节点完成此操作。过滤结构列表后,我们使用 List.SortByKey 节点以按其桩号值对结构进行排序。
如果您对操作列表不熟悉,请参见 使用列表部分。
检查以查看结构的偏移量是否小于阈值
将任何空值替换为 false
过滤结构和桩号列表
按桩号对结构排序
最后,我们需要为结构创建新名称。我们将使用的格式是 <alignment name>-STRC-<number>
。此处有一些额外节点,可用于根据需要为数字填充额外的零(例如,“01”而不是“1”)。
最后但同样重要的是,我们重命名结构。
以下是一个使用 Dynamo 播放器运行图形的示例。
如果您对使用 Dynamo 播放器不熟悉,请参见 Dynamo 播放器部分。
它有助于利用 Dynamo 的三维背景预览来可视化图形的中间输出,而不仅仅是可视化最终结果。我们可以轻松地显示结构的边界框。此外,此特定数据集在文档中包含“道路”,因此我们可以将“道路要素线”几何图形导入 Dynamo,以便为结构在空间中的位置提供一些上下文。如果图形用于没有任何道路的数据集,这些节点将不会执行任何操作。
现在,我们可以更好地了解按偏移过滤结构的过程是如何工作的。
以下是一些有关如何扩展此图形功能的想法。
根据结构的 最近路线 来重命名结构,而不是选择特定路线。
除了结构外,还 重命名管道。
根据结构的管路,来 设置其图层。
为间隙验证开发运动包络是轨道设计的重要部分。Dynamo 可用于为包络生成实体,而不是创建和管理复杂的道路子部件来执行该作业。
使用道路要素线
在坐标系之间转换几何图形
通过放样创建实体
使用连缀设置控制节点行为
此图形将在 Civil 3D 2020 及更高版本上运行。
首先下载下面的样例文件,然后打开 DWG 文件和 Dynamo 图形。
下面概述了此图形中的逻辑。
从指定的道路基准线获取要素线
沿道路要素线以所需的间距生成坐标系
将轮廓块几何图形转换为坐标系
在轮廓之间放样实体
在 Civil 3D 中创建实体
开始吧!
我们的第一步是获取道路数据。我们将按名称选择道路模型、获取道路中的特定基准线,然后按点代码获取基准线中的要素线。
现在,我们将沿道路要素线在起点桩号和终点桩号之间生成坐标系。这些坐标系将用于将车辆轮廓块几何图形与道路对齐。
如果您对使用坐标系不熟悉,请参见 向量、平面和坐标系部分。
请注意节点右下角的小 XXX。这意味着节点的连缀设置设为_“叉积”_,这对于以相同桩号值为两条要素线生成坐标系而言是必要的。
如果您对使用节点连缀不熟悉,请参见 什么是列表部分。
现在,我们需要以某种方式创建沿要素线的车辆轮廓的阵列。我们将使用 Geometry.Transform 节点来基于车辆轮廓块定义转换几何图形。这是一个难以可视化的概念,因此在我们查看节点之前,这里有一张图显示了将要发生的情况。
实际上,我们基于_单个_块定义获取 Dynamo 几何图形,然后移动/旋转该几何图形,同时沿要素线创建阵列。酷炫!节点序列如下所示。
这将从文档中获取块定义。
这些节点获取块中对象的 Dynamo 几何图形。
这些节点本质上定义了我们将转换几何图形的_来源_坐标系。
最后,此节点执行转换几何图形的实际工作。
注意此节点上的_“最长”_连缀。
以下是我们在 Dynamo 中获取的内容。
好消息!艰苦的工作已完成。我们现在只需在轮廓之间生成实体。这可以通过 Solid.ByLoft 节点轻松完成。
结果如下所示。请记住,这些是 Dynamo 实体 - 我们仍需要在 Civil 3D 中创建它们。
我们的最后一步是将生成的实体输出到模型空间中。我们还会为这些实体赋予颜色,以使它们易于区分。
以下是一个使用 Dynamo 播放器运行图形的示例。
如果您对使用 Dynamo 播放器不熟悉,请参见 Dynamo 播放器部分。
以下是一些有关如何扩展此图形功能的想法。
添加为每个轨迹单独使用 不同桩号范围 的功能。
拆分实体 为可以单独分析其是否发生碰撞的较小段。
检查以查看包络实体是否 与要素相交,并为发生碰撞的实体标注颜色。
我们之前提到,节点是 Dynamo 图形的核心构建块,它们在库中组织为逻辑组。在 Dynamo for Civil 3D 中,库中有两个类别(或工具架),其中包含用于处理 AutoCAD 和 Civil 3D 对象(如路线、轮廓、道路、块参照等)的专用节点。库的其余部分包含实际上更通用的节点,这些节点在 Dynamo 的所有“规格”(例如,适用于 Revit 的 Dynamo、Dynamo Sandbox 等)之间保持一致。
有关如何组织 Dynamo 核心库中节点的详细信息,请参见 库部分。
用于处理 AutoCAD 和 Civil 3D 对象的特定节点
通用节点
可以单独安装的第三方软件包中的节点
使用在 AutoCAD 和 Civil 3D 工具架下找到的节点,即表示您的 Dynamo 图形将仅在 Dynamo for Civil 3D 中运行。如果在别处(例如,在适用于 Revit 的 Dynamo 中)打开 Dynamo for Civil 3D 图形,则这些节点会被标记并显示警告,并且不会运行。
为什么 AutoCAD 和 Civil 3D 有两个单独的工具架?
此组织方式将用于原生 AutoCAD 对象(直线、多段线、块参照等)的节点与用于 Civil 3D 对象(路线、道路、曲面等)的节点区分开来。从技术角度而言,AutoCAD 和 Civil 3D 是两个独立的应用程序 - AutoCAD 是基础应用程序,而 Civil 3D 是在其基础上构建的。
要使用 AutoCAD 和 Civil 3D 节点,请务必全面了解每个工具架中的对象层次结构。还记得生物学的分类法吗?界、门类、类别、等级、族、属、种?AutoCAD 和 Civil 3D 对象以类似方式进行分类。让我们通过一些示例来进行讲解。
让我们以路线为例。
假定您要更改路线的名称。在此处,您要添加的下一个节点是 CivilObject.SetName 节点。
起初,这看起来可能不太直观。CivilObject 有什么作用,为什么本库没有 Alignment.SetName 节点?答案与 可重用性 和 简便性 有关。如果您想一想,无论 Civil 3D 对象是路线、道路、轮廓还是其他对象,更改该对象名称的过程都是相同的。因此,与其使用本质上都执行相同操作的重复节点(例如,Alignment.SetName、Corridor.SetName、Profile.SetName 等),不如将该功能封装到一个节点中。这正是 CivilObject.SetName 的作用!
此情况的另一种思考方式是就 关系 而言。路线和道路都是 Civil 对象类型,就像苹果和梨都是水果一样。Civil 对象节点适用于任何类型的 Civil 对象,就像您可能希望使用单个削皮器来削苹果和梨一样。如果您为每种水果都配备单独的削皮器,那么您的厨房会变得非常杂乱!从这个意义上讲,Dynamo 节点库就像您的厨房一样。
现在,让我们再深入一步。假定您要更改路线的图层。您将使用的节点是 Object.SetLayer 节点。
为什么没有名为 CivilObject.SetLayer 的节点?我们前面讨论过的相同可重用性和简便性原则也适用于此。图层 特性是 AutoCAD 中任何可绘制或插入的对象(如直线、多段线、文字、块参照等)所共有的特性。Civil 3D 对象(如路线和道路)属于同一类别,因此适用于对象的任何节点也可用于任何 Civil 对象。
道路、铁路、土地、公共设施、勘测、GIS...
土木基础设施包括但不限于所有这些内容!本部分包含多个实用的相关示例图形,有助于您熟练掌握 Dynamo,并充分挖掘 Dynamo for Civil 3D 的潜力。每个图形都完整提供(其中包含创建该图形时所用逻辑的详细描述),因此您不仅可以 使用 它,还可以 了解 它。
此外,这些示例还体现了用于构建强图形的最佳实践,这些实践都已经受时间的考验。当您完成学习示例后,建议您还要让自己熟悉 最佳实践部分,以了解有关如何构建功能强大、灵活且可维护的图形的更多想法。
典型住宅开发的工程设计涉及使用多个地下公共设施(如生活污水管、雨水排水、饮用水等)。本例将演示如何使用 Dynamo 来绘制从配水总管到给定小块土地(即地块)的服务设施连接。每个地块都需要连接服务设施,这会导致放置所有服务设施的工作非常繁琐。Dynamo 可以通过自动精确绘制必要的几何图形,并提供可调整以符合当地机构标准的灵活输入,从而加快该过程。
使用 Select Object 节点进行用户输入
使用坐标系
使用几何操作(如 Geometry.DistanceTo 和 Geometry.ClosestPointTo)
创建块参照
控制对象绑定设置
此图形将在 Civil 3D 2020 及更高版本上运行。
首先下载下面的样例文件,然后打开 DWG 文件和 Dynamo 图形。
下面概述了此图形中的逻辑。
获取配水总管的曲线几何图形
获取用户选定地块线的曲线几何图形,必要时反转
生成服务设施计量表的插入点
获取配水总管上距服务设施计量表位置最近的点
在模型空间中创建块参照和线
开始吧!
我们的第一步是将配水总管的几何图形输入到 Dynamo 中。我们将改为获取特定图层上的所有对象,并将这些对象一起连接为 Dynamo PolyCurve,而不是选择单条直线或多段线。
如果您对使用 Dynamo 曲线几何图形不熟悉,请参见 曲线部分。
接下来,我们需要将选定地块线的几何图形输入到 Dynamo 中,以便我们可以使用该几何图形。适合该作业的合适工具是 Select Object 节点,该节点使图形的用户能够拾取 Civil 3D 中的特定对象。
我们还需要处理可能会出现的潜在问题。地块线有起点和终点,这意味着它有方向。为了使图形能够生成一致的结果,我们需要所有地块线都有一致的方向。我们可以直接在图形逻辑中考虑此情况,这会使图形更具弹性。
获取地块线的起点和终点。
测量每个点到配水总管的距离,然后确定哪个距离更大。
所需结果是该线的起点距离配水总管最近。如果不是这种情况的话,则我们反转地块线的方向。否则,我们只需返回原始地块线。
现在应该确定服务设施计量表将放置的位置。通常情况下,放置位置由当地机构的要求确定,因此我们只需提供可以更改以适应各种情况的输入值。我们会将沿地块线的坐标系用作创建点的参照。这使得定义相对于地块线的偏移非常容易,而无需考虑地块线的方向。
如果您对使用坐标系不熟悉,请参见 向量、平面和坐标系部分。
现在,我们需要获取配水总管上距服务设施计量表位置最近的点。这将使我们能够在模型空间中绘制服务设施连接,以便它们始终垂直于配水总管。Geometry.ClosestPointTo 节点是完美解决方案。
这是配水总管 PolyCurve
这些是服务设施计量表插入点
最后一步是在模型空间中实际创建对象。我们将使用之前生成的插入点来创建块参照,然后使用配水总管上的点来绘制到服务设施连接的线。
当运行图形时,您应该会在模型空间中看到新的块参照和服务设施连接线。尝试更改某些输入,并观察所有内容自动更新!
您可能会注意到,在为一条地块线放置对象后,选择其他地块线会导致对象被“移动”。
这是 Dynamo 的默认行为,在许多情况下非常有用。但是,您可能会发现需要按顺序放置多个服务设施连接,并让 Dynamo 使用每个管路创建新对象,而不是修改原始对象。可以通过更改对象绑定设置来控制此行为。
有关详细信息,请参见对象绑定部分。
更改此设置会强制 Dynamo“忘记”它使用每个管路创建的对象。以下是一个使用 Dynamo 播放器运行图形(其对象绑定已关闭)的示例。
如果您对使用 Dynamo 播放器不熟悉,请参见 Dynamo 播放器部分。
以下是一些有关如何扩展此图形功能的想法。
同时放置 多个服务设施连接,而不是选择每条地块线。
调整输入以改为放置 污水管清扫口,而不是放置水表。
添加开关,以允许在地块线的特定侧(而不是两侧)放置单个服务设施连接。
现在,您对整体情况有了更多了解,让我们开始在 Civil 3D 中构建您的第一个 Dynamo 图形!
这是一个简单示例,旨在演示 Dynamo 的基本功能。建议您在新的空 Civil 3D 文档中完成这些步骤。
首先,在 Civil 3D 中打开一个空文档。进入后,导航到 Civil 3D 功能区中的 “管理” 选项卡,然后查找 “可视化编程” 面板。
单击 “Dynamo” 按钮,这即会在单独窗口中启动 Dynamo。
Dynamo 和 Dynamo 播放器之间有何区别?
Dynamo 是用于构建和运行图形的工具。Dynamo 播放器是一种运行图形的简单方法,无需在 Dynamo 中打开这些图形。
准备好尝试以后,转到 Dynamo 播放器部分。
Dynamo 打开后,您会看到开始屏幕。单击 “新建” 以打开一个空白工作空间。
有哪些样例?
Dynamo for Civil 3D 附带了一些预构建的图形,有助于激发更多有关如何使用 Dynamo 的想法。建议您在某个时候查看这些内容,以及在本 Primer 中此处参见样例工作流部分。
您现在应该看到一个空的工作空间。让我们看一看 Dynamo 的实际应用!我们的目标是:
很简单,对不对?但在开始之前,我们需要先介绍一些基础知识。
Dynamo 图形的核心构建块称为 “节点”。一个节点就像一台小型机器 - 您将数据输入到该机器中、它对该数据进行一些处理,然后输出结果。Dynamo for Civil 3D 有一个节点 库,可以使用 导线 将这些节点连接起来以形成一个比单个节点本身的作用更大更好的 图形。
好,让我们来构建图形。下面列出了我们需要的所有节点。
可以通过以下方式来找到这些节点:在本库的搜索栏中键入节点名称,或者在画布中的任意位置单击鼠标右键并在其中搜索。
如何知道要使用哪些节点以及在何处找到它们?
库中的节点根据它们的作用分组为逻辑类别。如需更深入浏览,请参见节点库部分。
您的最终图形应该如下所示。
让我们总结一下执行了哪些操作:
我们选择了要使用的文档。在这种情况(以及许多情况)下,我们希望在 Civil 3D 中的活动文档中工作。
我们定义了应创建文字对象的目标块(在本例中为模型空间)。
我们使用了 String 节点来指定应放置文字的图层。
我们使用 Point.ByCoordinates 节点创建了一个点来定义应放置文字的位置。
我们使用两个 Number Slider 节点定义了文字插入点的 X 和 Y 坐标。
我们使用了另一个 String 节点来定义文字对象的内容。
最后,我们创建了文字对象。
让我们看一看闪亮新图形的结果!
返回到 Civil 3D 中,确保 “模型” 选项卡处于选中状态。您应该会看到 Dynamo 已创建的新文字对象。
如果您看不到文字,则可能需要运行“ZOOM”->“EXTENTS”命令来缩放到正确的位置。
酷!现在,让我们对文字进行一些更新。
返回到您的 Dynamo 图形中,继续更改一些输入值(如文字字符串、插入点坐标等)。您应该会在 Civil 3D 中看到文字自动更新。另请注意,如果断开连接其中一个输入端口,文字会被删除。如果重新连接所有内容,则会再次创建该文字。
为什么 Dynamo 不在每次运行图形时插入一个新的文字对象?
默认情况下,Dynamo 会“记住”它创建的对象。如果更改节点输入值,则 Civil 3D 中的对象会更新,而不是创建全新的对象。有关此行为的详细信息,请参见对象绑定部分。
本例仅对 Dynamo for Civil 3D 的作用进行了简要介绍。继续阅读以了解更多信息!
Dynamo 的许多绝佳用例之一是沿道路模型动态放置离散对象。通常情况下,需要将对象放置在与沿道路插入的装配无关的位置,手动完成这项任务非常繁琐。当道路的水平或垂直几何图形发生更改时,会引入大量返工。
从外部文件读取数据(在本例中为 Excel)
组织词典中的数据
使用坐标系控制位置/比例/旋转
放置块参照
在 Dynamo 中可视化几何图形
此图形将在 Civil 3D 2020 及更高版本上运行。
首先下载下面的样例文件,然后打开 DWG 文件和 Dynamo 图形。
最好将 Excel 文件和 Dynamo 图形保存在同一目录中。
下面概述了此图形中的逻辑。
读取 Excel 文件并将数据输入到 Dynamo 中
从指定的道路基准线获取要素线
沿道路要素线以所需的桩号生成坐标系
使用坐标系将块参照放置在模型空间中
开始吧!
在本示例图形中,我们将使用 Excel 文件来存储 Dynamo 将用于放置灯杆块参照的数据。该表如下所示。
使用 Dynamo 从外部文件(如 Excel 文件)读取数据是一个很好的策略,尤其是当数据需要与其他团队成员共享时。
Excel 会如下所示输入到 Dynamo 中。
现在,我们已有数据,需要按列(“道路”、“基准线”、“点代码” 等)对数据进行拆分,以便可以在图形的其余部分中使用该数据。执行此操作的常见方法是使用 List.GetItemAtIndex 节点并指定我们所需每列的索引号。例如,“道路” 列位于索引 0 处,“基准线” 列位于索引 1 处,依此类推。
看起来不错,对吧?但这种方法有潜在问题。如果 Excel 文件中列的顺序将来发生更改,该怎么办?在两列之间添加新列,又该怎么办?然后,图形将无法正常运行,需要更新。我们可以通过将数据放入到词典中、将 Excel 列标题作为 键、将数据的其余部分作为 值,来使图形适应未来变化。
如果您对使用词典不熟悉,请参见 Dynamo 中的词典部分。
由于这允许灵活更改 Excel 中列的顺序,从而使图形更具弹性。只要列标题保持不变,即可使用 键(即列标题)从词典中检索数据,这是我们接下来要执行的操作。
现在,我们已输入 Excel 数据并准备就绪,让我们开始使用该数据以从 Civil 3D 中获取有关道路模型的一些信息。
按名称选择道路模型。
获取道路内的特定基准线。
通过点代码获取基准线内的要素线。
现在,我们将沿道路要素线以我们在 Excel 文件中指定的桩号值生成坐标系。这些坐标系将用于定义灯杆块参照的位置、旋转和比例。
如果您对使用坐标系不熟悉,请参见 向量、平面和坐标系部分。
请注意,在此处使用代码块可旋转坐标系,具体取决于坐标系位于基准线的哪一侧。这可以使用多个节点序列来实现,但这是一个很好的例子,说明只需编写代码块即可。
如果您对使用代码块不熟悉,请参见 代码块和 DesignScript部分。
我们即将完成!我们已有能够实际放置块参照所需的所有信息。首先,使用 Excel 文件中的 块名称 列获取我们所需的块定义。
在此处,最后一步是创建块参照。
当运行图形时,您应该会在模型空间中看到新的块参照沿道路显示。以下是一个很酷的部分 - 如果图形的执行模式设置为“自动”,然后您编辑 Excel 文件,则块参照会自动更新!
可以在 用户界面部分中,了解有关图形执行模式的详细信息。
以下是一个使用 Dynamo 播放器运行图形的示例。
如果您对使用 Dynamo 播放器不熟悉,请参见 Dynamo 播放器部分。
在 Dynamo 中可视化道路几何图形以提供上下文可能会很有帮助。此特定模型已在模型空间中提取了道路实体,因此让我们将这些道路实体输入到 Dynamo 中。
但我们还需要考虑其他一些事项。实体是一种较“重”的几何图形类型,这意味着此操作会降低图形的运行速度。如果有一种简单方法来_选择_我们是否需要查看实体,那就太好了。显而易见的答案是,只需断开连接 Corridor.GetSolids 节点,但这会对所有下游节点产生警告,这有点乱。在这种情况下,ScopeIf 节点的作用确实显著。
请注意,Object.Geometry 节点的底部有一个灰色条。这意味着节点预览处于关闭状态(可通过在节点上单击鼠标右键进行访问),从而使 GeometryColor.ByGeometryColor 节点能够避免与其他几何图形“争抢”后台预览中的显示优先级。
ScopeIf 节点基本上使您能够有选择地运行整个节点分支。如果 test 输入为 false,则连接到 ScopeIf 节点的每个节点都不会运行。
以下是 Dynamo 后台预览中的结果。
以下是一些有关如何扩展此图形功能的想法。
将 旋转 列添加到 Excel 文件中,然后使用该列来驱动旋转坐标系。
将 水平或垂直偏移 添加到 Excel 文件中,以便灯杆可以根据需要偏离道路要素线。
直接在 Dynamo 中使用起点桩号和典型间距生成桩号值,而不是使用具有桩号值的 Excel 文件。
Dynamo 是开始为 AEC 世界编码的绝佳起点。您可能对其中一些部分感兴趣,以开始您的编码之旅:
代码块是 Dynamo 中的一项独特功能,可将可视化编程环境与基于文本的环境动态链接。代码块可以访问所有 Dynamo 节点,并且可以在一个节点中定义整个图形。请仔细阅读本章,因为代码块是 Dynamo 的基本构建块。
虽然 Dynamo 是一款功能非常强大的工具,但也可以越过节点和导线,以文本形式编写代码。有两种方法可以执行此操作:
使用代码块编写 DesignScript
使用 Python 节点编写 Python
本部分将重点介绍如何在 Civil 3D 环境中利用 Python,来利用 AutoCAD 和 Civil 3D .NET API。
有关如何在 Dynamo 中使用 Python 的更多常规信息,请参见 部分。
AutoCAD 和 Civil 3D 都提供了多个 API,使像您这样的开发人员能够使用自定义功能扩展核心产品。在 Dynamo 的上下文中,相关的托管 .NET API 可用。以下链接对于了解 API 的结构及其工作方式至关重要。
在您浏览此部分时,可能会有一些您不熟悉的概念(如数据库、事务、方法、特性等)。其中许多概念是使用 .NET API 的核心,并不是 Dynamo 或 Python 特有的。本 Primer 的此部分不会详细讨论这些项目,因此建议您经常参见上述链接以了解详细信息。
当第一次编辑一个新的 Python 节点时,该节点会预填充模板代码以便于您快速开始。以下是模板的详细介绍,其中包含有关每个块的说明。
输入
sys
和clr
模块,这两个模块都是 Python 解释器能够正常运行所必需的。特别是,clr
模块使 .NET 名称空间能够基本上被视为 Python 软件包。加载标准程序集(即 DLL),以使托管 .NET API 能够用于 AutoCAD 和 Civil 3D。
添加对标准 AutoCAD 和 Civil 3D 名称空间的引用。这些引用分别相当于 C# 或 VB.NET 中的
using
或Imports
指令。可使用名为
IN
的预定义列表来访问节点的输入端口。可以使用特定端口的索引号来访问该端口中的数据(例如,dataInFirstPort = IN[0]
)。获取活动文档和编辑器。
锁定文档并启动数据库事务。
在此应放置脚本的大部分逻辑。
在主要工作完成后,取消注释此行以提交事务。
如果要输出节点中的任何数据,请在脚本末尾将该节点指定给
OUT
变量。
要自定义?
可以通过编辑位于 C:\ProgramData\Autodesk\C3D <version>\Dynamo
中的 PythonTemplate.py
文件,来修改默认 Python 模板。
让我们通过一个示例来演示在 Dynamo for Civil 3D 中编写 Python 脚本的一些基本概念。
以下是可以在本次练习中参照的示例文件。
下面概述了此图形中的逻辑。
查看 Civil 3D API 文档
按图层名称选择文档中的所有汇流
“展开”Dynamo 对象以访问 Civil 3D API 内部成员
从 AutoCAD 点创建 Dynamo 点
从点创建 PolyCurve
开始吧!
现在,我们可以开始构建图形逻辑。首先,获取文档中所有汇流的列表。有节点可用于此操作,因此我们不需要将其包含在 Python 脚本中。使用节点可以为可能读取图形的其他人提供更好的可见性(而不是在 Python 脚本中隐藏大量代码),它还使 Python 脚本能够专注于一件事:返回汇流的边界点。
请注意,All Objects on Layer 节点的输出内容是 CivilObject 的列表。这是因为 Dynamo for Civil 3D 当前没有任何用于处理汇流的节点,这正是我们需要通过 Python 访问 API 的原因。
根据经验,通常使用 InternalObjectId
特性获取对象 ID,然后在事务中访问包裹对象更安全。这是因为 InternalDBObject
特性会返回一个不处于可写状态的 AutoCAD DBObject。
以下是一个完整的 Python 脚本,用于访问内部汇流对象以获取其边界点。亮显行表示基于默认模板代码修改/添加的行。
单击脚本中带下划线的文字,可了解每行的说明。
根据经验,最好将大部分脚本逻辑包含在事务中。这可确保安全访问脚本正在读/写的对象。在许多情况下,忽略事务可能会导致出现致命错误。
在此阶段,Python 脚本应该会输出可在后台预览中看到的 Dynamo 点列表。最后一步是从这些点创建 PolyCurve。请注意,这也可以直接在 Python 脚本中完成,但我们有意将其放置在脚本之外的节点中,以便它更明显。最终图形如下所示。
以下最终的 Dynamo 几何图形。
在我们结束之前,作一个简短说明。根据您正在使用的 Civil 3D 版本,Python 节点的配置可能会有所不同。在 Civil 3D 2020 和 2021 中,Dynamo 使用名为 IronPython 的工具在 .NET 对象和 Python 脚本之间移动数据。但在 Civil 3D 2022 中,Dynamo 转变为使用标准的本地 Python 解释器(也称为 CPython),而不是使用 Python 3。此转变的好处包括能够访问常用现代库和新平台功能、基本维护和安全修补程序。
此行从 Dynamo 几何图形库中获取我们需要的特定类。请注意,我们在此处指定 import Point as DynPoint
而不是 import *
,因为后者会引发命名冲突。
在此处,我们准确指定哪个输入端口包含我们需要的数据,而不是使用默认的 IN
,后者指的是所有输入的整个列表。
在 Civil 3D 中使用几何空间点和点编组是许多现场完成过程的核心要素。Dynamo 在数据管理方面非常出色,我们将在本例中演示一个潜在用例。
使用列表
使用 List.GroupByKey 节点对类似对象进行分组
在 Dynamo 播放器中显示自定义输出
此图形将在 Civil 3D 2020 及更高版本上运行。
首先下载下面的样例文件,然后打开 DWG 文件和 Dynamo 图形。
下面概述了此图形中的逻辑。
获取文档中的所有几何空间点
按描述对几何空间点进行编组
创建点编组
将摘要输出到 Dynamo 播放器
开始吧!
我们的第一步是获取文档中的所有点编组,然后获取每个编组中的所有几何空间点。这将为我们提供 嵌套列表 或“列表的列表”(稍后如果我们使用 List.Flatten 节点将所有内容都向下展平为单个列表,将更易于使用它们)。
现在,我们已有所有几何空间点,需要根据这些几何空间点的描述将它们分成多个组。这正是 List.GroupByKey 节点的作用。它本质上是将共享相同键的任何项目分组在一起。
艰苦的工作已完成!最后一步是从分组的几何空间点创建新的 Civil 3D 点编组。
当您运行图形时,由于我们不在处理任何几何图形,因此在 Dynamo 后台预览中看不到任何内容。因此,查看图形是否正确执行的唯一方法是检查“工具空间”,或查看节点输出预览。但是,如果我们使用 Dynamo 播放器运行图形,则可以通过输出已创建的点编组的摘要来提供有关图形结果的更多反馈。您只需在节点上单击鼠标右键,然后将其设置为 “为输出”(Is Output)。在本例中,我们使用重命名的 Watch 节点来查看结果。
以下是一个使用 Dynamo 播放器运行图形的示例。
以下是一些有关如何扩展此图形功能的想法。
将点编组修改为基于 完整描述 而非原始描述。
按您选择的其他 预定义类别(例如,“地面快照”、“碑界”等)对点进行分组。
为某些组中的点自动创建三角网曲面。
Dynamo for Civil 3D 包含一个非常强大的机制,用于“记住”每个节点创建的对象。此机制称为 “对象绑定”,它使 Dynamo 图形能够每次在同一文档中运行时生成一致的结果。尽管这一机制在许多情况下都是非常需要的,但在其他情况下,您可能希望更好地控制 Dynamo 的行为。本部分将帮助您了解对象绑定的工作方式以及如何利用它。
请考虑此图形,该图形会在模型空间中的当前图层上创建一个圆。
注意半径发生更改时会出现什么情况。
这是正在进行对象绑定。Dynamo 的默认行为是_修改_圆的半径,而不是每次半径输入发生更改时都创建一个新圆。这是因为 Object.ByGeometry 节点“记住”:每次运行图形时,它都创建此_特定_圆。此外,Dynamo 会存储此信息,以便下次打开 Civil 3D 文档并运行图形时,它将具有完全相同的行为。
让我们看一个示例,在其中您可能希望更改 Dynamo 的默认对象绑定行为。假定您要构建一个将文字放置在圆中间的图形。但您使用此图形的目的是,该图形可以反复不断地运行,并每次为选定的任何圆都放置新文字。该图形可能如下所示。
但是,当选择其他圆时,实际上会发生这种情况。
进行更改后,我们会获得所需的行为。
Dynamo for Civil 3D 允许通过 “Dynamo” 菜单中的 “绑定数据存储” 设置来修改默认对象绑定行为。
请注意,“绑定数据存储”选项在 Civil 3D 2022.1 及更高版本中可用。
默认情况下,所有选项都处于启用状态。以下是每个选项的作用摘要。
启用此选项后,Dynamo 将“忘记”上次运行图形时创建的对象。因此,图形可以在任何情况下在任何图形中运行,每次都会创建新对象。
何时使用
如果希望 Dynamo“忘记”以前运行时所执行的所有操作并每次都创建新对象,请使用此选项。
此选项意味着对象绑定元数据会在保存时序列化到图形(.dyn 文件)中。如果关闭/重新打开图形并在同一图形中运行该图形,则所有操作都应与离开时相同。如果在其他图形中运行图形,则绑定数据会从该图形中删除,并创建新对象。这意味着,如果打开原始图形并再次运行图形,则除了旧对象外,还会创建新对象。
何时使用
如果希望 Dynamo“记住”上次它在特定图形中运行时创建的对象,请使用此选项。
此选项最适合在 特定图形 和 Dynamo 图形之间保持 1:1 关系的情况。选项 1 和 3 更适用于设计为在多个图形上运行的图形。
此选项类似于选项 2,不同之处在于对象绑定数据在图形中序列化,而不是在图形(.dyn 文件)中序列化。如果关闭/重新打开图形并在同一图形中运行该图形,则所有操作都应与离开时相同。如果在其他图形中运行图形,则由于绑定数据保存在图形 (drawing)(而不是图形 (graph))中,因此该绑定数据仍保留在原始图形中。
何时使用
如果要在多个图形中使用相同的图形,并让 Dynamo“记住”它在每个图形中执行的操作,请使用此选项。
使用此选项时,首先要注意的是,当通过主 Dynamo 界面运行图形时,该选项对图形与图形的交互方式没有影响。_仅_当使用 Dynamo 播放器运行图形时,此选项才适用。
如果使用主 Dynamo 界面运行图形,然后关闭并使用 Dynamo 播放器运行同一图形,则它将在之前创建的对象之上创建新对象。但是,Dynamo 播放器执行一次图形后,该播放器将序列化图形中的对象绑定数据。因此,如果通过 Dynamo 播放器多次运行图形,则该播放器会更新对象,而不是创建新对象。如果通过 Dynamo 播放器对其他图形运行图形,则由于绑定数据保存在图形 (drawing)(而不是图形 (graph))中,因此该绑定数据仍保留在原始图形中。
何时使用
如果要在多个图形中使用 Dynamo 播放器运行图形,并让它“记住”在每个图形中执行的操作,请使用此选项。
Dynamo 播放器提供了一种在 Civil 3D 中运行 Dynamo 图形的简化方法。创建了图形后,无需任何 Dynamo 专业知识即可使用播放器并运行图形。这方便与可能不想深入了解节点和导线的细节的其他人共享图形。
有关 Civil 3D 中 Dynamo 播放器的详细信息,请参见 站点上提供的文档。
Dynamo 软件包是第三方为扩展 Dynamo 的核心功能而开发的工具集。所有用户都可以访问这些软件包,只需单击相应按钮即可下载它们。
有关如何开始使用软件包的详细信息,请参见 部分。
下面列出了一些最受欢迎的软件包,这些软件包可将 Dynamo for Civil 3D 图形处理提升到更高级别。
Civil 3D Toolkit 是一个 Dynamo for Civil 3D 软件包,该软件包通过大量的附加节点显著增强了 Dynamo 的功能。
Camber 是一个开源的 Dynamo for Civil 3D 软件包,其中包含数百个用于处理标签、外部参照、数据快捷方式、样式等的节点。
CivilConnection 是一个开源的适用于 Revit 的 Dynamo 软件包,该软件包支持在 Civil 3D、Dynamo 和 Revit 之间交换信息。
Arkance Systems Nodes 是一个 Dynamo for Civil 3D 软件包,其中包含各种用于处理标注、表、视图、钻孔控制等的有用节点。
您可能已注意到 Dynamo 中节点名称的共同主题:每个节点都使用不带空格的 “.” 语法。这是因为每个节点顶部的文本表示脚本编写的实际语法,而 “.” (或 点符号 )会将图元与我们可以调用的可能方法分开。这样可轻松地将可视化脚本编写转换为基于文本的脚本编写。
作为点符号的一般类比,我们如何在 Dynamo 中处理参数化苹果?以下是我们在决定食用苹果之前将对苹果运行的几种方法。(注意:这些不是实际的 Dynamo 方法):
人类可读 | 点符号 | 输出 |
---|
我不了解您,但是从上表中的输出来看,这看起来像一只美味的苹果。我想我会 “Apple.eat()” 它。
考虑到苹果的类比,我们来看一下 “Point.ByCoordinates”,并说明如何使用代码块创建点。
“代码块” 语法 Point.ByCoordinates(0,10);
会提供与 Dynamo 中的 “Point.ByCoordinates” 节点相同的结果,但我们能够使用一个节点创建点。这相较于将单独的节点连接到 “X” 和 Y” 更加高效。
通过在代码块中使用 “Point.ByCoordinates”,我们指定输入的顺序与现成节点 “(X,Y)” 相同。
只要节点不是特殊的 “UI”节点 (具有特殊用户接口功能的节点),即可通过代码块调用库中的任何常规节点。例如,可以调用 “Circle.ByCenterPointRadius”,但调用 “Watch 3D” 节点并没有什么意义。
常规节点(库中的大多数)通常有三种类型。您会发现库是按这些类别来组织的。在代码块内调用这三种类型的方法或节点时,它们的处理方式有所不同。
创建 - 创建(或构造)对象
操作 - 对某个对象执行操作
查询 - 获取已存在对象的特性
“创建”类别将从头开始构造几何图形。我们在代码块中从左到右输入值。这些输入与节点上从上到下的输入顺序相同。
比较 “Line.ByStartPointEndPoint” 节点和代码块中的对应语法,可得到相同的结果。
操作是对该类型的对象所执行的动作。Dynamo 使用许多编码语言通用的 “点符号”,来对某个对象应用操作。确定操作对象后,键入一个点,然后键入操作的名称。与创建类方法一样,操作类方法的输入放置在圆括号中,只是您无需在相应节点上指定所见到的第一个输入。反之,我们指定要对其执行操作的元素:
“Point.Add” 节点是操作类节点,因此语法的工作方式略有不同。
要添加给它的输入分别是 (1) 点 和 (2) 向量。在 “代码块” 中,我们已将点(对象)命名为 “pt”。要将名为*“vec”*的向量添加到 “pt”,我们会写入 “pt.Add(vec)” 或写入“: 对象、点、操作”。“添加”操作仅有一个输入,或 “Point.Add” 节点的所有输入减去第一个输入。“Point.Add” 节点的第一个输入是点本身。
查询类方法可获取对象的特性。由于对象本身是输入,因此不必再指定任何输入。无需输入圆括号。
带节点的连缀与带代码块的连缀略有不同。使用节点,用户在相应节点上单击鼠标右键并选择要执行的连缀选项。使用代码块,用户可以更好地控制如何创建数据的结构。代码块简写方法使用 “复制指南”,来设置多个一维列表应如何成对。尖括号“<>”中的数字定义所生成嵌套列表的层次结构:<1>、<2>、<3> 等。
在本例中,我们使用简写来定义两个范围(更多简写位于本章的以下部分中)。简而言之,
0..1;
等效于{0,1}
,-3..-7
等效于{-3,-4,-5,-6,-7}
。结果将生成由 2 个 X 值和 5 个 Y 值组成的列表。如果我们不对这些不匹配的列表使用复制指南,则会得到一列两点,即最短列表的长度。使用“复制指南”,我们可以找出 2 和 5 坐标的所有可能组合(或“笛卡尔积”)。使用语法 Point.ByCoordinates
(x_vals<1>,y_vals<2>);
,可以得到 两 个列表(其中,每个列表中包含 五 个项目)。使用语法 Point.ByCoordinates
(x_vals<2>,y_vals<1>);
,可以得到 五 个列表(其中,每个列表中包含 两 个项目)。
使用这种表示法,我们还可以指定哪个列表是主列表:2 个列表(每个列表 5 个项目)或 5 个列表(每个列表 2 个项目)。在该示例中,更改复制指南的顺序可在栅格中生成以下结果:一个列表(每个列表包含一行点)或一个列表(每个列表包含一列点)。
尽管上面的代码块方法可能需要一些时间来适应,但 Dynamo 中有一个名为“节点到代码”的功能,该功能可使该过程更加容易。要使用此功能,请在 Dynamo 图形中选择一组节点,在画布上单击鼠标右键并选择“节点到代码”。Dynamo 将这些节点以及所有输入和输出压缩到代码块中!这不仅是学习代码块的优秀工具,还支持您更高效地处理参数化 Dynamo 图形。我们将通过使用“节点到代码”来汇总下面的练习,因此不要错过它。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
为了展现代码块的强大功能,我们将把现有的吸引器字段定义转换为代码块形式。使用现有定义演示代码块如何与可视化脚本编写相关联,有助于了解 DesignScript 语法。
首先,在上图中重新创建定义(或打开样例文件)。
请注意,“Point.ByCoordinates” 上的连缀已设置为 “笛卡尔积”。
在 Z 方向上,栅格中的每个点均基于其距参照点的距离进行上移。
曲面将重新创建并加厚,从而在几何图形中相对于距参照点的距离创建隆起。
从头开始,我们先定义参照点:Point.ByCoordinates
(x,y,0);
,我们使用与参照点节点顶部指定的相同 “Point.ByCoordinates” 语法。变量 “x” 和 “y” 会插入到 “代码块” 中,以便我们可以使用滑块动态地更新这些变量。
将一些 “滑块” 添加到 “代码块” 输入中(范围介于 -50 到 50 之间)。这样,我们就可以跨越默认的 Dynamo 栅格。
在 “代码块” 的第二行中,我们定义简写来替换数字序列节点:
coordsXY = (-50..50..#11);
。我们将在下一节中详细介绍此内容。现在,请注意,此简写与可视化脚本中的 “数字序列” 节点等效。
现在,我们要基于 “coordsXY” 序列创建点栅格。为此,我们要使用 “Point.ByCoordinates” 语法,但还需要采用与在可视化脚本中相同的方式初始化列表的 “笛卡尔积”。为此,我们键入以下代码行:
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);
。尖括号表示叉积参照。请注意,在 “Watch3D” 节点中,我们有一个点栅格穿过 Dynamo 栅格。
现在,面临的棘手情形是:我们希望根据距参照点的距离向上移动点栅格。首先,我们调用这组新的点 “transPts”。由于平移是对现有图元的操作(而不是使用
Geometry.Translate...
),因此我们使用gridPts.Translate
从画布上的实际节点读取时,我们会看到有三个输入。由于我们要对该图元执行操作(使用 “gridPts.Translate” ),因此已声明要平移的几何图形。其余两个输入将插入到函数的圆括号中:方向和 距离。
方向足够简单,我们使用
Vector.ZAxis()
来沿垂直方向移动。参照点与每个栅格点之间的距离仍需进行计算,因此我们以相同方式对该参照点执行这一计算操作:
refPt.DistanceTo(gridPts)
代码的最后一行会给出平移后的点:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
现在,我们得到具有相应数据结构的点栅格来创建 Nurbs 曲面。我们使用
srf = NurbsSurface.ByControlPoints(transPts);
构建曲面
最后,要为曲面添加一些深度,我们使用
solid = srf.Thicken(5);
构建实体;在本例中,我们使用代码将曲面加厚 5 个单位,但我们始终可以将其声明为一个变量(例如,将它命名为“thickness”),然后使用滑块控制该值。
“节点到代码”功能可自动执行我们只需单击按钮完成的整个练习。这不仅对于创建自定义定义和可重复使用的代码块来说是一项强大的功能,而且它对了解如何在 Dynamo 中编写脚本也是一个非常有用的工具:
从练习的步骤 1 开始处理现有可视化脚本。选择所有节点,在画布上单击鼠标右键,然后选择 “节点到代码”。就这么简单。
Dynamo 具有基于可视化图的版本、连缀和所有功能自动执行的文字。对可视化脚本测试此功能,然后发布该代码块的功能!
Dynamo 标准几何体库中最简单的几何对象是一个点。所有几何体均使用称为构造函数的特殊函数创建,每个函数都返回该特定几何体类型的新实例。在 Dynamo 中,构造函数以对象类型的名称(在本例中为“Point”)开始,然后是构造方法。要创建由 x、y 和 z 笛卡尔坐标指定的三维点,请使用 ByCoordinates 构造函数:
Dynamo 中的构造函数通常使用前缀为“By”指定,调用这些函数将返回该类型的新创建对象。此新创建的对象存储在等号左侧命名的变量中。
大多数对象都有许多不同的构造函数,我们可以使用 BySphericalCoordinates 构造函数创建位于球体上的点,由球体的半径、第一个旋转角度和第二个旋转角度(以度为单位指定)指定:
点可用于构造更大尺寸的几何图形(例如直线)。我们可以使用 ByStartPointEndPoint 构造函数在两点之间创建“直线”对象:
同样,直线可用于创建更多维的曲面几何体,例如使用 Loft 构造函数,该构造函数可获取一系列直线或曲线,并在它们之间内插曲面。
曲面也可用于创建更多维的实体几何体,例如通过按指定距离加厚曲面。许多对象都附加了函数(称为方法),程序员可以对该特定对象执行命令。所有几何图形通用的方法包括 Translate 和 Rotate,分别按指定的量平移(移动)和旋转几何图形。曲面具有 Thicken 方法,该方法采用单个输入,即指定曲面的新厚度的数字。
交点 命令可以从较高维度的对象提取较低维度的几何图形。提取的较低纬度几何图形可以在几何图形创建、提取和重建的循环过程中形成较高维度几何图形的基础。在本示例中,我们使用生成的实体来创建曲面,并使用曲面来创建曲线。
函数可以在代码块中创建,并在 Dynamo 定义中的其他位置进行调用。这将在参数化文件中创建另一层控制,并且可以作为基于文本版本的自定义节点进行查看。在这种情况下,“父”代码块可以随时访问,并且可以位于图形上的任意位置。不需要引线!
第一行包含关键字“def”,接着是函数名称,然后是括号中的输入名称。大括号定义函数的主体。使用“return =”返回值。定义函数的代码块没有输入或输出端口,因为它们是从其他代码块调用的。
通过提供名称和相同数量的参数,调用同一文件中具有另一代码块的函数。其工作原理与库中现成的节点一样。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在本练习中,我们将创建一个通用定义,该定义将通过输入的点列表创建球体。这些球体的半径由每个点的 Z 特性驱动。
首先从 0 到 100 的十个值范围开始。将这些值插入到 “Point.ByCoordinates” 节点,以创建对角线。
创建 “代码块”,然后引入我们的定义。
使用以下代码行:
“inputPt” 是我们提供的名称,用于表示将驱动函数的点。目前,该函数不会执行任何操作,但我们会在后续步骤中构建此函数。
通过添加到 “代码块” 函数,我们放置注释和 “sphereRadius” 变量(该变量会查询每个点的 “Z” 位置)。请记住,“inputPt.Z” 不需要圆括号以用作方法。这是对现有图元特性的 “查询”,因此不需要输入:
现在,我们再次调用在另一个 “代码块” 中创建的函数。如果双击画布以创建新的 “代码块”,然后键入 “sphereB”,我们会注意到 Dynamo 建议使用已定义的 “sphereByZ” 函数。您的函数已添加到智能库!非常棒。
现在,我们调用相应函数并创建一个名为 “Pt” 的变量,以连接在之前步骤中创建的点:
在输出中,我们注意到所有值都为空值。这是为什么呢?在定义函数后,我们会计算 “sphereRadius” 变量,但是我们未定义函数应 “返回” 为 “输出” 的内容。可以在下一个步骤中修复该问题。
一个重要步骤是,我们需要定义函数的输出,方法是将一行代码
return = sphereRadius;
添加到 “sphereByZ” 函数。现在,我们看到“代码块”的输出为我们提供了每个点的 Z 坐标。
现在,让我们通过编辑 “父” 函数,来创建实际球体。
首先,我们使用代码行定义一个球体:
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
接下来,我们将返回值更改为 “sphere”,而不是 “sphereRadius”:
return = sphere;
。这会在 Dynamo 预览中为我们提供一些巨大的球体!
1.要调整这些球体的大小,我们通过添加分隔器来更新“sphereRadius”值:
sphereRadius = inputPt.Z/20;
。现在,我们可以看到单独的球体,然后开始了解半径和 Z 值之间的关系。
在 “Point.ByCoordinates” 节点上,通过将连缀从“最短列表”更改为“叉积”,我们将创建点栅格。“sphereByZ” 函数仍然完全有效,因此所有点都会使用基于 Z 值的半径创建球体。
仅是为了测试水域,我们将原始数字列表连接到 “Point.ByCoordinates” 的 X 输入。现在,我们得到了一个球体的立方体。
注意:如果在计算机上的计算需要较长时间,请尝试将 “#10” 更改为 “#5” 之类的值。
请记住,我们创建的 “sphereByZ” 函数是一个通用函数,因此我们可以调用前一课中的螺旋,然后对其应用该函数。
最后一步:使用用户定义的参数来控制半径比。为此,我们需要为该函数创建新输入,并将 “20” 除数替换为参数。
将 “sphereByZ” 定义更新为以下内容:
通过向输入中添加“ratio”变量来更新子 “代码块”:
sphereByZ(Pt,ratio);
。将滑块插入到新创建的 “代码块” 输入中,并根据半径比改变半径大小。
计算设计中的对象很少在最终位置和形状中显式创建,并且通常基于现有几何体进行转换、旋转和定位。向量数学作为一种几何脚手架,用于提供几何体的方位和方向,以及概念化通过三维空间的移动而不是直观表示。
最基本的是,向量表示三维空间中的位置,通常被视为从位置 (0, 0, 0) 到该位置的箭头端点。可以使用 ByCoordinates 构造函数创建向量,以获取新创建的向量对象的 x、y 和 z 位置。请注意,向量对象不是几何对象,不会显示在 Dynamo 窗口中。但是,有关新创建或修改的向量的信息可以在控制台窗口中打印:
在向量对象上定义一组数学运算,可允许您在三维空间中添加、减去、相乘和移动对象,就像在数字行上的一维空间中移动实数一样。
向量相加定义为两个向量的分量之和,如果两个分量向量箭头按“尖端到尾部”放置,则可以将向量相加定义为结果向量。 向量相加是使用 Add 方法执行的,并由左侧的图表表示。
同样地,可以使用 Subtract 方法将两个向量对象相互减去。可以将向量相减看作从第一个向量到第二个向量的方向。
向量相乘可以看作是按给定比例因子在向量自身方向移动向量的端点。
在缩放向量时,通常需要使结果向量的长度与缩放量完全相等。通过首先标准化向量,即将向量的长度精确设置为一,可以轻松实现该目的。
c 仍指向与 a (1, 2, 3) 相同的方向,虽然现在它的长度完全等于 5。
向量数学中还存在两种其他方法,它们与一维数学、矢积和点积不完全平行。矢积是生成向量的一种方法,该向量(在 90 度)与两个现有向量正交。例如,x 轴和 y 轴的矢积为 z 轴,尽管这两个输入向量不需要相互正交。使用 Cross 方法计算矢积向量。
另外,某些向量数学的更高级函数是点积。两个向量之间的点积是一个实数(不是向量对象),它与两个向量之间的角度相关,但并不完全相关。点积的一个有用属性是:仅当两个向量垂直时,它们之间的点积将为 0。点积使用 Dot 方法计算。
简单来说,代码块中有一些基本的简写方法,这些方法使数据管理 更加 容易。我们将详细介绍下面的基础知识,并讨论如何使用此简写来创建和查询数据。
定义范围和序列的方法可缩减为基本简写。使用下图作为“..”语法的指导,以使用代码块定义数值数据列表。在完成此标记法后,创建数值数据是一个非常有效的过程:
在本例中,数字范围会替换为定义
beginning..end..step-size;
的基本 “代码块” 语法。通过以数字表示,可以得到:0..10..1;
请注意,语法
0..10..1;
等同于0..10;
,步长 1 是简写表示法的默认值。因此,0..10;
将给出一个从 0 到 10 的序列(步长为 1)。“序列” 示例类似,除了我们使用“#”来指明我们希望列表中包含 15 个值,而不是列表中的最大值为 15。在本例中,我们将定义:
beginning..#ofSteps..step-size:
。序列的实际语法为0..#15..2
使用上一步中的_“#”,我们现在将其放置在语法的“step-size”部分中。现在,我们有一个 数字范围,从 “beginning” 到 “end”,“step-size”_ 表示法指示两者之间均匀分布多个值:
beginning..end..#ofSteps
创建高级范围后,我们即可简单地处理列表的列表。在下面的示例中,我们将隔离主要范围表示法的变量,并创建该列表的另一个范围。
1.创建嵌套范围,将带“#”的表示法与不带符号的表示法进行比较。相同逻辑在基本范围中都适用,但它稍显复杂。
2.我们可以在主范围内的任意位置处定义子范围;请注意,我们也可以有两个子范围。
3.通过控制范围中的“end”值,我们可以创建多个长度不同的的范围。
作为逻辑练习,请比较上述两个简写,并尝试解析 “subranges” 和 “#” 表示法如何驱动结果输出。
除了使用简写生成列表外,我们还可以即时创建列表。这些列表可以包含多种元素类型,也可以进行查询(请记住,列表本身就是对象)。总之,使用代码块时,可以创建列表,并从带括号的列表中查询项目(即“方括号”):
1.使用字符串快速创建列表,并使用项目索引进行查询。
2.使用变量创建列表,并使用范围简写表示法进行查询。
管理嵌套列表的过程类似。请注意列表顺序,并使用多组方括号进行调用:
1.定义一列列表。
2.使用单括号表示法查询列表。
3.使用双括号表示法查询项目。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在本练习中,我们将调整新的简写技能,以创建由范围和公式定义的精美蛋壳曲面。在本练习中,请注意我们如何串联使用代码块和现有 Dynamo 节点:我们将代码块用于繁重的数据提升,而 Dynamo 节点以可视方式布局来使定义清晰易读。
首先,通过连接上述节点创建曲面。请勿使用数字节点定义宽度和长度,而是双击画布并在代码块中键入 100;
通过在 “代码块” 中键入
0..1..#50
,定义一个介于 0 和 1 之间的范围(其中包含 50 个划分)。将该范围连接到 “Surface.PointAtParameter”,它会在曲面上提取介于 0 和 1 之间的 u 和 v 值。请记得通过在 “Surface.PointAtParameter” 节点上单击鼠标右键,将“连缀”更改为“叉积”。
在此步骤中,我们会使用第一个函数以在 Z 方向上向上移动点栅格。此栅格将基于底层函数驱动生成的曲面。添加新节点,如下图所示
我们不使用公式节点,而是使用内含以下代码行的 “代码块”:
(0..Math.Sin(x*360)..#50)*5;
。为了对该内容快速详细介绍,我们定义了一个内部带有公式的范围。此公式为正弦函数。在 Dynamo 中,正弦函数接收度数输入,因此为了获得完整正弦波,我们将x 值(这一范围输入介于 0 到 1 之间)乘以 360。接下来,我们希望每行都具有与控制栅格点相同数量的划分,因此我们用 #50 定义了 50 个细分。最后,乘数 5 只会增加平移幅度,因此我们可以在 Dynamo 预览中查看效果。
虽然上一个 “代码块” 正常工作,但它并非完全参数化。我们希望动态驱动其参数,因此我们会将上一步中的代码行替换为
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;
。这使我们可以根据输入定义这些值。
通过更改滑块(范围介于 0 到 10 之间),我们会得到一些有趣的结果。
通过对数字范围执行转置,我们会反转幕墙波的方向:
transposeList = List.Transpose(sineList);
如果添加 sineList 和 tranposeList,我们会得到一个扭曲的蛋壳曲面:
eggShellList = sineList+transposeList;
我们会更改下面指定的滑块值,以“平静地控制”该算法。
最后,让我们使用“代码块”查询数据的隔离部分。要使用特定范围的点重新生成曲面,请在 “Geometry.Translate” 和 “NurbsSurface.ByPoints” 节点之间添加上述代码块。这包含以下文本行:sineStrips[0..15..1];
。这将选择前 16 行点(共 50 行)。通过重新创建曲面,可以看到我们已生成点栅格的隔离部分。
在最后一步中,为了提高此 “代码块” 的参数化,我们使用介于 0 到 1 之间的滑块来驱动查询。我们使用以下代码行来执行此操作:
sineStrips[0..((List.Count(sineStrips)-1)*u)];
。这看起来可能会令人困惑,但代码行提供的方法让我们可以快速地将列表的长度缩放为 0 到 1 之间的乘数。
滑块上的值 0.53
会创建刚好经过栅格中点的曲面。
如预期的一样,值为 1
的滑块会基于完整的栅格点创建曲面。
通过查看可视图形,我们可以亮显代码块并查看其每个函数。
1.第一个 “代码块” 替换 “Number” 节点。
2.第二个 “代码块” 替换 “Number Range” 节点。
3.第三个 “代码块” 替换 “Formula” 节点(以及 “List.Transpose” 、 “List.Count” 和 “Number Range” )。
4.第四个 “代码块” 查询一列列表,以便替换 “List.GetItemAtIndex” 节点。
代码块是深入 Dynamo 的核心编程语言 DesignScript 的窗口。从头进行构建的 DesignScript 可支持探索式设计工作流,它是一种可读且简明的语言,既可提供对少量代码的即时反馈,也可扩展到大型和复杂交互。DesignScript 还构成引擎的支柱,该引擎推动 Dynamo 的大部分方面“处于底层”。由于在 Dynamo 节点和交互中找到的几乎所有功能都与脚本语言有一对一关系,因此有独特的机会在基于节点的交互和脚本之间以流畅的方式进行移动。
对于初学者,节点可以自动转换为文本语法以帮助学习 DesignScript,或者只是缩小图形较大部分的大小。这是使用名为“节点到代码”过程完成的,将在中详细介绍该过程。有经验的用户可以使用“代码块”创建现有功能的自定义映射,并使用许多标准编码范例来创建用户编写的关系。在初学者和高级用户之间,有大量可加快设计速度的快捷方式和代码段。虽然对于非程序员来说,术语“代码块”可能有点令人畏惧,但它既易于使用又功能强大。初学者可以高效地使用代码块(最少编码),高级用户可以定义脚本化定义以在 Dynamo 定义中的其他位置重新调用。
简而言之,代码块是可视化脚本环境中的文本脚本界面。它们可以用作数字、字符串、公式和其他数据类型。代码块专为 Dynamo 设计,因此用户可以在代码块中定义任意变量,这些变量会自动添加到节点的输入:
使用代码块,用户可以灵活地确定如何指定输入。以下是通过坐标 “(10, 5, 0)” 创建基点的几种不同方法:
当您了解库中更多的可用函数时,您甚至会发现键入“Point.ByCoordinates”比在库中搜索和查找正确的节点更快。例如,当键入 “Point.” 时,Dynamo 会显示可能应用于点的函数列表。这使脚本更加直观,有助于了解如何在 Dynamo 中应用函数。
代码块位于 “核心”>“输入”>“操作”>“代码块” 中。但更快的是,只需双击画布,代码块即会显示。此节点经常被使用,因此赋予其完全双击权限。
代码块在数据类型方面也很灵活。用户可以快速定义数字、字符串和公式,且代码块将提供所需的输出。
在下图中,您可以看到“旧学校”的操作方法有点长:用户在界面中搜索预期节点、将节点添加到画布,然后输入数据。使用代码块,用户可以双击画布来调出节点,然后使用基本语法键入正确的数据类型。
数字、字符串和公式节点是三个 Dynamo 节点示例,这些节点相较于代码块无疑是过时的。
“过去”
代码块
通过在三维空间中明确指出 x、y 和 z 坐标,可以创建特定的几何体对象。但是,通常在对象本身或其基本 CoordinateSystem 上使用几何变换将几何体移动到其最终位置。
最简单的几何变换是平移,可在 x、y 和 z 方向上将对象移动指定的单位数。
虽然 Dynamo 中的所有对象均可通过在对象名称末尾附加 .Translate 方法进行转换,但更复杂的变换需要将对象从一个基础坐标系变换到新坐标系。例如,要绕 x 轴将对象旋转 45 度,我们将对象从其现有 CoordinateSystem(不旋转)变换为 CoordinateSystem(已使用 .Transform 方法绕 x 轴旋转 45 度):
除了平移和旋转外,还可以缩放或剪切 CoordinateSystems。可以使用 .Scale 方法缩放 CoordinateSystem:
通过将非正交向量输入 CoordinateSystem 构造函数,可以创建剪切的 CoordinateSystem。
缩放和剪切是比旋转和平移更复杂的几何变换,因此并非每个 Dynamo 对象都能进行这些变换。下表概述了 Dynamo 对象可以具有非统一比例缩放的 CoordinateSystems 和剪切的 CoordinateSystems。
Revit 版本 | 第一个稳定的 Dynamo 版本 | 上次支持的适用于 Revit 的 Dynamo 版本 |
---|---|---|
Civil 3D 版本 | Dynamo 版本 | 注释 |
---|---|---|
根据路线的桩号标注按顺序重命名管网结构。
任务完成!
使用车辆轮廓块来沿道路生成间隙包络三维实体。
任务完成!
将水表块参照放置在距地块线的指定偏移处,并为垂直于配水总管的每个服务设施连接绘制一条线。
任务完成!
构建一个会将文字插入到模型空间中的 Dynamo 图形。
任务完成!
沿道路在 Excel 文件中指定的桩号值处放置灯杆块参照。
任务完成!
获取图形中所有汇流的边界几何图形。
在我们开始构建图形和编写代码之前,最好先查看 Civil 3D API 文档,了解 API 的可用内容。在这种情况下,,该特性会返回汇流的边界点。请注意,此特性会返回一个 Point3dCollection
对象,而 Dynamo 并不会知道该如何处理该对象。换句话说,我们将无法从 Point3dCollection
创建 PolyCurve,因此最终需要将所有内容都转换为 Dynamo 点。稍后会对此进行详细介绍。
在进一步介绍之前,我们需要简要介绍一个重要概念。在部分中,我们讨论了 Objects 和 CivilObject 之间的关系。对此详加说明,Dynamo Object 是 AutoCAD Entity 的包裹器。同样,Dynamo CivilObject 是 Civil 3D Entity 的包裹器。可以通过访问对象的 InternalDBObject
或 InternalObjectId
特性来“展开”该对象。
Dynamo 类型 | 包裹 |
---|
任务完成!
可以在 上,详细了解此转变以及如何升级旧脚本。如果要继续使用 IronPython,只需使用 Dynamo Package Manager 安装 DynamoIronPython2.7 软件包。
为每个唯一的几何空间点描述创建点编组。
如果您对操作列表不熟悉,请参见 部分。
如果您对使用 Dynamo 播放器不熟悉,请参见 部分。
任务完成!
似乎每次运行图形时都会删除并重新创建文字。实际上,文字的位置会根据选择的圆进行_修改_。如此一来,就是文字相同,位置却不同!为了每次都创建新文字,我们需要修改 Dynamo 的对象绑定设置,以便不保留绑定数据(请参见下文的)。
如果您对使用 Dynamo 播放器不熟悉,请参见 部分。
类 | 非统一比例缩放的 CoordinateSystem | 剪切的 CoordinateSystem |
---|
2013
2014
2015
2016
2017
2018
2019
2020+
2.1.0 - Revit 2020+ 现在包含 Dynamo,并像 Revit 一样接收更新。)
不适用
2024.1
2.18
2024
2.17
Dynamo 播放器用户界面更新
2023.2
2.15
2023
2.13
Dynamo 用户界面更新
2022.1
2.12
添加了对象绑定数据存储设置
用于控制对象绑定的新节点
2022
2.10
已包含在 Civil 3D 主要安装中
从 IronPython 转换到 Python.NET
2021
2.5
2020.2
2.4
2020 Update 2
2.4
添加了新节点
2020.1
2.2
2020
2.1
初始发布版本
Object Autodesk.AutoCAD.DynamoNodes.Object | Entity Autodesk.AutoCAD.DatabaseServices.Entity |
CivilObject Autodesk.Civil.DynamoNodes.CivilObject | Entity Autodesk.Civil.DatabaseServices.Entity |
弧 | 否 | 否 |
NurbsCurve | 是 | 是 |
Nurbs 曲面 | 否 | 否 |
圆 | 否 | 否 |
直线 | 是 | 是 |
平面 | 否 | 否 |
点 | 是 | 是 |
多边形 | 否 | 否 |
实体 | 否 | 否 |
曲面 | 否 | 否 |
文本 | 否 | 否 |
在本节中,您将找到一系列有关使用 DesignScript 创建几何体的课程。接下来,将 DesignScript 示例复制到 Dynamo 代码块。
数据类型 | 标准 Dynamo | 等效代码块 |
数字 |
字符串 |
序列 |
范围 |
获取索引处的项目 |
创建列表 |
连接字符串 |
条件语句 |
节点 | 等效代码块 | 注释 |
任何运算符(+、&&、>=、Not 等) | +、&&、>=、! 等 | 请注意,“Not”变为“!”,但该节点被称为“Not”以区分“阶乘” |
布尔值 True | true; | 注意小写 |
布尔值 False | false; | 注意小写 |
现在,我们已演示了如何在 Dynamo 中使用 Python 脚本,接下来我们来了解如何将 Revit 库连接到脚本编写环境。请记住,我们输入了 Python 标准和 Dynamo 核心节点,其中代码块中前四行如下所示。要输入 Revit 节点、Revit 图元和 Revit 文档管理器,我们只需添加几行代码即可:
这样,我们便可以访问 Revit API,并为任何 Revit 任务提供自定义脚本编写。通过将可视化编程流程与 Revit API 脚本编写相结合,协作和工具开发得到显著改进。例如,BIM 经理和方案设计人员可以协同处理同一图形。在此协作中,他们可以改进模型的设计和执行。
Dynamo 项目背后的计划是拓宽平台实施范围。随着 Dynamo 向 Docket 中添加更多程序,用户将可以从 Python 脚本编写环境访问特定于平台的 API。尽管 Revit 是本部分的案例研究,但我们可以预见将来会有更多章节,这些章节会提供有关在其他平台上编写脚本的综合教程。此外,现在还有许多 IronPython 库可供访问,这些库都可以输入到 Dynamo 中!
下面的示例演示了在 Dynamo 中使用 Python 实现特定于 Revit 操作的方法。有关 Python 与 Dynamo 和 Revit 关系的更详细综述,请参见 Dynamo Wiki 页面。Python 和 Revit 的另一个有用资源是 Revit Python Shell 项目。
创建新的 Revit 项目。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在这些练习中,我们将在 Dynamo for Revit 中了解基本的 Python 脚本。本练习将重点介绍如何处理 Revit 文件和图元,以及 Revit 和 Dynamo 之间的通信。
这是一种用于检索与 Dynamo 任务链接的 Revit 文件的 doc、uiapp 和 app 的简便方法。之前使用过 Revit API 的程序员可能会在观察列表中注意到这些项目。如果这些项目看起来不太熟悉,没关系;我们将在下面练习中使用其他示例。
下面介绍如何在 Dynamo 中输入 Revit 服务和检索文档数据。
在 Dynamo 中查看 Python 节点。还可以在下面找到代码:
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在本练习中,我们将在 Revit 中使用 Dynamo Python 节点创建一个简单的模型曲线。
先在 Revit 中创建新的概念体量族。
打开 “概念体量文件夹”,然后使用 “Metric Mass.rft” 模板文件。
在 Revit 中,使用键盘快捷键 un
显示“项目单位设置”,将长度单位更改为“米”。
启动 Dynamo,然后创建下图中的节点集。首先,我们将在 Revit 中基于 Dynamo 节点创建两个参照点。
创建 “代码块”,并为其赋值
"0;"
将该值插入 X、Y 和 Z 输入的 “ReferencePoint.ByCoordinates” 节点。
创建三个滑块,范围从 -100 到 100,步长为 1。
将每个滑块都连接到 “ReferencePoint.ByCoordinates” 节点。
将 “Python” 节点添加到工作空间,单击节点上的“+”按钮以添加另一个输入并将两个参照点插入到每个输入。打开 “Python” 节点。
在 Dynamo 中查看 Python 节点。在下面查找完整代码。
System.Array:Revit 需要 “系统数组” 作为输入(而不是 Python 列表)。这只是多一行代码,但注意参数类型将有助于在 Revit 中进行 Python 编程。
在 Dynamo 中,我们使用 Python 创建了两个参照点以及一条连接它们的线。在下一练习中,我们将进一步介绍。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
本练习尽可能简单,但主要介绍将数据和几何图形从 Revit 连接到 Dynamo 和反向操作的主题。首先,打开 Revit-StructuralFraming.rvt。打开后,启动 Dynamo 并打开“Revit-StructuralFraming.dyn”文件。
此 Revit 文件实现的是基本功能。两条参照曲线:一条在标高 1 上绘制,另一条在标高 2 上绘制。我们希望将这些曲线输入 Dynamo,并保持实时链接。
在此文件中,我们有一组节点插入到 Python 节点的五个输入中。
选择模型图元节点:点击每个节点对应的选择按钮,然后在 Revit 中选择相应曲线。
代码块: 使用语法
0..1..#x;
, 将介于 0 到 20 之间的整数滑块连接到 “x” 输入。这会指定要在两条曲线之间绘制的梁数。结构框架类型:此处,我们将从下拉菜单中选择默认的 W12x26 梁。
标高:选择“标高 1”。
Python 中的这段代码更加密集,但代码中的注释描述了该过程中出现的情况
在 Revit 中,我们有一组横跨两条曲线的梁作为结构图元。注意:这不是一个真实示例...结构图元用作从 Dynamo 创建的原生 Revit 实例的示例。
在 Dynamo 中,我们也可以看到结果。“Watch3D” 节点中的梁引用从 Revit 图元查询所得的几何图形。
请注意,我们有一个连续过程,将数据从 Revit 环境转换到 Dynamo 环境。总之,下面介绍了该过程的具体流程:
选择 Revit 图元
将 Revit 图元转换为 Dynamo 曲线
将 Dynamo 曲线分割为一系列 Dynamo 点
使用两条曲线之间的 Dynamo 点来创建 Dynamo 线
通过参照 Dynamo 线创建 Revit 梁
通过查询 Revit 梁的几何图形输出 Dynamo 曲面
这听起来可能有点费劲,但脚本使它变得简单,就像在 Revit 中编辑曲线并重新运行求解器一样(尽管这样做可能必须删除以前的梁)。这是因为我们在 Pyhon 中放置梁,从而打破了 OOTB 节点的关联。
在 Revit 中更新参照曲线后,我们会得到新的梁阵列。
苹果是什么颜色? | Apple.color | red |
苹果成熟了吗? | Apple.isRipe | true |
苹果的重量是多少? | Apple.weight | 6 oz. |
苹果来自哪里? | Apple.parent | 树 |
苹果创建什么? | Apple.children | 种子 |
这个苹果是本地种植的吗? | Apple.distanceFromOrchard | 60 mi. |
Intersect、Trim 和 SelectTrim 主要用于较低维度的几何图形,例如点、曲线和曲面。另一方面,实体几何图形还有一组附加方法用于在构造后修改形状,方法是以与 Trim 类似的方式减去材质,并将图元合并到一起以形成更大的整体。
Union 方法可获取两个实体对象,并在两个对象覆盖的空间之外创建单个实体对象。对象之间的重叠空间会合并为最终形式。本例将球体和立方体合并为单个实体球体-立方体形状:
Difference 方法类似 Trim,从基础实体中减去输入工具实体的内容。在本例中,我们从球体中穿凿出一个小凹穴:
Intersect 方法会返回两个实体输入之间的重叠实体。在以下示例中,Difference 已更改为 Intersect,并且生成的实体是最初穿凿的缺失空心:
对 NurbsCurve 的二维模拟是 NurbsSurface,与自由形式的 NurbsCurve 一样,可以使用两种基本方法构建 NurbsSurface:输入一组基点并在它们之间内插 Dynamo,然后明确指定曲面的控制点。当设计师确切知道曲面需要的形状或者设计需要曲面通过约束点时,内插曲面也与自由曲线一样非常有用。另一方面,由控制点创建的曲面对于各种平滑级别的探索式设计更为有用。
要创建插值曲面,只需生成与曲面形状近似的点的二维集合即可。集合必须是矩形,即不能出现锯齿。NurbsSurface.ByPoints 方法通过这些点构造曲面。
也可以通过指定曲面的基本控制点来创建自由形式的 NurbsSurfaces。与 NurbsCurves 一样,控制点可以看作是表示具有直线段的四边形网格,这可以平滑到最终的曲面形式(取决于曲面的阶数)。要通过控制点创建 NurbsSurface,请为 NurbsSurface.ByPoints 添加两个附加参数,以指示基本曲线在曲面两个方向上的角度。
我们可以增加 NurbsSurface 的阶数,来更改生成的曲面几何图形:
就像可以通过在一组输入点之间内插来创建曲面一样,可以通过在一组基础曲线之间内插来创建曲面。这称为“放样”。放样曲线是使用 Surface.ByLoft 构造函数创建的,其中输入曲线集合作为唯一参数。
旋转曲面是通过绕中心轴扫掠基础曲线创建的附加类型的曲面。如果插值曲面是对插值曲线的二维模拟,则旋转曲面是对圆和圆弧的二维模拟。
旋转曲面由基本曲线指定,表示曲面的“边”;轴原点、曲面的基点;轴方向、中心“核心”方向;扫掠开始角;以及扫掠结束角。这些曲面用作 Surface.Revolve 构造函数的输入。
以下 Python 脚本为几个示例生成点数组。应将它们粘贴到 Python 脚本节点,如下所示:
python_points_1
python_points_2
python_points_3
python_points_4
python_points_5
为什么要在 Dynamo 的可视化编程环境中使用文本编程?可视化编程有许多优势。它使您无需在直观的可视化界面中学习特殊语法即可创建程序。但是,可视化程序可能会变得混乱,有时可能会在功能上有所降低。例如,Python 提供了更多可实现的方法来编写条件语句 (if/then) 和循环。Python 是一款功能强大的工具,可扩展 Dynamo 的功能,并允许您将许多节点替换为几行简明的代码。
可视化程序:
文本程序:
与代码块一样,Python 节点也是可视化编程环境中的脚本编写界面。Python 节点位于库中的“脚本”>“编辑器”>“Python 脚本”下。
双击节点会打开 Python 脚本编辑器(也可以在节点上单击鼠标右键,然后选择 “编辑...” )。您会注意到顶部的一些样本文字,旨在帮助您引用所需的库。输入存储在 IN 数组中。通过将值指定给 OUT 变量,可将这些值返回给 Dynamo
Autodesk.DesignScript.Geometry 库使您能够使用与代码块类似的点符号。有关 Dynamo 语法的详细信息,请参见 https://github.com/DynamoDS/DynamoPrimerNew/blob/master-chs/coding-in-dynamo/7_code-blocks-and-design-script/7-2_design-script-syntax.md以及 DesignScript 手册(要下载此 PDF 文档,请在链接上单击鼠标右键并选择“将链接另存为...”)。键入几何图形类型(如“Point.”),将显示用于创建和查询点的方法列表。
方法包括构造函数(如 ByCoordinates)、操作(如 Add)和查询(如 X、Y 和 Z 坐标)。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
在本示例中,我们将编写一个 Python 脚本,该脚本用于从实体模块创建图案,并将其转换为自定义节点。首先,我们使用 Dynamo 节点创建实体模块。
Rectangle.ByWidthLength:创建一个矩形,它将作为实体的基础。
Surface.ByPatch:将矩形连接到“closedCurve”输入以创建底部曲面。
Geometry.Translate:将矩形连接到“geometry”输入以向上移动它,从而使用代码块指定实体的基础厚度。
Polygon.Points:查询平移的矩形以提取角点。
Geometry.Translate:使用代码块创建与四个点对应的一列四个值,从而向上平移实体的一个角。
Polygon.ByPoints:使用平移的点来重建顶部多边形。
Surface.ByPatch:连接多边形以创建顶部曲面。
现在,我们有了顶面和底面,接下来让我们在两个轮廓之间放样来创建实体的侧面。
List.Create:将底部矩形和顶部多边形连接到索引输入。
Surface.ByLoft:放样两个轮廓以创建实体的侧面。
List.Create:将顶面、侧面和底面连接到索引输入以创建曲面列表。
Solid.ByJoinedSurfaces:连接曲面以创建实体模块。
现在,我们有了实体,接下来将 Python 脚本节点拖动到工作空间。
要向节点添加其他输入,请单击节点上的“+”图标。输入命名为 IN[0]、IN[1] 等,以指示它们表示列表中的各项。
首先定义输入和输出。双击该节点以打开 Python 编辑器。按照下面的代码,在编辑器中修改代码。
随着我们在练习中的进展,此代码将更有意义。接下来,我们需要考虑排列实体模块所需的信息。首先,我们需要知道实体的尺寸以确定平动距离。由于存在边界框 Bug,因此我们需要使用边曲线几何图形来创建边界框。
在 Dynamo 中查看 Python 节点。请注意,我们使用的语法与在 Dynamo 中节点标题中看到的语法相同。查看下面注释的代码。
由于我们将平移并旋转实体模块,因此我们使用 Geometry.Transform 操作。通过查看 Geometry.Transform 节点,我们知道需要源坐标系和目标坐标系来变换实体。源是实体的上下文坐标系,而目标是每个阵列模块的不同坐标系。这意味着我们需要遍历 X 和 Y 值,以每次变换不同的坐标系。
单击“运行”,然后保存代码。将 Python 节点与现有脚本连接,如下所示。
将 “Solid.ByJoinedSurfaces” 的输出连接为 Python 节点的第一个输入,然后使用“代码块”定义其他输入。
创建 “Topology.Edges” 节点,并使用 Python 节点的输出作为其输入。
最后,创建 “Edge.CurveGeometry” 节点,并使用“Topology.Edges”的输出作为其输入。
尝试更改种子值以创建不同的图案。还可以更改实体模块本身的参数以实现不同的效果。
现在,我们已创建了一个有用的 Python 脚本,接下来我们将它另存为一个自定义节点。选择 Python 脚本节点、在工作空间上单击鼠标右键,然后选择“创建自定义节点”。
指定名称、描述和类别。
这将打开一个新的工作空间,可以在其中编辑自定义节点。
输入:将输入名称更改为更具描述性的名称,并添加数据类型和默认值。
输出:更改输出名称。
将节点另存为 .dyf 文件,然后您应该会看到自定义节点反映了我们刚才所做的更改。
尽管 Dynamo 能够创建各种复杂的几何形状,但简单的几何基本体构成任何计算设计的支柱:直接以最终设计形式表示或用作生成更复杂几何体的脚手架。
虽然不是严格的一块几何体,但 CoordinateSystem 是构建几何体的重要工具。CoordinateSystem 对象可记录位置和几何变换(如旋转、调节和缩放)。
以 x = 0、y = 0、z = 0 的点为中心创建 CoordinateSystem,不进行旋转、缩放或调节变换,只需调用 Identity 构造函数:
具有几何变换的 CoordinateSystems 超出本章的范围,但另一个构造函数允许您在特定点 CoordinateSystem.ByOriginVectors 创建坐标系:
最简单的几何基本体是一个点,表示三维空间中的零维位置。如前所述,可以通过几种不同的方式在特定坐标系中创建点:Point.ByCoordinates 使用指定的 x、y 和 z 坐标创建点;Point.ByCartesianCoordinates 使用指定的 x、y 和 z 坐标在特定坐标系中创建点;Point.ByCylindricalCoordinates 使用半径、旋转角度和高度创建位于圆柱体上的点;Point.BySphericalCoordinates 使用半径和两个旋转角度创建位于球体上的点。
本例说明在各种坐标系中创建的点:
下一个较高维度的 Dynamo 基本体是一条线段,表示两个端点之间的无限多个点。可以通过构造函数 Line.ByStartPointEndPoint 明确指定两个边界点,或者通过 Line.ByStartPointDirectionLength 在该方向指定起点、方向和长度来创建直线。
Dynamo 有表示三维中大多数基本类型的几何基本体的对象:立方体,使用 Cuboid.ByLengths 创建;圆锥体,使用 Cone.ByPointsRadius 和 Cone.ByPointsRadii 创建;圆柱体,使用 Cylinder.ByRadiusHeight 创建;球体,使用 Sphere.ByCenterPointRadius 创建。
在计算设计中,曲线和曲面经常用作基础脚手架,用于构建后续几何体。为了使早期几何体用作以后几何体的基础,脚本必须能够提取诸如整个对象区域的位置和方向等特性。曲线和曲面均支持此提取,并且称为参数化。
曲线上的所有点可以看作具有从 0 到 1 的唯一参数。如果基于多个控制点或插值点创建 NurbsCurve,则第一个点将具有参数 0,而最后一个点将具有参数 1。无法提前知道什么是精确参数以及什么是中间点,这听起来像是严重限制,但这可通过一系列实用程序函数来减轻。虽然使用两个参数而不是一个参数(称为 u 和 v),但曲面的参数化与曲线相似。如果我们要使用以下点创建一个曲面:
p1 将具有参数 u = 0 v = 0,而 p9 将具有参数 u = 1 v = 1。
在确定用于生成曲线的点时,参数化并非特别有用,其主要用途是确定 NurbsCurve 和 NurbsSurface 构造函数生成中间点时的位置。
曲线具有 PointAtParameter 方法,该方法采用 0 到 1 之间的单个双精度参数,并返回该参数处的“点”对象。例如,此脚本会在参数 0、.1、.2、.3、.4、.5、.6、.7、.8、.9 和 1 处查找点:
同样,曲面具有 PointAtParameter 方法,该方法采用两个参数,即生成点的 u 和 v 参数。
尽管提取曲线和曲面上的各个点非常有用,但脚本通常需要了解参数处的特定几何特征,例如曲线或曲面面对的方向。CoordinateSystemAtParameter 方法不仅可以查找位置,还能查找位于曲线或曲面参数处的定向 CoordinateSystem。例如,以下脚本沿旋转曲面提取定向 CoordinateSystems,并使用 CoordinateSystems 的方向生成将法线粘滞到曲面的线:
如前所述,参数化在曲线或曲面的长度上并非始终统一,这意味着参数 0.5 并不始终与中点对应,0.25 并不始终对应于曲线或曲面上的 1/4 点。为了解决此限制,曲线还有一组附加的参数化命令,使您可以沿曲线找到特定长度处的点。
使用 Dynamo 2.0,我们可以指定在首次打开 Python 窗口时要使用的默认模板 (.py extension)
。这是一个渴望已久的请求,因为这可加快 Dynamo 内 Python 的使用。通过使用模板,我们可以在计划开发自定义 Python 脚本时准备好默认导入。
此模板的位置位于 Dynamo 安装的 APPDATA
位置。
这通常如下所示:( %appdata%\Dynamo\Dynamo Core\{version}\ )
。
为了能够利用此功能,我们需要在 DynamoSettings.xml
文件中添加以下行。(在记事本中编辑)
在我们看到 <PythonTemplateFilePath />
的位置,只需将其替换为以下内容:
注意:将 CURRENTUSER 替换为您的用户名
接下来,我们需要使用要内置的功能构建模板。在本例中,我们在使用 Revit 时嵌入 Revit 相关的导入和一些其他典型项目。
您可以开始一个空白记事本文档,并在其中粘贴以下代码:
完成后,将此文件在 APPDATA
位置中另存为 PythonTemplate.py
。
完成定义 Python 模板后,Dynamo 会在每次放置 Python 节点时查找该模板。如果找不到,它将看起来像默认的 Python 窗口。
如果找到 Python 模板(如我们的 Revit 模板),则您会看到所有内置的默认项目。
有关此出色附加功能(由 Radu Gidei 提供)的其他信息可以在此处找到。https://github.com/DynamoDS/Dynamo/pull/8122
目前,许多示例都关注从较少维的对象构造较多维的几何体。相交方法允许此较高维度的几何图形生成较低维度的对象,而“修剪”和“选择修剪”命令允许脚本在创建几何形状后对其进行大量修改。
Intersect 方法在 Dynamo 中的所有几何图形上定义,这意味着理论上,任何几何图形都可以与任何其他几何图形相交。通常,由于结果对象将始终是输入点本身,因此某些交点没有意义(例如涉及点的交点)。下图概述了对象之间可能存在的交点组合。下图概述了各种相交操作的结果:
下面非常简单的示例演示了平面与 NurbsSurface 的交集。该交集会生成 NurbsCurve 数组,可像使用任何其他 NurbsCurve 一样使用。
Trim 方法与“Intersect”方法非常相似,因为它几乎为每个几何图形都定义了该方法。但是,与 Intersect 相比,Trim 存在更多限制。
关于 Trim 方法需要注意的是,需要“选择”点、确定要丢弃哪些几何图形的点以及要保留哪些部分。Dynamo 会查找并放弃与选择点最近的已修剪几何图形。
Python 是一种广泛使用的编程语言,其流行程度与其语法风格有很大关系。它的可读性很高,因此比许多其他语言更易于学习。Python 支持模块和软件包,可以嵌入到现有应用程序中。有关如何启动和运行 Python 的信息,请访问 Python.org 上的“快速入门”页面(这是一个很好的资源)。
本参考页面扩展了脚本编写策略中涵盖的最佳实践,并对代码库、标签和样式进行了更加详细的介绍。我们将使用 Python 说明下面的概念,但相同原则在 Python 和 C#(Zerotouch) 中适用,语法却不同。
标准库位于 Dynamo 外部,并以编程语言 Python 和 C# (Zerotouch) 呈现。Dynamo 还有自己的库集,这些库直接对应于其节点层次结构,使用户能够使用代码构建可以由节点和线生成的任何内容。下面介绍了每个 Dynamo 库对哪些内容提供访问以及何时使用标准库。
标准库和 Dynamo 库
Python 和 C# 的标准库可用于在 Dynamo 环境中构建高级数据和流结构。
Dynamo 库直接对应于节点层次结构,用于创建几何图形和其他 Dynamo 对象。
Dynamo 库
ProtoGeometry*
功能:圆弧、边界框、圆、圆锥体、坐标系、立方体、曲线、圆柱体、边、椭圆、椭圆弧、面、几何图形、螺旋、索引组、线、网格、Nurbs 曲线、Nurbs 曲面、平面、点、多边形、矩形、实体、球体、曲面、拓扑、T 样条曲线、UV、向量、顶点。
如何输入:import Autodesk.DesignScript.Geometry
``
DSCoreNodes
功能:颜色、二维颜色范围、日期时间、时间跨度、IO、公式、逻辑、列表、数学、四元树、字符串、线程。
如何输入:import DSCore
细分
功能:凸面外壳、Delaunay、Voronoi。
如何输入:import Tessellation
DSOffice
功能:Excel。
如何输入:import DSOffice
*注意:通过 Python 或 C# 使用 “ProtoGeometry” 时,正在创建的是非托管对象,这些对象需要手动对其内存进行管理 - 请参见以下部分:“非托管对象” 以了解详细信息。
在编写脚本时,我们会不断使用标识符来表示诸如变量、类型、函数和其他实体等内容。通过这种符号表示法,在构建算法时,我们可以通过标签(通常由字符序列组成)方便地引用信息。在编写易于他人以及您自己将来轻松阅读和理解的代码方面,命名内容也发挥着重要作用!以下是在脚本中命名内容时要牢记的一些技巧:
可以使用缩写,但要用注释说明缩写:
避免重复标记:
对变量名称使用正逻辑,而不是负逻辑:
首选“反转符号”:
从结构角度来说,这显得更合理。
别名应用于缩短过长且经常重复的链:
使用别名可能会快速导致出现令人困惑且非标准程序。
仅使用必要字词:
“一切应尽可能简单,但不能为了简单而简单。”– Albert Einstein
一般来说,几乎所有内容都有一种以上的编程方法,因此您“个人风格”的脚本编写是您一路上选择做出(或不做出)无数小决定的结果。也就是说,您代码的可读性和可维护性直接源于其内部一致性以及其对常规样式约定的遵循。一般来说,在两个位置看起来相同的代码的作用也应该相同。下面是用于编写清晰且一致代码的一些技巧。
命名约定:(为代码中每类实体选择以下约定之一并坚持使用!)
变量、函数、方法、软件包、模块:
lower_case_with_underscores
类和例外:
CapWords
受保护的方法和内部函数:
_single_leading_underscore(self, ...)
私有方法:
__double_leading_underscore(self, ...)
常数:
ALL_CAPS_WITH_UNDERSCORES
技巧:避免使用单字母变量(尤其是 l、O、I),但在非常短的块中,当其含义从即时上下文中清晰可见时除外。
使用空行:
在顶级函数和类定义周围加上两个空行。
类内部的方法定义周围加上一个空行。
可以使用(谨慎)额外的空行分隔多组相关函数。
避免使用多余空格:
紧挨在圆括号、方括号或大括号内:
逗号、分号或冒号之前:
在开始函数调用的参数列表的左括号之前:
在开始索引或切片的左括号之前:
始终在这些二进制运算符周围的任一侧使用一个空格:
观察行长度:
请勿对其强加超过约 79 个字符。
限制所需的编辑器窗口宽度可以并排打开多个文件,并且使用在相邻列中显示两个版本的代码审核工具时也可以正常工作。
通过将表达式括在括号中,可以将较长行分成多行:
避免出现明显多余的注释:
有时,注释越少,代码越可读。尤其是当它强制您改用有意义的符号名称时。
采用良好的编码习惯可减少对注释的依赖:
技巧:注释告诉您原因,而代码告诉您方法。
检出开源代码:
开源项目建立在众多开发人员的协作基础之上。这些项目需要保持高水平的代码可读性,以便团队可以尽可能高效地协同工作。因此,最好浏览这些项目的源代码,以观察这些开发人员正在进行的工作。
改善您的约定:
询问每个约定是否符合当前的需求。
功能/效率是否受到影响?
查看这些 Wiki 页面,以了解有关为 Zerotouch 编写 C# 以及参与 Dynamo 的指南:
此 Wiki 介绍了一些用于记录和测试代码的常规编码标准:https://github.com/DynamoDS/Dynamo/wiki/Coding-Standards
此 Wiki 专门介绍了用于库、类别、节点名称、端口名称和缩写的命名标准:https://github.com/DynamoDS/Dynamo/wiki/Naming-Standards
非托管对象:
从创建的 Python 或 C# 几何图形对象使用 Dynamo 的几何图形库 (ProtoGeometry) 时将不由虚拟机进行托管,并且将需要手动清理其中许多对象的内存。要清理本地对象或非托管对象,可以使用 “Dispose” 方法 或 “using” 关键字。请参见此 Wiki 条目以了解概述:https://github.com/DynamoDS/Dynamo/wiki/Zero-Touch-Plugin-Development#dispose--using-statement。
只需处理不返回到图形或存储对其参照的非托管资源。在本部分的其余部分中,我们将这些对象称为 “中间几何图形”。在下面的代码示例中,可以看到此类对象的示例。此 Zerotouch C# 函数 “singleCube” 会返回单个立方体,但在其执行期间会额外创建 10000 个立方体。我们可以假定该其他几何图形用作一些中间构造几何图形。
此 Zerotouch 函数最有可能导致 Dynamo 崩溃。 由于我们创建了 10000 个实体,但仅存储其中的一个,并仅返回该实体。我们应该改为处理所有中间立方体,但要返回的立方体除外。我们不希望对返回的内容进行处理,因为它将传播到图形中并由其他节点使用。
修复的代码将如下所示:
通常,只需处理几何图形,如 Surfaces
、Curves
和 Solids
。但是,为了安全起见,可以处理所有几何图形类型(Vectors
、Points
、CoordinateSystems
)。
从最开始作为 Revit 中建筑信息模型 (BIM) 的附加模块,Dynamo 已逐渐成熟,可提供诸多功能。除此之外,它还是一个平台,使设计师能够探索可视化编程、解决问题并自行制作工具。通过设置一些环境让我们开始 Dynamo 探索之旅 - 它是什么?我如何使用它?
本入门的此部分是由“最佳实践”的日志构成的。它阐明了我们通过经验和研究所学的几大策略,从而最大程度地利用良好的参数化工作流。作为设计师和编程人员,我们的质量指标主要关注工具的可维护性、可靠性、可用性和效率。尽管这些最佳实践还针对基于视觉或文本的脚本编写提供了特定示例,但原理适用于所有编程环境,可用于指导许多计算工作流。
在本章之前,入门手册介绍了如何实现 Dynamo 的强大可视化脚本编写功能。充分了解这些功能是构建健壮可视化程序的坚实基础和第一步。我们在现场使用可视化程序、与同事共享这些程序、排除错误或测试限制时,我们还要处理其他问题。如果其他人将使用您的程序,或者您希望从现在开始六个月内打开它,则它需要具有直观的图形和清晰的逻辑。Dynamo 有许多工具可用于管理程序的复杂性,本章会提供有关何时使用它们的指南。
在开发 Dynamo 图形和测试想法时,它的大小和复杂性会迅速增加。尽管创建一个正常运行的程序很重要,但使其尽可能简单也同样重要。您的图形不但将运行得更快且更可预测,而且您和其他用户将在以后了解其逻辑。以下是几种可以帮助您阐明图形逻辑的方法。
组使您在构建程序时可以创建功能上不同的各部分
组使您可以移动程序的大部分内容,同时保持模块化和对齐
可以更改组的颜色以区分各组的功能(输入与函数)
可以使用组来开始组织图形以简化“自定义节点”创建
本程序中的颜色标识了每个组的用途。此策略可用于在您开发的任何图形标准或模板中创建层次结构。
“函数”组(蓝色)
“输入”组(橙色)
“脚本”组(绿色)
有关如何使用组的信息,请参见管理程序。
有时,可以使用代码块键入数字或节点方法,速度比搜索快(Point.ByCoordinates、Number、String、Formula)
代码块在您要在 DesignScript 中定义自定义函数以减少图形中的节点数量时非常有用
1 和 2 执行相同的函数。与分别搜索并添加每个节点相比,编写几行代码要快得多。代码块也更加简洁。
以代码块形式编写的设计脚本
节点中的等效程序
有关如何使用代码块的信息,请参见什么是代码块。
可以通过使用“节点到代码”降低图形的复杂性,这将采用一组简单节点并将其相应 DesignScript 写入单个代码块
“节点到代码”可以压缩代码而不会消除程序的清晰度
以下是使用“节点到代码”的优点:
轻松将代码压缩到一个仍可编辑的组件中
可以简化图形的重要部分
在“迷你程序”不经常被编辑时非常有用
对于合并其他代码块功能(如函数)非常有用
以下是使用“节点到代码”的缺点:
通用命名会降低易读性
其他用户难以理解
无法轻松返回到可视化编程版本
现有程序
基于“节点到代码”创建的代码块
有关如何使用“节点到代码”的信息,请参见设计脚本语法。
使用 List@Level,可以通过替换 List.Map 和 List.Combine 节点降低图形的复杂性,这可能会占用大量画布空间
List@Level 通过允许从节点的输入端口访问列表中任何级别的数据,从而为您提供了一种快于 List.Map/List.Combine 的方法来构建节点逻辑
我们可以通过为 CountTrue 的“列表”输入激活 List@Level,来验证 BoundingBox.Contains 返回的 True 值数以及具体列表。List@Level 允许用户确定输入从哪个级别获取数据。与其他涉及 List.Map 和 List.Combine 的方法相比,使用 List@Level 灵活、高效并且强烈建议采用。
计算列表级别 2 的 True 值
计算列表级别 3 的 True 值
有关如何使用 List@Level 的信息,请参见列表的列表。
除了使图形尽可能简单且高效之外,还要努力实现图形清晰。尽管您极力通过逻辑分组使图形直观,但关系可能并不容易显现。在组内简单注释或重命名滑块可以让您或其他用户不必经历不必要的混淆或无需在图形上平移。以下是几种可以帮助您在图形内和图形之间应用图形一致性的方法。
为了在完成构建图形后减少工作量,应尝试通过经常并在构建时对齐节点来确保节点布局清晰可辩
如果其他人将要使用您的图形,则应确保“节点-线”布局在发布之前轻松流动
为了帮助您进行对齐,请使用“清理节点布局”功能自动对齐您的图形,尽管不如您自己做的精确
未组织的图形
对齐的图形
有关如何使用“节点对齐”的信息,请参见管理程序。
重命名输入有助于其他人轻松了解您的图形,尤其是当他们插入的内容将离屏时
请谨慎重命名输入以外的节点。 除此之外,还可以基于节点群集创建自定义节点并重命名该节点;显而易见,它包含其他内容
曲面操纵的输入
建筑参数的输入
排水模拟脚本的输入
要重命名某个节点,请在其名称上单击鼠标右键并选择“重命名节点...”。
如果图形中的某些内容需要节点无法表达的简单语言说明,则应添加注释
如果一个节点集或一个组太大或太复杂且无法轻松理解,则应添加注释
描述程序中返回原始平移距离的部分的注释
描述将这些值映射到正弦波的代码的注释
有关如何添加注释的信息,请参见管理程序。
构建可视化脚本时,请务必验证返回的内容是否符合您的预期。并非所有错误或问题都会导致程序立即停止运行,尤其是可能影响远距下游内容的 Null 值或零值。在脚本编写策略中的文本脚本编写上下文中也讨论了此策略。以下练习有助于确保获得预期的效果。
构建程序时使用“观察”或“预览”气泡,来验证关键输出是否返回预期内容
“Watch”节点用于比较:
原始平移距离
通过正弦方程传递的值
有关如何使用“Watch”的信息,请参见库。
很可能会有其他人在某个时候打开您的程序,即使您独立工作也无法避免。他们应该能够通过程序的输入和输出,快速了解该程序所需的内容和生成的结果。在开发要与 Dynamo 社区共享并用于其他人的程序的自定义节点时,这一点尤为重要。这些练习有助于生成健壮的可重用程序和节点。
为了确保可读性和可扩展性,应尝试尽可能最大程度地减少输入和输出
在即使将一个节点添加到画布之前,也应尝试为将如何构建逻辑制定策略,方法是先创建逻辑可能如何工作的粗略概要。在开发粗略概要时,应跟踪脚本中将出现哪些输入和输出。
如果有要嵌入到图形中的特定选项或条件,则应使用预设进行快速访问
还可以使用预设来通过缓存特定滑块值降低复杂性(在时间运行较长的图形中)
有关如何使用预设的信息,请参见使用预设管理数据。
如果程序可以收集到单个容器中,则应使用自定义节点
当图形的某一部分将经常在其他程序中重复使用时,应使用自定义节点
如果要与 Dynamo 社区共享功能,则应使用自定义节点
将点平移程序收集到自定义节点,会使健壮的独特程序可移植且更易于理解。命名良好的输入端口将有助于其他用户了解如何使用该节点。请记住为每个输入添加描述和所需的数据类型。
现有吸引器程序
收集此程序的自定义节点 PointGrid
有关如何使用自定义节点的信息,请参见自定义节点简介。
可以构建模板以在整个可视化图形中建立图形标准,以确保协作者能够以标准化方式了解图形
构建模板时,可以标准化组颜色和字体大小,以对工作流或数据操作的类型进行分类。
构建模板时,甚至可以标准化您希望如何对图形中前端和后端工作流之间的差异进行标注、上色或设计样式。
程序的 UI 或前端包括项目名称、输入滑块和输入几何图形。
程序的后端。
分组颜色类别(常规设计、输入、Python 脚本、输入的几何图形)。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
现在,我们已经建立了几种最佳实践,让我们将它们应用于快速组合在一起的程序中。尽管该程序成功生成了屋顶,但图形的状态是作者的“思维导图”。它缺少任何组织或使用说明。我们将通过最佳实践来组织、描述和分析该程序,以便其他用户可以了解如何使用它。
程序运行正常,但图形混乱。
让我们先确定程序返回的数据和几何图形。
了解何时对数据进行重大更改对于建立逻辑划分或模块化至关重要。尝试使用“Watch”节点检查程序的其余部分,以查看在继续进行下一步之前是否可以确定组。
此带有数学方程的 “代码块” 看起来像是程序的关键部分。“Watch” 节点显示它正在返回平移距离列表。
该区域的用途并不明显。来自 “BoundingBox.Contains” 的列表级别 L2 的 True 值排列以及 “List.FilterByBoolMask” 的存在表明,我们要对点栅格的一部分进行采样。
在了解程序的基本部分后,让我们将它们放入组中。
组允许用户直观地区分程序的各个部分。
输入三维场地模型
基于正弦方程平移点栅格
点栅格的采样部分
创建建筑屋顶曲面
创建玻璃幕墙
建立组后,对齐节点以在整个图上创建视觉连续性。
视觉连续性有助于用户查看程序流和节点之间的隐式关系。
通过添加另一图形改进层,使程序更易于访问。添加注释以描述程序的特定区域如何工作、为输入提供自定义名称以及为不同类型的组指定颜色。
这些图形改进会告诉用户有关程序正在执行的操作的更多信息。不同的组颜色有助于区分输入和函数。
说明
带有描述性名称的输入
在开始压缩程序之前,让我们找到一个战略位置来介绍 Python 脚本排水模拟器。将第一个缩放屋顶曲面的输出插入相应的脚本输入。
我们选择此时将脚本集成到程序中,以便可以在原始的单屋顶曲面上运行排水模拟。该特定曲面不会被预览,但它让我们无需选择倒角的 Polysurface 的顶面。
脚本输入的源几何图形
Python 节点
输入滑块
开/关“开关”
现在一切就绪,让我们简化图形。
使用“节点到代码”和“自定义节点”压缩我们的程序,大大减小了图形的大小。创建屋顶曲面和墙的组已转换为代码,因为它们非常特定于此程序。点平移组包含在自定义节点中,因为它用于其他程序。在示例文件中,基于平移点组创建您自己的自定义节点。
“自定义节点”用于包含“平移点栅格”组
“节点到代码”用于压缩“创建建筑屋顶曲面和幕墙”组
最后一步,为示例性屋顶成型创建预设。
这些输入是屋顶成型的主要驱动力,将帮助用户发现程序的潜力。
我们的程序具有两个预设的视图。
屋顶排水模式为用户提供了各个预设的分析视图。
可视化脚本编写环境中基于文本的脚本编写支持使用 DesignScript、Python 和 ZeroTouch (C#) 实现功能强大的可视化关系。用户可以显示输入滑块等图元,将大型操作压缩为 DesignScript,以及通过 Python 或 C# 访问功能强大的工具和库,所有这些操作都可在同一工作空间内进行。在有效管理的情况下,结合使用这些策略可以将大量自定义、清晰和高效提供给整个程序。以下是一组准则,可帮助您使用文本脚本来增强可视化脚本。
文本脚本编写可建立比可视化编程复杂度更高的关系,但其功能也会明显重叠。这很有意义,因为节点实际上是预打包的代码,我们可能会采用 DesignScript 或 Python 编写整个 Dynamo 程序。但是,我们使用可视化脚本编写,因为节点和线的接口会创建直观的图形信息流。了解文本脚本编写的功能在哪些方面超出可视化脚本编写,这将向您提供应在何时使用它的重大提示,从而不会放弃节点和线的直觉本质。以下是有关何时编写脚本以及要使用哪种语言的准则。
文本脚本编写用于:
循环
递归
访问外部库
选择语言:
有关每个 Dynamo 库所提供访问内容的列表,请参见脚本编写参考。
在不可避免的参数化环境 Dynamo 中编写脚本时,明智的做法是相对于将要驻留的节点和线框架来构建代码。考虑使用包含文本脚本的节点,就像它是程序中具有几个特定输入、函数和预期输出的任何其他节点一样。这会立即为节点内的代码提供一小组在其中起作用的变量(这是干净参数系统的关键)。以下是一些将代码更好地集成到可视化程序中的准则。
标识外部变量:
尝试确定设计问题中的给定参数,以便可以构造直接基于该数据构建的模型。
编写代码之前,请标识变量:
最少的一组输入
预期输出
常数
编写代码之前已建立多个变量。
我们将模拟降雨所基于的曲面。
我们想要的雨滴(代理)数。
我们想让雨滴跑多远。
在降低最陡路径与遍历曲面之间切换。
具有相应数量输入的 Python 节点。
用于使返回的曲线呈现蓝色的代码块。
设计内部关系:
参数化允许编辑某些参数或变量,以便操纵或改变表达式或系统的最终结果。
只要脚本中的实体在逻辑上相关,就应将它们定义为彼此的函数。这样,当修改一个实体时,另一个实体可以相应更新。
通过仅显示关键参数来最大程度减少输入数量:
如果可以从更多父参数派生一组参数,则仅将父参数公开为脚本输入。通过降低脚本接口的复杂性,从而提高脚本的可用性。
Python 节点中的示例代码“模块”。
输入。
脚本内部变量。
使用这些输入和变量执行其函数的循环。
提示:像重视解决方案一样重视过程。
当有多种方法可用于在脚本中表达同一内容时,有时重复的表示会无法进行同步,这可能导致维护困难、分解不良和内部矛盾。
DRY 原则表述为“系统中的每条知识都必须具有单一、明确、权威的表示形式”:
成功应用该原则后,脚本中的所有相关图元都会以可预测的方式统一更改,并且所有不相关的图元彼此之间不会产生逻辑上的后果。
提示:在脚本中复制实体(如上例中的常量)之前,请先问问自己是否可以改为链接到源。
随着代码变得越来越长,越来越复杂,“大创意”或总体算法变得越来越难以辨认。此外,在跟踪具体内容发生的情况(和地点)、在出错时发现 Bug、集成其他代码以及分配开发任务方面也变得更加困难。为了避免出现这些麻烦,明智的做法是以模块形式编写代码,这是一种根据代码所执行任务将代码分解的组织策略。以下是一些通过模块化方式使脚本更易于管理的技巧。
以模块形式编写代码:
“模块”是执行特定任务的一组代码,类似于工作空间中的“Dynamo 节点”。
这可以是应与相邻代码(函数、类、一组输入或要输入的库)在视觉上分开的任何内容。
以模块形式开发代码可利用节点的可视化直观质量以及只有文本脚本编写才能实现的复杂关系。
这些循环调用我们将在练习中开发的名为“agent”的类。
定义每个代理的起点的代码模块。
更新代理的代码模块。
为代理的路径绘制轨迹的代码模块。
发现代码重用:
如果发现代码在多个位置执行相同(或非常相似)的操作,则想方设法将该代码聚类为可调用的函数。
“Manager”函数控制程序流,并且主要包含对处理底层细节(如在结构之间移动数据)的“Worker”函数的调用。
本例将根据中心点的 Z 值创建具有半径和颜色的球体。
两个“worker”父函数:根据中心点的 Z 值创建具有半径和颜色颜色的球体。
合并两个“worker”函数的“manager”父函数。调用此函数会调用其中的两个函数。
仅显示需要查看的内容:
模块接口表示该模块所提供和需要的图元。
在已定义单元之间的接口后,可分别对每个单元进行详细设计。
可分离性/可替换性:
模块之间互不通信。
模块化的常规形式:
代码分组:
函数:
类:
在 Dynamo 中开发文本脚本时,明智的做法是不断确保实际创建的内容符合您的预期。这将确保不可预见的事件(语法错误、逻辑差异、值不准确、异常输出等)在出现时即被迅速发现并进行处理,而不是在结束时立即全部处理。由于文本脚本位于画布上的节点内,因此它们已集成到可视化程序的数据流中。这使得对脚本的连续监视变得很简单,只需指定要输出的数据、运行程序以及使用“观察节点”评估从脚本流出的内容。以下是一些在构建脚本时不断检查脚本的技巧。
随手测试:
每当完成一组功能时:
返回并检查代码。
非常重要。协作者是否能够了解这样做的目的?我需要这样做吗?是否可以更高效地执行此函数?我是否在创建不必要的重复项或从属关系?
快速测试以确保返回的数据“有意义”。
将正在脚本中使用的最新数据指定为输出,以便在脚本更新时节点始终输出相关数据:
检查实体的所有边是否都将作为曲线返回,以围绕其创建边界框。
检查“Count”输入是否成功转换为“Ranges”。
检查坐标系是否已在此循环中正确转换和旋转。
预测“边缘情况”:
在编写脚本时,将输入参数故意指定为其分配域的最小值和最大值,以检查程序在极端条件下是否仍能正常运行。
即使程序在其极端条件下正常运行,也应检查它是否会返回意外的 Null 值/空值/零值。
有时,暴露脚本的一些潜在问题的 Bug 和错误仅在这些边缘情况下才会出现。
了解导致出现错误的原因,然后确定是需要进行内部修复还是需要重新定义参数域,来避免出现该问题。
提示:始终假定用户将使用已呈现给他/她的每个输入值的每种组合。这将有助于消除意外情况。
调试是从脚本中消除“Bug”的过程。Bug 可能是错误、效率低下、不准确或任何意外结果。解决 Bug 可能非常简单,只需更正拼写错误的变量名即可解决脚本中普遍存在的结构性问题。理想情况下,在构建脚本时对其进行调整将有助于及早发现这些潜在问题,尽管不能保证该脚本中没有 Bug。以下是对上述几种最佳实践的回顾,以帮助您系统地解决 Bug。
使用观察气泡:
通过将它指定给 OUT 变量(类似于调整程序的概念),来检查代码中不同位置返回的数据。
编写有意义的注释:
如果清楚地描述了代码模块的预期结果,则可以更加轻松地进行调试。
通常,这会造成过多的注释行和空行,但在调试时,它有助于将内容分解为可管理的各部分。
利用代码的模块化:
问题的根源可以隔离到特定模块。
确定故障模块后,修复问题相当简单。
当必须修改程序时,则以模块形式开发的代码将更容易更改:
可以将新模块或已调试模块插入到现有程序中,同时确保程序的其余部分不会更改。
调试 Python 节点中的示例文件。
正如我们可以通过将 xDist 和 yDist 指定给 OUT 后所看到的结果,输入几何图元返回的边界框大于自身的大小。
输入几何图元的边曲线返回一个适当的边界框,该边界框具有 xDist 和 yDist 的正确距离。
我们插入的“模块”代码可解决 xDist 和 yDist 的值问题。
单击下面的链接下载示例文件。
可以在附录中找到示例文件的完整列表。
考虑到我们的文本脚本编写的最佳实践,让我们来编写一个下雨模拟脚本。尽管我们能够以“图形策略”将最佳实践应用于杂乱无章的可视化编程,但使用文本脚本编写更难以做到这一点。采用文本脚本编写建立的逻辑关系不太明显,并且几乎不可能在杂乱的代码中解开。借助文本脚本编写的强大功能,可以采用组织形式承担更大责任。我们将逐步完成每个步骤,并沿用最佳实践。
我们的脚本已应用于吸引器变形的曲面。
首先,我们需要输入必要的 Dynamo 库。首先执行此操作将在 Python 中提供对 Dynamo 功能的全局访问。
我们打算使用的所有库都需要在此处输入。
接下来,我们需要定义脚本的输入和输出,这些将在节点上显示为输入端口。这些外部输入是脚本的基础,也是建立参数化环境的关键。
我们需要定义与 Python 脚本中的变量对应的输入,并确定所需的输出:
我们要漫游的曲面。
我们要走的代理数。
允许代理采取的最大步数。
沿曲面走最短路径或对其进行遍历的选项。
具有与脚本中的输入相对应的输入标识符(IN[0]、IN[1])的 Python 节点。
可以用不同颜色显示的输出曲线。
现在,让我们采用模块化的做法,并创建脚本的主体。对于多个起点,沿曲面模拟最短路径是一项艰巨任务,这需要多个函数。与其在整个脚本中调用不同的函数,不如通过将这些函数收集到一个类(即我们的代理)中来对代码进行模块化。此类或“模块”的不同函数可以使用不同变量调用,甚至可以在其他脚本中重用。
我们需要为代理定义一个类或蓝图,以便代理每走一步时都选择沿尽可能陡峭的方向行进,从而漫游曲面:
名称。
所有代理共享的全局属性。
每个代理特有的实例属性。
用于执行步骤的函数。
用于将每步的位置分类到轨迹列表的函数。
让我们通过定义代理的起始位置来初始化代理。这是调整脚本并确保代理类正常工作的好机会。
我们需要实例化要观察漫游曲面的所有代理,并定义其初始属性:
一个新的空轨迹列表。
它们将在曲面上开始其旅程的位置。
我们已将代理列表指定为输出,以检查脚本在此处返回的内容。返回的代理数目正确,但是稍后我们需要再次调整脚本以验证其返回的几何图元。
每一步都更新每个代理。然后,我们需要进入一个嵌套循环,在该循环中,针对每个代理和每一步,我们更新其位置并记录到其轨迹列表中。在每一步,我们还将确保代理尚未到达曲面上无法采取其他步骤(即允许代理下降)的点。如果满足该条件,我们将结束该代理的行程。
现在,我们的代理已完全更新,让我们返回代表它们的几何图元。在所有代理达到其下降限制或最大步数后,我们将创建一条贯穿其轨迹列表中点的复合线并输出复合线轨迹。
我们的脚本用于查找最陡路径。
预设在基础曲面上模拟降雨。
可以切换代理以遍历基础曲面,而不是查找最陡路径。
完整的 Python 文本脚本。
在可视化编程过程中工作可能是一项强大的创意活动,但是程序流和关键用户输入很快可能会被工作空间的复杂性和/或布局所掩盖。让我们来了解一些管理程序的最佳实践。
在向工作空间添加了多个节点后,我们可能需要为了清晰显示而重新组织节点的布局。通过选择多个节点并在工作空间上单击鼠标右键,弹出窗口会包括 “对齐当前选择” 菜单,其中包含 X 和 Y 方向的对正和分布选项。
选择多个节点
在工作空间中单击鼠标右键
使用 “对齐当前选择” 选项
有了一些经验后,我们可以通过查看节点名称并遵循程序流来“读取”可视化程序。对于所有经验级别的用户来说,最好还要包括纯语言标签和描述。Dynamo 有一个 “Notes” 节点,该节点有可编辑的文本字段来执行此操作。我们可以通过两种方式向工作空间添加注释:
浏览到菜单“编辑”>“创建注释”
使用键盘快捷键 Ctrl+W
将注释添加到工作空间后,将弹出一个文本字段,允许我们编辑注释中的文本。创建注释后,我们可以通过双击或在注释节点上单击鼠标右键来编辑注释。
当可视化程序变得非常大时,确定要执行的较大步骤会很有帮助。我们可以使用 “组” 亮显较大的节点集合,以在背景中使用彩色矩形和标题标记它们。有三种方法可以使包含多个节点的组处于选中状态:
浏览到菜单“编辑”>“创建组”
使用键盘快捷键 Ctrl+G
在工作空间上单击鼠标右键,然后选择“创建组”
在创建组后,我们可以编辑其设置,例如标题和颜色。
提示:使用“注释”和“组”是注释文件并提高可读性的有效方法。
以下是添加了“注释”和“组”的程序示例:
注释:“栅格参数”
注释:“栅格点”
组:“创建点栅格”
组:“创建吸引器点”
注释:“校准距离值”
注释:“圆的可变栅格”
使用: 点
曲线
平面
曲面
实体
开: 曲线
是
否
否
否
否
多边形
-
否
是
否
否
曲面
-
是
是
是
是
实体
-
-
是
是
是
循环
递归
压缩节点
外部库
简写
DesignScript
是
是
是
否
是
Python
是
是
部分
是
否
ZeroTouch (C#)
否
否
否
是
否
其中:
曲面
曲线
平面
实体
曲面
曲线
点
点,曲线
曲面
曲线
点
点
点
曲线
平面
曲线
点
曲线
曲线
实体
曲面
曲线
曲线
实体
在 Dynamo 中,有两种基本方法可以创建自由形式的曲线:指定点集合,并使 Dynamo 在它们之间内插平滑曲线,或者通过指定一定阶数曲线的基本控制点的更低级别方法。当设计师确切知道线应采用的形状,或者设计是否具有特定约束来控制曲线可以和不能通过的位置时,插值曲线非常有用。通过控制点指定的曲线本质上是一系列直线线段,算法会将其平滑为最终曲线形式。对于通过不同平滑度探索曲线形状或在需要曲线段之间的平滑连续性时,通过控制点指定曲线非常有用。
要创建插值曲线,只需将点集合传递到 NurbsCurve.ByPoints 方法。
生成的曲线与每个输入点相交,分别在集合中的第一个点和最后一个点开始和结束。可以使用可选的周期性参数创建闭合的周期性曲线。Dynamo 将自动填充缺失的段,因此不需要重复的端点(与起点相同)。
NurbsCurves 的生成方式几乎相同,输入点表示直线段的端点,第二个参数用于指定曲线经历的平滑量和类型(称为阶数)。* 阶数为 1 的曲线没有平滑;它是多段线。
对阶数为 2 的曲线进行平滑处理,使曲线相交并与多段线线段的中点相切:
Dynamo 支持最多 20 阶的 NURBS(非均匀有理 B 样条曲线)曲线,以下脚本说明了增加平滑级别对曲线形状的影响:
请注意,必须至少比曲线阶数多一个控制点。
通过控制点构建曲线的另一个好处是能够保持各个曲线段之间的相切。通过提取最后两个控制点之间的方向,并继续使用以下曲线的前两个控制点来完成此操作。下例创建两条单独的 NURBS 曲线,它们仍然像一条曲线一样平滑:
*这是对 NURBS 曲线几何图形的简单描述;有关更准确、更详细的讨论,请参见参考文献中的“Pottmann, et al, 2007”。