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...
Dynamo は、アクティブなオープンソース開発プロジェクトです。Dynamo を利用できるソフトウェアの一覧をご確認いただけます。
Dynamo は、Revit3D、FormIt、Civil3D などのソフトウェアに事前にインストールされています。
特定のソフトウェアで Dynamo を使用する方法の詳細については、次のセクションを参照してください。
スタンドアロン アプリケーションとしての Dynamo をご希望の場合は、Sandbox のダウンロードに関するガイダンスについて、引き続きお読みください。
Dynamo アプリケーションは、Dynamo の Web サイトから入手できます。公式の過去またはプレリリース版のバージョンは、両方ともダウンロード ページから入手できます。「Dynamo を取得」ページにアクセスし、[ダウンロード]をクリックして公式リリース バージョンをダウンロードしてください。
過去のリリースまたは「ブリーディング エッジ」開発リリースをお探しの場合は、同じページの下部セクションにすべてのバージョンがあります。
「ブリーディング エッジ」開発には、まだ完全にテストされていない新機能および実験的機能が含まれている可能性があるため、不安定になる可能性があります。これを使用して、バグや問題を発見したら、問題をチームに報告してアプリケーションの改善にご協力ください。
初心者ユーザーは安定した公式リリース版をダウンロードすることをお勧めします。
ダウンロードしたバージョンを起動する前に、選択したフォルダにコンテンツを解凍する必要があります。
この手順のために、ご使用のコンピュータに 7zip をダウンロードしてインストールします。
ZIP ファイルを右クリックして、[すべて展開]を選択します。
すべてのファイルを解凍する場所を選択します。
宛先フォルダで、DynamoSandbox.exe をダブルクリックして起動します。
次のように、DynamoSandbox の起動画面が表示されます。
これで、DynamoSandbox を使用するための設定が完了しました。
Geometry は、Dynamo Sandbox の追加機能です。この機能は、現在 Revit、Robot Structural Analysis、FormIt、Civil 3D の Autodesk ソフトウェアのサブスクリプションまたはライセンスを所有しているユーザのみが使用できます。Geometry を使用すると、Dynamo Sandbox からジオメトリを読み込み、作成、編集、書き出すことができます。
使用を開始するには、ツールバー パネルから起動します。使用しているソフトウェアによって異なりますが、起動アイコンは通常、[メニュー] > [管理]タブにあります。Dynamo アイコン をクリックして起動します。
Dynamo は、スタンドアロンの「Sandbox」モードで、または Revit、FormIt、Civil 3D などの他のソフトウェアのプラグインとして、ダウンロードして実行できる、ビジュアル プログラミング アプリケーションです。
Dynamo を使用すると、要素を相互に接続して、カスタム アルゴリズムを構成できる動作の関係とシーケンスを定義するビジュアル プログラミングのプロセス内での作業を可能にします。データの処理からジオメトリの生成まで、すべてリアルタイムで code
を記述せずに、さまざまな用途にアルゴリズムを使用できます。
ノードとワイヤは、ビジュアル プログラミング プロセスをサポートする Dynamo の主要なコンポーネントです。これにより、設計のパーツ間に明瞭な視覚的および体系的な関係を確立するのに役立ちます。マウスをクリックするだけでノードを簡単に接続しながら、設計ワークフローの開発および最適化ができます。
プロジェクトのワークフローにおけるビジュアル プログラミングの活用から、カスタマイズされたツールの開発まで、幅広い用途で使用できる Dynamo は、アプリケーションの開発に欠かせないツールです。
Revit の ビルディング インフォメーション モデリング(BIM)用アドオンとして開発が始まった Dynamo は、さまざまな機能を持つソフトウェアに成長しました。設計者は、開発プラットフォームである Dynamo を使用して問題を解決し、独自のツールを作成することができます。コンテキストを設定して、Dynamo を使用してみましょう。このセクションでは、Dynamo の概要と使用方法について説明します。
Dynamo は、設計者向けのオープン ソースのビジュアル プログラミング プラットフォームです。
この Dynamo Primer は、Autodesk Dynamo を使用したビジュアル プログラミングの総合ガイドです。この手引は、ビジュアル プログラミングの基本情報を共有することを目的としており、継続的に更新されています。この手引きには、ジオメトリの計算設計、規則に基づく設計のベストプラティクス、分野横断的なプログラミングの応用方法など、Dynamo プラットフォームに関するさまざまな情報が記載されています。
Dynamo は、広範囲にわたる設計関連ワークフローにおいてその真価を発揮します。Dynamo は、さまざまな方法で使用できます。
ビジュアル プログラミングをはじめて体験する
さまざまなソフトウェアのワークフローを接続する
さまざまなユーザや開発者が積極的に意見を交換するコミュニティに参加する
継続的な改善を目指してオープンソースのプラットフォームを開発する
こうして Dynamo の開発を続けていくうちに、適切な資料が必要になりました。その過程で作成されたのが、この Dynamo Primer です。
この Primer で知ることができる内容については、Primer のユーザ ガイドを参照してください。
Dynamo は継続的に改善されているため、機能によってはこの Primer での表示とは外観が異なる場合があります。ただし、機能に関するすべての変更は正しく反映されます。
Dynamo Primer は、オープン ソース プロジェクトです。高品質なコンテンツを提供するには、ユーザの皆様からのフィードバックが必要です。問題を発見した場合は、GitHub のバグ レポート ページ(https://github.com/DynamoDS/DynamoPrimer/issues)に投稿してください。
この Dynamo Primer に新しいセクションを追加する場合や、既存の内容を編集する場合は、GitHub のリポジトリ(https://github.com/DynamoDS/DynamoPrimer)にアクセスしてください。
Dynamo Primer は、オートデスクの Matt Jezyk 氏と Dynamo 開発チームによって開始されたオープン ソース プロジェクトです。
Dynamo Primer の初版は、Mode Lab によって作成されました。このような貴重なリソースの確立に取り組んでいただいたすべての方に感謝いたします。
Parallax Team の John Pierson 氏は依頼により、Dynamo 2.0 の改訂を反映するよう Primer を更新しました。
Matterlab では依頼により、Dynamo 2.13 の改訂を反映するよう Primer を更新しました。
Archilizer では依頼により、Dynamo 2.17 の改訂を反映するよう Primer を更新しました。
Wood Rodgers では依頼により、Dynamo for Civil 3D のコンテンツを使用して Primer を更新しました。
Dynamo プロジェクトの創立と指揮に携わった Ian Keough 氏に、深く感謝いたします。
さまざまな Dynamo プロジェクトで積極的に協力していただいた Matt Jezyk 氏、Ian Keough 氏、Zach Kron 氏、Racel Amour 氏、Colin McCrone 氏にも感謝を申し上げます。
Dynamo Dynamo の最新の安定したリリースについては、次のサイトを参照してください。
http://dynamobim.com/download/ または http://dynamobuilds.com
*注: Revit 2020 以降、Dynamo は Revit リリースにバンドルされているため、手動でインストールする必要はありません。詳細については、このブログの投稿をご覧ください。
DynamoBIM: 追加情報、ラーニング コンテンツ、フォーラムについては、DynamoBIM の Web サイトを参照してください。
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.
この Primer には、Mode Lab で作成された各章から構成されています。各章では、Dynamo を使用してビジュアル プログラミング開発を行うために必要な基本的知識と、その知識を応用するための重要な情報を紹介しています。
このガイドは、さまざまな背景やスキル レベルを持つ読者に役立つよう作られています。Dynamo の設定、ユーザ インタフェース、および主要な概念に関する一般的な概要については、次のセクションを参照してください。初心者の方には次のトピックを参照することをお勧めします。
特定のノードやその背後にある概念など、各要素についてより深く理解を深められるよう、それぞれの章で基礎的事項を説明します。
Dynamo のワークフローのデモを実際に見て確認できるよう、「サンプル ワークフロー」セクションにいくつかのグラフを追加しました。独自の Dynamo グラフを作成するには、添付されている手順に従ってください。
Dynamo に関するトピックについては、後の章で詳しく説明します。また、トピックに合わせた演習も用意しています。演習は、通常各ページの最後のセクションにあります。
Dynamo は、設計者向けのビジュアル プログラミング ツールとして設計されており、外部ライブラリを使用するツールや、API をサポートしているオートデスク製品を使用するツールを作成することができます。Dynamo Sandbox では、「サンドボックス」スタイルでプログラムを開発できます。Dynamo を取り巻くユーザや開発者のコミュニティは拡大を続けています。
プロジェクトのソース コードはオープン ソースとして公開されているため、個々のニーズに合わせて機能を拡張することができます。GitHub のプロジェクトにアクセスして、ユーザによる Dynamo のカスタマイズ作業の進行状況を確認してください。
プロジェクトにアクセスしてプロジェクトをフォークし、Dynamo をニーズに合わせて拡張することができます。
Dynamo のユーザ インタフェース(UI)は、5 つの主要な領域に分かれています。ここでは、概要について簡単に説明し、次のセクションでワークスペースとライブラリについて詳しく説明します。
メニュー
ツールバー
ライブラリ
ワークスペース
実行バー
これは Dynamo アプリケーションの基本機能を表示するメニューです。ほとんどの Windows ソフトウェアと同様に、最初の 2 つのメニューはファイルの管理、選択とコンテンツ編集の操作に関連しています。他のメニュー項目は、Dynamo 固有のメニュー項目です。
一般的な情報と設定は、Dynamo ドロップ ダウン メニューにあります。
[バージョン情報] - ご使用のコンピュータにインストールされている Dynamo のバージョンを確認できます。
[操作性データ収集の承諾] - これにより、Dynamo を改善するためのユーザ データの共有を開始または終了することができます。
[基本設定] - アプリケーションの小数点精度やジオメトリのレンダリング品質を定義するなどの設定が含まれます。
Dynamo を終了する
不明な点については、[ヘルプ] メニューを確認します。Dynamo の参照 Web サイトの 1 つにインターネット ブラウザからアクセスすることができます。
[スタートアップ] - Dynamo の使用方法を簡単に紹介しています。
[インタラクティブ ガイド] -
[サンプル] - 参照用のサンプル ファイルです。
[Dynamo ディクショナリ] - すべてのノードについての設計図書作成で参照するリソースです。
[Dynamo Web サイト] - GitHub で Dynamo プロジェクトを表示します。
[Dynamo プロジェクト Wiki] - Wiki にアクセスして、Dynamo API を使用する開発方法やライブラリとツールのサポートに関する情報を表示します。
[開始ページを表示] - ドキュメント内の Dynamo 開始ページに戻ります。
[バグをレポート] - GitHub 上に指摘事項を作成します。
Dynamo ツールバーには、[元に戻す][Ctrl + Z]コマンドと[やり直し][Ctrl + Y]コマンドの他に、ファイルに関する作業に役立つ一連のクイック アクセス ボタンが用意されています。右端にあるボタンを使用すると、ワークスペースのスナップショットを書き出すことができます。このボタンは、ドキュメントの作成や共有を行う場合に特に便利です。
ここから Dynamo スクリプトを実行します。実行ボタンのドロップダウン アイコンをクリックして、モードを切り替えます。
[周期]: このオプションは既定でグレー表示されます。DateTime.Now ノードが使用されている場合にのみ使用できます。指定した間隔で自動的に実行されるようにグラフを設定できます。
Dynamo ワークスペースは、4 つの主要な要素で構成されています。
すべてのアクティブなタブ
プレビュー モード
ズーム/画面移動コントロール
ワークスペース内のノード
新しいファイルを開くと、既定で新しいホーム ワークスペースが開きます。
カスタム ノードを作成し、カスタム ノード ワークスペースで開くことができます。
各 Dynamo ウィンドウで使用できるホーム ワークスペースは 1 つのみですが、タブで複数のカスタム ノード ワークスペースを開くことができます。
個別のプレビューを切り替えるには、次の 3 つの方法があります。
a.右上のアイコンを使用する
b.ワークスペースを右クリックする
3D プレビューからグラフ プレビューに切り替える
グラフ プレビューから 3D プレビューに切り替える
c.キーボード ショートカットを使用する(Ctrl + B)
アイコンまたはマウスを使用して、どちらのワークスペースでもナビゲートできます。
a.グラフ プレビュー モードで
アイコンを使用して以下の動作ができます。
マウスを使用して以下の動作ができます。
左クリック - 選択する
左クリックしてドラッグ - 選択ボックスで複数のノードを選択する
スクロール ホイールの上下 - 拡大/縮小ズーム
中マウス ボタンをクリックしてドラッグ - 画面移動
キャンバス上の任意の場所を右クリック - キャンバス内検索を開く
b.3D プレビュー モードで
アイコンを使用して以下の動作ができます。
マウスを使用して以下の動作ができます。
スクロール ホイールの上下 - 拡大/縮小ズーム
中マウス ボタンをクリックしてドラッグ - 画面移動
右クリックしてドラッグ - オービット
左クリックで任意のノードを選択します。
複数のノードを選択するには、クリックおよびドラッグで選択ボックスを作成します。
現在の Dynamo があるのは、熱心なユーザと開発者のコミュニティによって支えられてきたからです。開発チームのを読む、作品をギャラリーに投稿する、で Dynamo について議論するなどの方法で、ぜひこのコミュニテイに参加してください。
[新規] - 新しい .dyn ファイルを作成する場合に使用します。
[開く] - 既存の .dyn (ワークスペース)ファイルや .dyf (カスタム ノード)ファイルを開く場合に使用します。
[保存]/[名前を付けて保存] - アクティブな .dyn ファイルや .dyf ファイルを保存する場合に使用します。
[元に戻す] - 最後の操作を元に戻す場合に使用します。
[やり直し] - 次の操作をやり直す場合に使用します。
[ワークスペースをイメージとして書き出す] - 表示されているワークスペースを PNG ファイルに書き出す場合に使用します。
Dynamo ライブラリは、機能ライブラリのコレクションです。各ライブラリには、カテゴリ別にグループ化されたノードが含まれています。このライブラリは、Dynamo の既定のインストール時に追加される基本ライブラリで構成されています。引き続きこのライブラリの使用方法を紹介し、カスタム ノードと追加パッケージを使用して基本機能を拡張する方法について説明します。「」セクションでは、この使用方法を詳しく説明しています。
ワークスペースは、ビジュアル プログラムを構成する場所です。プレビューの設定を変更して、ここから 3D ジオメトリを表示することもできます。詳細については、「」を参照してください。
グラフ プレビュー
3D プレビュー
全体表示
ズーム イン
ズーム アウト
画面移動
全体表示
ズーム イン
ズーム アウト
画面移動
オービット
このセクションでは、プロのような独自のビジュアル プログラムを作成する際に役立つ、Dynamo ライブラリで使用できる基本ノードについて説明します。
計算設計用のジオメトリ: Dynamo のジオメトリ要素の仕組みを紹介します。プリミティブから単純な、または複雑なジオメトリを作成する複数の方法について説明します。
プログラムの構成要素: データの定義と、プログラムで使用できる基本的なタイプを紹介します。また、設計ワークフローに数値演算と論理演算を組み込む方法についても学習します。
リストを使用した設計 :データ構造を管理および調整する方法を紹介します。リストの概念の詳細を理解し、リストを使用して設計データを効率的に管理できるようにします。
Dynamo のディクショナリ: ディクショナリについて解説します。ディクショナリを使用して、既存の結果から特定のデータと値を検索する方法を確認してください。
ライブラリには、付属の 10 の既定カテゴリ ノード、追加でロードされるカスタム ノードやパッケージなど、ロードされたすべてのノードが格納されます。ライブラリ内のノードは、ライブラリ、カテゴリ、サブカテゴリ(該当する場合)内で階層で整理されます。
基本ノード: 既定のインストールに付属します。
カスタム ノード: 頻繁に使用するルーチンまたは特殊なグラフをカスタム ノードとして格納します。また、カスタム ノードをコミュニティに共有することもできます。
Package Manager のノード: パブリッシュされたカスタム ノードのコレクション。
ノードの階層カテゴリを確認し、ライブラリからすばやく検索する方法を示し、その中で頻繁に使用するノードの一部について学習します。
これらのカテゴリを参照すると、ワークスペースに追加できるノードの階層や、これまでに使用したことがない新しいノードを探す最適な方法について、簡単に理解することができます。
メニューをクリックしてライブラリを参照し、各カテゴリとそのサブカテゴリを展開します。
[Geometry]には最も多くのノードが含まれているため、ノードを探す場合は最初にこれらのカテゴリを使用することをお勧めします。
ライブラリ
カテゴリ
サブカテゴリ
ノード
この階層によってノードは細かく分類され、データを Create するノードか、Action を実行するノードか、データを Query するノードかに基づいて、同じサブカテゴリに分類されます。
ノードの名前とアイコン以外の詳細情報を表示するには、ノードにマウスを合わせます。これにより、そのノードの機能、必要な入力、生成される出力について、すぐに確認できます。
ノードに関する簡単な説明
[ライブラリ]メニューの大きなアイコン
入力(名前、データ タイプ、データ構造)
出力(データ タイプと構造)
ワークスペースに追加するノードが相対的に特定できるか分かっている場合は、[検索]フィールドに入力して、一致するすべてのノードを検索します。
追加するノードをクリックして選択するか、[Enter]を押してハイライト表示されたノードをワークスペースの中心に追加します。
キーワードを使用してノードを検索するだけでなく、検索フィールドまたは Code Block (Dynamo テキスト言語 を使用)でピリオドで区切って階層を入力することもできます。
各ライブラリの階層は、ワークスペースに追加されたノードの名前に反映されます。
ライブラリ階層内のノードの場所の任意の部分を library.category.nodeName
という形式で入力すると、次のように異なる結果が返されます。
library.category.nodeName
category.nodeName
nodeName
またはkeyword
通常、ワークスペース内のノードの名前は category.nodeName
という形式で表示されますが、いくつかの例外があります。特に注意が必要な例外は、Input カテゴリと View カテゴリです。
ノードの名前は同じですが、カテゴリが異なっていることに注意してください。
ほとんどのライブラリのノードには、カテゴリ形式が含まれています。
Point.ByCoordinates
ノードと UV.ByCoordinates
ノードは、名前は同じですがカテゴリが異なっています。
注意する例外としては、Built-in Functions、Core.Input、Core.View、Operators などがあります。
Dynamo の既定のインストールには、数百個のノードが付属しています。では、ビジュアル プログラムを作成するために必要なノードはどれでしょうか。ここでは、プログラムのパラメータを定義するノード(Input)に注目し、ノードのアクション(Watch)の結果を確認して、ショートカット(Code Block)を使用して入力や機能を定義してみましょう。
Input ノードは、ビジュアル プログラムのユーザが重要なパラメータを使用する場合の主要な手段です。Core ライブラリから以下のものを利用できます。
Boolean
Number
String
Number Slider
Directory Path
Integer Slider
File Path
Watch ノードは、ビジュアル プログラムを経由してやり取りされるデータを管理するために必要なノードです。ノードの上にマウス カーソルを合わせると、ノード データのプレビューでノードの結果を表示できます。
Watch ノードで表示したままにしておくと便利です。
または、Watch3D ノードを使用してジオメトリの結果を確認します。
これらのノードは、どちらも Core ライブラリの View カテゴリに含まれています。
ヒント: ビジュアル プログラムに多数のノードが含まれている場合、3D プレビューの表示が見にくくなることがあります。その場合は、[設定]メニューの[背景 3D プレビューの表示]オプションを選択解除し、Watch3D ノードを使用してジオメトリをプレビューすることをお勧めします。
Code Block ノードでセミコロン区切りの行を使用して、Code Block を定義することができます。これは、X/Y
のように単純な場合もあります。
また、Code Block ノードをショートカットとして使用して Number Input ノードを定義したり、別のノードの機能を呼び出すこともできます。構文は、Dynamo テキスト言語である DesignScript の命名規則に従って作成されます。
次に、スクリプトで Code Block を使用するための簡単なデモンストレーションを示します(手順を含む)。
ダブルクリックして Code Block ノードを作成します。
Circle.ByCenterPointRadius(x,y);
と入力します。
ワークスペースをクリックして選択をクリアすると、x
と y
の入力が自動的に追加されます。
Point.ByCoordinates ノードと Number Slider ノードを作成して Code Block の入力に接続します。
ビジュアル プログラムの実行結果は、3D プレビューに円として表示されます。
ジオメトリは、設計用の言語です。プログラミング言語やプログラミング環境の核心部分でジオメトリ カーネルを使用している場合は、設計ルーチンを自動化し、アルゴリズムを使用して設計の繰り返し部分を生成することにより、正確で安定したモデルを設計することができます。
ジオメトリのタイプとその相互関係を理解すれば、ライブラリ内で使用できるジオメトリ ノードのグループをナビゲートできるようになります。ジオメトリ ノードは、階層別ではなくアルファベット順に整理されています。Dynamo のユーザ インタフェース内のレイアウトに似たイメージで表示されます。
Dynamo でモデルを作成し、[背景プレビュー]でプレビュー表示される内容をグラフ内のデータ フローに接続する作業は、時間の経過に伴ってより直感的に行うことができるようになります。
仮の座標系が色付きのグリッド ラインによってレンダリングされています。
ノードを選択すると、そのノードによってジオメトリが作成される場合は、対応するジオメトリが背景内でハイライト表示されます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
ジオメトリとは、古典的な定義によれば、形状の外形、サイズ、相対的な位置、空間上の特性に関する研究(幾何学)のことです。この分野には、数千年にもおよぶ豊かな歴史があります。コンピュータの出現と普及により、私たちは、ジオメトリの定義、研究、生成を行うための強力な手段を手に入れました。現在では、ジオメトリの複雑な相互作用の結果を簡単に計算できるようになりました。
コンピュータを利用してどれほど多様で複雑なジオメトリを作成できるかということを確かめるには、「Stanford Bunny」という文字列で Web を検索してみてください。「Stanford Bunny」とは、アルゴリズムのテストで使用されている標準モデルのことです。
アルゴリズム、コンピューティング、複雑性という観点からジオメトリを理解するのは、難しそうだと感じるかもしれません。しかし、比較的単純ないくつかの重要な原則を理解すれば、それをベースとしてより高度なケースに適用することができます。
ジオメトリはデータです。コンピュータや Dynamo にとって、Stanford Bunny と数値に大きな違いはありません。
ジオメトリは、抽象化に依存します。基本的に、ジオメトリの要素は、特定の空間座標系内で、数値、関係、計算式によって記述されます。
ジオメトリには階層があります。点が集まって線が構成され、線が集まって面が構成されます。
ジオメトリは、細部と全体の両方を同時に記述します。たとえば曲線が存在する場合、その曲線は曲線の形状を表すと同時に、その曲線を構成する点群も表します。
実際の作業では、複雑なモデルの開発においてさまざまなジオメトリの構成、解体、再構成を柔軟に実行できるように、作業の内容(ジオメトリのタイプやジオメトリの構成など)について理解しておく必要があります。
ここで、ジオメトリの抽象と階層との関係について簡単に説明します。これら 2 つの概念は相互に関係していますが、この関係を最初から明確に理解するのは必ずしも簡単なことではありません。そのため、複雑なワークフローやモデルの開発を開始すると、すぐに理解の壁に直面することがあります。ここでは、入門者向けに次元という概念を使用して、モデリングについて簡単に説明します。1 つの形状を記述するためにいくつの次元が必要になるかを考えると、ジオメトリの階層構成を理解する手がかりになります。
座標によって定義される点には、次元は存在しません。点は、各座標を示す単なる数字に過ぎません。
2 つの点によって定義される線には、1 つの次元が存在します。線の上では、前方(正の方向)または後方(負の方向)に向かって移動することができます。
複数の線によって定義される面には、2 つの次元が存在します。面の上では、前後だけでなく左右に移動することもできます。
複数の面によって定義される直方体には 、3 つの次元が存在します。ボックスの中では、前後左右に加えて、高低の位置関係を定義することができます。
ジオメトリを分類する場合、次元という概念は役に立ちますが、必ずしもそれが最適な概念というわけではありません。なぜなら、点、線、面、直方体だけを使用してモデルを作成することはほとんどないからです。曲線や曲面を使用する場合を考えてみれば、それは明らかです。また、方向、体積、パーツ間の関係などを定義する、完全に抽象的なジオメトリ タイプのまったく異なるカテゴリもあります。ベクトルを実際にこの手でつかむことはできません。では、空間内に見えているものに対してベクトルを定義するにはどうすればいいでしょうか。ジオメトリの階層をさらに細分化すると、抽象的なジオメトリ タイプを「補助的なジオメトリ タイプ」とみなすべきだということがわかります。各タイプは、その機能と、モデル要素の形状を記述するタイプを基準として、グループ化することができます。
Dynamo で作成するモデルは、ノードを使用して生成されるモデルだけではありません。ジオメトリでの作業を次のレベルに進めるには、キーとなる方法がいくつかあります。
Dynamo では、CSV ファイルを使用して点群を読み込んだり、SAT ファイルを読み込んでサーフェスを作成するなど、ファイルを読み込んでさまざまな操作を行うことができます。
Dynamo を Revit と組み合わせると、Revit の要素を参照して Dynamo で使用することができます。
Dynamo Package Manager には、ジオメトリのタイプや操作を拡張するための追加の機能が用意されています。Mesh Toolkit パッケージを確認してください。
ビジュアル プログラミング環境の Dynamo では、データの処理方法を構築することができます。数値やテキストだけでなく、ジオメトリもデータです。コンピュータが認識できるジオメトリ(計算設計用のジオメトリと呼ぶ場合もあります)は、美しいモデル、複雑なモデル、パフォーマンス重視のモデルを作成するためのデータです。ジオメトリを使用するには、そのジオメトリのさまざまな入力と出力を理解する必要があります。
Dynamo のノードは、ビジュアル プログラムを形成するために接続するオブジェクトです。各ノードは、特定の操作を実行します。操作には、数値の保存といった単純なものもあれば、ジオメトリの作成やクエリーの実行といった複雑なものもあります。
Dynamo のほとんどのノードは、5 つのパーツで構成されています。入力ノードなどの例外はありますが、各ノードの構造は次のようになります。
名前 -
Category.Name
の命名規則に準拠したノードの名前。メイン - ノードの本体。ここを右クリックすると、ノード全体レベルのオプションが表示されます。
ポート(入力および出力) - ワイヤの出入り口。ノードに入力データを渡し、ノードのアクションの結果を出力します。
既定値 - 入力ポートを右クリックすると、一部のノードでは既定値が表示されます。既定値は、使用しても使用しなくてもかまいません。
レーシング アイコン - 一致するリスト入力に対して指定されているレーシング オプションを示します(後で詳しく説明します)。
ノードの入力と出力はポートと呼ばれ、ワイヤの出入り口として機能します。データは左側のポートを経由して入力され、操作が実行されるとノードの右側から出力されます。
ポートは、特定のタイプのデータを受け取るように設定されています。たとえば、 2.75 という数値を Point.ByCoordinates ノードのポートに接続すると、点が正常に作成されます。ただし、同じポートに対して 「Red」 を指定すると、エラーが発生します。
ヒント: ポートにカーソルを合わせると、そのポートの正しいデータ タイプを含むツールチップが表示されます。
ポートのラベル
ツールチップ
データ タイプ
既定値
Dynamo は、各ノードのステータスに基づいて異なるカラー スキームでノードをレンダリングすることにより、ビジュアル プログラムの実行状態を示します。状態の階層は、エラー > 警告 > 情報 > プレビューの順に表示されます。
名前やポートにカーソルを合わせるか右クリックすると、追加の情報やオプションが表示されます。
入力が十分 - 入力ポートに青色の垂直バーがあるノードは、適切に接続され、すべての入力が正常に接続されています。
入力が不十分 – 1 つ以上の入力ポートに赤色の垂直バーがあるノードでは、そのポートの入力を接続する必要があります。
関数 – 関数を出力し、出力ポート上に灰色の垂直バーがあるノードは関数ノードです。
選択済み - 現在選択されているノードは、縁が水色でハイライト表示されます。
フリーズ - 半透明の青色のノードは、フリーズされてノードの実行が停止しています。
警告 - ノードの下の黄色のステータス バーは警告状態を示します。そのノードで入力データが不足しているか、不正なデータ タイプが含まれている可能性があることを意味しています。
エラー - ノードの下の赤色のステータス バーは、ノードがエラー状態にあることを示します。
情報 - ノードの下の青色のステータス バーは情報状態を示し、ノードに関する有用な情報があることがわかります。この状態は、ノードによってサポートされる最大値に近づいた場合や、パフォーマンスに潜在的な影響を与える可能性のある方法でノードを使用している場合などに、トリガされることがあります。
ヒント: このツールチップ情報を使用して上流のノードを検査することにより、必要なデータ タイプまたはデータ構造にエラーがないか確認できます。
警告のツールチップ - 「Null」またはデータがない場合は、倍精度浮動小数点数つまり数値として認識されません。
Watch ノードを使用して入力データを検査します。
上流の Number ノードに数値ではなく「red」が指定されています。
場合によっては、ビジュアル プログラムで特定のノードが実行されないようにする必要があります。これを行うには、ノードの右クリック メニューから選択してノードを「フリーズ」します。
ノードをフリーズすると、その下流にあるノードもフリーズします。つまり、フリーズされたノードの出力に依存するすべてのノードもフリーズされます。
ワイヤは各ノードを接続してノード間の関係を作成し、ビジュアル プログラムのフローを確立します。ワイヤはその名前のとおり、特定のオブジェクトから次のオブジェクトにデータ パルスを送信するための電線と考えることができます。
ワイヤは、特定のノードの出力ポートを別のノードの入力ポートに接続します。この接続により、ビジュアル プログラムのデータ フローが確立します。
入力ポートは左側にあり、出力ポートはノードの右側にあります。そのため、通常、プログラム フローは左から右に移動します。
ポートを左クリックしてワイヤを作成し、続いて別のノードのポートを左クリックして接続を作成します。接続の作成中、ワイヤは破線で表示され、正常に接続されると実線に変わります。
データは常にこのワイヤを経由して出力から入力へと移動します。ただし、接続されているポートをクリックする順序によって、どちらの方向にもワイヤを作成できます。
多くの場合、ワイヤで表示されている接続を編集して、ビジュアル プログラムのプログラム フローを調整する必要が生じます。ワイヤを編集するには、既に接続されているノードの入力ポートを左クリックします。ワイヤを編集する場合の方法は 2 つあります。
入力ポートへの接続を変更するには、別の入力ポートを左クリックします。
ワイヤを削除するには、ワイヤを入力ポートから離してワークスペースを左クリックします。
複数のワイヤを再接続するには、Shift+ 左クリックを使用します。
ワイヤを複製するには、Ctrl+ 左クリックを使用します。
既定では、ワイヤは灰色のストロークでプレビュー表示されます。ノードを選択すると、接続されているワイヤがそのノードと同じ水色でハイライト表示されます。
ハイライト表示されたワイヤ
既定のワイヤ
既定でワイヤを非表示
グラフ内のワイヤを非表示にする場合は、[表示] > [コネクタ] > [コネクタを表示]のチェックを外します。
このように設定すると、選択したノードとその連結ワイヤのみが薄い水色でハイライト表示されます。
また、ノードの出力を右クリックして[ワイヤを非表示]を選択すると、選択したワイヤのみを非表示にすることができます。
モデル内でを使用して、オブジェクトを 3 次元の世界で表現できるようにします。曲線は常に平らというわけではありません。つまり、曲線は 3 次元のオブジェクトですが、曲線が定義する空間は必ず 1 次元になります。サーフェスを定義すると、次元をもう 1 つ増やし、別のプロパティの集合を他のモデリング操作で使用できるようになります。
Dynamo のパラメータにサーフェスを読み込んで評価し、どのような情報を抽出できるかを確認します。
Surface.PointAtParameter ノードは、指定された UV 座標における点を返します。
Surface.NormalAtParameter ノードは、指定された UV 座標における法線ベクトルを返します。
Surface.GetIsoline ノードは、U 座標または V 座標におけるアイソパラメトリック曲線を返します。入力が isoDirection であることに注意してください。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
サーフェスは、1 つの関数と 2 つのパラメータによって定義される数学的な形状です。曲線を定義する t
ではなく、サーフェスでは U
と V
を使用してパラメータ空間を定義します。そのため、このタイプのジオメトリを使用すると、より多くのジオメトリ データを描画することができます。たとえば、曲線には法線ベクトルと接平面があり、接平面は曲線に沿って回転させることができます。一方、サーフェスの法線ベクトルと接平面は、方向が固定されています。
サーフェス
U アイソカーブ
V アイソカーブ
UV 座標
接平面
法線ベクトル
サーフェスの範囲: サーフェスの範囲は、そのサーフェス上の 3 次元の点を指定する(U,V)パラメータの範囲として定義されます。各次元(U または V)の範囲は、通常 2 つの数値(U の最小値から U の最大値までの数値と、V の最小値から V の最大値までの数値)で表されます。
サーフェスの形状が「長方形」に見えない場合や、サーフェスのローカルのアイソカーブの密度が高い場合や低い場合がありますが、サーフェスの範囲によって定義される「空間」は常に 2 次元になります。Dynamo におけるサーフェスの範囲は、U 方向と V 方向の両方向で、最小値 0.0 から最大値 1.0 までの範囲内で定義する必要があります。ただし、平らなサーフェスやトリム サーフェスについては、範囲が異なる場合があります。
アイソカーブ(アイソパラメトリック曲線): サーフェス上の U 定数値または V 定数値と、対応するもう一方の U 方向または V 方向の値の範囲によって定義される曲線です。
UV 座標: U と V (場合によってはさらに W)を使用して定義される、UV パラメータ空間内の点です。
接平面: 特定の UV 座標において、U アイソカーブと V アイソカーブの両方に接する平面です。
法線ベクトル: 接平面に対して相対的に「上」方向を定義するベクトルです。
NURBS サーフェスは、NURBS 曲線によく似ています。NURBS サーフェスは、2 つの方向に向かう NURBS 曲線のグリッドとして考えることができます。NURBS サーフェスの形状は、制御点の数と、そのサーフェスの U 方向および V 方向の次数によって定義されます。制御点、ウェイト、次元を使用して、形状、法線、接線、曲率などのプロパティを計算する場合にも、同じアルゴリズムが使用されます。
NURBS サーフェスの場合、ジオメトリによって 2 つの方向が暗黙的に定義されます。これは、表示される形状に関係なく、NURBS サーフェスは制御点から構成される長方形のグリッドであるためです。これらの方向は、多くの場合、ワールド座標系に対して任意の方向が相対的に設定されています。このチュートリアルでは、これらの方向を頻繁に使用し、サーフェスに基づいてモデルの解析や他のジオメトリの生成を行います。
Degree (U,V) = (3,3)
Degree (U,V) = (3,1)
Degree (U,V) = (1,2)
Degree (U,V) = (1,1)
ポリサーフェスは、エッジで結合されているサーフェスによって構成されます。ポリサーフェスのトポロジを経由して結合された形状間を移動できるため、ポリサーフェスは 2 次元の UV 定義よりも多くの機能を持っています。
一般的にトポロジとは、パーツの結合や関連についての概念を指しますが、Dynamo におけるトポロジとは、一種のジオメトリでもあります。具体的には、トポロジは、サーフェス、ポリサーフェス、ソリッドの親カテゴリにあたります。
このような方法でサーフェスを結合することにより、複雑な形状を作成したり、継ぎ目の形状の詳細を定義することができます。このように結合されたサーフェスは、パッチと呼ばれる場合もあります。ポリサーフェスのエッジに対して、フィレット操作や面取り操作を簡単に適用することができます。
は、座標と呼ばれる 1 つまたは複数の値によって定義されます。点を定義するために必要な座標値の数は、その点が存在する座標系やコンテキストによって異なります。
Dynamo で使用される最も一般的な種類の点は、3 次元のワールド座標系内に存在します。それらの点には、[X,Y,Z]の 3 つの座標があります(Dynamo の 3D 点)。
Dynamo の 2D 点には 2 つの座標[X,Y]があります。
曲線とサーフェスのパラメータは連続しており、指定されたジオメトリのエッジを超えて拡張されます。パラメータ空間を定義する形状は 3 次元のワールド座標系内に存在しているため、パラメータ座標をいつでも「ワールド」座標に変換することができます。たとえば、サーフェス上の点[0.2, 0.5]は、ワールド座標系の点[1.8, 2.0, 4.1]と同一です。
ワールド XYZ 座標とみなされる座標で表された点
指定された座標系(円柱座標)で表された点
サーフェス上の UV 座標で表された点
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
ジオメトリがモデルの言語だと仮定すると、点はアルファベットにあたります。点は、点以外のすべてのジオメトリを作成するための基礎になります。たとえば、1 本の曲線を作成するには、少なくとも 2 つの点が必要です。また、1 つのポリゴンまたはメッシュ面を作成するには、少なくとも 3 つの点が必要です。正弦関数を使用して点群の位置、順序、関係を定義すると、円や曲線など、高次元のジオメトリを定義することができます。
関数
x=r*cos(t)
とy=r*sin(t)
を使用する円関数
x=(t)
とy=r*sin(t)
を使用した正弦曲線
点は、2 次元の座標系内にも存在することができます。通常は、使用する空間に応じて異なる文字表記を使用します。この手引では、平面上では[X,Y]を使用し、サーフェス上では[U,V]を使用します。
ユークリッド座標系上の点: [X,Y,Z]
曲線パラメータの座標系上の点: [t]
サーフェス パラメータの座標系上の点: [U,V]
は大きさと方向を表すもので、特定の速度で特定の方向に向かって加速する矢印として描画できます。ベクトルは、Dynamo のモデルにおける主要なコンポーネントです。ベクトルは[Helper]という抽象的なカテゴリに分類されるため、ベクトルを作成しても背景プレビューには何も表示されないことに注意してください。
ベクトル プレビューの代わりに線分を使用することができます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
平面は抽象的な概念ですが、平面には基準点があるため、空間内で平面の場所を特定することができます。
Dynamo では、平面は背景プレビューにレンダリングされます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
座標系は抽象的な概念ですが、座標系には基準点があるため、空間内で座標系の場所を特定することができます。
Dynamo の座標系は、点(基準点)と 3 つの軸を定義する線分(X は赤、Y は緑、Z は青で表示)として背景プレビューにレンダリングされます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
抽象的なジオメトリ タイプの主要なグループは、ベクトル、平面、座標系により構成されています。ベクトル、平面、座標系により、形状を表すその他のジオメトリの位置、方向、空間コンテキストを定義することができます。たとえば、ニューヨーク市 42 丁目のブロードウェイ(座標系)の路上(平面)に立って北(ベクトル)を向いている場合、ベクトル、平面、座標系という[Helper]カテゴリの情報を使用して自分の現在の居場所を定義していることになります。電話ケース製品や高層ビルについても、同じことが言えます。モデルを開発するには、このコンテキストが必要です。
ベクトルとは、方向と大きさを表すジオメトリの量です。ベクトルは抽象的な概念です。つまり、ジオメトリ要素ではなく量を表します。ベクトルは点と同様に値のリストで構成されているため、点とベクトルを混同しないようにする必要があります。ただし、点とベクトルには大きな違いがあります。点が特定の座標系における位置を表すのに対して、ベクトルは位置における相対的な差異を表します。これは、「方向」と言い換えることもできます。
相対的な違いの考え方が分かりにくい場合は、ベクトル AB を「点 A に立って点 B の方向を向いている」と考えてみてください。 現在地 A から目的地 B に対する方向が、ベクトルです。
ここでは、同じ AB 表記を使用して、ベクトルを構成する要素について説明します。
ベクトルの開始点は、起点と呼ばれます。
ベクトルの終了点は、先端または向きと呼ばれます。
ベクトル AB とベクトル BA は違います。これらは、反対方向のベクトルです。
ベクトルとその定義に関するジョークとして、古典的なコメディである Airplane (邦題: フライングハイ)の有名なジョークがあります。
Roger, Roger.What's our vector, Victor? (訳注: ロジャー、了解だ(発音は「ロジャー」、ラジャー)。ビクター、機首の向き(発音は「ベクター」、ベクトル)は?
平面は、2 次元の抽象的な Helper です。 より厳密に定義すると、平面とは 2 つの方向に無限に延びる概念的に「平らな」面のことです。平面は、通常、小さな長方形として基準点の近くにレンダリングされます。
ここで、「基準点とは、CAD ソフトウェアでモデルを作成する場合に使用する、座標系に関係ある用語ではないだろうか」と思いつく人がいるかもしれません。
そのとおりです。多くのモデル作成ソフトウェアは、構築面(「レベル」)を使用してローカルな 2 次元のコンテキストを定義し、その面上に図面を作成します。XY 平面、XZ 平面、YZ 平面や、北、南東などの用語の方がなじみがあるかもしれません。これらはすべて、無限の平らなコンテキストを定義する平面です。平面には深さはありませんが、方向の記述に役立ちます。
平面を理解できれば、座標系もすぐに理解することができます。平面のすべての要素は、標準的なユークリッド座標系または XYZ 座標系の要素と同じです。
ただし、円柱や球体など、他の座標系もあります。平面の要素は、これらの座標系の要素とは異なります。他のジオメトリ タイプに座標系を適用し、そのジオメトリ上の位置を定義することもできます。これについては、これ以降のセクションで説明します。
別の座標系(円柱、球体)に関する説明をここに追加
単一のサーフェスから作成することのできない複雑なモデルを構築する場合や、明示的な体積を定義する場合は、(およびポリサーフェス)を使用する必要があります。単純な立方体でさえ、全部で 6 つのサーフェスが必要になる複雑な構造をしています。ソリッドには、サーフェスには存在しない 2 つの重要な概念があります。それは、高度な位相幾何学的な概念(面、辺、頂点)と、ブール演算という概念です。
を使用して、ソリッドを修正することができます。いくつかのブール演算を使用して、スパイク状のボールを作成してみましょう。
Sphere.ByCenterPointRadius ノードを使用して、ベースとなるソリッドを作成します。
Topology.Faces ノードと Face.SurfaceGeometry ノードを使用してソリッドの面のクエリーを実行し、サーフェス ジオメトリに変換します。この場合、球体には 1 つの面しかありません。
Cone.ByPointsRadii ノードで、サーフェス上の点を使用して円錐を作成します。
Solid.UnionAll ノードを使用して、円錐と球体との和演算を行います。
Topology.Edges ノードを使用して、新しいソリッドの辺のクエリーを実行します。
Solid.Fillet ノードを使用して、スパイク状の球体のエッジの面取りを行います。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
ブール演算は複雑なため、計算に時間がかかります。「フリーズ機能」を使用すると、選択したノードとその影響を受ける下流ノードの実行を中断できます。
1. Solid.UnionAll ノードの和演算をフリーズするには、右クリックしてコンテキスト メニューを使用します。
2.選択したノードとすべての下流ノードがライト グレーのゴースト モードでプレビュー表示され、影響を受けるワイヤが破線で表示されます。影響を受けるジオメトリのプレビューも、ゴースト モードになります。これで、ブール論理和を計算することなく、上流で値を変更することができます。
3.ノードのフリーズを解除するには、ノードを右クリックして[フリーズ]の選択を解除します。
4.影響を受けるすべてのノードとそれに関連するジオメトリのプレビューが更新され、標準プレビュー モードに戻ります。
ソリッドは 1 つまたは複数のサーフェスから構成され、「内部」と「外部」を定義する閉じた境界によって体積が定義されます。 ソリッドとして認識される条件は、サーフェスの数に関係なく、全体が完全に閉じた形状になっているということです。ソリッドは、サーフェスまたはポリサーフェスを結合して作成することも、ロフト、スイープ、回転などの操作を使用して作成することもできます。球体、立方体、円錐、円柱プリミティブなどもソリッドです。立方体から 1 つまたは複数の面を取り除いた場合、その形状はポリサーフェスとして認識されます。ポリサーフェスのプロパティはソリッドのプロパティと似ていますが、このポリサーフェスはソリッドではありません。
単一のサーフェスで構成される平面は、ソリッドではありません。
単一のサーフェスで構成される球体は、ソリッドです。
2 つの結合されたサーフェスで構成される円錐は、ソリッドです。
3 つの結合されたサーフェスで構成される円柱は、ソリッドです。
6 つの結合されたサーフェスで構成される立方体は、ソリッドです。
ソリッドは、頂点、辺、面という 3 種類の要素で構成されます。面は、ソリッドを構成するサーフェスです。辺は、隣接する面の接続を定義する曲線です。頂点は、これらの曲線の開始点と終了点です。Topology ノードを使用すると、これらの要素についてクエリーを実行することができます。
面
辺
頂点
ソリッドの辺をフィレット操作や面取り操作で変更することにより、角のとがりや出っ張りを取り除くことができます。面取り操作を実行すると、2 つの面の間に直線的なサーフェスが作成され、フィレット操作を実行すると、2 つの面がなめらかに接合されます。
ソリッド立方体
面取りされた立方体
フィレットされた立方体
ソリッドのブール演算は、2 つ以上のソリッドを組み合わせるための方法です。ブール演算を 1 回実行すると、実際には次に示す 4 つの操作が実行されます。
2 つ以上のオブジェクトを交差させる。
すべてのオブジェクトを交点で分割する。
ジオメトリの不要な部分を削除する。
すべてのオブジェクトを 1 つに結合する。
和: ソリッドの重複部分を削除して 1 つのソリッドに結合します。
差: 一方のソリッドから別のソリッドを取り除きます。取り除く側のソリッドは、ツールと呼ばれます。ツールとなるソリッドを切り替えて、逆のボリュームを作成することができます。
積: 2 つのソリッドが交差している部分だけを保持します。
UnionAll ノードは、球体と外側を向いた円錐の和演算を行います。
DifferenceAll ノードは、球体と内側を向いた円錐の差演算を行います。
コンピュータ モデリングの分野では、3D ジオメトリを表現する形式としてが広く普及しています。メッシュ ジオメトリは一般的に四角形または三角形の集合で構成され、NURBS 操作の代替として、軽量で柔軟なジオメトリにすることができます。メッシュは、レンダリングやビジュアライゼーションからデジタル製造や 3D プリントまで、あらゆる用途に使用されます。
Dynamo では、面と頂点のデータ構造を使用してメッシュを定義します。最も基本的なレベルでは、この構造はポリゴンにグループ化された単なる点の集合です。メッシュの点を頂点と呼び、サーフェスのような形状のポリゴンを面と呼びます。
メッシュを作成するには、頂点のリストと、それらの頂点をインデックス グループと呼ばれる面にグループ化するための仕組みが必要です。
頂点のリスト
面を定義するためのインデックス グループのリスト
このライブラリには、メッシュの変更や修復を行うためのツールや、製造処理で使用する水平方向のスライスを抽出するためのツールも用意されています。
メッシュは、サーフェスまたはソリッド ジオメトリを表す四角形と三角形の集まりです。メッシュ オブジェクトは、ソリッドと同様に、頂点、辺、面から構成されます。メッシュには、標準のプロパティの他に、法線のような独自のプロパティもあります。
メッシュの頂点
メッシュの辺: 隣接する面が 1 つだけの辺を「裸の辺」と呼びます。 それ以外のすべての辺を、「おおわれた辺」と呼びます。
メッシュの面
メッシュの頂点は、単純な点のリストです。メッシュを作成する場合や、メッシュの構造に関する情報を取得する場合、頂点のインデックスは非常に重要です。各頂点には、対応する頂点法線(ベクトル)があります。この頂点法線は、頂点において隣接する面の方向の平均を表すため、メッシュが「内向き」か「外向き」かを判断する場合に役立ちます。
頂点
頂点法線
面は、3 つまたは 4 つの頂点の順番付きリストです。そのため、メッシュ面の「サーフェス」としての表示方法は、インデックス化された頂点の位置によって決まります。メッシュを構成する頂点のリストは既に作成されているため、ここでは個々の点を指定して面を定義するのではなく、頂点のインデックスをそのまま使用します。これにより、複数の面で同じ頂点を使用することができます。
四角形の面は、0、1、2、3 のインデックスから構成されます。
三角形の面は、1、4、2 のインデックスから構成されます。インデックス グループの順序は、変更することができます。ただし、反時計回りに並んでいる必要があります。これにより、面が正しく定義されます。
メッシュ ジオメトリと NURBS ジオメトリとの違いは何でしょうか。どのような場合にどちらのジオメトリを使用したらよいのでしょうか。
前の章で、NURBS サーフェスは 2 つの方向に向かう一連の NURBS 曲線によって定義されるということを説明しました。これらの方向には、U
と V
というラベルが付けられます。これにより、2 次元サーフェスの範囲に応じて、NURBS サーフェスをパラメータ化することができます。曲線自体は、計算式としてコンピュータに格納されます。これにより、生成されるサーフェスを任意の精度で計算することができます。ただし、複数の NURBS サーフェスを結合するのは難しい場合があります。2 つの NURBS サーフェスを結合すると、ポリサーフェスが作成されます。ジオメトリの異なる部分には、異なる UV パラメータと曲線がそれぞれ定義されます。
サーフェス
アイソパラメトリック(Isoparm)曲線
サーフェス制御点
サーフェス制御ポリゴン
パラメトリック点
サーフェス フレーム
メッシュ
裸の辺
メッシュ ネットワーク
メッシュの辺
頂点法線
メッシュ面、メッシュ面の法線
NURBS サーフェスとは異なり、メッシュは、正確に定義された複数の不連続な頂点と面で構成されます。頂点のネットワークは、通常、単純な UV
座標で定義することはできません。面は互いに連続していないため、精度はメッシュ内で定義されます。精度を高めるには、メッシュを変更し、面の数を増やす必要があります。メッシュには数学的な表現方法がないため、1 つのメッシュ内で複雑なジオメトリをより柔軟に処理することができます。
メッシュと NURBS サーフェスのもう一つの重要な違いは、メッシュ内または NURBS ジオメトリ内のローカルの変更が形状全体に与える影響の度合いです。メッシュで 1 つの頂点を移動すると、その頂点に隣接する面だけが影響を受けます。NURBS サーフェスの場合、影響の範囲はより複雑で、サーフェスの次数、制御点のウェイト、制御点のノットによって影響の範囲が異なります。ただし、一般的には、NURBS サーフェスで 1 つの制御点を移動した場合の方が、ジオメトリの変更はより広範囲で滑らかなものになります。
NURBS サーフェスで 1 つの制御点を移動すると、形状全体に影響が及びます。
メッシュ ジオメトリで 1 つの頂点を移動すると、隣接する要素にのみ影響が及びます。
この対比関係は、直線と曲線で構成されるベクター イメージと、個々のピクセルで構成されるラスター イメージとの関係に似ています。ベクター イメージを拡大表示しても曲線はくっきりと表示されるのに対して、ラスター イメージを拡大表示すると個々のピクセルが拡大されて表示されます。つまり、NURBS サーフェスは、数学的に滑らかな関係があるという点でベクター イメージに似ています。一方メッシュは、一定の解像度を持つという点でラスター イメージに似ています。
この索引では、この手引で言及しているすべてのノードと他の便利なコンポーネントについて、補足情報を提供します。ここで紹介するのは、Dynamo で使用できる 500 個のノードのうち一部にすぎません。
**つまり、直方体の幅(X 軸)の長さ 10 を作成し、それを X 軸で 2 倍のスケーリングを行う座標系に変換しても、幅は 10 のままです。ASM では、ボディの頂点を予測可能な順序で抽出することができないため、変換後に寸法を決定することはできません。
Create: 最初からジオメトリを作成または構築します。たとえば、円を作成します。
Action: オブジェクトに対してアクションを実行します。たとえば、円のスケールを変更します。
Query: 既に存在するオブジェクトのプロパティを取得します。たとえば、円の半径を取得します。
プレビュー オフ - ノードの下の灰色のステータス バーと目のアイコン は、ノードのジオメトリ プレビューがオフになっていることを示します。
ビジュアル プログラムに警告やエラーが含まれている場合、その問題に関する追加情報が表示されます。また、黄色のノードでも、ノード名の上にツールチップが表示されます。警告 またはエラー ツールチップ アイコンにマウス カーソルを合わせて展開します。
は 2 次元サーフェスで、無限に広がる平坦なサーフェスとして描画できます。各平面には、原点、X 方向、Y 方向、Z (上)方向があります。
は、点やその他のジオメトリ要素の位置を決定します。次の画像は、Dynamo での外観と各カラーの意味について説明しています。
ノードのフリーズの詳細については、「」セクションを参照してください。
このように、ソリッドのブール演算は、作業時間を節約するための強力な機能です。ソリッドのブール演算には、ジオメトリのどの部分を保持するかを区別する 3 つの操作があります。
これら 3 つの演算に加えて、Dynamo には、さまざまなソリッドの差演算と和演算を実行するための Solid.DifferenceAll ノードと Solid.UnionAll ノードが用意されています。
Dynamo のメッシュ機能は、 パッケージをインストールすることによって拡張することができます。Dynamo Mesh Toolkit は、外部ファイル形式からメッシュを読み込む機能、Dynamo のジオメトリ オブジェクトからメッシュを作成する機能、頂点とインデックスからメッシュを手動で作成する機能を提供するライブラリです。
このパッケージの使用例については、「」を参照してください。
CREATE
Color.ByARGB アルファ、赤、緑、青の各成分から色を作成します。
Color Range 開始色と終了色間の色のグラデーションから色を取得します。
ACTIONS
Color.Brightness 色の明度の値を取得します。
Color.Components 色の各成分を、アルファ、赤、緑、青の順のリストとして返します。
Color.Saturation 色の彩度の値を取得します。
Color.Hue 色の色相の値を取得します。
QUERY
Color.Alpha 色のアルファ成分の値(0 ~ 255)を取得します。
Color.Blue 色の青色成分の値(0 ~ 255)を取得します。
Color.Green 色の緑色成分の値(0 ~ 255)を取得します。
Color.Red 色の赤色成分の値(0 ~ 255)を取得します。
CREATE
GeometryColor.ByGeometryColor 任意の色を使用してジオメトリを表示します。
ACTIONS
View.Watch ノードの出力を視覚化します。
View.Watch 3D ジオメトリのダイナミック プレビューを表示します。
ACTIONS
Boolean True と False のいずれかを選択します。
Code Block DesignScript のコードを直接作成することができます。
Directory Path システム上で任意のフォルダを選択して、そのパスを取得することができます。
File Path システム上で任意のファイルを選択して、そのファイル名を取得することができます。
Integer Slider 整数値を生成するスライダです。
Number 数値を作成します。
Number Slider 数値を生成するスライダです。
String 文字列を作成します。
Object.IsNull 指定されたオブジェクトが NULL であるかどうかを判断します。
CREATE
List.Create 与えられた入力に基づいて新しいリストを作成します。
List.Combine 2 つのシーケンスの各要素にコンビネータを適用します。
Number Range 指定された範囲内で数値のシーケンスを作成します。
Number Sequence 数値のシーケンスを作成します。
ACTIONS
List.Chop リストを、それぞれ指定された個数の項目から成るリストの集合に分割します。
List.Count 指定されたリストに格納されている項目の数を返します。
List.Flatten ネストされたリストのリストを、指定された量だけフラットにします。
List.FilterByBoolMask 別個のブール値を要素に持つリスト内で対応するインデックスを検索して、シーケンスをフィルタします。
List.GetItemAtIndex リストの、指定されたインデックスにある項目を取得します。
List.Map リスト内のすべての要素に関数を適用し、その結果から新しいリストを生成します。
List.Reverse 指定されたリスト内の項目を逆順で含む新しいリストを作成します。
List.ReplaceItemAtIndex リストの、指定されたインデックスにある項目を置き換えます。
List.ShiftIndices リスト内のインデックスを、指定された量だけ右に移動します。
List.TakeEveryNthItem 指定されたオフセットの後、指定された値の倍数であるインデックスの項目を、指定されたリストから取得します。
List.Transpose 任意のリストのリストの行と列を入れ替えます。他の行よりも短い行がある場合は、作成される配列が常に長方形になるように、プレースホルダーとして NULL 値が挿入されます。
ACTIONS
If 条件ステートメントです。テスト入力のブール値をチェックします。テスト入力が true である場合は、結果として true の入力を出力します。false である場合は、結果として false の入力を出力します。
ACTIONS
Math.Cos 角度の余弦を求めます。
Math.DegreesToRadians 度単位の角度をラジアン単位の角度に変換します。
Math.Pow 指定された指数に対して値を累乗します。
Math.RadiansToDegrees ラジアン単位の角度を度単位の角度に変換します。
Math.RemapRange 分布比率を保持しながら数値のリストの範囲を調整します。
Math.Sin 角度の正弦を求めます。
Formula 数学式を評価します。NCalc を評価に使用します。次を参照してください。http://ncalc.codeplex.com
Map 値を入力された範囲にマッピングします。
ACTIONS
String.Concat 複数の文字列を 1 つの文字列に連結します。
String.Contains 指定された文字列に指定されたサブストリングが含まれているかどうかを判断します。
String.Join 複数の文字列を 1 つの文字列に連結し、結合されるそれぞれの文字列の間に区切り文字を挿入します。
String.Split 1 つの文字列を文字列のリストに分割します。指定された区切り文字によって分割場所が決定されます。
String.ToNumber 文字列を整数または倍精度浮動小数点数に変換します。
CREATE
Circle.ByCenterPointRadius 入力された中心点と半径をワールド座標系の XY 平面に持ち、ワールド座標系の Z 軸を法線とする円を作成します。
Circle.ByPlaneRadius 入力された平面の基準点(ルート)に中心を持ち、指定された半径を持つ円を平面上に作成します。
CREATE
CoordinateSystem.ByOrigin 入力された点に基準点を持ち、X 軸と Y 軸を WCS(ワールド座標系)の X 軸および Y 軸に設定した座標系を作成します。
CoordinateSystem.ByCyclindricalCoordinates 指定された座標系に対して、指定された円柱座標パラメータに基づいて座標系を作成します。
CREATE
Cuboid.ByLengths ワールド座標系の基準点を中心として、幅、長さ、高さを持つ直方体を作成します。
Cuboid.ByLengths (origin)
中心を入力された点に設定し、指定された幅、長さ、高さの直方体を作成します。
Cuboid.ByLengths (coordinateSystem)
ワールド座標系の基準点を中心として、幅、長さ、高さを持つ直方体を作成します。
Cuboid.ByCorners
lowPoint から highPoint までの範囲に広がる直方体を作成します。
Cuboid.Length
実際のワールド空間寸法ではなく、直方体の入力寸法を返します。**
Cuboid.Width
実際のワールド空間寸法ではなく、直方体の入力寸法を返します。**
Cuboid.Height
実際のワールド空間寸法ではなく、直方体の入力寸法を返します。**
BoundingBox.ToCuboid
ソリッドの直方体として境界ボックスを取得します。
ACTIONS
Curve.Extrude (distance) 法線ベクトルの方向に曲線を押し出します。
Curve.PointAtParameter StartParameter() から EndParameter() までの範囲の指定されたパラメータで曲線上の点を取得します。
ACTIONS
Geometry.DistanceTo このジオメトリから別のジオメトリへの距離を取得します。
Geometry.Explode 複合要素または分割されていない要素をコンポーネント パーツに分割します。
Geometry.ImportFromSAT 読み込まれたジオメトリのリストです。
Geometry.Rotate (basePlane) 平面の基準点と法線を中心にオブジェクトを指定された角度だけ回転させます。
Geometry.Translate 指定された方向に距離を指定して、ジオメトリ タイプを平行移動させます。
CREATE
Line.ByBestFitThroughPoints 点の散布図に最もよく近似する直線を作成します。
Line.ByStartPointDirectionLength 開始点から始まり、ベクトルの向きに指定された長さだけ延長する線分を作成します。
Line.ByStartPointEndPoint 入力された 2 点を端点とする線分を作成します。
Line.ByTangency 入力された曲線に接し、曲線のパラメータで指定された点に位置する直線を作成します。
QUERY
Line.Direction 曲線の方向を返します。
Create
NurbsCurve.ByControlPoints 明示的な制御点を使用して B スプライン曲線を作成します。
NurbsCurve.ByPoints 点間を補間して B スプライン曲線を作成します。
Create
NurbsSurface.ByControlPoints 明示的な制御点と指定された U 次数と V 次数を使用して NURBS 曲面 を作成します。
NurbsSurface.ByPoints 指定された補間される点、U 次数、V 次数を使用して NURBS 曲面を作成します。作成されるサーフェスはすべての指定された点を通過します。
CREATE
Plane.ByOriginNormal 中心をルート点に持ち、入力された法線ベクトルを持つ平面を作成します。
Plane.XY ワールド座標系の XY に平面を作成します。
CREATE
Point.ByCartesianCoordinates 指定された座標系と 3 つのデカルト座標で点を作成します。
Point.ByCoordinates (2d) 指定された 2 つのデカルト座標を使用して、XY 平面に点を作成します。Z コンポーネントは 0 です。
Point.ByCoordinates (3d) 指定された 3 つのデカルト座標を使用して点を作成します。
Point.Origin 基準点 (0,0,0)を取得します。
ACTIONS
Point.Add 点にベクトルを追加します。Translate(Vector)と同じ操作です。
QUERY
Point.X 点の X 座標を取得します。
Point.Y 点の Y 座標を取得します。
Point.Z 点の Z 座標を取得します。
CREATE
Polycurve.ByPoints 点をつなげる線分のシーケンスからポリカーブを作成します。閉じた曲線を作成するには、最後の点の位置を始点の位置と同じにします。
CREATE
Rectangle.ByWidthLength (Plane) 入力された幅(平面の X 軸の長さ)と高さ(平面の Y 軸の長さ)を使用して、平面のルートを中心とする長方形を作成します。
CREATE
Sphere.ByCenterPointRadius 入力された点を中心とし、指定された半径を持つソリッド球体を作成します。
CREATE
Surface.ByLoft 入力された断面曲線間をロフトしてサーフェスを作成します。
Surface.ByPatch 入力された曲線で設定される閉じた境界の内部を塗り潰してサーフェスを作成します。
ACTIONS
Surface.Offset サーフェスの法線の方向に指定された距離だけサーフェスをオフセットします。
Surface.PointAtParameter 指定された U および V パラメータの点を返します。
Surface.Thicken サーフェスに厚みを持たせてソリッドを作成します。サーフェスを法線の方向に両側に押し出します。
CREATE
UV.ByCoordinates 2 つの倍精度浮動小数点値から UV を作成します。
CREATE
Vector.ByCoordinates 3 つのユークリッド座標でベクトルを形成します。
Vector.XAxis 基底 X 軸ベクトル(1,0,0)を取得します。
Vector.YAxis 基底 Y 軸ベクトル(0,1,0)を取得します。
Vector.ZAxis 基底 Z 軸ベクトル(0,0,1)を取得します。
ACTIONS
Vector.Normalized 正規化されたベクトルを取得します。
CREATE
CoordinateSystem.ByOrigin 入力された点に基準点を持ち、X 軸と Y 軸を WCS(ワールド座標系)の X 軸および Y 軸に設定した座標系を作成します。
CoordinateSystem.ByCyclindricalCoordinates 指定された座標系に対して、指定された円柱座標パラメータに基づいて座標系を作成します。
+ 加算
- 減算
* 乗算
/ 除算
% 剰余演算により、1 番目の入力を 2 番目の入力で除算して剰余を取得します。
< より小さい
> より大きい
== 2 つの値が等しいかどうか検証します。
色は、効果的なビジュアルを作成するためだけではなく、ビジュアル プログラムの出力で差異をレンダリングするためにも重要なデータ タイプです。抽象的なデータや変化する数値を操作する場合、何がどの程度変化するのかを確認するのが難しいことがあります。Dynamo は、色の処理に優れたアプリケーションです。
Dynamo では、ARGB 入力を使用して色を作成します。これは、アルファ、赤、緑、青の各チャネルに対応しています。アルファは色の 透明度 を表し、他の 3 つのチャネルは、色のスペクトル全体を生成するための原色として組み合わせて使用されます。
ARGB Color (Color.ByARGB)
A、R、G、B
color
次の表に記載されている各ノードにより、色を定義するアルファ、赤、緑、青の各プロパティのクエリーが実行されます。Color.Components ノードは、これら 4 つのプロパティをそれぞれ異なる出力として生成します。そのため、色のプロパティのクエリーを実行する場合は、このノードを使用すると便利です。
アルファ(Color.Alpha)
color
A
赤(Color.Red)
color
R
緑(Color.Green)
color
G
青(Color.Blue)
color
B
コンポーネント(Color.Components)
color
A、R、G、B
次の表に記載されている色は、HSB 色空間に対応しています。色を、色相、彩度、明るさに分割すると、より直感的に色を解釈することができます。たとえば、最初に処理する色を決め、次にその色の彩度と明るさを設定します。このように、色相、彩度、明るさをそれぞれ個別に設定していきます。
色相(Color.Hue)
color
Hue
彩度(Color.Saturation)
color
Saturation
明るさ(Color.Brightness)
color
Brightness
色範囲は、#part-ii-from-logic-to-geometry の演習で説明した、数値のリストを別の範囲に再マッピングする Remap Range ノードに似ています。ただし、色範囲は、数値 の範囲にマッピングされるのではなく、入力された 0 から 1 までの数値に基づいて 色のグラデーション にマッピングされます。
現在のノードは正しく機能しますが、最初からすべてを正しく機能させるのは少し大変です。色のグラデーションを理解するための最適な方法は、色のグラデーションを対話式に試す方法です。ここでは、簡単な演習を行い、数値に対応する色の出力を使用してグラデーションを設定する方法を確認します。
3 つの色を定義する: Code Block ノードを使用して 0 から 255 までの適切な数値の組み合わせに接続することにより、赤、緑 、 青 を定義します。
リストを作成する: 3 つの色を 1 つのリストにマージします。
インデックスを定義する: 0 から 1 までの範囲で、各色のグリップ位置を定義するリストを作成します。緑の値が 0.75 になっていることに注意してください。これにより、色範囲スライダの水平方向のグラデーションの 4 分の 3 が緑色になります。
Code Block ノードを設定する: 0 から 1 までの値を入力することで、グラデーションを色に変換します。
Display.ByGeometry ノードを使用すると、Dynamo のビューポート内でジオメトリに色を付けることができます。この機能は、ジオメトリの各種タイプを区別する場合、パラメータの概念を表現する場合、シミュレーション用の解析凡例を定義する場合に便利です。この場合の入力は単純で、ジオメトリと色だけです。上の図のようなグラデーションを作成するには、color 入力を Color Range ノードに接続します。
Display.BySurfaceColors ノードを使用すると、サーフェス全体にデータを色でマッピングすることができます。この機能により、日照解析、エネルギー解析、近接度解析など、各種の解析で取得したデータを視覚化することができます。Dynamo では、他の CAD 環境でマテリアルにテクスチャを適用する場合と同様に、サーフェスに色を適用することができます。次の簡単な演習で、このツールの使用方法を確認します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習では、パラメータを使用して、ジオメトリと並行して色の管理を行います。この演習で使用するジオメトリは、単純ならせん構造です。このらせん構造は、Code Block ノードを使用して定義します。これは、パラメータを使用する関数をすばやく簡単に作成するための方法です。この演習の目的は、ジオメトリではなく色を操作することであるため、コード ブロックを使用してキャンバスを見やすい状態に保ったまま、らせん構造を効率的に作成します。この手引ではより高度なマテリアルを取り上げるようになるため、ここからは、コード ブロックを頻繁に使用することになります。
Code Block ノードを使用して、上図に示す式を持つ 2 つのコード ブロックを定義します。これは、パラメータを使用してらせん構造をすばやく作成するための方法です。
Point.ByCoordinates ノードの座標(x,y,z)に Code Block ノードの 3 つの出力を接続します。
これで、らせん構造を形成する点の配列が表示されます。次の手順では、このらせん構造の点群から曲線を作成して、完全ならせん構造を作成します。
PolyCurve.ByPoints ノードの points 入力に Point.ByCoordinates ノードの出力を接続します。これにより、らせん状の曲線が作成されます。
Curve.PointAtParameter ノードの curve 入力に PolyCurve.ByPoints ノードの出力を接続します。この手順の目的は、曲線に沿ってスライドするパラメータのアトラクタ点を作成することです。この曲線によってパラメータの点が評価されるため、0 から 1 の範囲で param の値を入力する必要があります。
Number Slider ノードをキャンバスに追加したら、Min の値を 0.0 、Max の値を 1.0、Step の値を .01 に変更します。次に、Number Slider ノードの出力を Curve.PointAtParameter ノードの param 入力に接続します。らせん構造全体に沿って表示されている点を、スライダのパーセンテージとして表すことができるようになりました(開始点は 0、終点は 1)。
これで、参照点が作成されました。次に、この参照点から、らせん構造を定義する元の点までの距離を比較します。この距離により、色とジオメトリをコントロールします。
Geometry.DistanceTo ノードの other 入力に Curve.PointAtParameter ノードの出力を接続します。geometry 入力に Point.ByCoordinates ノードを接続します。
Watch ノードに、らせん構造の曲線を構成するそれぞれの点から参照点までの距離のリストが表示されます。
次の手順では、らせん構造の各点から参照点までの距離のリストを使用して、パラメータを設定します。また、これらの距離の値を使用して、曲線に沿った一連の球形の半径を定義します。これらの球形を適切なサイズに保つには、距離の値を 再マッピング する必要があります。
Math.RemapRange ノードの numbers 入力に Geometry.DistanceTo ノードの出力を接続します。
値が 0.01 の Code Block ノードを Math.RemapRange ノードの newMin 入力に接続し、値が 1 の Code Block ノードを Math.RemapRange ノードの newMax 入力に接続します。
いずれかの Watch ノードに Math.RemapRange ノードの出力を接続し、もう一方の Watch ノードに Geometry.DistanceTo ノードの出力を接続します。次に、結果を比較します。
この手順により、距離のリストがより狭い範囲に再マッピングされます。再マッピングの結果が適切な場合であっても、newMin と newMax の値を編集することができます。これらの値は、範囲全体で 分布比率 を保持したまま再マッピングされます。
Sphere.ByCenterPointRadius ノードの radius 入力に Math.RemapRange ノードの出力を接続し、元の Point.ByCoordinates ノードの出力を Sphere.ByCenterPointRadius ノードの centerPoint 入力に接続します。
Number Slider ノードの値を変更し、球体のサイズが更新されることを確認します。ここで、パラメータ ツールを使用します。
球体のサイズは、曲線に沿った参照点によって定義されるパラメータ配列を示しています。ここでは、球体の半径と同じ考え方で、球体の色を操作してみます。
Color Range ノードをキャンバス上に追加します。value 入力にマウス ポインタを置くと、0 から 1 までの範囲で数値を指定する必要があることがわかります。ここでは、Geometry.DistanceTo ノードの出力から数値を再マッピングして、それらの数値をこの範囲に対応させる必要があります。
Sphere.ByCenterPointRadius ノードでのプレビューを一時的に無効にします(右クリックして[プレビュー]を選択)。
Math.RemapRange ノードの numbers 入力にも同様にGeometry.DistanceTo ノードの出力を接続します。
Code Block ノードを使用して、Math.RemapRange ノードの newMin 入力の値として 0 を設定し、newMax 入力の値として 1 を設定します。この場合、1 つのコード ブロックで 2 つの出力を定義できることに注意してください。
Color Range ノードの value 入力に Math.RemapRange 出力を接続します。
Color.ByARGB ノードを使用して、2 つの色を作成します。この手順は複雑そうに感じるかもしれませんが、他のソフトウェアで使用する RGB カラーの場合と同じです。ここでは、ビジュアル プログラミングを使用して色を処理するというだけのことです。
Code Block ノードを使用して、0 と 255 という 2 つの値を作成します。次に、上の図のように、この 2 つの値を Color.ByARGB の各入力に接続します(または、任意の色を 2 つ作成します)。
Color Range ノードの colors 入力では、色のリストが必要になります。上の手順で作成した 2 つの色を使用して、色のリストを作成する必要があります。
List.Create ノードを使用して、2 つの色を 1 つのリストにマージします。次に、このノードの出力を Color Range ノードの colors 入力に接続します。
Display.ByGeometryColor ノードの geometry 入力に Sphere.ByCenterPointRadius ノードを接続し、Color Range ノードを Display.ByGeometryColor ノードの color 入力に接続します。これで、曲線領域全体にスムーズな色のグラデーションが適用されます。
前の手順の Number Slider ノードの値を定義内で変更すると、色とサイズが変更されます。この場合、色と半径のサイズは相互に直接関係しています。これで、2 つのパラメータ間の関係を視覚的に確認することができます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
最初に、Display.BySurfaceColors ノードの入力として使用するサーフェスを作成(または参照)する必要があります。この例では、正弦曲線と余弦曲線間をロフトします。
このノード グループ は、Z 軸に沿って点を作成してから、正弦関数と余弦関数に基づいてそれらの点の位置を変更します。その後、2 つの点リストを使用して NURBS 曲線が生成されます。
Surface.ByLoft ノードを使用して、NURBS 曲線のリスト間に、補間されたサーフェスを生成します。
File Path ノードを使用して、下流のピクセル データのサンプリングを行うためのイメージ ファイルを選択します。
File.FromPath ノードを使用してファイル パスをファイルに変換し、そのファイルを Image.ReadFromFile ノードに渡してサンプリング用のイメージを出力します。
Image.Pixels ノードを使用してイメージを入力し、そのイメージの X、Y 座標に対応して使用されるサンプル値を指定します。
Slider ノードを使用して、Image.Pixels ノードのサンプル値を指定します。
Display.BySurfaceColors ノードを使用して、色の値の配列を、X、Y 座標に対応してサーフェス全体にマッピングします。
400x300 のサンプル解像度で、出力サーフェスのプレビューを拡大します。
ジオメトリ データ タイプには複数のタイプがありますが、最初に曲線について説明します。曲線には、曲がっているか、まっすぐか、長いか、短いかなど、その形状を表す一連のプロパティが存在します。線分からスプライン曲線まで、すべての曲線タイプは点という構成要素で定義されることに注意してください。
線分
ポリライン
円弧
円
楕円
NURBS 曲線
ポリカーブ
NURBS は、曲線やサーフェスを正確に表現するために使用されるモデルです。NURBS 曲線の作成には 2 つ方法があります。それぞれの方法で Dynamo で正弦曲線を作成し、結果を比較してみましょう。
NurbsCurve.ByControlPoints ノードは、点のリストを制御点として使用します。
NurbsCurve.ByPoints ノードは、点のリストを使用して曲線を描画します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
曲線という用語は通常、すべての曲がった形状を指します(直線を含みます)。大文字の「C」で始まる「Curve」は、直線、円、スプライン曲線など、すべての形状タイプの親カテゴリです。より厳密に定義すると、曲線とは、(x = -1.26*t, y = t
)などの単純な関数から微積分を使用する複雑な関数まで、さまざまな関数の集合に「t」を代入して指定することができるすべての点のことです。操作する曲線の種類に関係なく、この「t」というパラメータが評価対象のプロパティになります。また、形状の外観にかかわらず、すべての曲線には開始点と終了点があり、この開始点と終了点が、曲線の作成に使用される t の最小値と最大値に対応します。これを理解すると、曲線の方向についても理解できます。
Dynamo では、曲線に対する t の値の範囲は 0.0 ~ 1.0 になります。これは、覚えておく必要があります。
すべての曲線には、曲線の記述や解析で使用されるさまざまなプロパティと性質があります。開始点と終了点の間の距離がゼロの場合は、「閉じた」曲線になります。 また、すべての曲線には複数の制御点があります。これらの点がすべて一つの平面上に配置されている場合、その曲線は「平らな」曲線になります。 一部のプロパティは曲線全体に適用されますが、曲線上の特定の点にのみ適用されるプロパティもあります。たとえば平面性はグローバル プロパティですが、特定の t 値における接線ベクトルはローカル プロパティです。
線分は、最も簡単な形状の曲線です。直線は曲線には見えないかもしれませんが、曲率がゼロであるというだけで、実際には曲線です。線分を作成する方法はいくつかあります。最も直感的な方法は、点 A から点 B までの線分を作成する方法です。この場合、線分 AB の形状が点間に描画されますが、数学的には、直線が両方向に無限に延びている状態になります。
2 つの線分を接続すると、ポリラインが作成されます。ここで、制御点について簡単に説明します。どの制御点の位置を編集しても、ポリラインの形状が変化します。ポリラインが閉じている場合は、ポリゴンが作成されます。ポリゴンの辺の長さがすべて同じである場合、このポリゴンは正多角形になります。
ここからは、形状を定義するための複雑なパラメトリック関数を見ていきます。これまでは線分について説明しましたが、ここでは 1 つまたは 2 つの半径を設定することにより、円弧、円、楕円弧、楕円を作成します。円弧と円または楕円の違いは、形状が閉じているかどうかだけです。
NURBS (非一様有理スプライン)は、単純な 2 次元の線分、円、円弧、長方形の形状から、複雑な 3 次元フリーフォームの有機的な曲線まで、あらゆる形状を正確にモデル化することができる数学的表現です。その柔軟性(比較的少ない制御点で、次数の設定に基づいたスムーズな補間が可能)と精度(堅牢な数学演算による形状指定)により、イラストレーションやアニメーションから製造にわたる幅広いプロセスで使用することができます。
次数: 曲線の次数により、制御点が曲線に与える影響力の範囲が決まります。次数が大きいほど、影響力の範囲も大きくなります。次数は正の整数です。この数値は通常 1、2、3、または 5 ですが、任意の正の整数にすることができます。NURBS 線分とポリラインの次数は、通常は 1 です。ほとんどのフリーフォーム曲線の次数は、3 または 5 です。
制御点: 制御点は、次数 + 1 個以上の点を含むリストです。NURBS 曲線の形状を変更するための最も簡単な方法は、その制御点を移動する方法です。
ウェイト: 制御点には、ウェイトと呼ばれる数値が関連付けられています。ウェイトは、通常は正の数値です。曲線の制御点のすべてのウェイトの値が同じである場合(通常は 1)、その曲線は非有理曲線と呼ばれます。それ以外の場合は、有理曲線と呼ばれます。ほとんどの NURBS 曲線は、非有理曲線です。
ノット: ノットは、N を制御点の数としたとき、「次数 + N - 1」個の数値のリストとして表されます。ノットはウェイトとともに使用され、作成される曲線上の制御点の影響力をコントロールします。ノットは、曲線上の特定の点でねじれを作成する場合などに使用します。
次数 = 1
次数 = 2
次数 = 3
次数の値が大きいほど、作成される曲線を補間するための制御点の数が多くなります。
ここまでの説明で、ビジュアル プログラミングの基本的な仕組みについて確認しました。ここからは、ビジュアル プログラミングで使用する構成要素について詳しく見ていきましょう。この章では、Dynamo 内で受け渡されるデータの基本的な概念について説明します。
文字列とは、正確には、リテラル定数や何らかのタイプの変数を表す一連の文字の集合のことです。広い意味では、文字列とは、テキストを意味するプログラミング用語です。ここまでの手順では、整数と小数の両方を使用してパラメータをコントロールしてきましたが、テキストについても同じ処理を行うことができます。
文字列は、カスタム パラメータの定義、ドキュメント セットの注釈付け、テキストベースのデータ セットの解析など、さまざまな目的で使用することができます。String ノードは、[Core] > [Input]カテゴリで使用することができます。
上記のサンプル ノードは、すべて文字列用のノードです。数値は文字と同様に、文字列として表すことも、テキスト配列全体として表すこともできます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
文字列のクエリーを実行することにより、大量のデータをすばやく解析することができます。ここでは、ワークフローを促進してソフトウェアの相互運用性を向上させるための基本的な操作について説明します。
次の図は、外部のスプレッドシートから取得したデータの文字列を示しています。この文字列は、XY 面上の長方形の頂点を表しています。簡単な演習として、文字列の分割操作を確認してみましょう。
「;」セパレータは、長方形の各頂点を分割します。これにより、各頂点の 3 つの項目が含まれているリストが作成されます。
String.Split ノードの中央にある[+]をクリックして、新しいセパレータを作成します。
「,」という文字をキャンバスに追加し、separator1 入力に接続します。
リストの項目が 10 個になります。String.Split ノードは、separator0 に基づいて分割を行ってから、separator1 に基づいて分割を行います。
上記のリストの項目は数値に見えますが、Dynamo 内では個別の文字列として認識されます。点群を作成するには、データ タイプを文字列から数値に変換する必要があります。これを行うには String.ToNumber ノードを使用します。
String.ToNumber ノードは、単純なノードです。String.Split ノードの出力を String.ToNumber ノードの入力に接続します。出力の表示は変わりませんが、データ タイプは 文字列 から 数値 に変換されています。
いくつかの基本的な操作を実行すると、元の文字列の入力に基づいて基準点に三角形が描画されます。
文字列は一般的なテキスト オブジェクトであるため、さまざまな目的で使用することができます。ここでは、[Core] > [String]カテゴリの主要なアクションをいくつか見てみましょう。
このカテゴリには、複数の文字列を順に結合する方法が用意されています。リストから各リテラル文字列を取得して、1 つの文字列に結合します。
以下は、3 つの文字列を連結する方法を示しています。
String.Concat ノード中央の[+]/[-]ボタンをクリックして、連結する文字列の追加と除外を行います。
出力として、スペースと句読点を含む 1 つの連結された文字列が生成されます。
結合操作は連結操作に非常によく似ていますが、句読点のレイヤーが追加される点が異なります。
Excel を使用したことがあれば、CSV ファイルについても知っているでしょう。CSV とは、カンマ区切り値という意味です。セパレータとしてカンマ(この場合は 2 つのダッシュ)を String.Join ノードで使用すると、CSV に似たデータ構造を作成することができます。
次の図は、2 つの文字列を結合する方法を示しています。
separator 入力を使用して、結合された文字列の区切り文字を指定することができます。
この演習では、文字列のクエリーと文字列の操作を実行して、Robert Frost の「Stopping By Woods on a Snowy Evening」という詩の最後の節を分解してみましょう。実際の開発作業で詩の文字列を操作することはありませんが、文字列に対する操作を理解するのに役立ちます。
最初に、節の文字列を分解する基本的な操作を実行します。文字はカンマに基づいて書式設定されていることがわかります。この書式を使用して、各行を個々の項目に分割します。
ベースとなる文字列を String ノードに貼り付けます。
別の String ノードを使用して、セパレータを指定します。ここでは、カンマをセパレータとして使用します。
String.Split ノードをキャンバスに追加し、2 つの String ノードに接続します。
出力として、各行が個別の要素に分割されます。
次に、詩のサビとなる最後の 2 行を処理しましょう。元の節は 1 つのデータ項目でした。最初の手順で、このデータを個別の項目に分割しました。そのため、必要な文字列を検索する必要があります。この例では、リストの最後にある 2 つの項目を選択することは難しく ありません が、書籍全体が処理対象になるような場合、内容をすべて読んでから各要素を手作業で区別するのは大変な作業になります。
String.Contains ノードを使用して文字セットを検索すれば、こうした手作業を行う必要はありません。これは、文書ファイルで「検索」コマンドを実行するのと似ています。この場合、対象のサブストリングが項目内で見つかったかどうかに応じて、「true」または「false」が返されます。
String.Contains ノードの searchFor 入力で、節内で検索するサブストリングを定義します。ここでは、String ノードで「And miles」と指定します。
出力として、false と true のリストが表示されます。次の手順では、このブール値ロジックを使用して各要素をフィルタします。
List.FilterByBoolMask ノードを使用して false と true を抽出します。in 出力は、mask 入力が true になっているステートメントを返し、out 出力は、mask 入力が false になっているステートメントを返します。
in 出力により、節の最後の 2 行が返されます。この 2 行には、「And miles」という文字列が含まれています。
次に、最後の 2 行を結合して節の繰り返しを強調します。前の手順の出力を確認すると、リスト内に 2 つの項目が含まれていることがわかります。
2 つの List.GetItemAtIndex ノードを使用し、0 と 1 を index 入力の値として指定することにより、2 つの項目を分離することができます。
各ノードの出力として、最後の 2 行が順に表示されます。
これらの 2 つの項目を 1 つに結合するには、String.Join ノードを使用します。
String.Join ノードを追加したら、セパレータを指定する必要があります。
セパレータを指定するには、キャンバスに String ノードを追加してカンマを入力します。
最終的な出力として、最後の 2 行が 1 行に結合されます。
このように、最後の 2 行を分割する作業は手間がかかります。文字列の操作では、多くの場合、事前の作業が必要になります。ただし、文字列の操作は拡張可能であるため、大規模なデータセットにも比較的簡単に適用することができます。スプレッドシートでパラメータを使用して対話式に操作する場合は、文字列の操作を実行すると便利です。
データの最も単純な形式が数値だとするならば、数値を関連づける最も簡単な方法は数学的方法を活用することです。割り算のような単純な演算子から、三角関数などの複雑な計算式まで、数学的方法は数値の関係とパターンを調べるための非常に便利な方法です。
演算子は、代数関数と 2 つの入力値を組み合わせて使用する一連のコンポーネントであり、1 つの出力値を生成します(加算、減産、乗算、除算など)。演算子は、[Operators] > [Actions]で使用できます。
加算(+)
var[]...[], var[]...[]
var[]...[]
減算(-)
var[]...[], var[]...[]
var[]...[]
乗算(*)
var[]...[], var[]...[]
var[]...[]
除算(/)
var[]...[], var[]...[]
var[]...[]
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
演算子と変数を組み合わせて、式を使用してより複雑な関係を形成します。スライダを使用して、入力パラメータでコントロールできる式を作成します。
1. この数列は、パラメータ式内の「t」を表しています。ここでは、サイズの大きなリストを使用して、らせん構造を定義します。
Number Sequence ノードで、start、amount、step という 3 つの入力に基づいて数列を定義します。
2.上記の手順により、パラメータ領域を定義するための数値のリストが作成されます。次に、黄金螺旋式を表すノードのグループを作成します。
黄金螺旋は、次の等式として定義されます。
次の図は、ビジュアル プログラミング形式の黄金螺旋を表しています。ここからは、順を追ってノード グループを確認していきます。ビジュアル プログラムと記述形式の等式との相違点に注意してください。
a.Number Slider ノードを使用して、キャンバスに 2 つの数値スライダを追加します。これらのスライダは、パラメータ式の変数である「a」と「b」を表します。これらの変数は、柔軟に変化する定数や、必要な結果に合わせて調整可能なパラメータを表します。
b.Multiplication (*) ノードはアスタリスクで表されます。このノードを繰り返し使用して、乗算変数を接続します。
c.Math.RadiansToDegrees ノードで「t」の値を角度に変換して、三角関数内でその角度を評価します。Dynamo では、三角関数の評価には角度が既定で使用されます。
d.Math.Pow ノードは、「t」および数値「e」の関数として動作し、フィボナッチ数列を作成します。
e.Math.Cos と Math.Sin ノードは、三角関数です。パラメータ指定の各点の X 座標と Y 座標を識別します。
f.Watch ノードで、出力値として 2 つのリストが生成されたことを確認します。これらのリストが、らせんの生成に使用される点群の x 座標と y 座標になります。
上記の手順でも問題なく機能しますが、多数のノードを使用するため、手間がかかります。より効率的なワークフローを作成するには、DesignScript を確認し、Dynamo 表現の文字列を 1 つのノード内に定義します。次の手順では、パラメータ式を使用してフィボナッチ曲線を描画する方法について確認します。
Point.ByCoordinates ノードの x 入力に上部の乗算ノードを接続し、y 入力に下部の乗算ノードを接続します。この操作により、パラメータで制御された点群のらせん構造が画面上に表示されます。
Polycurve.ByPoints ノードは、前のステップの Point.ByCoordinates を points に接続します。ここでは閉曲線は作成しないため、connectLastToFirst 入力には何も接続しなくてかまいません。この操作により、前の手順で定義した各点を通過するらせん構造が作成されます。
これで、フィボナッチ曲線が作成されました。ここからは、2 つの演習で「オウムガイ」と「ヒマワリ」を作成してみましょう。これらは自然界にみられる形状を抽象的に表しているばかりではなく、フィボナッチ曲線の 2 つの異なる適用例を的確に表現しています。
円弧を作成するための Circle.ByCenterPointRadius ノードの入力ポートに、前の手順と同じ値を接続します。radius 入力の値は既定で 1.0 に設定されているため、出力として円弧が即座に表示されます。点群が基準点から遠ざかっていく様子がよくわかります。
数列のノード グループは「t」の元の配列です。これを Circle.ByCenterPointRadius の radius 入力に接続すると、円弧の中心は基準点から離れていきますが、円の半径は次第に長くなっていき、特長的な形状のらせん構造が作成されます。
余裕があれば、これを 3D に変換してみてください。
ここまでの手順では、円弧を重ねたオウムガイのような形状を作成しました。次に、パラメータ制御のグリッドを使用してみましょう。ここでは、フィボナッチ曲線の基本的ならせんを使用して、フィボナッチ グリッドを作成していきます。結果として、ヒマワリのようならせん形状が作成されます。
最初に、前の演習と同じ手順を実行します。Point.ByCoordinates ノードを使用して、点群をらせん状に並べた配列を作成します。
![](../images/5-3/2/math-part IV-01.jpg)
次に、これらの手順に従って、さまざまな回転の一連のらせんを生成します。
a.Geometry.Rotate ノードには、同じ名前のノードが複数存在します。geometry、basePlane、degrees という入力を持つ Geometry.Rotate ノードを選択してください。geometry 入力に Point.ByCoordinates ノードを接続します。このノードを右クリックして、レーシングが「直積」に設定されていることを確認します。
b.Plane.XY ノードを basePlane 入力に接続します。これにより、基準点に向かって回り込んでいくように点が描画されます。基準点の位置は、らせんの基準の位置と同じです。
c.Number Range ノードで角度を入力することにより、複数の巻き筋を作成します。Number Range コンポーネントを使用すると、この操作をすばやく実行することができます。このコンポーネントを degrees 入力に接続します。
d.Number ノードをキャンバスに 3 つ追加して縦に並べ、数値の範囲を定義します。上から下に、それぞれ 0.0、360.0、120.0 の値を割り当てます。これらの値により、らせんの巻き筋が制御されます。Number Range ノードに 3 つの Number ノードを接続すると、結果が出力されます。
出力結果が渦の流れのようになってきました。Number Range パラメータの一部を調整して、出力結果がどのように変わるか確認してみましょう。
Number Range ノードの step の入力値を 120.0 から 36.0 に変更します。この操作により、巻き筋の数が増え、グリッドの密度が上がります
Number Range ノードの step の入力値を 36.0 から 3.6 に変更します。この操作により、グリッドの密度が大幅に上がり、螺旋の方向が不明瞭になります。これで、ヒマワリが完成しました。
ロジック(正確には条件付きロジック)により、テストに基づく単一のアクションや一連のアクションを指定することができます。テストの評価を行うと、True
または False
のブール値が返されます。このブール値を使用して、プログラム フローをコントロールすることができます。
数値変数には、さまざまな数値の範囲全体を格納することができます。ブール変数には、True または False、Yes または No、1 または 0 など、2 つの値のみを格納することができます。このようにブール値の範囲は限られているため、ブール値を使用して計算を行うことはほとんどありません。
If ステートメントは、プログラミングにおける重要な概念です。このステートメントは、「 この条件 が真である場合は この処理 を実行し、偽である場合は 別の処理 を実行する」という形式で記述されます。このステートメントの結果として出力されるアクションは、ブール値によって制御されます。Dynamo で If ステートメントを定義する場合、いくつかの方法があります。
If (If)
test、true、false
結果
Formula (IF(x,y,z))
x、y、z
結果
Code Block ((x?y:z);)
x? y, z
結果
ここでは簡単な例を使用して、If 条件ステートメントを使用する 3 つのノードの動作を確認していきます。
上の図では、Boolean ノードの出力値が True に設定されているため、その結果として "this is the result if true" という文が表示されます。この場合、If ステートメントを構成する 3 つのノードの動作は同じになります。
繰り返しますが、これら 3 つのノードの動作はすべて同じになります。ブール値 を False に変更すると、元の If ステートメントで定義されているとおりに、出力結果の値が Pi になります。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
ここでは、ロジックを使用して、数値のリストを偶数のリストと奇数のリストに分割してみましょう。
a.Number Range ノードを使用して、数値の範囲をキャンバスに追加します。
b.Number ノードを使用して、3 つの Number ノードをキャンバスに追加します。各 Number ノードで、次のように値を指定します。start 入力: 0.0、end 入力: 10.0、step 入力: 1.0。
c.Output として、0 から 10 までの範囲にわたる 11 個の数値のリストが生成されます。
d.「(%)」ノード(モジュロ演算ノード)の x 入力に Number Range ノードを接続し、y 入力で 2.0 を指定します。この操作により、リスト内の各数値を 2 で除算した場合の余りが算出されます。このリストの出力値は、0 と 1 が交互に現れる数値のリストになります。
e.「(==)」ノード(等価テスト ノード)を使用して、キャンバスに等価テストを追加します。「(%)」ノードの出力を「(==)」ノードの x 入力に接続し、Number ノードの 0.000 出力を「(==)」ノードの y 入力に接続します。
f.Watch ノードを使用して、等価テストの出力が true と false の値を交互に繰り返すリストになっていることを確認します。これらの値を使用して、リスト内の項目が区別されます。0 (または true)は偶数を表し、1 (または false)は奇数を表します。
g.List.FilterByBoolMask ノードは、ブール値の入力に基づいて数値をフィルタし、2 つの異なるリストに分割します。元の 数値の範囲 を list 入力に接続し、「(==)」ノードの出力を mask 入力に接続します。in 出力は true の値を表し、out 出力は false の値を表します。
h.Watch ノードを使用して、偶数のリストと奇数のリストが生成されたことを確認します。これで、論理演算子を使用して、リストがパターン別に分類されました。
ここでは、最初の演習で作成したロジックを変更してモデリング操作に適用してみましょう。
2.ここでも、前の演習と同じノードを使用します。ただし、次のように、いくつか違いがあります。
a.これらの入力値で Sequence ノードを使用します。
b.List.FilterByBoolMask ノードの list 入力に対する接続が解除されています。これらのノードは、この演習の後半で使用します。
3.最初に、上の図に示されているように、グラフの別のグループを作成します。このノード グループは、曲線を定義するためのパラメータ制御式を表しています。ここで、次の点に注意する必要があります。
a.最初の Number Slider は、波の周波数を表します。最小 1、最大 4、ステップ 0.01 の値である必要があります。
b.2 番目の Number Slider は、波の振幅を表します。最小 0、最大 1、ステップ 0.01 の値である必要があります。
c.PolyCurve.ByPoints ノードにより、上図のとおりにノード ダイアグラムを構成した時点で、Dynamo のプレビューに正弦曲線が出力されます。
ここでは、静的なプロパティで Number ノードを使用し、動的なプロパティで Number Slider ノードを使用して入力を行います。この手順の最初で定義した元の数値の範囲をそのまま使用してもかまいませんが、ここで作成する正弦曲線に対して、ある程度の柔軟性を設定しておく必要があります。Number Slider ノードの値を変更して、曲線の周波数と振幅がどのように変化するかを確認してください。
4.ここで少し先回りをして、最終的な結果を確認しましょう。個別に作成した最初の 2 つのステップを接続する必要があります。基本の正弦曲線を使用して、ジッパー状のコンポーネントの位置をコントロールし、真偽判定のロジックを使用して、小さなボックスと大きなボックスを交互に配置します。
a.Sequence ノードの step 入力の値 2 で作成された数列の範囲を Math.RemapRange ノードで再マッピングして、新しい一連の数値を作成します。元の数値の範囲は、0 から 100 までになります(step 値 1)。新しい数値の範囲は、0 から 1 になります。最小値の 0 を newMin 入力に接続し、最大値の 1 を newMax 入力に接続します。
5.Curve.PointAtParameter ノードを作成し、ステップ 04 の Math.RemapRange 出力を param 入力として接続します。
この操作により、曲線に沿って点群が作成されます。ここでは数値の範囲を 0 から 1 までの範囲に再マッピングしましたが、その理由は、param 入力に 0 から 1 までの範囲の値を指定する必要があるためです。0 の値は始点を表し、1 の値は終点を表します。すべての中間値は、[0,1] の範囲内で評価されます。
6.Curve.PointAtParameter ノードの出力を List.FilterByBoolMask ノードに接続し、奇数インデックスと偶数インデックスのリストを分離します。
a.List.FilterByBoolMask ノードの list 入力に、前の手順で使用した Curve.PointAtParameter ノードを接続します。
b.Watch ノードを in 出力と out 出力に 1 つずつ接続し、偶数値のインデックスを表すリストと奇数値のインデックスを表すリストが生成されたことを確認します。これらの点群は、曲線上に同じ方法で配置されます。これについては、次の手順で確認します。
7.次に、ステップ 05 で List.FilterByBoolMask ノードの出力結果を使用して、インデックスに従ってサイズが設定されたジオメトリを生成します。
Cuboid.ByLengths ノードを上の図のように接続し、正弦曲線に沿ったジッパー構造を作成します。ノード名の「Cuboid」とは、直方体という意味です。ここでは、直方体の中央に位置する曲線上の点を基準として、直方体のサイズを定義します。この操作により、偶数と奇数の除算ロジックがモデル内に明示的に定義されます。
a.偶数インデックスの直方体のリスト。
b.奇数インデックスの直方体のリスト。
できました!この演習で説明したロジック演算に従ってジオメトリ寸法を定義するプロセスをプログラムしました。
データは、各種プログラムの構成要素です。データはワイヤ経由でやり取りされ、そのデータを処理するノードに入力情報を提供します。処理されたデータは、新しい形式の出力データになります。ここでは、データの定義と構造について確認し、Dynamo で実際にデータを使用してみます。
データとは、定性的な変数や定量的な変数の集まりのことです。最も単純な形式のデータは、0
、3.14
、17
などの数値です。この他にも、変化する数値を表す変数(height
)、文字(myName
)、ジオメトリ(Circle
)、データ項目のリスト(1,2,3,5,8,13,...
)など、さまざまな種類のデータがあります。
Dynamo のノードの入力ポートには、データを追加または送信する必要があります。アクションが設定されていないデータを使用することはできますが、ノードが表すアクションを処理する場合はデータが必要になります。ノードをワークスペースに追加する際に、そのノードに対して入力データを指定しなかった場合、結果として関数が返されます。アクション自体の結果は返されません。
単純なデータ
データとアクション(ノード)が正常に実行される
入力データが指定されていないアクション(ノード)から一般的な関数が返される
Null に注意しましょう。'null'
タイプはデータが存在しないことを表します。これは抽象的な概念ですが、ビジュアル プログラミングを使用しているとよく登場します。たとえば、アクションを実行して正しい結果が生成されなかった場合に、ノードから NULL が返されます。
安定したプログラムを作成するには、NULL をテストし、データ構造から NULL を削除することが重要になります。
Object.IsNull
obj
bool
ビジュアル プログラミングを行うと、大量のデータを非常に短時間で生成できるため、データ階層を管理するための手段が必要になります。これを行うには、データ構造を使用します。データ構造とは、データを格納するための構造化されたスキームのことです。データ構造の仕様と使用方法は、プログラミング言語によって異なります。
Dynamo の場合、リストを使用してデータに階層を追加します。これについては、これ以降の章で詳しく説明します。ここでは、簡単な操作から始めてみましょう。
リストは、1 つのデータ構造内に配置された項目の集合を表します。リストと項目の関係は次のようになります。
私の手(リスト)には 5 本の指(項目)がある。
私の家の前の通り(リスト)には 10 軒の家(項目)が建っている。
Number Sequence ノードは、start 入力、amount 入力、step 入力を使用して数値のリストを定義します。上の図の 2 つのノードを使用して、10 個の数値を格納する 2 つのリストを作成しました。一方のリストには 100 から 109 までの数値が格納され、もう一方のリストには 0 から 9 までの数値が格納されています。
List.GetItemAtIndex ノードは、特定のインデックスを使用して、リスト内の特定の項目を選択します。0 を選択すると、リスト内の最初の項目(この場合は 100)が取得されます。
もう一方のリストでも同じ手順を実行すると、リスト内の最初の項目である 0 が取得されます。
次に、List.Create ノードを使用して、2 つのリストをマージして 1 つのリストを作成します。このノードによって「リストのリスト」が作成されることに注意してください。これにより、データの構造が変化します。
インデックスを 0 に設定してもう一度 List.GetItemAtIndex ノードを使用すると、「リストのリスト」内の最初の項目が取得されます。この場合、リストが項目として処理されます。この動作は、他のスクリプト言語とは多少異なっています。リストの操作とデータ構造については、これ以降の章でさらに詳しく説明します。
Dynamo のデータ階層を理解するには、「データ構造については、リストが項目として認識される」という概念を理解する必要があります。つまり、Dynamo は、トップダウン プロセスを使用してデータ構造を認識するということです。これは何を意味するのでしょうか。例を使用して詳しく説明します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この最初の例では、ジオメトリ階層全体にわたるシェル化された円柱を作成します。ジオメトリ階層については、このセクションで説明します。
1.Point.ByCoordinates を追加する - このノードをキャンバスに追加すると、Dynamo プレビュー グリッドの基準点に点が表示されます。x,y 入力と z 入力の既定値は 0.0 です。この場合、Dynamo プレビュー グリッドの基準点に点が表示されます。
2.Plane.ByOriginNormal - ジオメトリ階層内の次の段階は、平面です。平面を作成する方法はいくつかありますが、ここでは、基準点と法線を入力して作成します。ここで使用する基準点は、前の手順で作成した点ノードです。
Vector.ZAxis - このノードは、Z 方向の単位ベクトルです。このノードには入力はなく、[0,0,1]という値のベクトルしかないことに注意してください。このノードは、Plane.ByOriginNormal ノードの normal の入力として使用します。これにより、Dynamo のプレビューに長方形の平面が表示されます。
3.Circle.ByPlaneRadius - 次に、前の手順で作成した平面から曲線を作成して階層を拡張します。このノードに接続すると、基準点に円が表示されます。このノードの半径の既定値は 1 です。
4.Curve.Extrude - このノードに深さを設定することにより、基準点に表示されている円を立体的な 3 次元の円柱にします。このノードは、曲線を押し出してサーフェスを作成します。このノードの距離の既定値は 1 です。この場合、ビューポートに円柱が表示されます。
5.Surface.Thicken - このノードは、指定の距離でサーフェスをオフセットして形状を閉じることにより、閉じたソリッドを作成します。厚さの既定値は 1 です。この場合、その値に従って、シェル化された円柱がビューポートに表示されます。
6.Number Slider - ここでは、すべての入力に対して既定値を使用するのではなく、パラメータ制御をモデルに追加してみましょう。
範囲編集用キャレット - 数値スライダをキャンバスに追加したら、左上のキャレットをクリックして範囲オプションを表示します。
Min/Max/Step - Min、Max、Step の値を、それぞれ 0、2、0.01 に変更します。これにより、ジオメトリ全体のサイズをコントロールします。
7.Number Slider - すべての既定の入力で、この数値スライダのコピー アンド ペースト操作を繰り返します(Number Slider ノードを選択して[Ctrl]+[C]を押し、次に[Ctrl]+[V]を押す)。この操作は、既定値が設定されているすべての入力に Number Slider ノードが接続されるまで繰り返します。定義を有効にするには、一部のスライダ値をゼロより大きな値に設定する必要があります。たとえば、サーフェスに厚みを付ける場合は、押し出しの深さをゼロより大きな値に指定する必要があります。
8.これで、数値スライダを使用したパラメータ制御のシェル化された円柱が作成されました。いくつかのパラメータの値を変更して、Dynamo のビューポート内でジオメトリが動的に更新されることを確認してください。
Number Slider - これまでの手順で、多くのスライダをキャンバスに追加してきました。そのため、作成したツールのインタフェースをクリーンアップする必要があります。各スライダを右クリックして[名前変更]を選択し、そのスライダのパラメータ(厚さ、半径、高さなど)に適した名前に変更します。
9.ここまでの手順で、厚みのある円柱が作成されました。この時点では、この円柱はまだ 1 つのオブジェクトにすぎません。ここからは、動的にリンクされた円柱の配列を作成していきます。そのためには、項目を 1 つずつ操作するのではなく、円柱のリストを作成します。
追加用ノード (+) - ここでの目的は、前の手順で作成した円柱の横に、一連の円柱を追加することです。現在の円柱の横に別の円柱を追加するには、円柱の半径とシェルの厚さの両方を考慮する必要があります。ここでは、2 つのスライダの値を追加して、円柱の半径とシェルの厚さを設定します。
10.この操作は少し複雑であるため、手順を追って詳しく説明します。最終的な目標は、連続する各円柱の位置を定義する数値のリストを作成することです。
a.乗算用ノード (*) - 最初に、前の手順で指定した値を 2 倍にします。前の手順で指定した値は半径でしたが、ここでは円柱の直径を指定します。
b.Sequence - 次に、このノードを使用して、数値の配列を作成します。最初の入力は、前の手順の 乗算用ノード (*) の step の値です。start の値は、Number ノードを使用して 0.0 に設定します。
c.Integer Slider - Integer Slider ノードを接続して amount の値を設定します。これにより、作成される円柱の数が決まります。
d.出力のリスト - このリストには、配列内の各円柱の移動距離が表示されます。このリストは、元のスライダのパラメータによって制御されます。
11.この手順は簡単です。前の手順で指定したシーケンスを、元の Point.ByCoordinates ノードの x 入力に接続するだけです。この操作により、pointX スライダが置き換えられます。このスライダは、削除してかまいません。これで、ビューポートに円柱の配列が表示されます(Integer Slider ノードで 0 よりも大きな値を設定してください)。
12.円柱の配列は、すべてのスライダに動的にリンクされたままの状態になっています。各スライダの値を変更して、円柱の定義がどのように更新されるかを確認してください。
リストとは何かということを理解したところで、ここからは、リストに対して実行できる操作について見ていきます。ここでは、リストをトランプのカードだと考えてください。1 組のトランプがリストで、1 枚 1 枚のカードが 1 つの項目ということになります。
リストに関する質問(クエリー)を作成する場合、次のような質問が考えられます。これにより、リストの特性(プロパティ)がわかります。
Q: カードの数は?A: 52 枚
Q: スートの数は?A: 4 つ
Q: 素材は?A: 紙
Q: 長さは?A: 89 ミリ
Q: 幅は?A: 64 ミリ
リストに対して実行できる操作(アクション)としては、次のような操作が考えられます。この場合、実行する操作に応じてリストが変化します。
カードをシャッフルする。
数字の順にカードを並べ替える。
スート別にカードを並べ替える。
カード全体をいくつかに分割する。
各プレーヤにカードを配ることにより、カード全体をいくつかに分割する。
デッキから特定のカードを選ぶ。
Dynamo では、これらの操作に似た操作を実行することができます。その場合、Dynamo の各ノードを使用して、一般的なデータのリストを操作することになります。これ以降の各演習では、リストに対して実行できる基本的な操作をいくつか見ていきます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
下の図は、2 つの円の間に線を引いて基本的なリスト操作を表しているベース グラフです。リスト内のデータを管理する方法を紹介し、次のリスト アクションを使用して視覚的な結果を示します。
最初に、
500;
という値が表示されている Code Block ノードを使用します。上記の Code Block ノードを Point.ByCoordinates ノードの x 入力に接続します。
上記のノードを Plane.ByOriginNormal ノードの origin 入力に接続します。
Plane.ByOriginNormal ノードを Circle.ByPlaneRadius ノードの plane 入力に接続します。
Code Block ノードを使用して、radius の値を
50;
に設定します。これは、最初に作成する円の半径です。Geometry.Translate ノードを使用して、上記の円を Z の正の向きに 100 単位移動します。
Code Block ノードで
0..1..#10;
というコードを指定して、0 から 1 までの範囲で 10 個の数字を定義します。上記の Code Block ノードを 2 つの Curve.PointAtParameter ノードの param 入力に接続します。次に、上部に配置されている方の Curve.PointAtParameter ノードの curve 入力に Circle.ByPlaneRadius ノードを接続し、下部に配置されている方の Curve.PointAtParameter ノードの curve 入力に Geometry.Translate ノードを接続します。
Line.ByStartPointEndPoint ノードを使用して、2 つの Curve.PointAtParameter ノードを接続します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.Count ノードは、リスト内の値の数をカウントしてその数を返すという単純なノードです。「リストのリスト」を操作する場合は、このノードの使用方法も多少複雑になりますが、それについてはこれ以降のセクションで説明します。
**List.Count ****** ノードは、Line.ByStartPointEndPoint ノード内の線分の数を返します。この場合は 10 という値が返されますが、これは、元の Code Block ノードで作成した点の数に対応しています。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.GetItemAtIndex ノードは、リスト内の項目のクエリーを実行するための基本的な方法です。
まず、Line.ByStartPointEndPoint ノードを右クリックして、プレビューをオフにします。
List.GetItemAtIndex ノードを使用して、インデックス値「0」を選択するか、線分のリスト内の先頭の項目を選択します。
スライダの値を 0 から 9 の間で変更し、List.GetItemAtIndex ノードを使用して別の項目を選択します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.Reverse ノードは、リスト内のすべての項目の順序を逆にします。
順序が逆になった線分のリストをわかりやすく表示するために、Code Block を
0..1..#50;
に変更して線分の数を増やします。Line.ByStartPointEndPoint ノードを複製し、Curve.PointAtParameter ノードと 2 番目の Line.ByStartPointEndPoint ノードの間に List.Reverse ノードを挿入します。
Watch3D ノードを使用して、2 つの異なる結果をプレビューします。一方のノードには、リストが反転されていない結果が表示されます。それぞれの線分が、対応する点に対して垂直に接続されています。もう一方のノードには、反転していないリストとは逆の順序で、すべての点が接続されます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.ShiftIndices ノードは、ねじれパターンやらせんパターンなどを作成する場合に便利なノードです。このノードは、指定されたインデックス値の分だけ、リスト内の項目を移動します。
List.Reverse ノードの場合と同様に、List.ShiftIndices ノードを Curve.PointAtParameter ノードと Line.ByStartPointEndPoint ノードの間に挿入します。
Code Block ノードを使用して、リストを移動するインデックス値として「1」を指定します。
この場合の変化はわずかですが、下部に表示されている方の Watch3D ノード内のすべての線分が、インデックス 1 つ分だけ横にずれた点に接続されています。
Code Block ノードの値を「30」などの大きな値に変更すると、すべての線分が大きく変化することがわかります。元の円柱形状がこのように変化する動作は、カメラの絞りによく似ています。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.FilterByBooleanMask ノードは、ブール値のリストに基づいて、特定の項目を削除します。ブール値とは、「true」または「false」を読み取る値のことです。
「true」または「false」を読み取る値のリストを作成するには、次の手順を実行します。
Code Block ノードを使用して、
0..List.Count(list);
という構文の式を作成します。次に、Curve.PointAtParameter ノードを list 入力に接続します。この設定については、Code Block の章で詳しく説明します。ここでは、上記の構文を使用すると、Curve.PointAtParameter ノードの各インデックス値を表すリストが作成されるということだけを覚えてください。剰余演算を処理する「%」ノードを使用して、Code Block ノードの出力を x 入力に接続し、4 という値を y 入力に接続します。この操作により、インデックス値のリストを 4 で割った場合の余りが取得されます。剰余演算を処理する「%」ノードは、パターンを作成する場合に非常に便利なノードです。たとえば、整数を 4 で割った場合の余りは、0、1、2、3 のいずれかになります。
剰余演算を処理する「%」ノードの値が 0 になっている場合、インデックス値は 4 で割り切れる数値(0、4、8 など)であるということがわかります。「== 」ノードを使用して、インデックス値を「0」という値に対してテストすると、そのインデックス値が割り切れる数値であるかどうかを判断することができます。
Watch ノードには、true,false,false,false... というパターンでテストの結果が表示されます。
この true/false のパターンを使用して、2 つの List.FilterByBooleanMask ノードの mask 入力に接続します。
Curve.PointAtParameter ノードを、2 つの List.FilterByBooleanMask ノードの list 入力に接続します。
List.FilterByBooleanMask の出力が in と out から読み取られます。in は、「true」というマスク値を持つ値を表し、out は、「false」というマスク値を持つ値を表します。in 出力を Line.ByStartPointEndPoint ノードの startPoint 入力と endPoint 入力に接続すると、フィルタされた線分のリストが作成されます。
下部に表示されている方の Watch3D ノードに、線分の数が点の数よりも少ない円柱が表示されます。フィルタ処理で true の値だけに絞り込んだため、ノードの 25% だけが選択されました。
ディクショナリは、キーと呼ばれる別のデータと関連付けられているデータの集まりです。ディクショナリでは、データを検索、削除、および挿入する機能が公開されています。
基本的には、ディクショナリを非常にスマートな検索手段と考えることができます。
ディクショナリの機能はこれまで Dynamo 内で利用可能でしたが、Dynamo 2.0 では、このデータ タイプを管理する新しい方法を導入しました。
リストを使用して、データを整理することができます。コンピュータのオペレーティング システム上にはファイルとフォルダがありますが、Dynamo では、項目とリストが、それぞれファイルとフォルダに対応します。オペレーティング システムのように、さまざまな方法でデータの作成、変更、クエリーを実行することができます。この章では、Dynamo でリストを管理する方法を詳しく説明します。
リストとは、要素(項目)の集合です。例として、1 房のバナナを考えてみましょう。1 本のバナナが、リスト(房)内の 1 つの項目になります。それぞれのバナナをばらばらに取り上げるより、房をまとめて持ち上げる方が簡単です。同じことが、データ構造内のパラメータに基づく関係によって各要素をグループ化する場合についても当てはまります。
日用品を購入する場合、購入した商品をすべて買い物カゴに入れます。このカゴも、リストと考えることができます。たとえば、3 房のバナナを使用して 多くの バナナ ブレッドを作るとします。この場合、すべてのバナナが入っている袋がバナナの房のリストで、それぞれの房がバナナのリストになります。この袋は 2 次元の「リストのリスト」で、バナナの房は 1 次元の「リスト」です。
Dynamo では、リスト データには順序が付けられ、各リストの最初の項目にはインデックス「0」が割り当てられます。次のセクションでは、Dynamo におけるリストの定義の仕組みと、複数のリストの相互関係について説明します。
リストのインデックスは、1 ではなく必ず 0 から始まります。これは、最初は不思議に感じるかもしれません。今後、リストの最初の項目と言う場合は、インデックス 0 の付いた項目のことを意味します。
たとえば、右手の指を使って数を数える場合、1 から 5 の順序で数えます。0 から数え始めることはほとんどないはずです。しかし、右手の指を Dynamo のリストだと仮定すると、それぞれの指に 0 から 4 のインデックスが割り当てられることになります。プログラミングの初心者にとっては少し不思議に感じられるかもしれませんが、ほとんどのコンピュータ システムでは、インデックスの値はゼロで始まるのが普通です。
ここでも、引き続きリスト内に 5 つの項目が含まれています。ただし、最初の項目に 0 のインデックス値が割り当てられているものと仮定して説明を続けます。リストに格納できる項目は、数値だけではありません。Dynamo でサポートされているデータ タイプであれば、点、曲線、サーフェス、ファミリなど、任意のデータ タイプをリスト内に格納することができます。
a.インデックス
b.点
c.項目
多くの場合、リストに格納されているデータのタイプを確認する最も簡単な方法は、ノードの出力を Watch ノードに接続する方法です。既定では、Watch ノードにはリストの左側のすべてのインデックスと、右側のすべてのデータ項目が自動的に表示されます。
これらのインデックスは、リストを操作する場合の重要な要素です。
リストの入力と出力は、使用する Dynamo ノードによって異なります。例として、5 つの点を持つリストのノードの出力を PolyCurve.ByPoints ノードと Circle.ByCenterPointRadius ノードに接続してみましょう。
PolyCurve.ByPoints ノードの points 入力には、Point[] が必要です。これは、点のリストを表しています。
PolyCurve.ByPoints ノードの出力は、5 つの点を持つリストから作成された単一のポリカーブです。
Circle.ByCenterPointRadius ノードの centerPoint 入力には、Point が必要です。
Circle.ByCenterPointRadius ノードの出力は、5 つの円を持つリストです。それぞれの円の中心が、元のリスト内の点に対応しています。
PolyCurve.ByPoints と Circle.ByCenterPointRadius の入力データは同じですが、Polycurve.ByPoints ノードは 1 つのポリカーブを返し、Circle.ByCenterPointRadius ノードは各点を中心とする 5 つの円を返します。この場合、5 つの点をつなぐ曲線としてポリカーブが描画され、Circle.ByCenterPointRadius ノードは各点を中心とする個別の円を描画します。これは、直感的に理解することができます。では、データには何が起きているのでしょうか。
Polycurve.ByPoints の points 入力の上にカーソルを置くと、この入力に Point[] が必要であることがわかります。最後の角括弧に注意してください。これは、点のリストであることを表しています。ポリカーブを作成するには、ポリカーブごとにリストを入力する必要があります。入力された各リストは、Polycurve.ByPoints ノードによって 1 つのポリカーブに集約されます。
一方、Circle.ByCenterPointRadius ノードの centerPoint 入力には、Point が必要です。このノードはリストの項目である 1 つの点を取得し、それを円の中心として定義します。入力されたデータから 5 つの円が生成されるのは、このためです。Dynamo の入力に関するこれらの違いを認識しておくと、ノードによるデータ処理の仕組みを正しく理解することができます。
データの一致は、明確に解決することができない問題です。このような問題は、異なるサイズの入力をノードに渡すときに発生します。データ一致アルゴリズムを変更すると、結果が大きく変わってしまうことがあります。
例として、2 点の間に直線セグメントを作成するノード(Line.ByStartPointEndPoint)を考えてみます。このノードは、点の座標を指定する 2 つの入力パラメータを使用します。
最も単純な方法は、一方のリストが終了するまで、入力された点を 1 対 1 で接続していく方法です。これは、「最短リスト」アルゴリズムと呼ばれます。Dynamo ノードの既定の動作です。
「最長リスト」アルゴリズムの場合、すべてのリストの最後の項目に達するまで、同じ要素を繰り返し使用して入力が接続されたままの状態になります。
最後に、「直積」方式について説明します。この方式では、考えられる接続がすべて生成されます。
これらの点の集まりの間に直線を描画する場合、いくつかの方法があります。レーシング オプションを使用するには、ノードの中心を右クリックして[レーシング]メニューを選択します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
次の図を使用して、レーシング操作について説明します。ここでは、上記の基準ファイルを使用して、最短リスト、最長リスト、直積を定義します。
Point.ByCoordinates ノードでレーシングを変更しますが、上図のグラフについては何も変更しません。
レーシング オプション(既定のオプションも同様)として_最短リスト_を選択すると、5 つのポイントで構成される基本的な対角線が得られます。最短リストのレーシングは、2 つのリストのうち短い方のリストの最後の項目に達した場合に動作が終了します。そのためこの例では、5 つの点が含まれているリストの最後に達すると、レーシング動作が停止します。
レーシングを[最長リスト]に変更すると、垂直方向に伸びる対角線が生成されます。上の概念図のように、長い方のリストの最後の項目に達するまで、短い方のリスト(項目数が 5 のリスト)の最後の項目が繰り返し使用されます。
レーシングを[直積]に変更すると、各リスト間で考えられるすべての組み合わせの 5x10 の点のグリッドが生成されます。これは、上の概念図に示す直積に該当するデータ構造です。ただし、ここで使用しているデータは、「リストのリスト」です。ポリカーブを接続すると、各リストは X 値によって定義され、垂直な直線の列が生成されていることがわかります。
ここでは、階層にもう 1 つの層を追加してみましょう。「リストの操作」の章で例として取り上げたトランプを、ここでも例として使用します。たとえば、複数のデッキ(デッキとは 1 組のトランプのこと)が含まれたボックスを作成したとすると、そのボックスはデッキを格納するリストで、各デッキはカードのリストということになります。これが、「リストのリスト」という考え方です。たとえば次の図では、硬貨の山のリストが入っていて、それぞれの山には硬貨のリストが含まれています。
リストのリストに関する質問(クエリー)を作成する場合、次のような質問が考えられます。これにより、リストの特性(プロパティ)がわかります。
Q: 硬貨は何種類?A: 2.
Q: 硬貨のタイプ値は? A: $0.01 と $0.25 です。
Q: 25 セント硬貨の材質は?A: 銅 75%、ニッケル 25%
Q: 1 セント硬貨の材質は?A: 亜鉛 97.5%、銅 2.5%
リストのリストに対して実行できる操作(アクション)としては、次のような操作が考えられます。この場合、実行する操作に応じてリストのリストが変化します。
25 セント硬貨または 1 セント硬貨の特定の山を選ぶ。
特定の 25 セント硬貨または 1 セント硬貨を選ぶ。
25 セント硬貨の山と 1 セント硬貨の山の配置を変える。
25 セント硬貨の山と 1 セント硬貨の山をすべて入れ替える。
前の章でも説明したように、Dynamo の各ノードを使用して、上記の操作に似た操作を実行することができます。ここでは、物理的な物体ではなく抽象的なデータを操作するため、データ階層を上下に移動する方法をコントロールするための一連のルールが必要になります。
リストのリストを操作する場合、データは複雑な階層構造になっていますが、この複雑な構造により、非常に高度なパラメータ操作を実行することができます。これ以降の各演習では、基礎的な概念といくつかの操作方法を確認していきます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
このセクションで説明する基本的な概念は、「Dynamo は、リストをオブジェクトとして処理する」ということです。トップダウン階層は、オブジェクト指向プログラミングをベースとして開発されています。Dynamo は、List.GetItemAtIndex などのコマンドでサブ要素を選択するのではなく、データ構造内でメイン リストのインデックスを選択します。リスト中で選択したその項目が、別のリストである場合もあります。ここからは、サンプルの図を使用して詳しく説明していきます。
Code Block ノードを使用して、
0..2; 0..3;
という 2 つの範囲が定義されています。これらの範囲は、レーシングが「外積」に設定された Point.ByCoordinates ノードに接続されています。これにより、点のグリッドが作成され、リストのリストが出力として返されます。
Watch ノードの各リストで、4 つの項目を持つ 3 つのリストが指定されていることに注意してください。
インデックス値 0 を指定して List.GetItemAtIndex ノードを使用した場合、Dynamo は、最初のリストとそのリスト内のすべてのコンテンツを選択します。他のプログラムでは、データ構造内のすべてのリストの最初の項目だけが選択される場合がありますが、Dynamo は、トップダウン階層を使用してデータの処理を行います。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
フラット化を行うと、データ構造からすべてのデータ層が削除されます。この機能は、操作にデータ階層が必要ない場合に便利ですが、情報が削除される可能性があります。次の図は、データのリストをフラット化した結果を示しています。
Code Block ノードで
-250..-150..#4;
というコード行を挿入して範囲を定義します。Code Block ノードを Point.ByCoordinates ノードの x 入力と y 入力に接続します。これにより、点のグリッドを取得するための「外積」に対するレーシングが設定されます。
Watch ノードに、リストのリストが表示されます。
PolyCurve.ByPoints ノードは、各リストを参照して個別のポリカーブを作成します。Dynamo のプレビューに 4 つのポリカーブが表示されます。それぞれのポリカーブが、グリッド内の各行を表しています。
PolyCurve.ByPoints ノードの前に Flatten ノードを挿入して、すべての点を含む単一のリストを作成します。PolyCurve.ByPoints ノードは、リストを参照して 1 つのカーブを作成しますが、すべての点が 1 つのリスト上に存在しているため、点のリスト全体を通過するジグザクのポリカーブが 1 つだけ作成されます。
独立したデータ層をフラット化する方法も用意されています。List.Flatten ノードを使用すると、データ層の数を定義して、最上位の階層からデータ層をフラット化することができます。このノードは、現在のワークフローに必ずしも関係しない複雑なデータ構造を操作する場合に特に便利です。別の方法として、Flatten ノードを関数として List.Map ノードで使用することもできます。List.Map ノードの詳細については、以下で説明します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
パラメトリック モデリングを行う際に、既存のリストのデータ構造を修正したい場合があります。その場合、さまざまなノードを使用できますが、List.Chop ノードが最も基本的なノードです。List.Chop ノードで設定された数の項目を使用すると、1 つのリストを複数のサブリストに分割することができます。
Chop コマンドを実行すると、指定されたリストの長さに従ってリストが分割されます。List.Chop ノードは、データ構造を削除するのではなく新しいデータ層をデータ構造に追加するなど、いくつかの点で List.Flatten ノードとは逆の動作を行います。List.Chop ノードは、次の例のようなジオメトリに関する操作を実行する場合に便利です。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.Map ノードと List.Combine ノードは、階層内の 1 段階下の層で、設定された関数を入力リストに適用します。リストの組み合わせとリストのマップはほとんど同じ操作ですが、組み合わせの場合は、特定の関数の入力に対応する複数の入力を使用できる点が、マップとは異なっています。
簡単な例として、前のセクションで説明した List.Count ノードをもう一度確認してみましょう。
List.Count ノードは、リスト内のすべての項目をカウントします。ここでは、List.Count ノードを使用して、List.Map ノードの仕組みについて説明します。
Code Block ノードで、次の 2 行を挿入します。
-50..50..#Nx; -50..50..#Ny;
このコードを入力すると、Code Block ノードに Nx と Ny という 2 つの入力が作成されます。
2 つの Integer Slider ノードを使用して Nx の値と Ny の値を Code Block ノードに接続すると、これらの値が定義されます。
次に、Code Block ノードの各行を Point.ByCoordinates ノードの x 入力と y 入力に接続します。このノードを右クリックして「レーシング」と「外積」を続けて選択します。この操作により、点のグリッドが作成されます。-50 から 50 までの範囲が定義されているため、ここでは既定の Dynamo グリッド全体を使用しています。
Watch ノードに、作成された点が表示されます。データ構造を確認すると、リストのリストが作成されていることがわかります。それぞれのリストが、グリッドの点の 1 行を表しています。
前の手順の Watch ノードの出力に List.Count ノードを接続します。
Watch ノードを List.Count ノードの出力に接続します。
List.Count ノードによって 5 という値が生成されていることに注意してください。これは、Code Block ノードで定義されている「Nx」変数と同じ値です。こうなる理由は次のとおりです。
まず、Point.ByCoordinates ノードは、リストを作成するための主要な入力として「x」入力を使用します。Nx の値が 5 で Ny の値が 3 の場合、3 つの項目を持つ 5 つのリストが含まれた 1 つのリストが作成されます。
Dynamo は、リストをオブジェクトとして処理するため、List.Count ノードは、階層内のメインのリストに適用されます。その結果、メインのリストに含まれているリストの数である 5 という値が生成されることになります。
List.Map ノードを使用して、階層内の 1 段階下の層で「関数」を実行します。
List.Count ノードには入力がないことに注意してください。List.Count ノードは関数として使用されるため、このノードは階層内の 1 段階下の層にあるすべてのリストに適用されます。List.Count ノードの空の入力は、List.Map ノードの list 入力に対応しています。
List.Count ノードにより、5 つの項目を持つリストが 1 つ作成されます。それぞれの項目の値は 3 になります。この値は、各サブリストの長さを表しています。
この演習では、List.Combine ノードを使用して、個別のオブジェクト リストに関数を適用する方法を説明します。
最初に、2 つの点のリストを設定します。
Sequence ノードを使用して 10 の値を生成し、各値に 10 のステップ増分を指定します。
結果を Point.ByCoordinates ノードの x 入力に接続します。これにより、Dynamo で点のリストが作成されます。
2 番目の Point.ByCoordinates ノードをワークスペースに追加し、x 入力として同じ Sequence 出力を使用し、y 入力として Integer Slider を使用し、その値を 31 (1 番目の点のセットと重ならない限り任意の値)に設定して、2 つの点のセットがお互いに重ならないようにします。
次に、List.Combine ノードを使用して、2 つの異なるリスト内のオブジェクトに関数を適用します。この場合、単純な線描画関数になります。
ワークスペースに List.Combine ノードを追加し、2 つの点のセットを list0 と list1 入力として接続します。
List.Combine ノードの入力関数として Line.ByStartPointEndPoint ノードを使用します。
完了すると、2 つの点のセットが Line.ByStartPointEndPoint 関数を介して一緒に圧縮またはペアリングされ、Dynamo で 10 行が返されます。
List.Combine の別の使用例については、N 次元のリストの演習を参照してください。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
List.Map ではなく List@Level 機能を使用すると、ノードの入力ポートに使用するリストのレベルを直接選択することができます。この機能は、入力ポートに指定されたあらゆる入力値に使用できます。使用すると、もっともすばやく簡単にリストのレベルにアクセスすることができます。ノードの入力として使用するリストのレベルを指定するだけで、後はすべてをノードに任せることができます。
この演習では、List@Level 機能を使用して特定のデータ レベルを分離してみましょう。
点によって構成される単純な 3D グリッドから始めることにします。
X、Y、Z に Range ノードを接続することでグリッドが構成されています。したがって、データの構造は X リスト、Y リスト、Z リストの 3 層から成ることがわかります。
これらの層は、異なるレベルに存在します。レベルは、プレビュー バルーンの下に表示されます。リスト レベルの列はリスト データに対応しています。ここで、作業中のレベルを確認することができます。
リスト レベルは逆順で階層化されているので、最低レベルのデータは常に「L1」にあります。これにより、上流で何かが変更されたとしても、グラフを意図したとおりに動作させることができます。
List@Level 機能を使用するには、[>]をクリックします。このメニュー内部では、2 つのチェックボックスが表示されます。
レベルを使用 - このオプションをオンにすると、List@Level の機能が有効になります。このオプションをクリックした後で、ノードで使用する入力リスト レベルをすべてクリックして選択することができます。このメニューで上矢印か下矢印をクリックすることにより、さまざまなレベル オプションを試すことができます。
リスト構造を保持 - オンにしていると、その入力のレベル構造を保持することができます。意図的にデータを複数のサブリストに整理している場合は、このオプションをオンにしておくと、いかなる情報も失わずにリスト構造をそのまま保持しておくことができます。
リスト レベル全体を切り替えることにより、単純な 3D グリッド上でリスト構造を視覚的に確認することができます。リスト レベルとインデックスの組み合わせを変更すると、元の 3D セットとは異なる点のセットが返されます。
DesignScript で「@L2」を選択すると、レベル 2 のリストのみを選択することができます。index に 0 が入力されているとき、レベル 2 のリストには Y を 0 とする点のセットのみが含まれているので、XZ のグリッド面のみが返されます。
レベル フィルタを「@L1」に変更すると、リスト レベル 1 に含まれるすべての点を確認することができます。index に 0 が入力されているとき、レベル 1 のリストにはフラット リストの 3D ポイントがすべて含まれています。
同様に「@L3」に変更すると、リスト レベル 3 の点のみが表示されます。index に 0 が入力されているとき、レベル 3 のリストには Z を 0 とする点のセットのみが含まれているので、XY のグリッド面のみが返されます。
同様に「@L4」に変更すると、リスト レベル 4 の点のみが表示されます。index に 0 が入力されているとき、レベル 4 のリストには X を 0 とする点のセットのみが含まれているので、YZ のグリッド面のみが返されます。
今回の例は List.Map でも作成できますが、List@Level を使用すると、動作を単純化して簡単にノード データにアクセスできるようになります。次に List.Map と List@Level の比較をご覧ください。
どちらの方法でも同じ点にアクセスすることができますが、List@Level を使用するとたった 1 個のノードだけでデータのレイヤを簡単に切り替えることができます。
List.Map を使用して点構成のグリッドにアクセスするには、List.Map の隣に List.GetItemAtIndex ノードを配置する必要があります。レベルの階層を下りていくたびに、List.Map ノードを追加していく必要があります。リストが複雑になればなるほど、目的の情報レベルにアクセスするには、多数の List.Map ノードをグラフに追加しなければなりません。
この例では、List.GetItemAtIndex ノードを List.Map ノードに接続することにより、List.GetItemAtIndex で「@L3」を選択したときと同じリスト構造を持つ同じ点のセットを取得しています。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
転置は、リストのリストを操作する場合の基本的な機能です。転置を実行すると、スプレッドシート プログラムの場合と同様に、データ構造内の列と行の位置が反転します。次の基本的な行列を使用して、転置の仕組みを説明します。また、次のセクションでは、転置機能を使用して幾何学的な関係を作成する方法について説明します。
最初に、前の演習で使用した List.Count ノードを削除して別のジオメトリに移動し、データ構造がどのようになっているかを確認します。
Point.ByCoordinates ノードから続く Watch ノードの出力に、PolyCurve.ByPoints ノードを接続します。
出力として 5 つのポリカーブが作成され、Dynamo のプレビューにそれらのポリカーブが表示されます。Dynamo ノードは点のリスト(この場合は、点のリストのリスト)を検索し、そのリストから 1 つのポリカーブを作成します。原則として、各リストはデータ構造内で曲線に変換されます。
List.Transpose ノードは、すべての項目をメイン リスト内のすべてのリストと切り替えます。この動作は少し複雑に感じるかもしれませんが、データ構造内の列と行を入れ替える Microsoft Excel と同じ仕組みです。
転置により、リストの構造が変更されていることを確認します。転置前は 3 つの項目を持つ 5 つのリストだったのに対して、転置後は 5 つの項目を持つ 3 つのリストに変わっています。
PolyCurve.ByPoints ノードにより、元の曲線に対して垂直方向に 3 つのポリカーブが作成されます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この演習では、前の演習で作成したロジックを使用してサーフェスを編集します。この演習の目的は直感的な操作を行うことですが、データ構造のナビゲーションは少し複雑な操作です。ここでは、制御点を移動することにより、サーフェスの編集を行います。
最初に、上図の各ノードの文字列を操作します。既定の Dynamo グリッド全体にわたる基本的なサーフェスを作成します。
Code Block ノードを使用して次の 2 つのコード行を入力し、Surface.PointAtParameter ノードの u 入力と v 入力にそれぞれのコード行を接続します(
-50..50..#3;
と-50..50..#5;
)。Surface.PointAtParameter ノードのレーシングを「外積」に設定します。
Watch ノードに、5 つの項目を持つ 3 つのリストが含まれた 1 つのリストが表示されます。
この演習では、作成したグリッドの中心点のクエリーを実行します。これを行うには、中央のリストの中心点を選択します。
正しい点を選択するには、Watch ノードの各項目をクリックして、正しい点が選択されているかどうかを確認します。
Code Block ノードを使用して、リストのリストをクエリーするための基礎となるコード行を次の形式で指定します。
points[1][2];
Geometry.Translate ノードを使用して、選択した点を Z の正の向きに 20 単位移動します。
List.GetItemAtIndex ノードを使用して、点の中央の行を選択します。前の手順と同様に、Code Block ノードで
points[1];
というコード行を指定してクエリーを実行することもできます。
ここまでの手順で、中心点のクエリーを実行し、中心点を上方向に移動しました。ここでは、この中心点を元のデータ構造に戻します。
最初に、前の手順で分離したリストの項目を置き換えます。
List.ReplaceItemAtIndex ノードで「2」というインデックス値を使用し、置き換える項目を対象となる点(Geometry.Translate ノードの Geometry 出力)に接続して、中心点を置き換えます。
対象の点がリストの中央の項目に入力されたことが出力として表示されます。
ここでは、前の演習で変更したリストを、元のデータ構造であるリストのリストに戻します。
前の演習と同様に、List.ReplaceItemAtIndex ノードを使用して、中央のリストを変更したリストで置き換えます。
これら 2 つのノードのインデックスを定義する Code Block ノードの値は、それぞれ 1 と 2 であることに注意してください。これらの値は、Code Block ノードで指定した元のクエリー(points[1][2])に対応しています。
インデックス 1 の位置でリストを選択すると、Dynamo のプレビューでデータ構造がハイライト表示されます。これで、対象の点が元のデータ構造に正しく移動されたことになります。
上図の点のセットからサーフェスを作成する方法はいくつかあります。ここでは、複数の曲線をまとめてロフトしてサーフェスを作成してみましょう。
NurbsCurve.ByPoints ノードを作成し、新しいデータ構造を接続して、3 つの NURBS 曲線を作成します。
Surface.ByLoft ノードを NurbsCurve.ByPoints ノードの出力に接続します。これで、サーフェスが変更されました。ジオメトリの元の Z 値を変更することができます。この値を変更して、ジオメトリがどのように変化するかを確認してください。
ここでは、データ階層にさらに層を追加して、より高度なリストの操作方法について見ていきます。データ構造を拡張して、2 次元を超える多次元のリストのリストを作成することができます。Dynamo のリストは項目として処理されるため、必要な数の次元を持つデータを作成することができます。
多次元のリストの構造は、ロシアのマトリョーシカ人形に似ています。各リストは、複数の項目を格納するコンテナとして考えることができます。各リストには独自のプロパティが存在し、それぞれのリストは独自のオブジェクトとして見なされます。
ロシアのマトリョーシカ人形(写真: )は、N 次元のリストの構造に似ています。それぞれの層が 1 つのリストを表し、各リスト内に項目が格納されています。Dynamo では、1 つのリストに複数のリストを格納することができます。この場合、格納されているそれぞれのリストが、格納元のリストの項目になります。
N 次元のリストを視覚的に説明するのは難しいため、この章ではいくつかの演習を使用して、2 次元を超える多次元のリストを操作する方法について見ていきます。
Dynamo のデータ管理において最も複雑な概念はマッピングですが、複雑なリスト階層を操作する場合は特に、マッピングが重要になります。この章の演習では、多次元のデータを操作する際に、どのようなケースでマッピングと組み合わせ機能を使用するかについて説明します。
List.Map ノードと List.Combine ノードの概要については、前の章で説明しました。この章の最後の演習でこれらのノードを使用して、複雑なデータ構造の操作を行います。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この章では、読み込んだジオメトリを操作するための演習を 3 つ見ていきます。この演習はその最初の演習です。演習を進めていくにつれて、より複雑なデータ構造を扱います。
最初に、演習ファイル フォルダ内の .sat ファイルを使用します。このファイルを取得するには、File Path ノードを使用します。
Geometry.ImportFromSAT ノードを使用すると、ジオメトリが 2 つのサーフェスとして Dynamo のプレビューに読み込まれます。
説明を簡単にするため、この演習では 1 つのサーフェスだけを使用します。
インデックス値として 1 を選択して、上部のサーフェスをグラブします。これを行うには、List.GetItemAtIndex ノードを使用します。
Geometry.ImportFromSAT プレビューのジオメトリ プレビューをオフにします。
次に、グラブしたサーフェスを点のグリッドに分割します。
1.Code Block ノードを使用して、次の 2 つのコード行を入力します。
0..1..#10;
0..1..#5;
2.2 つの Code Block 値を、Surface.PointAtParameter ノードの u 入力と v 入力に接続します。次に、このノードの_レーシング_を「外積」に変更します。
3.出力としてデータ構造が表示されます。このデータ構造は、Dynamo のプレビューで表示することもできます。
次に、最後のステップの点を使用して、サーフェスに沿って 10 個のカーブを生成します。
NurbsCurve.ByPoints ノードを Surface.PointAtParameter ノードの出力に接続して、データ構造の内容を確認します。
List.GetItemAtIndex ノードのプレビューをオフにすると、結果が明確になります。
基本的な List.Transpose ノードにより、リストのリストの列と行が反転します。
List.Transpose ノードの出力を NurbsCurve.ByPoints ノードに接続すると、サーフェスに沿って水平方向に 5 本の曲線が作成されます。
前のステップで NurbsCurve.ByPoints ノードのプレビューをオフにしていると、イメージで同じ結果が得られます。
この演習では、少し複雑な操作を実行してみましょう。ここでは、前の演習で作成した曲線に対して操作を実行します。具体的には、これらの曲線を別のサーフェスに関連付けて、2 つのサーフェス間で曲線をロフトします。この操作を実行する場合、データ構造の処理が少し複雑になりますが、基本的な考え方はこれまでと同じです。
最初に、List.GetItemAtIndex ノードを使用して、前の演習で読み込んだジオメトリの上部サーフェスを分離します。
Surface.Offset ノードで 10 という値を指定して、サーフェスをオフセットします。
前の演習と同様に、Code Block ノードで次の 2 つのコード行を入力します。
0..1..#10;
0..1..#5;
上記のコード行を 2 つの Surface.PointAtParameter ノードに接続し、各ノードの レーシング を「外積」に設定します。いずれか一方のノードが元のサーフェスに接続され、もう一方のノードがオフセットされたサーフェスに接続されます。
これらのサーフェスのプレビューをオフにします。
前の演習と同様に、Surface.PointAtParameter ノードの出力を 2 つの NurbsCurve.ByPoints ノードに接続します。結果は、2 つのサーフェスに対応するカーブを示します。
List.Create ノードを使用して、2 組の曲線を 1 つのリストのリストに結合します。
10 個の項目を持つ 2 つのリストが出力として表示されます。各リストが、NURBS 曲線の各接続セットを表しています。
Surface.ByLoft ノードを実行すると、このデータ構造を視覚的に理解することができます。このノードは、各サブリスト内のすべての曲線をロフトします。
前のステップで Surface.ByLoft ノードのプレビューをオフにします。
List.Transpose ノードを使用すると、リスト内のすべての列と行が反転します。このノードにより、10 本の曲線を持つ 2 つのリストが、2 本の曲線を持つ 10 個のリストに変換されます。また、各 NURBS 曲線が、もう一方のサーフェスの隣接する曲線に関連付けられます。
Surface.ByLoft ノードを使用して、リブ形状の構造物を作成します。
次に、この結果を得るための別のプロセスを説明します。
開始する前に、前のステップで Surface.ByLoft プレビューをオフにして、混乱を避けます。
ここでは、List.Transpose ノードの代わりに List.Combine ノードを使用します。このノードは、各サブリスト上で「コンビネータ」を実行します。
この演習では、List.Create ノードを「コンビネータ」として使用します。これにより、サブリスト内の各項目のリストが作成されます。
Surface.ByLoft ノードを使用して、前の手順と同じサーフェスを取得します。この場合は List.Transpose ノードを使用した方が簡単ですが、さらに複雑なデータ構造を操作する場合は、List.Combine ノードを使用することをお勧めします。
リブ形状の構造物内の曲線の方向を切り替える場合は、手順をいくつか戻り、NurbsCurve.ByPoints ノードに接続する前に List.Transpose ノードを使用します。これにより、リスト内の列と行が反転し、水平方向のリブ形状が 5 つ作成されます。
ここからは、さらに高度な操作を実行してみましょう。この演習では、読み込んだ 2 つのサーフェスを両方とも使用して、複雑なデータ階層を作成します。ただし、基本的な考え方はこれまでと同じで、同じ操作を実行することになります。
最初に、前の演習で読み込んだファイルを使用します。
前の演習と同様に Surface.Offset ノードを使用し、サーフェスをオフセットする値として 10 を指定します。
オフセットされたノードによって 2 つのサーフェスが作成されたことが出力として表示されます。
前の演習と同様に、Code Block ノードで次の 2 つのコード行を入力します。
0..1..#20;
0..1..#20;
上記のコード行を 2 つの Surface.PointAtParameter ノードに接続し、各ノードのレーシングを 「外積」 に設定します。いずれか一方のノードが元のサーフェスに接続され、もう一方のノードがオフセットされたサーフェスに接続されます。
前の演習と同様に、Surface.PointAtParameter ノードの出力を 2 つの NurbsCurve.ByPoints ノードに接続します。
NurbsCurve.ByPoints ノードの出力を確認すると、この出力が 2 つのリストを持つリストであることがわかります。これは、前の演習で扱ったリストよりも複雑なデータ構造です。データは基礎となるサーフェスによって分類されるため、構造化されたデータに別の層を追加します。
Surface.PointAtParameter ノードでは、データ構造がさらに複雑になっていることがわかります。このノードでは、「リストのリストのリスト」が作成されます。
続行する前に、既存のサーフェスのプレビューをオフにします。
List.Create ノードを使用して、NURBS 曲線を 1 つのデータ構造にマージします。これにより、「リストのリストのリスト」が作成されます。
Surface.ByLoft ノードを接続すると、元のサーフェスが取得されます。これは、元のデータ構造から作成された独自のリスト内にサーフェスがそのまま残っているためです。
前の演習では、List.Transpose ノードを使用してリブ形状の構造物を作成しましたが、ここでは同じ操作を行うことはできません。List.Transpose ノードを使用できるのは 2 次元のリストの場合ですが、ここでは 3 次元のリストを操作するため、リスト内の列と行を反転する操作を簡単に実行することはできません。これまでに説明したように、リストはオブジェクトとして処理されるため、サブリストが含まれていないリストを List.Transpose ノードを使用して反転することはできますが、階層内の 1 段階下の層でリストの NURBS 曲線を反転することはできません。
ここでは、List.Combine ノードを使用します。さらに複雑なデータ構造を処理する場合は、List.Map ノードと List.Combine ノードを使用します。
List.Create ノードを「コンビネータ」として使用して、この操作に適したデータ構造を作成します。
階層内の 1 段階下の層で、データ構造を転置する必要があります。これを行うには、List.Map ノードを使用します。このノードは List.Combine ノードに似ていますが、複数の入力リストではなく 1 つの入力リストだけを使用する点が異なっています。
List.Map ノードに List.Transpose ノードを適用します。これにより、メイン リスト内のサブリストの列と行が反転します。
これで、適切なデータ階層を持つ NURBS 曲線をまとめてロフトし、リブ形状の構造物を作成できるようになりました。
図に示されている入力設定を持つ Surface.Thicken ノードを使用して、ジオメトリに深さを追加します。
この構造にサーフェスを追加して補強してみましょう。別の Surface.ByLoft ノードを追加し、前のステップの NurbsCurve.ByPoints ノードの最初の出力を入力として使用します。
プレビューが見にくくなってきたので、これらのノードのプレビューをオフにします。ノードを右クリックし、[プレビュー]のチェックを外して結果を見やすくします。
選択したサーフェスに厚みをつければ、操作は完了です。
これで、さまざまなデータを使用したロッキング チェアが完成しました。
最後に、ロッキング チェアの溝の方向を変えてみましょう。前の演習では転置用のノードを使用しましたが、ここでも同じような方法で操作を行います。
データ階層にもう 1 つ深い層があるため、List.Map ノードと List.Tranpose 関数を使用して Nurbs の曲線方向を変更します。
Code Block ノードのコード行を次のように変更して、溝の数を増やします。
0..1..#20;``0..1..#30;
最初に作成したロッキング チェアは滑らかな形状でしたが、このロッキング チェアはまったく異なる形状になりました。
線分はポイントのセットで構成され、各ラインには最低 2 つのポイントがあります。Dynamo で線分を作成する最も一般的な方法の 1 つは、Line.ByStartPointEndPoint
を使用して Dynamo で線分を作成することです。
写真:
オリジナル画像提供:
写真:
写真:
注: この演習は前バージョンの Dynamo を使用して作成されました。 List.Map の機能に関する問題の大半は、 List@Level _機能の追加によって解決されました。詳細については、後述の _ を参照してください。
注: この演習は前バージョンの Dynamo を使用して作成されました。List.Combine の機能に関する問題の大半は、 List@Level 機能の追加によって解決されました。詳細については、後述の を参照してください。
Code Block では、「[]」という省略表記を使用してリストを定義します。この方法を使用すると、List.Create ノードを使用するよりも素早く柔軟にリストを作成することができます。Code Block の詳細は、「」を参照してください。次の図は、Code Block を使用して、複数の式を持つリストを作成する方法を示しています。
Code Block で「[]」という省略表記を使用すると、複雑なデータ構造で特定の項目をすばやく簡単に選択することができます。Code Block の詳細は、「で説明しています。次の図は、Code Block を使用して、複数のデータ タイプが存在するリストのクエリーを実行する方法を示しています。
Dynamo 2.0 では、ディクショナリのデータ タイプをリストのデータ タイプと分離する概念が導入されました。この変更により、ワークフローにおけるデータの作成や操作の方法が大幅に変更される可能性があります。2.0 よりも前のバージョンでは、ディクショナリとリストは 1 つのデータ タイプとして統合されていました。つまり、リストが実際には整数キーを持つディクショナリだったのです。
ディクショナリは、キーと値のペアの集合で構成されたデータ タイプで、各キーは各集合に固有です。ディクショナリは順序付けされておらず、基本的には、リストにあるようなインデックス値の代わりにキーを使用して「調べる」ことができます。Dynamo 2.0 では、キーに文字列のみを使用できます。
リストは、順序付けされた値の集合で構成されたデータ タイプです。Dynamo では、リストはインデックス値として整数を使用します。
ディクショナリは、リストと分離されたことによって第一級オブジェクトとなりました。そのため、インデックス値を覚えたり、ワークフロー全体で厳密なリスト構造を維持することなく、値の格納や検索をすばやく容易に行うことができます。ユーザのテストにおいて、複数の GetItemAtIndex
ノードの代わりにディクショナリを使用した場合に、グラフのサイズが大幅に低減することがわかりました。
構文 の変更により、コード ブロック内のディクショナリとリストの初期化および操作の方法が変更されました。
ディクショナリは {key:value}
の構文を使用します。
リストは [value,value,value]
の構文を使用します。
ディクショナリを作成、編集、クエリーするための 新しいノード が、ライブラリに追加されました。
v1.x のコード ブロックで作成されたリストは、スクリプトのロード時に、角括弧 [ ]
を波括弧 { }
の代わりに使用する新しいリスト構文に自動的に移行されます。
コンピュータ サイエンスにおいて、ディクショナリはリストのように、オブジェクトの集合です。リストは特定の順序で並んでいますが、ディクショナリは 順序なし の集合です。一連番号(インデックス)に依存せず、キー を使用します。
次の画像では、可能性のあるディクショナリの使用例を示しています。多くの場合、ディクショナリを使用して、直接的な関係を持たない 2 つのデータを関連付けます。ここでは、スペイン語バージョンの単語を英語バージョンに接続して、後で検索できるようにしています。
2 つのデータを関連付けるディクショナリを作成します。
指定されたキーを使用して値を取得します。
Dynamo のノードのライブラリには、すぐに使用できる多くの機能が保存されています。頻繁に使用するルーチンや、コミュニティと共有する特殊なグラフがある場合は、カスタム ノードとパッケージによって Dynamo をさらに拡張できます。
Dynamo 2.0 では[Dictionary]カテゴリのさまざまなノードが公開されており、使用することができます。作成、アクション、クエリー のノードがあります。
Dictionary.ByKeysValues
は、指定した値とキーでディクショナリを作成します。(項目数は、最短のリストの入力によります)
Dictionary.Components
は、入力ディクショナリのコンポーネントを作成します。(これはノードの作成と逆の操作です)。
Dictionary.RemoveKeys
は、入力キーが削除された新しいディクショナリのオブジェクトを作成します。
Dictionary.SetValueAtKeys
は、入力キーと値に基づいて新しいディクショナリを作成し、対応するキーで現在の値を置き換えます。
Dictionary.ValueAtKey
は、入力キーに対する値を返します。
Dictionary.Count
は、ディクショナリに含まれるキーと値のペア数を示します。
Dictionary.Keys
は、現在ディクショナリに格納されているキーを返します。
Dictionary.Values
は、現在ディクショナリに格納されている値を返します。
ディクショナリに関するあらゆるデータは、インデックスとリストを操作する従来の方法に代わる優れた手段です。
Revit 内で、そこに含まれるデータの一部を使って検索しようとしたことがありますか?
次の例のような作業を行ったことがあるのではないでしょうか。
下図では、Revit モデル内のすべての部屋を収集し、必要な部屋のインデックスを(部屋番号で)取得し、最終的にそのインデックスにある部屋がわかります。
モデル内のすべての部屋を収集します。
検索する部屋番号。
部屋番号を取得し、その番号のインデックスを見つけます。
インデックスで部屋を取得します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
次に、ディクショナリを使用して、これを再作成してみましょう。まず、Revit モデル内のすべての部屋を収集する必要があります。
操作する Revit カテゴリを選択します(ここでは部屋を操作します)。
Dynamo に対して、これらの要素すべての収集を指示します。
使用するデータは部屋番号です。
ここでは、指定されたキーと要素でディクショナリを作成します。
Dictionary.ByKeysValues ノードは、適切に入力されるとディクショナリを作成します。
Keys
は文字列であることが必要ですが、values
はさまざまなオブジェクト タイプにすることができます。
最終的に、部屋番号を使って、ディクショナリから部屋を取得することができます。
String
は、ディクショナリからオブジェクトを検索するために使用しているキーです。Dictionary.ValueAtKey ノードで、ディクショナリからオブジェクトを取得します。
ディクショナリによるこの同じ方法を使用して、グループ化されたオブジェクトでディクショナリを作成することもできます。指定されたレベルですべての部屋を検索する場合、上のグラフを次のように修正できます。
キーとして部屋番号を使用するのではなく、パラメータの値(ここではレベル)を使用できます。
これで、部屋をそのレベルごとにグループ化することができます。
レベルごとにグループ化された要素を使用することで、共有のキー(固有のキー)をディクショナリのキーとして使用し、部屋のリストを要素として使用できるようになります。
最終的に、Revit モデル内のレベルを使用して、ディクショナリ内で、そのレベルに配置されている部屋を検索できます。
Dictionary.ValueAtKey
は、レベル名を取得して、そのレベルの部屋オブジェクトを返します。
[Dictionary]カテゴリのノードを使用する機会は、実際には無限にあるのです。Revit 内の BIM データを要素自体に関連付けることができるので、さまざまな使用例が考えられます。
Dynamo には、ビジュアル プログラミングのさまざまなタスクで使用できる多くのコア ノードが用意されています。ただし、独自のノードを作成した方が、迅速かつ効率的な方法で、簡単に問題を解決できる場合があります。これらの独自のノードは複数の異なるプロジェクトで再利用できるため、グラフが見やすくなります。これらのノードを Package Manager にプッシュして、世界中の Dynamo コミュニティと共有することもできます。
Dynamo 2.0 では、これまでに説明したディクショナリのノードだけでなく、コード ブロックにおけるディクショナリの新機能も導入されました。
次のような構文、つまりノードの DesignScript ベースの表現を使用できます。
ディクショナリは Dynamo のオブジェクト タイプであるため、次のアクションを実行できます。
このような操作は、Revit データを文字列に関連付ける場合に特に便利です。次に、Revit での使用例を見てみましょう。
次に、このデータを検索するために使うキーを決定する必要があります。(キーに関する情報は、「」セクションを参照してください)。
ここまでの手順で、カスタム ノードを作成して Dynamo グラフ内の特定のプロセスに適用しました。このセクションでは、このノードを他の Dynamo グラフでも参照できるように、このノードをライブラリに保存します。これを実行するには、目的のノードをローカルにパブリッシュします。これは、パッケージをパブリッシュする場合と同様の手順です。パッケージのパブリッシュについては、次の章で詳しく説明します。
ノードをローカルにパブリッシュすると、新しいセッションを開いたときに、Dynamo ライブラリからそのノードにアクセスできるようになります。ノードをパブリッシュせずに Dynamo グラフからカスタム ノードを参照する場合、グラフのフォルダ内に、そのカスタム ノードを含めておく必要があります。または、[ファイル] > [ライブラリを読み込み] を使用してカスタム ノードを Dynamo に読み込む必要があります。
ホスト API の依存関係がない限り、バージョン 2.17 以降で Dynamo Sandbox からカスタム ノードとパッケージをパブリッシュすることができます。旧バージョンでは、カスタム ノードとパッケージのパブリッシュは、Dynamo for Revit と Dynamo for Civil 3D でのみ有効です。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
前のセクションで作成したカスタム ノードを使用して、次の手順に進みましょう。PointsToSurface カスタム ノードを開くと、Dynamo のカスタム ノード エディタにグラフが表示されます。または、Dynamo グラフ エディタ内でカスタム ノードをダブルクリックしてカスタム ノードを開くこともできます。
カスタム ノードをローカルにパブリッシュするには、キャンバス上で右クリックして、[このカスタム ノードをパブリッシュ...]を選択します。
上図のように、関連情報を入力して[ローカルにパブリッシュ]を選択します。[グループ]フィールドで、Dynamo メニューからアクセスできる主要な要素を定義します。
ローカルにパブリッシュするすべてのカスタム ノードを格納するフォルダを 1 つ選択します。Dynamo を読み込むたびにこのフォルダが確認されるため、このフォルダの場所は変更しないでください。このフォルダにナビゲートし、[フォルダを選択]を選択します。これで、Dynamo ノードがローカルにパブリッシュされ、プログラムを読み込むたびに、このフォルダが Dynamo ライブラリに表示されるようになります。
カスタム ノードのフォルダの場所を確認するには、[Dynamo] > [基本設定] > [パッケージ設定] > [ノードとパッケージのパス] に移動します。
このウィンドウには、パスのリストが表示されます。
Documents\DynamoCustomNodes... は、ローカルにパブリッシュされたカスタム ノードの場所を参照します。
AppData\Roaming\Dynamo... は、オンラインでインストールされる Dynamo パッケージの既定の場所を示しています。
リスト内でローカル フォルダ パスを下に移動する場合は、パス名の左側にある下向き矢印をクリックします。一番上に表示されているフォルダが、パッケージがインストールされる既定のパスになります。そのため、Dynamo パッケージの既定のインストール パスを既定のフォルダのままにすると、オンライン パッケージをローカルにパブリッシュしたノードと区別することができます。
Dynamo の既定のパスをパッケージのインストール場所に設定するため、パス名の順序を変更しました。
このローカル フォルダにナビゲートすると、Dynamo のカスタム ノード ファイルの拡張である元のカスタム ノードが .dyf フォルダに表示されます。このフォルダ内のファイルを編集すると、UI 上でノードが更新されます。また、メインの DynamoCustomNode フォルダにノードを追加すると、Dynamo の再起動時に、それらのノードがライブラリに追加されます。
これで、Dynamo を読み込むたびに、PointsToSurface ノードが Dynamo ライブラリの[DynamoPrimer]グループに表示されるようになります。
カスタム ノードは、他のノードとカスタム ノードを「Dynamo のカスタム ノード」内にネストすることによって作成されます。Dynamo のカスタム ノードは、コンテナとして考えることができます。このコンテナ ノードをグラフ内で実行すると、コンテナ ノード内のすべてのノードが実行されるため、ノードを自由に組み合わせて再利用や共有を行うことができます。
グラフ内でカスタム ノードの複数のコピーを使用している場合、基準となるカスタム ノードを編集することにより、一度にすべてのコピーを更新することができます。これにより、ワークフローや設計にどのような変更が生じた場合でも、グラフをシームレスに更新して変更に対応することができます。
カスタム ノードの最も便利な機能は、ワーク シェアリング機能です。たとえば、Dynamo の上級ユーザが複雑な Dynamo グラフを作成し、そのグラフを Dynamo を初めて使用する設計者に渡したとします。この場合、グラフを渡されたユーザはそのグラフを簡素化し、設計についてのやり取りに必要な最小限の要素だけに絞り込むことができます。カスタム ノードを開いて内部のグラフを編集することができますが、「コンテナ」はシンプルな状態に保たれます。このプロセスにより、カスタム ノードを使用する Dynamo ユーザは、直感的で見やすいグラフを設計することができます。
Dynamo では、さまざまな方法でカスタム ノードを作成することができます。この章の例では、Dynamo UI からカスタム ノードを直接作成します。C# や Zero-Touch の構文の詳細については、Dynamo Wiki のこのページを参照してください。
カスタム ノード環境を実際に使用して、パーセンテージを計算する単純なノードを作成してみましょう。カスタム ノード環境は、Dynamo のグラフ環境とは異なりますが、インタラクションは基本的に同じです。では、最初のカスタム ノードを作成してみましょう。
カスタム ノードを一から作成するには、Dynamo を起動して[カスタム ノード]を選択するか、キャンバスで[Ctrl]+[Shift]+[N]を押します。
[カスタム ノード プロパティ]ダイアログ ボックスで、カスタム ノードの名前、説明、カテゴリを入力します。
名前: Percentage
説明: Calculate the percentage of one value in relation to another (一方の値に対するもう一方の値のパーセンテージを計算)
カテゴリ: Math.Functions
キャンバスの背景色が黄色で表示されます。これは、カスタム ノードの内部を表しています。このキャンバス内では、Input ノードや Output ノードなど、Dynamo の核となるすべてのノードを使用することができます。この 2 つのノードにより、カスタム ノードでやり取りされるデータにラベルが付けられます。これらは[Input] > [Basic]にあります。
Input ノードは、カスタム ノード上に入力ポートを作成します。入力ノードの構文は、input_name : datatype = default_value(オプション) です。
Output ノードは、Input ノードと同様に、カスタム ノード上に出力ポートを作成して名前を付けます。カスタム コメントを入力ポートと出力ポートに追加して、入力タイプと出力タイプがわかるようにすることをお勧めします。詳細については、「カスタム ノードを作成する」セクションを参照してください。
作成したカスタム ノードは、.dyf ファイルとして保存することができます(標準ノードの場合は .dyn ファイルとして保存されます)。保存したファイルは、現在のセッションと将来のセッションに自動的に追加されます。カスタム ノードは、ライブラリの[Add-ons]セクションにあります。
ここまでの手順では、最初のカスタム ノードを作成しました。これ以降の各セクションでは、カスタム ノードの機能と、一般的なワークフローをパブリッシュする方法について詳しく説明します。次のセクションでは、ジオメトリを特定のサーフェスから別のサーフェスに転送するカスタム ノードを作成する方法について説明します。
前の章では、いくつかのカスタム ノードを作成しました。ここでは、パッケージを使用してカスタム ノードを整理し、パブリッシュしてみましょう。パッケージは、独自のノードを保存し、Dynamo コミュニティと共有できる便利な方法です。
Dynamo Mesh Toolkit は、外部ファイル形式からメッシュを読み込む機能、Dynamo のジオメトリ オブジェクトからメッシュを作成する機能、頂点とインデックスからメッシュを手動で作成する機能を提供するライブラリです。このライブラリには、メッシュの変更や修復を行うためのツールや、製造処理で使用する水平方向のスライスを抽出するためのツールも用意されています。
Dynamo Mesh Toolkit は、オートデスクによるメッシュ研究の一環として開発されているため、今後も拡張を続けていきます。このツールキットには、頻繁に新しいメソッドが追加される予定になっています。コメント、バグの報告、新機能の提案については、お気軽に Dynamo チームまでご連絡ください。
Dynamo で、上部メニュー バーの[パッケージ] > [Package Manager]に移動します。検索フィールドに「MeshToolkit」と入力します。スペースを入れずに 1 つの単語として入力してください。[インストール]をクリックし、確認を承諾してダウンロードを開始します。非常に簡単です。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この例では、Mesh Toolkit の Intersection ノードについて説明します。メッシュを読み込み、そのメッシュを一連の入力面と交差させてスライスを作成します。レーザー カッター、ウォータージェット カッター、CNC ミルなどの製造用モデルを作成する場合は、最初にこの操作を実行することになります。
最初に、Dynamo で Mesh-Toolkit_Intersect-Mesh.dyn を開きます。
File Path ノードで、読み込むメッシュ ファイル(stanford_bunny_tri.obj)の場所を指定します。サポートされるファイル タイプは、.mix と .obj です。
Mesh.ImportFile ノードに File Path ノードを接続して、メッシュを読み込みます。
Point.ByCoordinates ノードで、点を作成します。この点が、円弧の中心になります。
Arc.ByCenterPointRadiusAngle ノードで、上記の点を中心とする円弧を作成します。この曲線を使用して、一連の面が配置されます。 設定は次のとおりです。
radius: 40, startAngle: -90, endAngle:0
円弧に沿って方向付けられた一連の平面を作成します。
Code Block ノードで、0 から 1 までの 25 個の数値を入力します。
Curve.PointAtParameter ノードの curve 入力に Arc.ByCenterPointRadiusAngle ノードの Arc 出力を接続し、param 入力に Code Block ノードの出力を接続します。これにより、曲線に沿って一連の点が抽出されます。
Curve.TangentAtParameter ノードの curve 入力に、Arc.ByCenterPointRadiusAngle ノードの Arc 出力を接続します。
Plane.ByOriginNormal ノードの origin 入力に Curve.PointAtParameter ノードの Point 出力を接続し、normal 入力に Curve.TangentAtParameter ノードの Vector 出力を接続します。これにより、各点に一連の平面が作成されます。
次に、これらの平面を使用してメッシュを交差させます。
Mesh.Intersect ノードで、読み込んだメッシュと平面を交差させ、一連のポリカーブの輪郭線を作成します。ノードを右クリックして、レーシングを最長に設定します。
PolyCurve.Curves ノードで、ポリカーブを曲線のフラグメントに分割します。
Curve.EndPoint ノードで、各曲線の終了点を抽出します。
NurbsCurve.ByPoints ノードで、点群を使用して NURBS 曲線を作成します。次に、Boolean ノードを True に設定して曲線を閉じます。
続行する前に、Mesh.ImportFile、Curve.EndPoint、Plane.ByOriginNormal および Arc.ByCenterPointRadiusAngle など、一部のノードのプレビューをオフにして、結果を見やすくします。
Surface.ByPatch ノードで、各輪郭線に対してサーフェスを作成して、メッシュの「スライス」を作成します。
2 つ目のスライスの集合を追加すると、2 種類のスライスが格子のように表示されます。
メッシュを使用すると、交差の演算がソリッドよりも高速になることがわかります。この演習で紹介したようなワークフローには、メッシュが適しています。
Dynamo では、いくつかの方法でカスタム ノードを作成することができます。最初からカスタム ノードを作成することも、既存のグラフから作成することも、C# を使用して明示的に作成することもできます。このセクションでは、既存のグラフを使用して Dynamo UI 内にカスタム ノードを作成する方法について説明します。ワークスペースを整理し、一連のノードをパッケージ化して別の場所で再利用する場合は、この方法が最適です。
次の図は、UV 座標を使用して、1 つのサーフェスから別のサーフェスに点をマッピングする場合の例を示しています。この概念を適用して、XY 平面上の曲線を参照する、複数の小さなパネルから構成されるサーフェスを作成してみましょう。ここでは、パネル化用の四角形のパネルを作成しますが、同じ概念を適用して、UV マッピングを使用する多様なパネルを作成することもできます。この演習を行うと、このグラフや Dynamo の別のワークフローで同様のプロセスを簡単に繰り返すことができるようになるため、カスタム ノード開発のよい練習になります。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
Code Block: この行を使用して、-45 ~ 45
45..45..#10;
の範囲の 10 個の数値を作成します。Point.ByCoordinates: Code Block ノードの出力を x 入力と y 入力に接続し、[レーシング]を[外積]に設定します。これで、点のグリッドが作成されます。
Plane.ByOriginNormal: Point 出力を origin 入力に接続して、各点に平面を作成します。この操作では、既定の法線ベクトル(0,0,1)が使用されます。
Rectangle.ByWidthLength: 前の手順で作成した平面を plane 入力に接続し、値 10 の Code Block ノードを使用して幅と長さを指定します。
これで、長方形のグリッドが作成されます。UV 座標を使用して、これらの長方形を目的のサーフェスにマッピングします。
Polygon.Points: 前の手順の Rectangle.ByWidthLength 出力を polygon 入力に接続し、各長方形の頂点を抽出します。これらの点を、目的のサーフェスにマッピングします。
Rectangle.ByWidthLength: 値 100 で Code Block ノードを使用して、長方形の幅と長さを指定します。これが、基準サーフェスの境界線になります。
Surface.ByPatch: 前の手順の Rectangle.ByWidthLength 出力を closedCurve 入力に接続し、基準となるサーフェスを作成します。
Surface.UVParameterAtPoint: Polygon.Points ノードの Point 出力と Surface.ByPatch ノードの Surface 出力を接続して、各点で UV パラメータを返します。
これで、基準となるサーフェスと UV 座標のセットが作成されました。次に、目的のサーフェスを読み込み、2 つのサーフェス間で点をマッピングします。
File Path: 読み込むサーフェスのファイル パスを選択します。ファイル タイプは .sat にしてください。[参照...]ボタンをクリックして、上でダウンロードした .zip ファイルの UVmapping_srf.sat にナビゲートします。
Geometry.ImportFromSAT: ファイル パスを接続して、サーフェスを読み込みます。読み込んだサーフェスがジオメトリのプレビューに表示されます。
UV: UV パラメータ出力を UV.U ノードと UV.V ノードに接続します。
Surface.PointAtParameter: 読み込んだサーフェス、U 座標、V 座標を接続します。これで、目的のサーフェス上に 3D の点のグリッドが表示されます。
最後に、3D の点を使用して長方形のサーフェス パッチを作成します。
PolyCurve.ByPoints: サーフェス上の点群を接続し、その点群からポリカーブを作成します。
Boolean: Boolean ノードをワークスペースに追加して connectLastToFirst 入力に接続し、値を True に切り替えてポリカーブを閉じます。これで、サーフェスに長方形がマッピングされて表示されます。
Surface.ByPatch: ポリカーブを closedCurve 入力に接続し、サーフェス パッチを作成します。
次に、ノードの入力と出力を考慮しながら、カスタム ノード内にネストするノードを選択します。長方形以外の任意のポリゴンをマッピングできるように、カスタム ノードの柔軟性を可能な限り高めてみましょう。
次のノード(Polygon.Points から始まる)を選択し、ワークスペースを右クリックして[カスタム ノードを作成]を選択します。
[カスタム ノード プロパティ]ダイアログボックスで、カスタム ノードに名前、説明、カテゴリを割り当てます。
名前: MapPolygonsToSurface
説明: 基準点からターゲット サーフェスにポリゴンをマッピングします
アドオン カテゴリ: Geometry.Curve
カスタム ノードにより、ワークスペースが見やすくなりました。入力と出力には、元のノードに基づいて名前が付いています。カスタム ノードを編集して、これらの名前をもっとわかりやすい名前に変更しましょう。
編集するカスタム ノードをダブルクリックします。ワークスペースの背景色が黄色で表示されます。これは、カスタム ノードの内部を表しています。
各 Input ノードの入力名を baseSurface と targetSurface に変更します。
マッピングするポリゴン用に Output ノードを追加します。
カスタム ノードを保存し、ホーム ワークスペースに戻ります。MapPolygonsToSurface ノードに変更内容が反映されます。
カスタム コメントを追加して、カスタム ノードの内容をさらにわかりやすくすることもできます。コメントを入力すると、入力タイプと出力タイプの内容だけでなく、ノードの機能を説明することができます。カスタム ノードの入力や出力にカーソルを置くと、コメントが表示されます。
編集するカスタム ノードをダブルクリックします。背景が黄色のワークスペースがもう一度表示されます。
Input の Code Block ノードの編集を開始します。コメントを入力する場合は、最初に「//」を入力してから、コメント テキストを入力します。ノードの内容を説明するためのコメントを入力してください。ここでは、targetSurface ノードの説明を入力します。
特定の値に一致する入力タイプを設定して、inputSurface ノードの既定値を設定します。ここでは、既定値を元の Surface.ByPatch のセットに設定します。
コメントは、Output に適用することもできます。
Output の Code Block ノードのテキストを編集します。「//」の後ろにコメント テキストを入力します。ここでは、Polygons と surfacePatches の Output の詳細な説明を追加します。
カスタム ノード入力にカーソルを置いてコメントを表示します。
inputSurface ノードの既定値が設定されているため、Surface 入力を使用することなく定義を実行することができます。
Dynamo には豊富な機能が用意されており、Dynamo の機能を大幅に拡張できる広範なパッケージ ライブラリも保持されています。パッケージは、カスタム ノードまたは追加機能のコレクションです。Dynamo Package Manager は、オンラインでパブリッシュされたパッケージをダウンロードするためのコミュニティ ポータルです。これらのツールセットは、Dynamo の基本機能を拡張するためにサード パーティによって開発されたもので、すべてのユーザがアクセスでき、ボタンをクリックするだけでダウンロードすることができます。
Dynamo のようなオープンソース プロジェクトは、このようなコミュニティによって成長しています。サード パーティの専任開発者の取り組みにより、Dynamo はさまざまな業界のワークフローで採用されています。そのため、Dynamo チームは、パッケージの開発とパブリッシュの合理化を連携して進めています。これについては、以降のセクションで詳しく説明します。
パッケージを最も簡単にインストールするには、Dynamo インタフェースの[パッケージ]メニュー オプションを使用します。では、実際にパッケージをインストールしてみましょう。ここでは、次に示す簡単な例を使用して、グリッド上に四角いパネルを作成するためのパッケージをインストールします。
Dynamo で、[パッケージ] > [Package Manager...] に移動します。
[検索]バーで、「quads from rectangular grid」を検索してみましょう。しばらくすると、この検索クエリーに一致するパッケージがすべて表示されます。一致する名前を持つ最初のパッケージを選択します。
[インストール]をクリックしてこのパッケージをライブラリに追加し、確認を承諾します。以上です。
Dynamo ライブラリに「buildz」という名前の新しいグループが表示されます。この名前は、パッケージの開発者を参照して付けられます。また、カスタム ノードはこのグループ内に配置されます。このグループは、すぐに使用することができます。
Code Block ノードを使用して長方形のグリッドをすばやく定義し、その結果を Polygon.ByPoints ノードに、続いて Surface.ByPatch ノードに出力して、作成した長方形のパネルのリストを表示します。
上記の例では、1 つのカスタム ノードが含まれているパッケージを使用しましたが、複数のカスタム ノードやサポート データ ファイルが含まれているパッケージをダウンロードする場合も、同じプロセスを実行します。ここでは、より包括的な Dynamo Unfold パッケージを使用して手順を説明します。
上記の例と同様に、[パッケージ] > [Package Manager...] を選択します。
今回は、「DynamoUnfold」 という、スペースを入れない 1 つの単語を検索します。パッケージが表示されたら、[インストール]をクリックして Dynamo Unfold をダウンロードし、Dynamo ライブラリに追加します。
Dynamo ライブラリに DynamoUnfold グループが表示されます。このグループに、複数のカテゴリとカスタム ノードが含まれているのがわかります。
ここで、パッケージのファイル構造を確認しましょう。
まず、[パッケージ] > [Package Manager] > [インストール済みパッケージ]に移動します。
次に、[ルート フォルダを表示]をクリックして、このパッケージのルート フォルダを開きます。
この操作により、パッケージのルート フォルダが表示されます。このルート フォルダには、3 つのフォルダと 1 つのファイルが格納されています。
bin フォルダには .dll ファイルが格納されます。この Dynamo パッケージは Zero-Touch を使用して開発されているため、カスタム ノードはこのフォルダに格納されます。
dyf フォルダにはカスタム ノードが格納されます。このパッケージは Dynamo カスタム ノードを使用して開発されたものではないため、このフォルダには格納されません。
extra フォルダには、サンプル ファイルを含め、すべての追加ファイルが格納されます。
pkg ファイルは、パッケージの設定を定義する基本のテキスト ファイルです。ここでは、このファイルは無視してかまいません。
extra フォルダを開くと、インストール時にダウンロードされた多数のサンプル ファイルが格納されていることがわかります。すべてのパッケージにサンプル ファイルが付属しているわけではありませんが、付属のサンプル ファイルはこのフォルダに格納されています。
ここで、SphereUnfold ファイルを開いてみましょう。
ファイルを開いてからソルバで[実行]をクリックすると、展開された球形が表示されます。これらのサンプル ファイルは、新しい Dynamo パッケージの使用方法を理解するのに役立ちます。
Package Manager では、[パッケージの検索]タブで並べ替えとフィルタ オプションを使用してパッケージを参照できます。ホスト プログラム、ステータス(新規、非推奨、非推奨解除)、およびパッケージに依存関係があるかどうかを示すフィルタがいくつかあります。
パッケージを並べ替えることで、評価の高いパッケージや最もダウンロードされているパッケージを特定したり、最新の更新プログラムが適用されたパッケージを検索することができます。
[詳細を表示]をクリックして、各パッケージの詳細にアクセスすることもできます。これにより、Package Manager のサイド パネルが開き、バージョン情報や依存関係、Web サイトまたはリポジトリの URL、ライセンス情報などの情報を検索できます。
パッケージ ファイルの保存場所を確認する場合は、一番上のナビゲーションで[Dynamo] > [基本設定] > [パッケージ設定] > [ノードとパッケージ ファイルの場所]をクリックします。ここから現在のルート フォルダを見つけることができます。
既定では、パッケージは C:/Users/[ユーザ名]/AppData/Roaming/Dynamo/[Dynamo バージョン] というフォルダ パスにインストールされます。
Dynamo コミュニティは、常に成長と進化を続けています。Dynamo Package Manager を定期的に確認して、便利な新機能を発見してください。これ以降のセクションでは、エンドユーザの視点から見た独自の Dynamo パッケージの作成など、パッケージについてより詳しく確認していきます。
次の演習では、Mesh Toolkit を使用して、いくつかの基本的なメッシュ操作を説明します。この演習では、メッシュを一連の平面と交差させます。この操作でメッシュではなくソリッドを使用すると、計算量が多くなります。ソリッドとは異なり、メッシュには「解像度」の集合があります。現在の作業に応じて、この解像度を定義することができます。メッシュは、数学的にではなく位相幾何学的に定義されています。メッシュとソリッドとの関係について詳しくは、この手引の「」の章を参照してください。Mesh Toolkit の詳細な説明については、を参照してください。次の演習で、パッケージの内容を確認してみましょう。
最初に、カスタム ノード内にネストするグラフを作成します。この例では、UV 座標を使用して、基準となるサーフェスから目的のサーフェスにポリゴンをマッピングするグラフを作成します。この UV マッピング プロセスは頻繁に使用するプロセスであるため、カスタム ノードの演習素材として適しています。サーフェスと UV 空間の詳細については、「」ページを参照してください。完全なグラフは、上記でダウンロードした .zip ファイルの UVmapping_Custom-Node.dyn になります。
DynamoUnfold の横にあるオプション メニュー を選択します。
Dynamo パッケージの仕組みを理解する別の方法として、 の Web サイトを参照する方法もあります。ここでは、パッケージや作成者のリーダーボードに関する統計情報を確認できます。また、Dynamo Package Manager からパッケージ ファイルをダウンロードすることもできますが、Dynamo から直接ダウンロードした方が簡単です。
Dynamo を Revit に組み込んで使用すると、Revit のビルディング インフォメーション モデリング(BIM)機能を、データとロジックに基づく Dynamo の視覚的なアルゴリズム編集環境によって拡張することができます。Dynamo の柔軟性を Revit の堅牢なデータベース機能と組み合わせることにより、BIM の新しい可能性が広がります。
この章では、Dynamo を使用した BIM ワークフローについて説明します。この章の各セクションでは、演習を行いながら BIM を確認していきます。BIM の視覚的なアルゴリズム編集機能の仕組みを理解するには、サンプルのプロジェクトで実際に操作するのが最適な方法です。ただしその前に、Dynamo の歴史を簡単に説明します。
Revit と Dynamo はどちらも進化し続けているため、作業中の Revit のバージョンが、マシンにインストールされている Revit 用の Dynamo のバージョンと互換性がない場合があります。次の一覧は Revit と互換性のある Revit 用の Dynamo のバージョンの概要です。
2013
2014
2015
2016
2017
2018
2019
2020
2.1.0 - Revit 2020 以降では Dynamo が含まれるようになりました。Revit の更新がすぐに反映されます。
(動作なし)
Dynamo プロジェクトは、開発チームとコミュニティの積極的なサポートによってここまで発展しましたが、最初の目標は小さなものでした。
Dynamo は、もともと Revit の設計ワークフローを合理化するために開発されました。Revit では、プロジェクトごとに堅牢なデータベースが作成されますが、ユーザ インタフェースの制約を受けることなくこの情報にアクセスすることは、一般的なユーザにとっては難しい場合があります。Revit には包括的な API (アプリケーション プログラム インタフェース)が用意されているため、サードパーティの開発者はこれらの API を使用して、カスタマイズされたツールを作成することができます。プログラマーであればこの API には慣れていますが、プログラミングの経験がないユーザとっては、テキストベースのスクリプトを記述することは簡単なことではありません。Dynamo の開発チームは、わかりやすい視覚的なアルゴリズム エディタを提供することにより、Revit のデータを簡単に操作できるようにすることを目指しています。
カスタマイズされた Revit と Dynamo の主要なノードを組み合わせて使用すると、相互運用性、設計図書作成、解析、モデル生成などにおいて、パラメータ制御によるワークフローの範囲を大きく広げることができます。Dynamo を使用すれば、面倒なワークフロー作業を自動化し、設計作業に集中することができます。
Revit プロジェクトやファミリ エディタで、[アドイン]タブから[Dynamo]をクリックします。*
*Dynamo は、Dynamo を起動したファイル内でのみ実行されることに注意してください。
Revit で Dynamo を起動すると、Dynamo のライブラリ内に[Revit]という新しいカテゴリが表示されます。この新しいカテゴリから、Revit ワークフロー専用のノードにアクセスすることができます。
*Revit 固有のファミリを扱うノードを使用する場合、Dynamo グラフは Revit 用の Dynamo から開いたときにのみ正常に動作します。たとえば、Revit 用の Dynamo のグラフを Dynamo Sandbox で開くと、Revit ノードが失われます。
Revit は堅牢なプロジェクト管理を提供するプラットフォームであるため、場合によっては Dynamo のパラメータ操作が複雑になり、計算速度が低下することがあります。Dynamo によるノード計算で時間がかかる場合は、ノードを「フリーズ」する機能を使用して、グラフの開発中に Revit 関連操作の実行を停止することができます。
ノードのフリーズの詳細については、「ノードとワイヤ」セクションを参照してください。
Dynamo は、もともと建築設計者や構造設計者向けに開発されたツールです。Dynamo のコミュニティは、建設業界の専門家と交流しながら学ぶことができる場所として、現在も成長を続けています。Dynamo のコミュニティは、情報の共有と開発プロジェクトに積極的に参加する建築設計者、構造設計者、プログラマ、デザイナーによって構成されています。
Dynamo は、継続的に進化していくオープンソース プロジェクトであり、その開発の大部分は Revit に関係しています。ディスカッション フォーラムにアクセスし、質問を投稿してみてください。プログラマとして Dynamo プロジェクトに参加する場合は、GitHub リポジトリを参照してください。また、Dynamo package manager では、さまざまなサードパーティ製ライブラリが提供されています。提供されているパッケージの多くは、建設業界のワークフローで使用することを目的として作成されています。実際に、パネル作成用のサードパーティ製パッケージを使用してみましょう。
Dynamo 開発チームは、ブログを頻繁に更新しています。最近の記事を確認し、最新の開発情報を入手してください。
Dynamo は、さまざまなプログラムで活用できるように設計された柔軟なプログラミング環境ですが、もともとは Revit と組み合わせて使用するために開発されました。ビジュアル プログラミングにより、ビルディング インフォメーション モデリング(BIM)の堅牢な設計案を作成することができます。Dynamo には、Revit 専用に設計されたさまざまなノードが用意されています。さらに建設業者のコミュニティでも、各種のサードパーティ製ライブラリが開発されています。この章では、Dynamo を Revit に組み込んで使用する際の基本的な操作方法について説明します。
Revit は、非常に豊富なデータを扱う環境です。このため、選択機能が「ポイント アンド クリック」をはるかに超えた範囲にまで拡張されています。パラメトリックな操作の実行中に、Revit のデータベースにクエリーを行い、Revit の要素を Dynamo のジオメトリに動的にリンクすることができます。
[Revit]ライブラリの[Selection]カテゴリから、さまざまな方法でジオメトリを選択できます。
Revit の要素を選択するには、Revit の要素の階層構造について十分に理解しておくことが大切です。プロジェクト内のすべての壁を選択するには、カテゴリ単位で選択します。ミッドセンチュリー モダン スタイルのロビーに配置したイームズ チェアをすべて選択するには、ファミリ単位で選択します。
Revit の階層を簡単に確認してみましょう。
生物学ではあらゆる生物が体系的に分類されており、その分類法は、上位から下位にかけて、界、門、網、目、科、属、種という階層構造から成り立っています。Revit における要素の分類法はこれに似ています。基本的には、Revit の階層構造は、上位から下位にかけて、カテゴリ、ファミリ、タイプ、インスタンスに分かれています。インスタンスは(ユニークな ID を持つ)個別のモデル要素です。カテゴリは、「壁」や「床」などの一般的なグループのことです。このようにして構成されている Revit のデータベースを使用して、1 つの要素を選択したり、階層構造の中の指定したレベルに基づいて同種の要素をすべて選択することができます。
*Revit における「タイプ」の定義は、プログラミングでいう「型」とは異なります。Revit でいう「タイプ」は、いわゆる「データ型」の「型」ではなく、分類階層における 1 つの枝を指します。
次の 3 つの画像では、Revit の要素を Dynamo で 選択するいくつかの主だった方法を紹介しています。これらのツールを組み合わせて使用すると便利です。その一部をこれ以降の演習で実際に使用してみましょう。
ポイント アンド クリック は、Revit の要素を直接選択する最も簡単な方法です。モデル要素全体であれ、そのトポロジの一部(たとえば 1 つの面や 1 つのエッジ)であれ、選択することができます。この方法では Revit オブジェクトへの動的なリンクが維持されるため、Revit ファイルの場所やパラメータが変更されると、グラフ内で参照されている Dynamo の要素が更新されます。
ドロップダウン メニュー で、Revit プロジェクト内のアクセス可能なすべての要素のリストが作成されます。ビューで確認できない Revit の要素も含めて、これで参照できます。Revit プロジェクトやファミリ エディタで既存の要素をクエリーしたり、新しい要素を作成するには、このツールが役に立ちます。
![](../.gitbook/assets/selecting _database_navigation_with_dynamo_nodes_02.png)
Revit の要素の選択方法としては、他に Revit の階層構造 から特定の階層を指定する方法もあります。この方法は、設計図書作成、インスタンスの生成とカスタマイズなどのために準備されている大規模なデータ配列をカスタマイズするのにとても役立ちます。
上記の 3 点の画像に留意して、この章の続きで説明するパラメトリック アプリケーションの作成に備えて、基本的な Revit プロジェクトから要素を選択する演習を開始しましょう。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この Revit ファイルのサンプルには、3 つの要素タイプから成る 1 つの単純な建物モデルが含まれています。それでは、このモデルを見本として使用して、次に挙げる Revit の階層構造の中で Revit の要素を選択してみましょう。
建物のマス(基本形状)
梁(構造フレーム)
トラス(アダプティブ コンポーネント)
Revit のプロジェクト ビューに表示されている要素から、どのような結論を導き出すことができますか。また、適切な要素を選択するには、階層をいくつ降りていく必要があるでしょうか。言うまでもありませんが、大規模なプロジェクトで作業する際にはこの問題はもっと複雑になります。使用できるオプションはたくさんあり、カテゴリ別、レベル別、ファミリ別、インスタンス別に要素を選択することができます。
ここでは基本的な構造を扱っているので、Categories ドロップダウン ノードで[Mass]を選択して、建物のマスを選択してみましょう。これは、[Revit] > [Selection]タブにあります。
[Mass]カテゴリのノードでは、単純にカテゴリ自体が出力されるので、要素を選択する必要があります。これを実行するには、All Elements of Category ノードを使用します。
この時点では、Dynamo にジオメトリが何も表示されません。Revit の要素が既に選択されていますが、まだ Dynamo ジオメトリに変換されてはいません。この区別は重要です。多数の要素を選択する場合は、すべての動作が非常に遅くなるおそれがあるため、すべての要素を Dynamo でプレビューすることは好ましくありません。Dynamo は、ジオメトリ操作の実行を必要とせずに Revit のプロジェクトを管理することのできるツールです。そのことについては、この章の次のセクションで説明します。
ここでは単純なジオメトリを使用して演習を行っているので、Dynamo のプレビューでジオメトリを表示できるようにします。上記の Watch ノード中の「BldgMass」の隣に、緑の背景色付きで数値が表示されています。これは要素の ID を表しており、この ID からユーザが Dynamo ジオメトリではなく Revit 要素を扱っていることがわかります。次の手順で、この Revit 要素を Dynamo ジオメトリに変換してみましょう。
Element.Faces ノードを使用して、Revit のマスの各面を表すサーフェスのリストを取得します。これで、Dynamo のビューポートでジオメトリを表示し、その面をパラメトリック操作の際に参照できるようになりました。
別の方法を紹介します。この場合は、(All Elements of Category ノードを使用して) Revit の階層から選択を行い、Revit のジオメトリを指定して明示的に選択するという方法を採りません。
Select Model Element ノードを使用して、[選択] (または [変更] )ボタンをクリックします。Revit のビューポートで、目的の要素を選択します。この場合は、建物のマスを選択することにします。
Element.Faces ノードではなく Element.Geometry ノードを使用すると、マス全体を 1 つのソリッド ジオメトリとして選択できます。このノードでは、そのマスの内部に含まれるすべてのジオメトリが選択されます。
Geometry.Explode ノードを使用した場合も、サーフェスのリストを取得できます。これら 2 つのノードは、Element.Faces と同様の機能に加えて、Revit 要素のジオメトリを掘り下げるのに役立つオプションを提供します。
リストの基本的操作をいくつか行うことで、対象の面のクエリーを実行できます。
最初に、選択した要素を前のノードから Element.Faces ノードに出力します。
次に List.Count ノードを使用して、作業中のマスに 23 のサーフェスが含まれていることを確認します。
この数値を基準として、Integer Slider ノードの最大値を 「22」 に変更します。
List.GetItemAtIndex ノードを使用して、list と index に入力します(index には Integer Slider ノードを使用)。選択したスライダを index 9 まで動かして、トラスをホストしているメイン ファサードが選択表示された段階で停止します。
前の手順は少し面倒でした。Select Face ノードを使用すると、同じことをもっとすばやく実行できます。この方法では、Revit プロジェクト内ではそれ自体で 1 つの要素として扱われない面も選択できます。Select Model Element でも同様の操作を行うことができます。ただし、こちらでは要素全体ではなくサーフェスを選択します。
建物のメイン ファサードの壁を選択してみましょう。Select Faces ノードを使用してこれを行うことができます。[選択]ボタンをクリックし、Revit で 4 つのメイン ファサードを選択します。
4 つの壁面を選択した後で、必ず Revit で[終了]ボタンをクリックしてください。
これで、面が Dynamo にサーフェスとして読み込まれました。
さて、アトリウムの上の梁を見てみましょう。
Select Model Element ノードを使用して、梁のうち 1 つを選択します。
梁の要素を Element.Geometry ノードに接続すると、Dynamo のビューポートで梁が表示されるようになります。
Watch 3D ノードを使用してジオメトリを拡大表示することができます(Watch 3D で梁が表示されない場合は、右クリックしてから[全体表示]を選択します)。
Revit と Dynamo の使用中にしばしば生じる疑問として、1 つの要素を選択して、それに類似するすべての要素を取得するにはどうすればいいのか、というものがあります。選択した Revit 要素にはその要素の階層に関する情報がすべて含まれているので、そのファミリ タイプをクエリーして、同じタイプの要素をすべて選択することができます。
梁の要素を Element.ElementType ノードに接続します。
Watch ノードで、出力が Revit 要素ではなくファミリ記号になっていることが確認できます。
Element.ElementType は単純なクエリーであるため、コード ブロック内で
x.ElementType;
と入力するだけで同様の結果を得ることができます。
残りの梁を選択するには、All Elements of Family Type ノードを使用します。
Watch ノードで、5 つの Revit 要素が選択されていることを確認します。
これら 5 つの要素すべてを Dynamo のジオメトリに変換することもできます。
しかし、500 本の梁を変換しなければならないとしたら、どうでしょうか。すべての要素を Dynamo ジオメトリに変換するにはたいへんな時間がかかるでしょう。Dynamo によるノード計算で時間がかかる場合は、ノードを「フリーズ」する機能を使用して、グラフの開発中に Revit 関連操作の実行を停止することができます。ノードをフリーズする操作の詳細については、「ソリッド」の章の「フリーズ」セクションを参照してください。
いずれにせよ、500 本の梁を読み込まなければならない場合、目的のパラメータ操作を実行するのにすべてのサーフェスは必要でしょうか。それとも、梁から基本情報を抽出して、基本的なジオメトリを使用して生成タスクを実行すればよいでしょうか。この問いを念頭に置きながら、この章での演習を進めていくことにしましょう。たとえば、次はトラス システムについて考えてみましょう。
同じノードのグラフを使用して、梁要素ではなくトラス要素を選択します。この操作を行う前に、ここまでの手順で使用した Element.Geometry を削除してください。
次に、トラスのファミリ タイプから基本的な情報を抽出する準備を行います。
Watch ノードで、Revit から選択されたアダプティブ コンポーネントのリストを取得していることを確認できます。基本情報を抽出するために、まずはアダプティブ点からとりかかります。
All Elements of Family Type ノードを AdaptiveComponent.Location ノードに接続します。これによってリストのリストが 1 つ作成されます。各リストは、アダプティブ点の場所を表す 3 つの点から構成されています。
Polygon.ByPoints ノードを接続すると、ポリカーブが返されます。これは Dynamo のビューポートで確認できます。この方法により、1 つの要素のジオメトリを表示し、残りの要素配列のジオメトリを抽出しました(なお、ここで扱った例よりも多くの要素を抽出することが可能です)。
ヒント: Dynamo で、Revit 要素の緑の背景色付きで表示されている数字をクリックすると、Revit のビューポートでその要素が拡大表示されます。
前のセクションでは、カスタム ノードとサンプル ファイルを使用して MapToSurface パッケージを設定する方法について確認しました。では、ローカルで作成したパッケージはどのようにパブリッシュすればよいでしょうか。このケース スタディでは、ローカル フォルダ内のファイル セットを使用してパッケージをパブリッシュする方法について確認します。
パッケージは、さまざまな方法でパブリッシュできます。ここでは、パッケージをローカルにパブリッシュして作成し、オンラインでパブリッシュする方法を確認していきます。最初に、パッケージ内のすべてのファイルを格納するフォルダを作成します。
前の演習で MapToSurface パッケージをインストールした場合は、同じパッケージを使用しないようにするため、このパッケージをアンインストールしてください。
まず、[パッケージ] > [Package Manager] > [インストール済みパッケージ]タブ > [MapToSurface]の横にある縦のドット メニュー> [削除]をクリックします。
次に、Dynamo を再起動します。[パッケージを管理]ウィンドウをもう一度開いて、MapToSurface が表示されていないことを確認してください。これで、作業を開始する準備ができました。
ホスト API の依存関係がない限り、バージョン 2.17 以降で Dynamo Sandbox からカスタム ノードとパッケージをパブリッシュすることができます。旧バージョンでは、カスタム ノードとパッケージのパブリッシュは、Dynamo for Revit と Dynamo for Civil 3D でのみ有効です。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習で、パッケージを初めて送信することになります。サンプル ファイルとカスタム ノードは、すべて 1 つのフォルダ内に格納されています。このフォルダが作成されていれば、Dynamo Package Manager にパッケージをアップロードすることができます。
このフォルダには、5 つのカスタム ノード(.dyf)が格納されています。
このフォルダには、5 つのサンプル ファイル(.dyn)と、1 つの読み込み済みベクトル ファイル(.svg)も格納されています。これらのファイルは、カスタム ノードの使用方法を理解するための演習用のファイルです。
Dynamo で、[パッケージ] > [Package Manager] > [新しいパッケージをパブリッシュ] タブをクリックします。
[パッケージをパブリッシュ] タブで、ウィンドウの左側にある関連フィールドに入力します。
次に、パッケージ ファイルを追加します。[フォルダを追加(1)]を選択すると、1 つまたはすべてのフォルダにファイルを追加できます。.dyf ファイル以外のファイルを追加するには、ブラウザ ウィンドウでファイル タイプを必ず [すべてのファイル(.)] に変更してください。カスタム ノード(.dyf)やサンプル ファイル(.dyn)など、すべてのファイルが追加されていることを確認してください。パッケージをパブリッシュすると、Dynamo によってこれらのファイルが分類されます。
MapToSurface フォルダを選択すると、フォルダの内容が Package Manager に表示されます。複雑なフォルダ構造を持つ独自のパッケージをアップロードする場合に、Dynamo でフォルダ構造を変更したくない場合は、[フォルダ構造を保持]切り替えを有効にします。このオプションは上級者向けのため、パッケージが意図的に特定の方法で設定されているのでなければ、この切り替えをオフのままにして、必要に応じて Dynamo でファイルを整理できるようにしておくことをお勧めします。[次へ]をクリックして続行します。
ここでは、パブリッシュする前に Dynamo がパッケージ ファイルを整理する方法をプレビューすることができます。[完了]をクリックして続行します。
[ローカルにパブリッシュ] (1)をクリックして、パッケージをパブリッシュします。次に、[オンラインでパブリッシュ]ではなく[ローカルにパブリッシュ]をクリックします。これは、多数の複製パッケージを Package Manager にパブリッシュしないようにするためです。
パブリッシュが完了すると、DynamoPrimer グループまたは Dynamo ライブラリで目的のカスタム ノードを使用できるようになります。
次に、ルート フォルダを開き、作成したパッケージが Dynamo でどのようにフォーマットされているかを確認します。これを行うには、[インストール済みパッケージ]タブ > [MapToSurface]の横にある縦のドット メニューをクリックし、[ルート フォルダを表示]を選択します。
ルート フォルダは、パッケージのローカルの場所にあります(ここまでの手順で、パッケージはローカルにパブリッシュされています)。Dynamo は、このフォルダを参照してカスタム ノードを読み込みます。そのため、デスクトップではなく、ローカルの永続的な場所にパブリッシュする必要があります。Dynamo パッケージ フォルダの内容は次のとおりです。
bin フォルダには、C# ライブラリまたは Zero-Touch ライブラリを使用して作成された .dll ファイルが格納されます。このパッケージにはこうしたファイルがないため、このフォルダは空になっています。
dyf フォルダにはカスタム ノードが格納されます。このフォルダを開くと、このパッケージのすべてのカスタム ノード(.dyf ファイル)が表示されます。
extra フォルダには、すべての追加ファイルが格納されます。通常、これらのファイルは、Dynamo ファイル(.dyn)または必須の追加ファイル(.svg、.xls、.jpeg、.sat など)です。
pkg ファイルは、パッケージの設定を定義する基本のテキスト ファイルです。このファイルは Dynamo によって自動的に作成されますが、必要な場合は編集することができます。
注: 独自のパッケージを実際にパブリッシュしない場合は、この手順を実行しないでください。
パブリッシュの準備ができたら、[パッケージ] > [Package Manager] > [インストール済みパッケージ]ウィンドウで、パブリッシュするパッケージの右側にあるボタンを選択し、[パブリッシュ]を選択します。
既にパブリッシュされているパッケージを更新する場合、[パブリッシュ バージョン]を選択すると、パッケージのルート フォルダ内の新しいファイルに基づいて、パッケージがオンラインで更新されます。
パブリッシュしたパッケージのルート フォルダ内にあるファイルを更新した場合、[マイ パッケージ]タブで[パブリッシュ バージョン...]を選択して、新しいバージョンのパッケージをパブリッシュすることもできます。この方法により、シームレスにコンテンツを更新してコミュニティ間で共有することできます。[パブリッシュ バージョン]オプションは、ユーザがパッケージを保守している場合にのみ機能します。
ここまで、基本的な建物のマスを編集する方法について紹介してきました。ここからは、多数の要素を一度に編集することで Dynamo と Revit のリンクについてより深く掘り下げていきましょう。カスタマイズする対象の規模が拡大すると、リストのデータ構造においてより高度な操作が要求されるので、カスタマイズの操作がより複雑になります。ただし、それを実行する背景で駆動している原理原則は、根本的にはこれまでと変わりありません。検討のために、アダプティブ コンポーネントのセットからいくつかの事例を取り上げてみましよう。
アダプティブ コンポーネントを既に作成したという前提で、これからその点群の位置に基づいてパラメータを編集していくことにします。点群により、たとえば、要素の領域にかかわる厚みのパラメータをコントロールすることができます。また、太陽光の年間露光量にかかわる透過性のパラメータをコントロールすることもできます。Dynamo では、少ない手順で簡単に解析結果をパラメータに渡すことができます。次の演習でその基本的な手順を実践してみましょう。
AdaptiveComponent.Locations ノードを使用して、選択したアダプティブ コンポーネントのアダプティブ点のクエリーを実行します。これにより、Revit の要素を解析用に抽出したバージョンを使用して作業することができます。
アダプティブ コンポーネントを構成する点の位置を抽出することで、その要素に関するさまざまな解析を行うことができます。4 点構成のアダプティブ コンポーネントにより、たとえば指定したパネルにおける水平面からの偏差を検討することができます。
再マッピング機能を使用すると、一連のデータ セットを一定のパラメータ範囲にマッピングすることができます。これはパラメトリック モデリングで使用する基本的なツールです。これ以降の演習で実際に扱ってみることにします。
Dynamo を使用すると、アダプティブ コンポーネントを構成する点群の位置から、要素ごとに最も適した平面を作成することができます。さらに Revit ファイル内の太陽の位置を参照して、太陽に対するその平面の向きを、他のアダプティブ コンポーネントと比較しながら検討することもできます。これ以降の演習で、アルゴリズムに基づいて屋根の形状を生成することで、その設定を行っていきましょう。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この演習では、前のセクションで紹介したテクニックについて詳しく説明します。このケースでは、Revit の要素からパラメトリック サーフェスを設定して、4 点構成のアダプティブ コンポーネントをインスタンス化し、太陽に対する向きに基づいて編集します。
まず、Select Edge ノードを使用して 2 本のエッジを選択します。2 本のエッジはアトリウムの長辺です。
List.Create ノードを使用して、2 本のエッジを組み合わせて 1 つのリストを作成します。
Surface.ByLoft ノードを使用して、2 本のエッジの間に 1 つのサーフェスを作成します。
Code Block ノードを使用して、0 から 1 までの範囲を 10 等分した値
0..1..#10;
に指定します。Code Block ノードから Surface.PointAtParameter ノードの *u * 入力と v 入力に接続し、Surface.ByLoft ノードを surface 入力に接続します。ノードを右クリックして、レーシング を[直積]に変更します。これで、サーフェス上の点群から構成されるグリッドを取得できるようになります。
この点群によるグリッドは、パラメータに基づいて設定されたサーフェスの制御点として機能します。これら各点の位置を u と v の値として抽出することで、その値をパラメータの式に代入し、同一のデータ構造を保持できます。これを行うには、先ほど作成した点群の位置のパラメータをクエリーする必要があります。
Surface.ParameterAtPoint ノードをキャンバスに追加し、その入力を上図のように接続します。
UV.U ノードを使用して、上記のパラメータの u の値をクエリーします。
UV.V ノードを使用して、上記のパラメータの v の値をクエリーします。
サーフェス上のすべての点に対応する u と v の値が出力されます。これで、適切なデータ構造で 0 から 1 までの範囲で各値を取得したので、パラメトリック アルゴリズムを適用する準備ができました。
キャンバスに Code Block ノードを追加して、次のコードを入力します。
Math.Sin(u*180)*Math.Sin(v*180)*w;
これは、平坦なサーフェスから正弦波状の隆起を作成するパラメトリック関数です。UV.U を u 入力に、UV.V を v 入力に接続します。
w 入力は形状の 振幅 を表します。そのため、ここには Number Slider を接続します。
ここまでの手順で、アルゴリズムによって定義された値のリストを取得することができました。この値のリストを使用して、点群を Z の正の向きに動かしましょう。Geometry.Translate を使用して、Code Block ノードを zTranslation 入力に、Surface.PointAtParameter ノードを geometry 入力に接続します。Dynamo のプレビューに新しい点群が表示されるはずです。
最後に、前の手順から NurbsSurface.ByPoints ノードの points 入力に接続することで、サーフェスを作成します。こうしてパラメトリック サーフェスができあがりました。スライダを自由に動かして、隆起面が上下するのを確認してください。
パラメトリック サーフェスを使用して、その曲面を多数の小さなパネルから成る構造に変換する方法を設定し、4 点構成のアダプティブ コンポーネントを配列していきましょう。Dynamo で提供されている既定のノードには、サーフェスを多面構造に変換する機能をもつものはありません。そこで、コミュニティにアクセスして便利な Dynamo パッケージを入手しましょう。
[パッケージ] > [パッケージの検索] に進みます。
「LunchBox」のキーワードで検索し、「LunchBox for Dynamo」をインストールします。このパッケージは、この種のジオメトリ操作にじつに役に立つツール セットです。
ダウンロードすると、LunchBox スイートに完全にアクセスできるようになります。「Quad Grid」を検索し、LunchBox Quad Grid By Face ノードを選択します。このノードの surface 入力にパラメトリック サーフェスを接続し、U 区分と V 区分を 15 に設定します。複数の長方形のパネルから成るサーフェスが Dynamo のプレビューに表示されます。
構成の詳細については、Lunch Box ノードをダブルクリックして確認してください。
Revit に戻って、ここで使用しているアダプティブ コンポーネントを簡単に確認しておきましょう。必ずしも実際に確認する必要はありませんが、いずれにせよこれからインスタンス化する対象であるこのコンポーネントは屋根のパネルです。この 4 点構成のアダプティブ コンポーネントは、ETFE システムをおおまかに表現しています。中央の開口部は ApertureRatio というパラメータによってコントロールされています。
これから Revit 内の多数のジオメトリをインスタンス化するので、必ず事前に Dynamo のソルバを[手動]に切り替えてください。
Family Types ノードをキャンバスに追加し、[ROOF-PANEL-4PT]を選択します。
AdaptiveComponent.ByPoints ノードをキャンバスに追加し、その points 入力に LunchBox Quad Grid by Face ノードの Panel Pts 出力を接続します。familySymbol 入力に Family Types ノードを接続します。
[実行]をクリックします。Revit はジオメトリの作成中に計算に 少々時間をかける 必要があります。あまりにも時間がかかりすぎている場合、Code Block ノードの「15」の値を より小さな数に減らしてください。これを行うと、屋根の部分に使用されるパネルの数が減少します。
注: Dynamo でノードの計算に膨大な時間がかかる場合は、ノードをフリーズする機能を使用して、グラフの開発中に Revit 関連操作の実行を停止することができます。ノードをフリーズする操作の詳細については、「ソリッド」の章の「フリーズ」セクションを参照してください。
Revit に戻ると、屋根の上にバネルの配列が出現しています。
拡大表示すると、サーフェスの品質を詳細に確認できます。
前の手順からさらに先へと進み、各パネルが太陽光を浴びている量に基づいてそれぞれのパネルの開き方をコントロールしてみましょう。Revit でビューを拡大表示して 1 つのパネルを選択すると、プロパティ バーに[開口率]というパラメータが表示されます。ファミリは、開口率の範囲が 0.05 ~ 0.45 になるように設定されています。
太陽の軌道の表示をオンにすると、Revit で現在の太陽の位置を確認することができます。
SunSettings.Current ノードを使用すると、この太陽の位置を参照することができます。
そのノードの SunSettings の出力を Sunsetting.SunDirection ノードの入力に接続し、太陽光のベクトルを取得します。
アダプティブ コンポーネントの作成に使用した Panel Pts からの出力を、Plane.ByBestFitThroughPoints ノードを使用して、そのコンポーネントのために平面に近づけます。
この平面の 法線 のクエリーを実行します。
内積 を使用して太陽の向きを計算します。内積に基づいて、2 つのベクトルが平行であるかどうかを判定することができます。つまり、各アダプティブ コンポーネントの平面法線を取得し、それと太陽光のベクトルを比較することで、太陽の向きをおおまかにシミュレートします。
結果の_絶対値_を取得します。これにより、平面法線が逆方向を向いている場合に正確な内積が算出されます。
[実行]をクリックします。
内積 を確認すると、複数の数値が広範囲にわたって取得されています。これからその相対分布を使用するのですが、しかしそれらの数値を集約して[開口率]の適切な範囲に収めなければなりません。
これにたいへん役立つツールが Math.RemapRange ノードです。そのノードにリストを入力し、その分布範囲を 2 つの目標値にマッピングし直します。
目標値を Code Block ノードで 0.15 と 0.45 として定義します。
[実行]をクリックします。
マッピングし直した値を Element.SetParameterByName ノードに接続します。
そのノードの parameterName 入力に、「Aperture Ratio」という文字列を接続します。
同じノードの element 入力に、AdaptiveComponent.ByPoints ノードの Adaptive Components 出力を接続します。
[実行]をクリックします。
Revit に戻って建物のマスを遠くから見てみると、ETFE パネルの開き方が太陽の向きによって変化していることが確認できます。
拡大表示すると、太陽により向き合っているパネルほどより閉じていることがわかります。太陽光の照射による過熱を抑えることがねらいです。太陽光をたくさん浴びている面ほどより多く採光するように設定するには、ただ Math.RemapRange ノードで範囲を逆に切り替えるだけで済みます。
Dynamo では、完全なパラメトリック コントロールを使用して Revit 要素の配列を作成できます。Dynamo の Revit ノードは、一般的なジオメトリから特定のカテゴリ タイプ(壁、床など)まで、さまざまな要素を読み込む機能を提供します。このセクションでは、パラメータを使用してアダプティブ コンポーネントを含む柔軟性が高い要素を読み込みます。
アダプティブ コンポーネントはオブジェクトの生成に役立つ柔軟性の高いファミリ カテゴリです。インスタンス化すると、アダプティブ点の基本的な位置でコントロールされる複雑なジオメトリ要素を作成することができます。
以下は、ファミリ エディタ上で 3 つのアダプティブ点により構成されているアダプティブ コンポーネントです。これにより生成されるトラスは、各アダプティブ点の位置によって設定されます。次の演習では、このコンポーネントを使用して、ファサード全体に一連のトラスを生成します。
アダプティブ コンポーネントは相互運用性のベスト プラクティスの好例です。基本的なアダプティブ点を設定することにより、アダプティブ コンポーネントの配列を作成できます。また、このデータを他のプログラムに転送すると、ジオメトリを単純なデータに変換できます。Excel などのプログラムに読み込んだり書き出す場合も同様です。
ファサード設計の監修者が、完全なジオメトリを詳細に解析する必要なく、トラス要素の位置を確認する必要があるとします。製造の準備段階で、コンサルタントはアダプティブ点の位置を参照することにより、Inventor などのプログラムでジオメトリを再生成できます。
次の演習のワークフローでは、このようなデータすべてにアクセスしながら、Revit 要素を作成するための設定を行います。このプロセスにより、概念化、ドキュメント作成、製造を、1 つのシームレスなワークフローに統合できます。これにより、相互運用性を実現するためのよりインテリジェントで効率的なプロセスを作成できます。
Dynamo のパラメトリック ジオメトリを Revit に読み込む別の方法として、DirectShape を使用する方法があります。つまり、DirectShape 要素と関連クラスは、外部で作成されたジオメトリ形状を Revit ドキュメントに保存する機能をサポートしています。ジオメトリには閉じたソリッドやメッシュを含めることができます。DirectShape の主な目的は、「実際」の Revit 要素を作成するための情報が不足している IFC や STEP などの他のデータ形式の形状を読み込むことにあります。DirectShape 機能は、IFC や STEP のワークフローのように、Dynamo で作成されたジオメトリを Revit プロジェクトに実際の要素として読み込むことに優れています。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
このセクションでサンプル ファイルの使用を開始した場合(または、前のセッションの Revit ファイルを継続して使用した場合)は、同じ Revit のマスが表示されます。
これはファイルを開いた状態です。
これは、Dynamo で作成したトラス システムです。高度な方法で Revit のマスにリンクされています。
これまで Select Model Element ノードと Select Face ノードを使用しました。ここでは、ジオメトリ階層の 1 段階下の層で Select Edge ノードを使用します。Dynamo ソルバを 自動 で実行するように設定すると、グラフは Revit ファイルの変更に応じて継続的に更新されます。選択したエッジは Revit 要素トポロジに動的に関連付けられます。トポロジ* が変更されない限り、Revit と Dynamo 間の接続はリンクされ続けます。
グレージング ファサードの最上部の曲線を選択します。これは建物の全体の長さに及びます。Revit でエッジを選択するには、エッジにカーソルを置いて、目的のエッジがハイライト表示されるまで [Tab] を押し続けます。
2 つの Select Edge ノードを使用して、ファサード中央の傾斜を示す各エッジを選択します。
Revit でファサードの最下部のエッジに対して同じ操作を行います。
Dynamo に線が設定されたことが Watch ノードによって示されます。エッジ自体は Revit 要素ではないため、自動的に Dynamo ジオメトリに変換されます。これらの曲線は、ファサード全体にわたるアダプティブ トラスをインスタンス化する際に使用する参照です。
*トポロジの一貫性を保持するため、面やエッジが追加されないモデルを参照しています。パラメータを使用して形状を変更することはできますが、トポロジの作成方法を変更することはできません。
まず曲線を結合して 1 つのリストに統合する必要があります。これにより、曲線を「グループ化」して、ジオメトリ操作を実行できます。
ファサードの中央にある 2 つの曲線のリストを作成します。
List.Create コンポーネントを Polycurve.ByJoinedCurves ノードに接続して、2 つの曲線を 1 つのポリカーブに結合します。
ファサードの最下部にある 2 つの曲線のリストを作成します。
List.Create コンポーネントを Polycurve.ByJoinedCurves ノードに接続して、2 つの曲線を 1 つのポリカーブに結合します。
最後に、3 つの主要な曲線(1 つの直線と 2 つのポリカーブ)を 1 つのリストに結合します。
直線になっている最上部の線を使用して、ファサードのスパン全体を表します。この線に沿って平面を作成し、リストでグループ化した曲線のセットと交差させます。
Code Block ノードで、構文
0..1..#numberOfTrusses;
を使用して範囲を設定します。Integer Slider ノードを Code Block ノードの入力に接続します。お分かりのとおり、これはトラスの数を表します。スライダは項目の数を 0 から 1 の範囲でコントロールします。
Code Block ノードを Curve.PlaneAtParameter ノードの param 入力に接続し、最上部のエッジを curve 入力に接続します。これにより、10 個の平面がファサードのスパン全体にわたって均等に配置されます。
平面はジオメトリの抽象的なピースであり、無限の 2 次元空間を表します。平面は輪郭や交差の作成に適しています。実際に行ってみましょう。
Geometry.Intersect ノード(レーシングのオプションを直積に設定)を使用して、Curve.PlaneAtParameter を Geometry.Intersect ノードの entity 入力に接続します。メインの List.Create ノードを geometry 入力に接続します。Dynamo のビューポートには、設定した平面と各曲線の交点が表示されます。
出力にはリストのリストのリストが表示されます。操作目的に対してリストの数が多すぎます。リストの一部をフラットにしましょう。リストの 1 段階下の層で結果をフラットにします。これを行うには、Dynamo Primer のリストに関する章で説明したように、List.Map 操作を使用します。
Geometry.Intersect ノードを List.Map の list 入力に接続します。
Flatten ノードを List.Map ノードの f(x) 入力に接続します。この結果、リストは 3 個になり、各リストにはトラスと同じ数の項目が含まれます。
このデータは変更する必要があります。トラスをインスタンス化する場合は、ファミリで設定されているアダプティブ点と同じ数を使用する必要があります。これは 3 つの点で構成されているアダプティブ コンポーネントです。このため、それぞれ 10 個の項目(numberOfTrusses)が含まれている 3 個のリストではなく、それぞれ 3 個の項目が含まれている 10 個のリストが必要になります。これにより、10 個のアダプティブ コンポーネントを作成できます。
List.Map ノードを List.Transpose ノードに接続します。これで目的のデータ出力を得ることができます。
データが正しいことを確認するには、Polygon.ByPoints ノードをキャンバスに追加して、Dynamo プレビューで再確認します。
ポリゴンを作成するのと同じ方法で、アダプティブ コンポーネントを配列します。
AdaptiveComponent.ByPoints ノードをキャンバスに追加し、List.Transpose ノードを points 入力に接続します。
Family Types ノードを使用して、AdaptiveTruss ファミリを選択し、これを AdaptiveComponent.ByPoints ノードの FamilyType 入力に接続します。
Revit では、10 個のトラスがファサード全体にわたって均等に配置されています。
グラフを柔軟に調整することができます。Integer Slider ノードを変更して numberOfTrusses を「30」にします。トラスの数が尋常でなく増えますが、パラメトリック リンクは機能しています。確認したら、numberOfTrusses を 15 に設定します。
最後の確認として、Revit でマスを選択してインスタンス パラメータを編集することにより建物の形状を変更して、トラスがこれに従って変更されるかを確認します。この更新を確認するには、この Dynamo グラフを開いておく必要があります。閉じた場合、リンクはすぐに切断されます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
このレッスンのサンプル ファイル ARCH-DirectShape-BaseFile.rvt を開きます。
3D ビューには、前の演習で使用した建物のマスが表示されます。
アトリウムのエッジに沿って見えるのは 1 つの参照曲線です。これは Dynamo で参照する曲線として使用します。
アトリウムの反対側のエッジに見えるのは別の参照曲線です。これも Dynamo で参照します。
Dynamo でジオメトリを参照するには、Revit の各要素に対して Select Model Element ノードを使用します。Revit でマスを選択し、Element.Faces ノードを使用して Dynamo にジオメトリを読み込みます。これで、マスが Dynamo プレビューに表示されるようになります。
Select Model Element ノードと CurveElement.Curve ノードを使用して、一方の参照曲線を Dynamo に読み込みます。
Select Model Element ノードと CurveElement.Curve ノードを使用して、もう一方の参照曲線を Dynamo に読み込みます。
この構造は、Diagonal Shift、Camber、Radius という 3 つの主要なパラメータでコントロールされます。
このグラフのパラメータをクローズアップします。これらを調整して、さまざまなジオメトリを出力できます。
DirectShape.ByGeometry ノードをキャンバス上にドロップすると、geometry、category、material、name という 4 つの入力が表示されます。
ジオメトリは、グラフのジオメトリ作成部分から作成されるソリッドになります。
category 入力は、ドロップダウン Categories ノードを使用して選択されます。ここでは、[Structural Framing]を使用します。
上記のノードの配列から material 入力が選択されます。この場合は、より単純に「既定値」として設定できます。
Dynamo を実行した後に Revit に戻ると、プロジェクト内の屋根に読み込まれたジオメトリが表示されます。これは生成モデルではなく構造フレーム要素です。Dynamo へのパラメトリック リンクは維持されます。
Dynamo では、さまざまな方法でパッケージを作成することができます。作成したパッケージは、個人的に使用することも、Dynamo コミュニティで共有することもできます。ここで紹介するケース スタディでは、既存のパッケージの中身を確認しながら、パッケージの設定方法について説明します。このケース スタディは、前の章の演習に基づいて構成されており、UV 座標を使用して Dynamo の特定のサーフェスから別のサーフェスへジオメトリをマッピングする際に使用した一連のカスタム ノードを提供します。
ここでは、点群を特定のサーフェスから別のサーフェスに UV マッピングする演習で使用したサンプル パッケージを使用していきます。ツールの基本部分は、この手引の「」セクションで既に作成されています。ここでは、UV マッピングの概念を理解する方法と、パブリッシュ可能なライブラリ用の一連のツールを開発する方法について確認します。
このイメージは、UV 座標を使用して 1 つの点を特定のサーフェスから別のサーフェスにマッピングする場合の例を示しています。パッケージ構成はこの考え方に基づいていますが、パッケージには、より複雑なジオメトリが含まれます。
前の章では、Dynamo 内の XY 平面上に定義された複数の曲線に基づいてサーフェスをパネル化する方法について確認しました。このケース スタディでは、この考え方を広げて、より高次元のジオメトリを処理します。ここでは、この構築済みパッケージをインストールし、このパッケージがどのように開発されたかを確認していきます。次のセクションでは、このパッケージのパブリッシュ方法を確認します。
Dynamo で、[パッケージ] > [Package Manager]をクリックして、「MapToSurface」(スペースを入れない 1 つの単語)でパッケージを検索します。[インストール]をクリックしてダウンロードを開始し、パッケージをライブラリに追加します。
インストール後は、カスタム ノードを[アドオン] > [DynamoPrimer]セクションで使用できるようになります。
これでパッケージのインストールが完了しました。次に、パッケージの設定方法を確認しましょう。
ここで作成するパッケージでは、参照用として既に作成されている 5 つのカスタム ノードを使用します。ここで、各ノードの機能を確認しましょう。一部のカスタム ノードは、他のカスタム ノードを使用して作成されています。また、他のユーザが簡単に理解できるように、グラフにはレイアウトが用意されています。
上の図は、5 つのカスタム ノードによって構成される単純なパッケージを示しています。次の手順で、各カスタム ノードの設定について簡単に説明します。
これは基本的なカスタム ノードで、他のすべてのマッピング ノードのベースになるノードです。このノードは、ソース サーフェスの UV 座標の点を、ターゲット サーフェスの UV 座標にマッピングします。点は、複雑なジオメトリを構築するための最も基本的なジオメトリであるため、このロジックを使用して、2D ジオメトリだけでなく 3D ジオメトリについても、特定のサーフェスから別のサーフェスにマッピングすることができます。
このノードを使用すると、1D ジオメトリのマッピングされた点群を 2D ジオメトリに拡張するロジックを、ポリゴンによって簡単に確認することができます。図のように、PointsToSurface ノードがこのカスタム ノード内にネストされていることがわかります。この方法で各ポリゴンの点群をサーフェスにマッピングし、その点群からポリゴンを再生成することができます。適切なデータ構造(点群のリストのリスト)を維持することにより、ポリゴンを一連の点群に変更した場合でも、それらのポリゴンを個別に保持することができます。
このノードでは、PolygonsToSurface ノードと同じロジックが適用されます。ただし、ここでは、ポリゴンの点群をマッピングするのではなく、NURB 曲線の制御点をマッピングします。
OffsetPointsToSurface
このノードの構成はやや複雑ですが、その概念は単純です。PointsToSurface ノードと同じように、このノードは特定のサーフェスから別のサーフェスに点群をマッピングします。ただし、OffsetPointsToSurface ノードは、元のソース サーフェス上には存在しない点群を識別し、その点から最も近い UV パラメータまでの距離を取得して、対応する UV 座標上のターゲット サーフェスの法線にマッピングします。これは、サンプル ファイルを見るとよくわかります。
このノードは、サンプル ファイル内のソース グリッドから波形のサーフェスにマッピングするためのパラメータ制御のサーフェスを作成する単純なノードです。
サンプル ファイルは、パッケージのルート フォルダにあります。[Package Manager] > [インストール済みパッケージ]タブをクリックします。
[MapToSurface]の横にある縦のドット メニュー > [ルート フォルダを表示]をクリックします
次に「extra」フォルダにナビゲートします。このフォルダには、パッケージ内のすべてのファイル(カスタム ノードを除く)が格納されています。Dynamo パッケージ用のサンプル ファイル(存在する場合)も、このフォルダに格納されています。これ以降のスクリーンショットは、各サンプル ファイルの概念を示しています。
このサンプル ファイルでは、同様のワークフローを使用して、特定のサーフェスから別のサーフェスに円弧をマッピングする場合のセットアップ例を確認することができます。このファイルでは PolygonsToSurface ノードを使用します。
このサンプル ファイルは NurbsCrvToSurface ノードと連携するため、多少複雑な構成になっています。ターゲット サーフェスは指定した距離でオフセットされ、NURB 曲線が元のターゲット サーフェスとオフセット後のサーフェスにマッピングされます。その後、マッピングされた 2 本の曲線がロフトされて 1 つのサーフェスが作成され、そのサーフェスに厚みが加えられます。その結果として出力されるソリッドは、ターゲット サーフェスの法線を表す波形の形状になります。
このサンプル ファイルでは、ひだがついたポリサーフェスをソース サーフェスからターゲット サーフェスにマッピングする方法について確認することができます。ソース サーフェスはグリッド上に広がる長方形のサーフェスで、ターゲット サーフェスは回転体のサーフェスです。
このサンプル ファイルでは、ソース サーフェスのソース ポリサーフェスをターゲット サーフェスにマッピングする方法について確認することができます。
カスタム ノードを使用すると、さまざまなタイプの曲線をマッピングすることができます。このサンプル ファイルでは、Illustrator から書き出した SVG ファイルを参照し、読み込んだ曲線をターゲット サーフェスにマッピングすることができます。
.svg ファイルの構文を解析することにより、曲線が .xml 形式から Dynamo のポリカーブに変換されます。
読み込んだ曲線がターゲット サーフェスにマッピングされます。これにより、Illlustrator でパネルを明示的に(ポイント アンド クリック操作で)設計し、そのパネルを Dynamo で読み込んでターゲット サーフェスに適用することができます。
Zero-Touch Importing とは、C# ライブラリを読み込むための単純なポイント アンド クリック操作のことです。Dynamo は、.dll ファイルの public メソッドを読み取って 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 だけを使用します。この .dll ファイルを選択して [開く] をクリックします。
Dynamo に戻ると、ノードの [AForge] グループがライブラリに新しく表示されます。これで、ビジュアル プログラミングから AForge のイメージ ライブラリにアクセスできるようになりました。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
ライブラリを読み込んだら、最初に簡単な演習を行います(01-EdgeDetection.dyn)。ここでは、サンプルのイメージに対して基本的なイメージ処理を実行することにより、AForge イメージのフィルタ機能について説明します。Watch Image ノードを使用して処理の実行結果を表示し、Dynamo のフィルタを適用します。Dynamo のフィルタは、Photoshop のフィルタに似ています。
File Path ノードにより、ユーザが選択したイメージのパスの文字列が提供されます。次に、Dynamo で使用可能なイメージ ファイルに変換する必要があります。
File From Path を使用して、ファイル パス項目を Dynamo 環境のイメージに変換します。
File Path ノードを File.FromPath ノードに接続します。
Image.ReadFromFile ノードを使用して、file 出力をイメージに変換します。
最後に、結果を確認します。Watch Image ノードをキャンバスにドロップして Image.ReadFromFile ノードに接続します。ここでは AForge をまだ使用していませんが、イメージを Dynamo 環境に正しく読み込むことができました。
ナビゲーション メニューの AForge.Imaging.AForge.Filters の下に、さまざまな使用可能なフィルタが表示されます。ここでは、1 つのフィルタを使用し、しきい値に基づいてイメージの彩度を下げてみましょう。
3 つのスライダをキャンバスにドロップし、各スライダの範囲を 0 から 1 に変更して、ステップ値を 0.01 に変更します。
キャンバスに Grayscale.Grayscale ノードを追加します。これは、グレースケール フィルタをイメージに適用する AForge フィルタです。手順 1 の 3 つのスライダを、Grayscale.Grayscale ノードの入力(cr、cg、cb)にそれぞれ接続します。1 番目と 3 番目のスライダの値を 1 に設定し、2 番目のスライダの値を 0 に設定します。
グレースケール フィルタを適用するには、イメージに対してアクションを実行する必要があります。この場合、BaseFilter.Apply を使用します。イメージを image 入力に接続し、Grayscale.Grayscale ノードを baseFilter 入力に接続します。
Watch Image ノードに接続すると、イメージの彩度が下がります。
赤、緑、青のしきい値に基づいて、イメージの彩度を下げる方法をコントロールすることができます。これらのしきい値は、Grayscale.Grayscale ノードに対する入力によって定義されます。上図のイメージは暗くなっていますが、これは、スライダで緑のしきい値が 0 に設定されているためです。
次に、1 番目と 3 番目のスライダの値を 0 に設定し、2 番目のスライダの値を 1 に設定します。この設定により、彩度を下げたイメージが明確に表示されます。
次に、彩度を下げたイメージに対して別のフィルタを適用します。彩度が低いイメージにはいくらかのコントラストがあります。ここでは、輪郭線の検出をテストしてみましょう。
キャンバスに SobelEdgeDetector.SobelEdgeDetector ノードを追加します。
これを BaseUsingCopyPartialFilter.Apply に接続し、彩度を下げたイメージをこのノードの image 入力に接続します。
Sobel Edge Detector により、新しいイメージ内で輪郭線がハイライト表示されます。
拡大表示すると、Edge Detector により、イメージ内の泡の輪郭がピクセル単位で描画されていることがわかります。AForge ライブラリには、このような処理を行うためのツールや、Dynamo のジオメトリを作成するためのツールが用意されています。Dynamo のジオメトリを作成する方法については、次の演習で説明します。
前の演習では、基本的なイメージ処理について確認しました。この演習では、イメージを使用して Dynamo のジオメトリを操作してみましょう。簡単な操作として、AForge と Dynamo を使用してイメージの「ライブ トレース」を実行します。説明を簡単にするため、ここでは参照イメージから長方形を抽出しますが、AForge には、より複雑な操作を実行するための各種ツールが用意されています。この演習では、ダウンロードした演習ファイルの 02-RectangleCreation.dyn を使用します。
File Path ノードを使用して、演習フォルダの grid.jpg にナビゲートします。
残りの一連のノードを接続し、パラメトリック グリッドを表示します。
BlobCounter をキャンバスに追加したら、前の演習で使用した BaseFilter.Apply ツールと同じような方法でイメージを処理する必要があります。
しかし、Process Image ノードは Dynamo ライブラリ内に直接表示されません。これは、このノード(関数)を AForge のソース コード内で表示することができないためです。この問題を解決するには、何らかの回避策が必要です。
キャンバスに Python ノードを追加し、Python ノードに次のコードを追加します。このコードによって AForge ライブラリが読み込まれ、読み込まれたイメージが処理されます。
Watch Image ノードの image 出力を Python Script ノードの入力に接続すると、Python Script ノードによって AForge.Imaging.BlobCounter の結果が取得されます。
Python Script ノードの出力を BlobCounterBase.GetObjectRectangles に接続します。この操作により、しきい値に基づいてイメージ内のオブジェクトが読み取られ、定量化された長方形がピクセル スペースから抽出されます。
別の Python Script ノードをキャンバスに追加して GetObjectRectangles に接続し、次のコードを入力します。この操作により、Dynamo オブジェクトの整理されたリストが作成されます。
前の手順で追加した Python Script ノードの出力を置き換えます。この操作により、各長方形の X 座標、Y 座標、幅、高さを表す 4 つのリストが作成されます。
Code Block ノードを使用して、Rectangle.ByCornerPoints ノードに対応する構造にデータを編成します(次のコードを参照)。
イメージ内の白い正方形を表す長方形の配列が表示されます。この演習では、プログラミング コードを入力して、Illustrator のライブ トレースに類似する機能を作成しました。
ただし、まだクリーンアップが必要です。拡大表示すると、必要のない小さな長方形がたくさん残っていることがわかります。
次に、不要な長方形を削除するためのコードを記述します。
GetObjectRectangles ノードと別の Python ノードの間に Python ノードを挿入します。このノードのコードは次のとおりです。このコードで指定したサイズよりも小さな長方形がすべて削除されます。
不要な長方形を削除したら、それらの長方形からサーフェスを作成し、その長方形の面積に基づく距離を使用して長方形を押し出してみましょう。
both_sides 入力パラメータを false に変更すると、長方形が一方向に押し出されます。この操作により、非常に面白いテーブルが作成されます。
Dynamo には、パラメトリック レベルでパラメータを編集するための強力な機能が用意されています。たとえば、生成アルゴリズムやシミュレーションの結果を使用して、要素の配列のパラメータをコントロールすることができます。この方法で、同じファミリのインスタンスの集合に、Revit プロジェクトのカスタム プロパティを設定することができます。
インスタンス パラメータは、0.1 ~ 0.4 の開口率で、屋根サーフェス上のパネルの開口部を定義します。
タイプベースのパラメータは、サーフェス上のすべての要素に適用されます。これらの要素は同じファミリ タイプであるためです。たとえば、各パネルのマテリアルをタイプベースのパラメータによってコントロールできます。
Revit ファミリを設定する場合と同様に、ここで文字列、数値、寸法などのパラメータ タイプを指定する必要があります。 Dynamo からパラメータを割り当てる場合は、必ず正しいデータ タイプを使用してください。
また、Revit ファミリのプロパティで定義されたパラメトリック拘束と組み合わせて Dynamo を使用することもできます。
Revit のパラメータの簡単な復習として、タイプ パラメータとインスタンス パラメータの 2 種類があることを思い出してください。両方とも Dynamo で編集できますが、次の演習ではインスタンス パラメータを使用します。
バージョン 0.8 以降、基本的に Dynamo では単位が使用されなくなりました。これにより、抽象的なビジュアル プログラミング環境が実現します。Revit の寸法を使用する Dynamo のノードは、Revit プロジェクトの単位を参照します。たとえば、Revit の長さパラメータを Dynamo で設定する場合、Dynamo の数値は Revit プロジェクトの既定の単位に対応します。次の演習では、メートル単位の数値を操作します。
単位を素早く変換するには、Convert Between Units ノードを使用します。このノードは、長さ、面積、体積の単位をその場で変換できる便利なツールです。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
次の演習では、メートル単位の数値を操作します。
この演習では、Dynamo でジオメトリ操作を実行することなく Revit 要素を編集します。Dynamo ジオメトリを読み込まず、Revit プロジェクトで直接パラメータを編集します。これは基本的な演習です。Revit の上級ユーザであれば、次の図のパラメータはマスのインスタンス パラメータであることがわかるでしょう。同じロジックを要素の配列に適用し、大規模なカスタマイズを行うことができます。これは、すべて Element.SetParameterByName ノードで行います。
このセクションでは、最初にサンプルの Revit ファイルを使用します。構造要素とアダプティブ トラスは、前のセクションで削除されました。この演習では、Revit のパラメータ機能を確認しながら、Dynamo で操作を行います。
Revit で建物のマスを選択すると、プロパティ パネルにインスタンス パラメータの配列が表示されます。
Dynamo では、ターゲット要素を選択してパラメータを取得できます。
Select Model Element ノードを使用して、建物のマスを選択します。
Element.Parmaters ノードを使用して、このマスのすべてのパラメータのクエリーを実行できます。パラメータには、タイプ パラメータとインスタンス パラメータがあります。
Element.Parameters ノードをクリックして、ターゲット パラメータを検索します。または、前の手順のプロパティ パネルを表示して、編集するパラメータ名を選択することもできます。この場合、建物のマスの形状に大きく影響するパラメータを探す必要があります。
Element.SetParameterByName ノードを使用して、Revit 要素に変更を加えます。
Code Block ノードを使用してパラメータ リストを定義します。各項目は文字列を示す引用符で囲みます。List.Create ノードを使用して、"文字列" で示した一連のノードを複数の入力に接続することもできますが、Code Block ノードを使用すると処理が高速かつ簡単になります。文字列が Revit の名前と一致していることを確認します(大文字と小文字は区別されます)。
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};
各パラメータの値を指定します。Integer Slider ノードを 6 つキャンバスに追加し、リスト内のパラメータに合わせて名前を変更します。また、各スライダの値を上の図のように設定します。上から下に、62、92、25、22、8、12 の順で設定します。
パラメータ名の数と同じ長さのリストを使用して、別の Code Block ノードを定義します。その際、Code Block ノードの入力を作成する変数の名前を、引用符を使用せずに入力します。このリスト
{bw,bl,bh,ao,io,lu};
の各入力に スライダ を接続します。Code Block ノードを Element.SetParameterByName ノード* の value 入力に接続します。[自動実行]がオンになっている場合は、結果が自動的に表示されます。
*このデモンストレーションは、インスタンス パラメータには対応していますが、タイプ パラメータには対応していません。
Revit と同様に、これらのパラメータの多くは相互に依存関係があります。これらの中には、ジオメトリが壊れてしまう組み合わせもあります。この問題を解決するには、定義済みの式をパラメータ プロパティで使用するか、Dynamo の数値演算で同様のロジックを設定します。余裕があれば、この演習の追加の課題として取り組んでみてください。
100、92、100、25、13、51 という組み合わせにより、特徴的な新しいデザインが建物のマスに追加されます。
次に、同様のプロセスを使用してファサードを編集する方法について説明します。
グラフをコピーして、トラス システムを格納するファサードのグレージングを確認します。この場合、4 つのパラメータを分離します。
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
また、Number Slider ノードを使用して、対応するパラメータに合わせて名前を変更します。上から 3 つのスライダは[0,10]の範囲に再マップし、一番下のスライダ(Facade Bend Location)は[0,1]の範囲に再マップします。次に、これらの値を 2.68、2.64、2.29、0.5 にそれぞれ設定します(実際は任意です)。
新しい Code Block ノードを定義し、スライダを接続します。
{so,mo,no,fbl};
グラフのこの部分の スライダ を使用して値をそれぞれ 9.98、10.0、9.71、0.31 に変更すると、ファサード ガラスがさらにがっしりとした形状になります。
ここまでのセクションの演習に続けて、パラメータを編集して設計図書を作成してみましょう。このセクションでは、パラメータを編集することで、要素のジオメトリの特性を左右するのではなく、Revit ファイルから設計図書を作成できるようにする方法について紹介します。
以降の演習では、水平面からの基本的な偏差を使用して、設計図書作成用に Revit のシートを作成します。パラメータで定義した屋根構造上のパネルにはそれぞれ異なる偏差の値が与えられています。そこで、色分けによって値の範囲をわかりやすく表示し、アダプティブ点を集計表に書き出してファサード設計の監修者、設計者、または施工業者に渡すことができるようにしましょう。
水平面からの偏差を取得するノードにより、4 つの点群と最適な水平面の間の距離が計算されます。これで施工性をすばやく簡単に検討することができます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
このセクション用の Revit ファイルを使用して(または前のセクションからの続きとして)演習を開始しましょう。このファイルには、屋根上の ETFE パネルの配列が収録されています。以降の演習でこれらのパネルを参照します。
Family Types ノードをキャンバスに追加し、ROOF-PANEL-4PT を選択します。
このノードを All Elements of Family Type ノードに接続することで、すべての要素を Revit から Dynamo に取得します。
AdaptiveComponent.Locations ノードにより、各要素のアダプティブ点の位置をクエリーします。
Polygon.ByPoints ノードを使用して、これら 4 点から 1 つのポリゴンを作成します。これにより、Revit 要素のジオメトリをすべて読み込むことなく、パネル システムの抽象化されたバージョンを Dynamo で取得できます。
Polygon.PlaneDeviation ノードを使用して、水平面からの偏差を計算します。
前の演習と同様に、各パネルの開口率を水平面からの偏差に基づいて設定してみましょう。
Element.SetParameterByName ノードをキャンバスに追加して、その element 入力にアダプティブ コンポーネントを接続します。開口率(Aperture Ratio) を読み取っている Code Block ノードを、parameterName 入力に接続します。
偏差の出力を直接 value 入力に接続することはできません。なぜなら、複数の値をパラメータ範囲にマッピングし直す必要があるからです。
Math.RemapRange ノードを使用して、Code Block ノードに
0.15; 0.45;
を入力することで偏差の値を 0.15 から 0.45 までの範囲にマッピングし直します。そのノードの出力を Element.SetParameterByName の value 入力に接続します。
Revit に戻ると、サーフェス全体の開口率が 多少 変化したことがわかります。
拡大表示するとはっきりわかるように、サーフェスの四隅に近付くほどパネルが閉じていく傾向にあり、また隆起の頂点へ近付くほどパネルが開いていく傾向にあります。これは、四隅のあたりでは水平面からの偏差が大きく、ふくらみの部分では水平に近くになっているためです。
[開口率]の設定では、屋根上のパネルの偏差があまりよくわかりません。また、実際の要素のジオメトリが変更されてしまいます。単に製造性の観点から偏差を検討するだけであれば、設計図書作成の際に、偏差の範囲に基づいてパネルを色分けするとよいでしょう。下記の一連の手順によってそのような色分けを行うことができます。これは上記の手順にとてもよく似ています。
Element.SetParameterByName ノードとその入力ノードを削除し、Element.OverrideColorInView ノードを追加します。
Color Range ノードをキャンバスに追加して、そのノードを Element.OverrideColorInView の color 入力に接続します。さらに、グラデーションを作成するために偏差の値を Color Range ノードに接続する必要があります。
value 入力にカーソルを合わせると、その入力の値が 0 から 1 までの範囲で表示されます。この値は、値ごとに色をマッピングするのに使用されます。偏差の値をこの範囲にマッピングし直す必要があります。
Math.RemapRange を使用して、水平面からの偏差を 0 から 1 までの範囲にマッピングし直します(注: MapTo ノードを使用してソースの範囲を設定することもできます)。
その出力結果を Color Range ノードに接続します。
ここでの出力は、数値の範囲ではなく、色の範囲です。
[手動]に設定している場合は[実行]をクリックします。これ以降の手順では、[自動]に設定しないように注意してください。
Revit に戻ると、かなり見やすいグラデーションが表示されます。これは、ユーザが指定した色の範囲に基づいて、水平面からの偏差を表しています。色分けをカスタマイズするには、どうすればよいでしょうか。いま偏差の最小値は赤色で表示されていますが、これとは逆の色分けに変更してみましょう。つまり、偏差の最大値を赤色に、偏差の最小値をもっと落ちついた色に設定することにします。Dynamo に戻ってこの修正を行ってみましょう。
Code Block ノードを使用して、
0;
と255;
という 2 つの数値を、2 行に分けて追加します。2 つ の Color.ByARGB ノードに適切な値を接続することで、赤色と青色を作成します。
これらの 2 色から 1 つのリストを作成します。
このリストを Color Range ノードの colors 入力に接続し、カスタマイズした色の範囲が更新されていることを確認します。
Revit に戻ると、水平面からの偏差が四隅の領域で最大になっていることがよりはっきり確認できます。なお、このノードはビュー内の色の優先設定に使用されます。したがって、一連の図面のなかで特定のシートが特定のタイプの解析を目的としている場合に、とても役に立ちます。
Revit で ETFE パネルを選択すると、XYZ1、XYZ2、XYZ3、XYZ4 という 4 つのインスタンス パラメータが表示されます。作成後、これらのパラメータはすべて空になっています。これらは文字ベースのパラメータであり、値を必要とします。Dynamo を使用して、各パラメータにアダプティブ点の位置を入力します。この機能は、ジオメトリをファサード設計の監修者に送信する必要がある場合に、相互運用性の確保に役立ちます。
サンプルのシートには大規模な空の集計表が含まれています。XYZ パラメータは Revit ファイルでも使用される共有パラメータであり、このファイルによってパラメータを集計表に追加することができます。
拡大表示すると、XYZ パラメータはまだ入力されていません。左側 2 つのパラメータは Revit によって処理されています。
これらのパラメータに値を入力するために、これから複雑なリスト操作を行います。グラフ自体は単純ですが、考え方はリストの章で紹介したリストのマッピングを大いに活用しています。
2 つのノードを使用してアダプティブ コンポーネントをすべて選択します。
AdaptiveComponent.Locations ノードを使用して、各点の位置を抽出します。
これらの点を文字列に変換します。なお、パラメータはテキストベースですから、正しいデータ タイプを入力する必要があることに注意してください。
変更するパラメータを定義する 4 つの文字列 XYZ1、XYZ2、XYZ3 、 XYZ4 から、1 つのリストを作成します。
このリストを Element.SetParameterByName ノードの parameterName 入力に接続します。
Element.SetParameterByName ノードを List.Combine ノードの combinator 入力に接続します。アダプティブ コンポーネント を list1 入力に接続します。String from Object ノードを list2 入力に接続します。
ここでリスト マッピングを行います。各要素に 4 つの値を書いていて、複雑なデータ構造になっているからです。List.Combine ノードはデータ階層内の 1 段階下の層で操作を定義します。Element.SetParameterByName の element 入力と value の入力が空のままになっているのはこのためです。List.Combine ノードは、入力のサブリストを、接続された順番に基づいて Element.SetParameterByName ノードの空の入力に接続します。
Revit でパネルを選択すると、各パラメータに文字列値が入力された状態で表示されます。実際のプログラミングでは、(X,Y,Z)のようにより単純な形式で 1 つの点を作成するものです。これは Dynamo の文字列操作で可能ですが、この章で取り扱う範囲から逸脱しないようにするために、その方法はここでは紹介しません。
パラメータへの入力が完了しているサンプル集計表のビューです。
各 ETFE パネルを構成するすべてのアダプティブ点について XYZ 座標が記入されています。これらが製造用の各パネルの四隅を表します。
/
/
/
では、Revit 要素を作成するためのデータを Dynamo が参照する仕組みについて学習します。複数のアダプティブ コンポーネントを生成するには、リストのリストを設定します。各リストには、アダプティブ コンポーネントの各点を表す 3 つの点が含まれています。Dynamo でデータ構造を管理する際は、このことを考慮します。
で、Dynamo ジオメトリを DirectShape として Revit プロジェクトに読み込む方法を学習しましょう。この方法を使用すると、Dynamo グラフへのパラメトリック リンクを維持しつつ、読み込んだジオメトリのカテゴリ、マテリアル、名前を割り当てることができます。
縮小して画面をサンプル グラフの右に移動すると、大きなノードのグループが見えます。これらはジオメトリを操作し、Dynamo プレビューで表示される格子状の屋根構造を生成します。これらのノードは、Dynamo Primer の で説明されている[ ノードをコード化 ]機能を使用して生成されます。
このサンプル ファイルでは、PointsToSurface ノードを使用して長方形のグリッドに基づくサーフェスをパネル化する方法を確認することができます。同様のワークフローについては、で確認しました。
このセクションでは、Zero-Touch を使用してサードパーティのライブラリを読み込む方法について説明します。独自の Zero-Touch ライブラリを開発する方法については、を参照してください。
Zero-touch パッケージは、ユーザが定義するカスタム ノードを補完するパッケージです。次の図は、C# ライブラリを使用するいくつかのパッケージを示しています。パッケージの詳細については、付録の「」セクションを参照してください。
このケース スタディでは、 の外部 .dll ライブラリをインポートする方法について説明します。AForge は、イメージ処理機能から人工知能まで、さまざまな機能を提供する堅固なライブラリです。ここでは、AForge のイメージ クラスを使用して、いくつかのイメージ処理を行う方法について説明します。
最初に、AForge をダウンロードします。で [Download Installer] を選択し、ダウンロードが完了したらインストールを実行します。
イメージをインポートするには、File Path ノードをキャンバスに追加し、演習フォルダで soapbubbles.jpg を選択します(次の画面で使用されている画像の出典元: )。
次の手順では、イメージ内の白い正方形を表示して、実際の Dynamo ジオメトリに変換します。AForge には、多くの便利な Computer Vision ツールが用意されていますが、ここでは、その中でも特に重要なツールを というライブラリに対して使用します。
次の手順では、 を使用する場合のヒントとなる操作をいくつか紹介します。ただし、Dynamo で作業を行う場合に、すべての操作を理解する必要はありません。これらの操作を参照して、外部のライブラリを Dynamo 環境内で柔軟に使用できることを理解するのが目的です。
ここで紹介した例はどれも基本的なものばかりですが、その概念は実際のアプリケーションでも応用することができます。Computer Vision は、さまざまなプロセスで使用することができます。バーコード リーダー、パースペクティブ マッチング、、などはその一例です。この演習に関する AForge の詳細なトピックについては、を参照してください。
編集するパラメータの用途は幅広いため、Revit と Dynamo を併用すると、多くの要素を編集できます。これは 計算量の多い演算 であるため、速度が低下することがあります。多くの要素を編集する場合は、ノードを「フリーズ」する機能を使用して、グラフの作成中に Revit に関連した操作の実行を一時的に停止することをお勧めします。ノードをフリーズする操作の詳細については、「ソリッド」の章の「 」セクションを参照してください。
Dynamo は当初は Revit を念頭に置いて開発されたものでしたが、ビジュアル プログラミング ツールとしての汎用性は Revit を超えています。Dynamo は Civil 3D にも統合されるため 、ユーザは土木インフラストラクチャ プロジェクト用の強力な自動化ルーチンを作成できます。これは、一般的なタスクから最も複雑な設計ワークフローまで、あらゆる処理を行う上で非常に便利なツールであり、最終的に、時間の節約、設計の最適化、設計の意思決定の向上に役立ちます。Dynamo には、Civil 3D 専用に設計されたさまざまなノードが用意されています。さらに活発なコミュニティで、各種のサードパーティ製ライブラリが開発されています。
Primer のこの章では、Dynamo for Civil 3D の基本から始めて、より高度なトピックへと進んでいきます。
時間の経過とともに、基本を超えて、Dynamo の内部の仕組みを詳細に理解する必要が出てくることがあります。このセクションのページでは、グラフを次のレベルに引き上げることができるように、Dynamo for Civil 3D の高度な機能を明らかにしていきます。
ロゴ/イメージ
名前
全体像について少し詳しく理解できたところで、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 のアクティブなドキュメントで作業します。
Text オブジェクトを作成する対象のブロック(この場合はモデル空間)を定義しました。
String ノードを使用して、テキストを配置するレイヤを指定しました。
Point.ByCoordinates ノードを使用して点を作成し、テキストを配置する位置を定義しました。
2 つの Number Slider ノードを使用して、テキスト挿入位置の X 座標と Y 座標を定義しました。
別の String ノードを使用して、Text オブジェクトの内容を定義しました。
最後に、Text オブジェクトを作成しました。
真新しいグラフの結果を確認しましょう。
Civil 3D に戻り、[モデル] タブが選択されていることを確認します。Dynamo で作成された新しい Text オブジェクトが表示されるはずです。
テキストが表示されない場合は、[ズーム] -> [範囲]コマンドを実行して適切な位置にズームする必要があります。
素晴らしい。次に、テキストを更新します。
Dynamo グラフに戻り、テキスト文字列、挿入位置の座標などの入力値をいくつか変更します。Civil 3D でテキストが自動的に更新されます。また、入力ポートの 1 つを接続解除すると、テキストが削除されることにも注意してください。元通りにつなぎ直すと、テキストが再度作成されます。
グラフを実行するたびに Dynamo が新しい Text オブジェクトを挿入しない理由とは
既定では、Dynamo は作成したオブジェクトを「記憶」します。ノード入力値を変更すると、まったく新しいオブジェクトが作成されるのではなく、Civil 3D のオブジェクトが更新されます。この動作の詳細については、「オブジェクト バインド」セクションを参照してください。
この例では、Dynamo for Civil 3D で実行できる機能の基礎に触れただけです。詳細については読み続けてください。
Dynamo の多くの優れた使用事例の 1 つは、コリドー モデルに沿って個別のオブジェクトを動的に配置することです。多くの場合、オブジェクトはコリドーに沿って挿入されたアセンブリとは独立した位置に配置する必要があります。これは、手動で行うにはきわめて面倒な作業です。コリドーの水平ジオメトリまたは垂直ジオメトリが変更されると、大量の再作業が必要になります。
外部ファイル(この場合は Excel)からデータを読み込む
ディクショナリ内のデータを編成する
座標系を使用して位置/尺度/回転をコントロールする
ブロック参照を配置する
Dynamo でジオメトリを視覚化する
このグラフは Civil 3D 2020 以降で実行できます。
まず、以下のサンプル ファイルをダウンロードし、DWG ファイルと Dynamo グラフを開きます。
Excel ファイルを Dynamo グラフと同じフォルダに保存することをお勧めします。
このグラフのロジックの概要を以下に示します。
Excel ファイルを読み込み、データを Dynamo に読み込む
指定したコリドー基線から計画線を取得する
目的の測点でコリドー計画線に沿って座標系を生成する
座標系を使用してモデル空間にブロック参照を配置する
以上です。
このサンプル グラフでは、Excel ファイルを使用して、Dynamo が照明柱のブロック参照を配置するために使用するデータを保存します。表は次のようになります。
Dynamo を使用して外部ファイル(Excelファイルなど)からデータを読み込む方法は、特にデータを他のチーム メンバーと共有する必要がある場合に最適です。
Excel データは、次ように Dynamo に読み込まれます。
データが得られたら、列(Corridor、Baseline、PointCode など)で分割して、グラフの残りの部分で使用できるようにする必要があります。これを行う一般的な方法は、List.GetItemAtIndex ノードを使用して、必要な列のインデックス番号を指定することです。たとえば、[Corridor] 列はインデックス 0、[Baseline] 列はインデックス 1、などです。
問題なさそうですね?しかし、このアプローチには潜在的な問題があります。Excel ファイルの列の順序が将来変更されたらどうなるでしょうか?あるいは、2 つの列の間に新しい列が追加されたら?その場合は、グラフが正しく機能しなくなり、更新が必要になります。Excel の列ヘッダーを キー として、残りのデータを 値 として使用して、データをディクショナリに入れることで、グラフを将来も使用できるように保証します。
ディクショナリを初めて使用する場合は、「Dynamo のディクショナリ」セクションを参照してください。
これにより、Excel で列の順序を柔軟に変更できるため、グラフの柔軟性が向上します。列ヘッダーが同じであるかぎり、キー(列ヘッダー)を使用してディクショナリからデータを取得できます。これを次に実行します。
これで Excel データが読み込まれ、準備ができたので、このデータを使用して、コリドー モデルに関する情報を Civil 3D から取得しましょう。
コリドー モデルを名前で選択します。
コリドー内の特定の基線を取得します。
基線内の計画線をポイント コードにより取得します。
ここで、Excel ファイルで指定した測点値でコリドー計画線に沿って座標系を生成します。これらの座標系は、照明柱のブロック参照の位置、回転、および尺度を定義するために使用されます。
座標系を初めて使用する場合は、「ベクトル、平面、座標系」 セクションを参照してください。
基線のどちら側に座標系があるかに応じて座標系を回転するために、ここでコード ブロックを使用します。これは複数のノードのシーケンスを使用して実現できますが、これは単に書き出すほうが簡単である良い例です。
コード ブロックを初めて使用する場合は、「コード ブロックと DesignScript」 セクションを参照してください。
あと少しです。ブロック参照を実際に配置するために必要なすべての情報が揃いました。まず、Excel ファイルの BlockName 列を使用して必要なブロック定義を取得します。
ここから、最後の手順としてブロック参照を作成します。
グラフを実行すると、コリドーに沿ってモデル空間に新しいブロック参照が表示されます。これが素晴らしいところで、グラフの実行モードが[自動]に設定されている状態で Excel ファイルを編集すると、ブロック参照が自動的に更新されます。
グラフの実行モードの詳細については、「ユーザ インタフェース」 セクションを参照してください。
以下に、Dynamo プレーヤを使用してグラフを実行する例を示します。
Dynamo プレーヤを初めて使用する場合は、「Dynamo プレーヤ」セクションを参照してください。
コンテキストを提供するために、Dynamo でコリドー ジオメトリを視覚化すると便利です。この特定のモデルでは、モデル空間で既に抽出されたコリドーのソリッドが存在するため、Dynamo に取り込んでみましょう。
しかし、他にも検討する必要があることがあります。ソリッドは比較的重いジオメトリ タイプであるため、この操作によってグラフの速度が低下します。ソリッドを表示するかどうかを、簡単に 選択 できる方法があれば便利です。解決策は非常に単純で、 Corridor.GetSolids ノードの接続を解除するだけですが、これによってすべての下流ノードに警告が生成されてしまう点が少々面倒です。この状況では、ScopeIf ノードが役に立ちます。
Object.Geometry ノードの下部にグレーのバーがあることに注目してください。これは、ノードのプレビューがオフになり(ノードを右クリックしてアクセス可能)、GeometryColor.ByGeometryColor が、背景プレビューでの表示優先順位に関して他のジオメトリとの「競合」を回避できることを意味します。
ScopeIf ノードを使用すると、基本的にノードのブランチ全体を選択的に実行できます。test 入力が false の場合、ScopeIf ノードに接続されたすべてのノードは実行されません。
Dynamo の背景プレビューの結果は次のとおりです。
このグラフの機能を拡張する方法について、いくつかのアイデアを示します。
Excel ファイルに 回転 列を追加し、それを使用して座標系の回転を駆動します。
必要に応じて照明柱がコリドー計画線から外れるようにするため、Excel ファイルに 水平オフセットまたは垂直オフセット を追加します。
Excel ファイルで測点値を使用する代わりに、開始測点と標準間隔を使用して、Dynamo で直接 測点値を生成します。
以前に、ノードは Dynamo グラフの主要な構成要素であり、ライブラリ内で論理グループに編成されていると説明しました。Dynamo for Civil 3D では、ライブラリ内に、Alignments、Profiles、Corridors、Block References など、AutoCAD および Civil 3D オブジェクトを操作するための専用ノードを含む 2 つのカテゴリ(シェルフ)があります。ライブラリの残りの部分には、本質的により汎用的であり、Dynamo のすべての「フレーバー」(Revit 用の Dynamo、Dynamo Sandbox など)間で一貫しているノードが含まれています。
コアの Dynamo ライブラリでノードを構成する方法の詳細については、「ライブラリ」セクションを参照してください。
AutoCAD および Civil 3D オブジェクトを操作するための特定のノード
汎用ノード
個別にインストールできるサードパーティ製パッケージのノード
AutoCAD および Civil 3D シェルフにあるノードを使用すると、Dynamo グラフは Dynamo for Civil 3D でのみ動作します。Dynamo for Civil 3D グラフを別の場所(たとえば Revit 用の Dynamo)で開くと、これらのノードに警告フラグが設定され、実行されません。
AutoCAD と Civil 3D に 2 つの別個のシェルフがある理由とは
この構成により、ネイティブ AutoCAD オブジェクト(Lines、Polylines、Block References など)のノードと Civil 3D オブジェクト(Alignments、Corridors、Surfaces など)のノードが区別されます。また、技術的には、AutoCAD と Civil 3D は 2 つの別個の製品です。AutoCAD は基礎となるアプリケーションであり、Civil 3D はその上に構築されています。
AutoCAD ノードと Civil 3D ノードを使用するには、各シェルフ内のオブジェクト階層をしっかり理解しておくことが重要です。生物学ではあらゆる生物が体系的に分類されており、その分類法は、上位から下位にかけて、界、門、網、目、科、属、種という階層構造から成り立っています。AutoCAD と Civil 3D のオブジェクトも同様に分類されています。いくつかの例を使用して説明しましょう。
例として Alignment を使用しましょう。
目的が Alignment の名前を変更することであるとします。次に追加するノードは CivilObject.SetName ノードです。
最初は、あまり直感的には見えないかもしれません。CivilObject とは何ですか?ライブラリに Alignment.SetName ノードがないのはなぜですか?この答えは、再利用 と 簡易化 に関連しています。考えてみると、Civil 3D オブジェクトの名前を変更するプロセスは、オブジェクトが Alignment、Corridor、Profile など何であっても同じです。したがって、基本的にすべて同じ処理を行う繰り返しノード(Alignment.SetName、Corridor.SetName、Profile.SetName など)を使用する代わりに、その機能を単一のノードにラップすることをお勧めします。これはまさに、CivilObject.SetName で行うことです。
これについては、_関係_の観点で考えることもできます。Alignment と Corridor は、リンゴと梨の両方が果実の一種であるように、どちらも Civil オブジェクトの一種です。Civil オブジェクト ノードはあらゆるタイプの Civil オブジェクトに適用されますが、これは、リンゴと梨の両方の皮をむくのに単一のピーラーを使用するのに似ています。果物の種類ごとに専用のピーラーを揃えていたら、キッチンはひどく散らかってしまいます。その意味で、Dynamo ノード ライブラリはキッチンとまったく同じです。
では、この手順を一歩進めてみましょう。Alignment のレイヤを変更するとします。使用するノードは、Object.SetLayer ノードです。
CivilObject.SetLayer というノードがないのはなぜでしょうか?前述の再利用とシンプルさの原則が、ここにも適用されます。layer プロパティは、Line、Polyline、Text、Block Reference など、AutoCAD で描画または挿入できるオブジェクトに共通のものです。Alignment や Corridor などの Civil 3D オブジェクトは同じカテゴリに分類されるため、オブジェクトに適用されるノードは、どの Civil オブジェクトでも使用できます。
道路、鉄道、土地、ユーティリティ、測量、GIS...。
土木インフラは、これらすべてが含まれますが、それだけではありません。このセクションでは、Dynamo に習熟し、Dynamo for Civil 3D の可能性を最大限に引き出すための、実践的で関連性の高いサンプル グラフをいくつか紹介します。各グラフには、作成に使用されたロジックの詳細な説明が含まれています。これにより、そのロジックを 使用 できるだけでなく、理解 できるようになります。
さらに、これらのサンプルは、強力なグラフを構築するための実績のあるベスト プラクティスを具体化しています。サンプルを使用して作業する際に、強力で柔軟性があり、保守が可能なグラフを構築する方法についてのアイデアについて、「ベスト プラクティス」セクションを読むことをお勧めします。
Dynamo for Civil 3D は、土木インフラ プロジェクトで作業するエンジニアや設計者に ビジュアル プログラミング のパラダイムを提供します。Dynamo は、Civil 3D ユーザ向けの一種のデジタル マルチツールと考えることができ、タスクが何であれ、作業に適したツールを提供します。直感的なインタフェースにより、一行もコードを記述することなく、強力でカスタマイズ可能なルーチンを作成できます。Dynamo を使用するにはプログラマで ある 必要はありませんが、プログラマのロジックを使用して 考える ことができる必要があります。この章は、Primer の他の章と併せて、計算設計の観点からどのようなタスクにも取り組むことができるように、ロジック スキルを構築するのに役立ちます。
Dynamo は Civil 3D 2020 で初めて導入され、その後も進化を続けています。当初はソフトウェアの更新プログラムを介して個別にインストールされていましたが、今では Civil 3D のすべてのバージョンにバンドルされるようになりました。使用している Civil 3D のバージョンによっては、Dynamo のインタフェースがこの章で示す例とは若干異なる場合があります。これは、Civil 3D 2023 のインタフェースが大幅に改良されたためです。
Dynamo の開発に関する最新情報については、Dynamo Blog を参照してください。次の表は、Dynamo for Civil 3D のライフスパンにおける主要なマイルストーンの一覧です。
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
初回リリース
一般的な住宅開発のエンジニアリング設計には、汚水管、雨水排水、飲料水などの地下ユーティリティの使用が含まれます。この例では、Dynamo を使用して、配水本管から特定の区画にサービス接続を描画する方法を示します。これは、サービス接続を必要とするすべての区画で一般的であり、すべてのサービスを配置するには非常に面倒な作業が発生します。Dynamo を使用すると、必要なジオメトリを正確に自動的に描画したり、現地の関係機関の標準に合わせて調整できる柔軟な入力を提供したりすることで、プロセスをスピードアップすることができます。
ユーザ入力に Select Object ノードを使用する
座標系を使用する
Geometry.DistanceTo や Geometry.ClosestPointTo などのジオメトリ操作を使用する
ブロック参照を作成する
オブジェクト バインド設定をコントロールする
このグラフは Civil 3D 2020 以降で実行できます。
まず、以下のサンプル ファイルをダウンロードし、DWG ファイルと Dynamo グラフを開きます。
このグラフのロジックの概要を以下に示します。
排水本管の曲線ジオメトリを取得する
ユーザ選択の区画線の曲線ジオメトリを取得し、必要に応じて反転する
サービス メーターの挿入点を生成する
サービス メーターの位置に最も近い配水本管上の点を取得する
モデル空間でブロック参照と線分を作成する
以上です。
最初の手順では、Dynamo に配水本管のジオメトリを取得します。Lines または Polylines を個別に選択するのではなく、特定のレイヤ上のすべてのオブジェクトを取得し、Dynamo のポリカーブとしてそれらを結合します。
次に、選択した区画線のジオメトリを Dynamo に取り込んで、作業できるようにする必要があります。このジョブに適したツールは Select Object ノードで、グラフのユーザは、Civil 3D で特定のオブジェクトを選択できます。
また、発生する可能性のある潜在的な問題にも対処する必要があります。区画線には始点と終点があります。つまり、方向があります。グラフで一貫した結果を生成するには、すべての区画線の方向が一貫している必要があります。この条件はグラフ ロジックで直接考慮できるため、グラフの弾力性が向上します。
区画線の始点と終点を取得します。
各点から配水本管までの距離を測定し、どちらの距離が大きいかを特定します。
望ましい結果は、線分の始点が配水本管に最も近くなることです。そうでない場合は、区画線の方向を反転します。それ以外の場合は、元の区画線を返します。
次に、サービス メーターが配置される場所を決定します。通常、配置は現地の関係機関の要件によって決定されるため、さまざまな条件に合わせて変更できる入力値を指定します。点を作成するための参照として、区画線に沿って座標系を使用します。これにより、区画線に対するオフセットを、その向きに関係なく、非常に簡単に定義できます。
次に、サービス メーターの位置に最も近い点を配水本管上で取得する必要があります。これにより、サービス接続が配水本管に対して常に垂直になるようにモデル空間にサービス接続を描画できます。Geometry.ClosestPointTo ノードは最適な対処法です。
これは配水本管のポリカーブです
これらは、サービス メーターの挿入点です
最後の手順は、モデル空間にオブジェクトを実際に作成することです。以前に生成した挿入点を使用してブロック参照を作成し、次に、配水本管上のポイントを使用してをサービス接続に線分を描画します。
グラフを実行すると、モデル空間に新しいブロック参照とサービス接続線が表示されます。入力をいくつか変更して、すべてが自動的に更新されるのを確認してください。
1 つの区画線にオブジェクトを配置した後に、別の区画線を選択すると、オブジェクトが「移動」することがあります。
これは Dynamo の既定の動作で、多くの場合に非常に便利です。ただし、複数のサービス接続を順番に配置し、元の接続を変更するのではなく、Dynamo に実行ごとに新しいオブジェクトを作成させたい場合があるかもしれません。この動作は、オブジェクト バインドの設定を変更することでコントロールできます。
この設定を変更すると、Dynamo は各実行で作成されるオブジェクトを「忘れる」ようになります。次に、Dynamo プレーヤを使用してオブジェクト バインドをオフに設定した状態でグラフを実行する例を示します。
このグラフの機能を拡張する方法について、いくつかのアイデアを示します。
各区画行を選択する代わりに、複数のサービス接続 を同時に配置します。
入力を調整して、水道メーターの代わりに、下水管の掃除口 を配置します。
切り替えを追加 して、区画線の両側ではなく特定の側に単一のサービス接続を配置できるようにします。
クリアランス検証のための運動学的エンベロープの開発は、鉄道設計の重要な部分です。Dynamo を使用すると、複雑なコリドー サブアセンブリを作成して管理する代わりに、エンベロープのソリッドを生成してこのジョブを実行できます。
コリドー計画線を操作する
座標系間でジオメトリを変換する
ロフトによりソリッドを作成する
レーシング設定を使用してノードの動作をコントロールする
このグラフは Civil 3D 2020 以降で実行できます。
まず、以下のサンプル ファイルをダウンロードし、DWG ファイルと Dynamo グラフを開きます。
このグラフのロジックの概要を以下に示します。
指定したコリドー基線から計画線を取得する
コリドー計画線に沿って目的の間隔で座標系を生成する
プロファイルの Block ジオメトリを座標系に変換する
プロファイル間でソリッドをロフトする
Civil 3Dでソリッドを作成する
以上です。
最初の手順は、コリドー データを取得することです。コリドー モデルを名前で選択し、コリドー内の特定の基線を取得します。次に、基線内の計画線をそのポイント コードで取得します。
ここで、指定した開始測点と終了測点の間に、コリドー計画線に沿って座標系を生成します。これらの座標系は、車両プロファイルの Block ジオメトリを コリドーに位置合わせするために使用されます。
ノードの右下隅にある小さな XXX に注目してください。これは、ノードのレーシング設定が [直積] に設定されていることを意味します。これは、両方の計画線に対して同じ測点値で座標系を生成するために必要です。
ここで、計画線に沿って車両プロファイルの配列を何らかの方法で作成する必要があります。これから行う作業では、Geometry.Transform ノードを使用して、車両プロファイルのブロック定義からジオメトリを変換します。これは視覚化が難しい概念なので、ノードを確認する前に、次のグラフィックスでこれから起こる動作を示します。
基本的に、単一の Block 定義から Dynamo ジオメトリを取得し、移動または回転しながら、計画線に沿って配列を作成します。いいですね。ノード シーケンスは次のようになります。
これにより、ドキュメントから Block 定義を取得します。
これらのノードは、Block 内のオブジェクトの Dynamo ジオメトリを取得します。
これらのノードは、基本的にジオメトリの 変換元 の座標系を定義します。
最後に、このノードはジオメトリを変換する実際の作業を行います。
このノードの 最長 レーシングに注目してください。
Dynamo では、次のようになります。
とっておきの朗報です。大変な作業は終わりました。次に行う必要があるのは、プロファイル間にソリッドを生成することだけです。これは、Solid.ByLoft ノードを使用して簡単に行うことができます。
結果は次のようになります。これらは Dynamo ソリッドです。これらを Civil 3D で作成する必要があります。
最後の手順は、生成されたソリッドをモデル空間に出力することです。見やすくするために、色付けもします。
以下に、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 は、複数の図面で実行するように設計されたグラフに適しています。
これは、オブジェクト バインド データがグラフ(.dyn ファイル)ではなく図面内でシリアル化される点を除き、オプション 2 と同様です。グラフを閉じて再度開き、同じ図面で実行すると、すべてが、グラフを閉じる前と同じように動作するはずです。別の図面でグラフを実行すると、バインド データはグラフではなく図面に保存されるため、元の図面でも保持されます。
使用する状況
このオプションは、複数の図面で同じグラフを使用し、Dynamo にそれぞれのグラフで行ったことを「記憶」させる場合に使用します。
このオプションで最初に注意する点は、メインの Dynamo インタフェースでグラフを実行する場合に、グラフと図面の相互作用に影響を与えないことです。このオプションは、Dynamo プレーヤを使用してグラフを実行する場合に のみ 適用されます。
メインの Dynamo インタフェースを使用してグラフを実行し、その後閉じて、次に Dynamo プレーヤを使用して同じグラフを実行すると、以前に作成したオブジェクトの上に新しいオブジェクトが作成されます。ただし、Dynamo プレーヤでグラフを一度実行すると、図面内のオブジェクト バインド データがシリアル化されます。したがって、Dynamo プレーヤでグラフを複数回実行する場合、新しいオブジェクトを作成するのではなく、オブジェクトが更新されます。別の図面で Dynamo プレーヤを使用してグラフを実行した場合、バインド データはグラフではなく図面に保存されるため、元の図面で保持されます。
使用する状況
このオプションは、複数の図面で Dynamo プレーヤを使用してグラフを実行し、各グラフで行ったことを「記憶」させる場合に使用します。
パイプ ネットワークにパイプと構造物を追加する場合、Civil 3D はテンプレートを使用して名前を自動的に割り当てます。通常、初期の配置時にはこの値で十分ですが、設計が進行するにつれて、必然的に名前を変更する必要が出てきます。さらに、要求される命名パターンは多数あります。たとえば、パイプ配管内で最も下流の構造物から始めて構造物に順番に命名したり、現地の関係機関のデータ スキーマに沿った命名パターンに従ったりすることです。この例では、Dynamo を使用して、あらゆるタイプの命名方法を定義して、一貫して適用する方法を示します。
バウンディング ボックスを操作する
List.FilterByBoolMask ノードを使用してデータをフィルタする
List.SortByKey ノードを使用してデータを並べ替える
テキスト文字列を生成および修正する
このグラフは Civil 3D 2020 以降で実行できます。
まず、以下のサンプル ファイルをダウンロードし、DWG ファイルと Dynamo グラフを開きます。
このグラフのロジックの概要を以下に示します。
レイヤ別に構造物を選択する
構造物の位置を取得する
構造物をオフセットでフィルタし、測点で並べ替える
新しい名前を生成する
構造物の名前を変更する
以上です。
最初に、作業する構造物をすべて選択する必要があります。これを行うには、単純に特定のレイヤ上のすべてのオブジェクトを選択します。つまり、異なるパイプ ネットワークから構造物を選択できます(同じレイヤを共有していると仮定します)。
このノードを使用すると、構造物と同じレイヤを共有する可能性のある不要なオブジェクト タイプを誤って取り出すことがなくなります。
構造物が取得できたので、空間内での構造物の位置を特定し、位置に応じて構造物を並べ替えられるようにする必要があります。これを行うには、各オブジェクトのバウンディング ボックスを利用します。オブジェクトのバウンディング ボックスは、オブジェクトのジオメトリ範囲を完全に含む最小サイズのボックスです。バウンディング ボックスの中心を計算することで、構造物の挿入位置に非常に近い値が得られます。
これらの挿入位置を使用し、選択した Alignment を基準にして構造物の測点とオフセットを取得します。
ここでは、少し面倒な作業を開始します。この段階では、指定したレイヤ上のすべての構造物の大きなリストを取得し、それを並べ替える Alignment を選択しました。問題は、名前を変更したくない構造物がリストに含まれている可能性があることです。たとえば、構造物が対象となる特定の経路に含まれていない場合があります。
選択された Alignment
名前を変更する構造物
無視する必要がある構造物
そのため、Alignment からの特定のオフセットよりも外にある構造物は対象に含めないように、構造物のリストをフィルタする必要があります。これは、List.FilterByBoolMask ノードを使用して行うのが最適です。構造物のリストをフィルタした後、List.SortByKey ノードを使用して、測点値で並べ替えます。
構造物のオフセットがしきい値より小さいかどうかを確認する
Null 値を false に置き換える
構造物と測点のリストをフィルタする
構造物を測点で並べ替える
最後に、構造物の新しい名前を作成する必要があります。使用する形式は <alignment name>-STRC-<number>
です。ここに、必要に応じてゼロを追加して数値に埋め込むための追加ノードがいくつかあります(例: 「1」を「01」に)。
最後に、構造物の名前を変更します。
以下に、Dynamo プレーヤを使用してグラフを実行する例を示します。
Dynamo の 3D バックグラウンド プレビューを利用して、最終的な結果だけでなく、グラフの中間出力を視覚化すると便利です。簡単に行える方法の 1 つは、構造物のバウンディング ボックスを表示することです。さらに、この特定のデータセットにはドキュメントにコリドーがあるため、コリドー計画線ジオメトリを Dynamo に取り込んで、構造物が空間内のどこに位置するかを確認することができます。グラフがコリドーを持たないデータセットで使用されている場合、これらのノードは何も実行しません。
これで、オフセットによる構造物のフィルタ処理がどのように機能するかを理解できるようになりました。
このグラフの機能を拡張する方法について、いくつかのアイデアを示します。
特定の Alignment を選択するのではなく、最も近い Alignment に基づいて構造物の名前を変更します。
構造物に加えて パイプの名前も変更します。
経路に基づいて構造物の レイヤを設定します。
Civil 3D で COGO ポイントとポイント グループを使用して作業することは、多くのデータの一貫処理のプロセスの中核となる要素です。Dynamo はデータ管理に関して非常に優れています。この例では、その潜在的な使用例の 1 つを示します。
リストの操作
List.GroupByKey ノードを使用して類似オブジェクトをグループ化する
Dynamo プレーヤでカスタム出力を表示する
このグラフは Civil 3D 2020 以降で実行できます。
まず、以下のサンプル ファイルをダウンロードし、DWG ファイルと Dynamo グラフを開きます。
このグラフのロジックの概要を以下に示します。
ドキュメント内のすべての COGO ポイントを取得する
COGO ポイントを説明でグループ化する
ポイント グループを作成する
概要を Dynamo プレーヤに出力する
以上です。
最初に、ドキュメント内のすべてのポイントグループを取得し、次に各グループ内のすべての COGO ポイントを取得します。これにより、ネストされたリスト、つまり「リストのリスト」が得られます。これは、List.Flatten ノードを使用してリスト全体をフラット化する場合に、後で操作が簡単になります。
すべての COGO ポイントを取得できたので、説明に基づいてグループに分類する必要があります。これは、まさに List.GroupByKey ノードが行う処理です。基本的に、同じキーを共有する項目をグループ化します。
大変な作業は終わりました。最後の手順は、グループ化された COGO ポイントから新しい Civil 3D ポイント グループを作成することです。
グラフを実行しても、ジオメトリを操作していないため、Dynamo の背景プレビューには何も表示されません。グラフが正しく実行されたかどうかを確認する唯一の方法は、ツールスペースを確認するか、ノード出力のプレビューを確認することです。ただし、Dynamo プレーヤを使用してグラフを実行する場合は、作成したポイント グループの概要を出力することで、グラフの結果に関するフィードバックを増やすことができます。必要な操作は、ノードを右クリックして[出力]に設定することだけです。この場合、名前を変更した Watch ノードを使用して結果を表示します。
以下に、Dynamo プレーヤを使用してグラフを実行する例を示します。
このグラフの機能を拡張する方法について、いくつかのアイデアを示します。
ポイントのグループ化を、未処理の説明ではなく 完全な説明 に基づいて行うように修正します。
選択した他の 定義済みカテゴリ (「グラウンド ショット」、「モニュメント」など)によってポイントをグループ化します。
特定のグループのポイントに対して TIN サーフェスを自動的に作成します。
モデル空間にテキストを挿入する Dynamo グラフを作成します。
ミッションが達成されました。
Excel ファイルで指定した測点値でコリドーに沿って照明柱のブロック参照を配置します。
ミッションが達成されました。
水道メーターのブロック参照を区画線から指定したオフセットに配置し、配水本管に垂直に各サービス接続の線分を描画します。
Dynamo の曲線ジオメトリを初めて使用する場合は、「」 セクションを参照してください。
座標系を初めて使用する場合は、「」 セクションを参照してください。
詳細については、 セクションを参照してください。
Dynamo プレーヤを初めて使用する場合は、「」 セクションを参照してください。
ミッションが達成されました。
車両の縦断ブロックを使用して、コリドーに沿ってクリアランスのエンベロープ 3D ソリッドを生成します。
座標系を初めて使用する場合は、「」 セクションを参照してください。
ノード レーシングを初めて使用する場合は、「」 セクションを参照してください。
Dynamo プレーヤを初めて使用する場合は、「」セクションを参照してください。
ミッションが達成されました。
グラフを実行するたびにテキストが削除され、再作成されているように見えます。実際には、選択した円に応じてテキストの位置が 修正 されています。つまり、同じテキストが、別の場所に配置されているだけです。毎回新しいテキストを作成するには、バインド データが保持されないように、Dynamo のオブジェクト バインド設定を修正する必要があります(以下の「」を参照してください)。
Dynamo プレーヤを初めて使用する場合は、「」 セクションを参照してください。
Alignment の測点に基づいて、パイプ ネットワーク構造物の名前を順番に変更します。
リストを初めて使用する場合は、「」 セクションを参照してください。
Dynamo プレーヤを初めて使用する場合は、「」 セクションを参照してください。
ミッションが達成されました。
一意の COGO ポイントの説明ごとにポイント グループを作成します。
リストを初めて使用する場合は、「」 セクションを参照してください。
Dynamo プレーヤを初めて使用する場合は、「」セクションを参照してください。
ミッションが達成されました。
Dynamo プレーヤを使用すると、Civil 3D で Dynamo グラフを簡単に実行することができます。グラフが作成されたら、Dynamo の専門知識がなくても、Dynamo プレーヤを使用してグラフを実行できます。これにより、ノードやワイヤの詳細に関心のない他のユーザとグラフを簡単に共有できます。
Civil 3D の Dynamo プレーヤの詳細については、Civil 3D ヘルプ サイトに提供されているドキュメントを参照してください。
Dynamo は、AEC の世界に向けてコーディングを開始するのに最適です。コーディングの旅を始めるにあたり、次のセクションを参照することをお勧めします。
Dynamo パッケージは、Dynamo のコア機能を拡張するためにサード パーティが開発したツールセットです。すべてのユーザがアクセスでき、ボタンをクリックすることでダウンロードできます。
パッケージの使用を開始する方法の詳細については、「パッケージ」 セクションを参照してください。
Dynamo for Civil 3D のグラフを次のレベルに引き上げることができる最も人気の高いパッケージをいくつかご紹介します。
Civil 3D Toolkit は、追加ノードの大規模なインベントリにより、Dynamo の機能を大幅に強化する Dynamo for Civil 3D パッケージです。
Camber はオープン ソースの Dynamo for Civil 3D パッケージであり、ラベル、外部参照、データ ショートカット、スタイルなどを操作するための数百ものノードが含まれています。
CivilConnection は、Civil 3D、Dynamo、Revit 間での情報交換を可能にするオープン ソースの Revit 用の Dynamo パッケージです。
Arkance Systems Nodes は、Dynamo for Civil 3D パッケージであり、寸法、テーブル、ビュー、ドリル コントロールなどを操作するためのさまざまな便利なノードが用意されています。
コード ブロックは、ビジュアル プログラミング環境をテキストベースの環境に動的にリンクさせる、Dyanamo 独自の機能です。コード ブロックでは、1 つのノードですべての Dynamo ノードにアクセスし、グラフ全体を定義することができます。コード ブロックは Dynamo の基本的な要素です。この章をよく読んで、コード ブロックを理解してください。
Dynamo はビジュアル プログラミング ツールとして非常に強力ですが、ノードやワイヤを超えて、テキスト形式でコードを記述することもできます。これを行うには、次の 2 つの方法があります。
Code Block ノードを使用して DesignScript を記述する
Python ノードを使用して Python を記述する
このセクションでは、Civil 3D 環境で Python を活用して、AutoCAD および Civil 3D .NET API を利用する方法について説明します。
Dynamo での Python の使用に関する一般情報については、「Python」セクションを参照してください。
AutoCAD と Civil 3D にはどちらにも、開発者がカスタム機能を使用してコア製品を拡張できるようにする複数の API が用意されています。Dynamo のコンテキストで関連するのは、Managed .NET API です。次のリンクは、API の構造とその仕組みを理解するために不可欠です。
このセクションを進めていくと、データベース、トランザクション、メソッド、プロパティなど、馴染みのない概念が出てくるかもしれません。これらの概念の多くは、.NET API を使用するための中核であり、Dynamo や Python に固有のものではありません。これらの項目の詳細については、Primer のこのセクションでは取り上げません。詳細については、上記のリンクを頻繁に参照することをお勧めします。
新しい Python ノードを初めて編集すると、開始するためのテンプレート コードがあらかじめ入力されます。ここでは、テンプレートの概要と各ブロックに関する説明を示します。
sys
モジュールおよびclr
モジュールを読み込みます。どちらも Python インタプリタが正しく機能するために必要なモジュールです。特に、clr
モジュールを使用すると、.NET 名前空間を基本的に Python パッケージとして扱うことができます。AutoCAD および Civil 3D のマネージド .NET API を使用するための標準アセンブリ(DLL)をロードします。
標準の AutoCAD および Civil 3D 名前空間に参照設定を追加します。これらは、それぞれ、C# または VB.NET の
using
ディレクティブまたはImports
ディレクティブに相当します。ノードの入力ポートには、
IN
と呼ばれる定義済みのリストを使用してアクセスできます。特定のポートのデータには、そのインデックス番号を使用してアクセスできます(例:dataInFirstPort = IN[0]
)。アクティブなドキュメントおよびエディタを取得します。
ドキュメントをロックし、データベース トランザクションを開始します。
ここに、スクリプトのロジックの大部分を配置する必要があります。
メインの作業が完了した後にトランザクションをコミットするには、この行のコメントを解除します。
ノードからデータを出力する場合は、スクリプトの最後にある変数
OUT
に出力するデータを割り当てます。
カスタマイズする場合
既定の Python テンプレートは、C:\ProgramData\Autodesk\C3D <version>\Dynamo
内の PythonTemplate.py
ファイルを編集することで修正できます。
Dynamo for Civil 3D で Python スクリプトを作成する場合の基本的な概念について、例を見ていきましょう。
:datt: 図面内のすべての集水域の境界ジオメトリを取得します。
この演習で参照できるサンプル ファイルを次に示します。
このグラフのロジックの概要を次に示します。
Civil 3D API のドキュメントを確認する
レイヤ名でドキュメント内のすべての集水域を選択する
Dynamo オブジェクトを「アンラップ」して、内部の Civil 3D API メンバーにアクセスする
AutoCAD の点から Dynamo の点を作成する
点からポリカーブを作成する
以上です。
グラフの作成とコードの作成を開始する前に、Civil 3D API のドキュメントを参照して、API が提供する機能を理解することをお勧めします。この場合、集水域の境界点を返すプロパティが Catchment クラスに存在します。このプロパティは、Dynamo が処理する必要があるオブジェクトとは異なる Point3dCollection
オブジェクトを返すことに注意してください。つまり、Point3dCollection
からポリカーブを作成することはできないため、最終的にはすべてを Dynamo の点に変換する必要があります。詳細については、後で説明します。
これで、グラフ ロジックの作成を開始することができます。最初に、ドキュメント内のすべての集水域のリストを取得します。これに使用できるノードがあるため、Python スクリプトに含める必要はありません。ノードを使用すると、(Python スクリプトに多くのコードを埋め込むんだ場合に比べて)、他のユーザはグラフを読みやすくなり、Python スクリプトは集水域の境界点を返すという 1 つの事柄にも対処できます。
All Objects on Layer ノードからの出力は、CivilObjects のリストであることに注意してください。これは、Dynamo for Civil 3D には現在、集水域を操作するためのノードが存在しないためです。これが、Python を使用して API にアクセスする必要がある理由です。
先に進む前に、重要な概念について簡単に説明する必要があります。「ノード ライブラリ」セクションで、オブジェクトと CivilObjects の関係について説明しました。これをもう少し詳しく説明すると、Dynamo オブジェクト は AutoCAD 図形 のラッパーです。同様に、Dynamo CivilObject は、Civil 3D 図形のラッパーです。InternalDBObject
プロパティまたは InternalObjectId
プロパティにアクセスすることで、オブジェクトを「アンラップ」することができます。
オブジェクト Autodesk.AutoCAD.DynamoNodes.Object
図形 Autodesk.AutoCAD.DatabaseServices.Entity
CivilObject Autodesk.Civil.DynamoNodes.CivilObject
図形 Autodesk.Civil.DatabaseServices.Entity
経験則として、InternalObjectId
プロパティを使用してオブジェクト ID を取得し、トランザクションでラップされたオブジェクトにアクセスする方が一般的に安全です。これは、InternalDBObject
プロパティは書き込み可能な状態でない AutoCAD DBObject を返すためです。
内部の集水域オブジェクトにアクセスして境界点を取得する作業を行う完全な Python スクリプトを以下に示します。ハイライト表示された行は、既定のテンプレート コードから修正または追加された行を表します。
スクリプト内の下線付きのテキストをクリックすると、その行の説明が表示されます。
経験則として、スクリプト ロジックの大部分をトランザクション内に含めることをお勧めします。これにより、スクリプトが読み取り/書き込みを行うオブジェクトに安全にアクセスできるようになります。多くの場合、トランザクションを省略すると致命的なエラーが発生する可能性があります。
この段階では、Python スクリプトは、背景プレビューで確認できるように Dynamo の点のリストを出力する必要があります。最後の手順は、点から単純にポリカーブを作成します。これは Python スクリプトで直接行うこともできますが、より見やすくするために、ノードのスクリプトの外側に意図的に配置しています。最終的なグラフは次のようなものになります。
最終的な Dynamo ジオメトリは次のとおりです。
最後に、注意事項を簡単に説明します。使用している Civil 3D のバージョンに応じて、Python ノードの設定が異なる場合があります。Civil 3D 2020 および 2021 では、Dynamo は IronPython というツールを使用して .NET オブジェクトと Python スクリプトの間でデータを移動しました。Civil 3D 2022 では、Dynamo は Python 3 を使用するのではなく、標準のネイティブ Python インタプリタ(CPython とも呼ばれる)を使用するように移行しました。この移行には、人気のある最新ライブラリや新しいプラットフォーム機能、基本的なメンテナンス、セキュリティ パッチへのアクセスなどのメリットがあります。
この移行の詳細と、従来のスクリプトのアップグレード方法については、Dynamo Blog を参照してください。IronPython を今後も使用する場合は、Dynamo Package Manager を使用して DynamoIronPython2.7 パッケージをインストールする必要があります。
この行は、Dynamo ジオメトリ ライブラリから必要な特定のクラスを取得します。ここでは、import *
ではなく import Point as DynPoint
を指定します。前者の場合は名前の衝突が発生するからです。
ここでは、すべての入力のリスト全体を参照する既定の IN
の代わりに、どの入力ポートに必要なデータが含まれるかを正確に指定します。
このセクションでは、DesignScript を使用するジオメトリの作成に関する一連の演習を紹介します。サンプルの DesignScript を Dynamo のコード ブロックにコピーしながら操作してください。
コード ブロックを使用すると、Dynamo の核となる DesignScript というプログラミング言語を詳しく理解することができます。予備的な設計ワークフローをサポートするためにまったく新しく開発された DesignScript は、簡潔で理解しやすい言語です。短いコードを迅速に変更することも、大規模で複雑な相互作用に対応することもできます。DesignScript は、Dynamo 内部のほとんどの要素を駆動するエンジンの中核でもあります。Dynamo ノード内のほぼすべての機能と相互作用について、スクリプト言語に対する 1 対 1 の関係が存在するため、ノードベースの相互作用とスクリプトを柔軟に切り替えることができます。これは、Dynamo 独自の機能です。
操作に慣れていない初級ユーザのために、ノードを自動的にテキスト構文に変換する機能が用意されています。これにより、DesignScript の理解をサポートしたり、グラフの大きな部分のサイズを簡単に小さくすることができます。この操作は、「ノードをコード化」という処理を使用して実行されます。この処理については、「」のセクションで詳しく説明します。操作に慣れている上級ユーザは、コード ブロックで各種の標準的なコードのパラダイムを使用して、既存の機能とユーザ定義の関係を組み合わせてカスタマイズすることができます。初心者ユーザと上級ユーザの間に位置する中級ユーザについては、設計作業をすばやく行うためのさまざまなショートカットやコード スニペットが用意されています。プログラミング経験のないユーザにとって、「コード ブロック」という言葉は難しそうに感じるかもしれませんが、使用方法も簡単で、安定して動作します。初級ユーザは、最小限のコードを記述してコード ブロックを効率的に使用でき、上級ユーザは、Dynamo 定義内の任意の場所で呼び出すことのできるスクリプト定義を作成することができます。
コード ブロックとは、一言でいうと、ビジュアル スクリプティング環境内で使用するテキスト スクリプティング インタフェースです。コード ブロックは、数値、文字列、式などのデータ タイプとして使用することができます。コード ブロックは Dynamo 専用に設計されているため、コード ブロック内で任意の変数を定義することができます。定義した変数は、自動的にノードの入力に追加されます。
コード ブロックを使用すると、入力値の指定方法を柔軟に決定することができます。(10, 5, 0) という座標の基本的な点を作成するには、次のようにいくつかの方法があります。
ライブラリ内の使用可能な各種の関数に慣れてくると、「Point.ByCoordinates」と入力する方が、ライブラリ内を検索して目的のノードを探すよりも早いということがわかるようになります。「Point.」と入力すると、点に対して適用できる関数のリストが表示されます。これにより、直感的にスクリプトを作成することができ、Dynamo で関数を適用する方法を理解することができます。
Code Block ノードは、[Core] > [Input] > [Actions] > [Code Block] で使用することができます。または、キャンバス上でダブルクリックするだけで Code Block ノードが表示されます。この方が簡単です。Code Block ノードは頻繁に使用されるため、キャンバス上でダブルクリックするだけで Code Block ノードが表示されるようになっています。
Code Block ノードを使用すると、データ タイプについても柔軟に操作することができます。Code Block ノードを使用して、数値、文字列、式をすばやく定義し、目的の値を出力することができます。
次の図を見ると、値を定義するための従来の方法(左側の方法)は少し冗長であることがわかります。この方法では、インタフェース内で目的のノードを検索してキャンバスに追加し、データを入力する必要があります。Code Block ノードを使用すると、キャンバス上でダブルクリックするだけで Code Block ノードを表示し、基本的な構文で正しいデータ タイプを入力することができます。
Code Block ノードと比べた場合、Number、String、Formula の各ノードは旧式のノードということができます。
従来の方法
コード ブロック
関数は Code Block ノード内で作成することができ、Dynamo 定義の任意の場所から呼び出すことができます。これにより、パラメトリック ファイル内に新しいコントロール レイヤーが追加されます。Code Block ノードは、テキストベースのカスタム ノードとしてみなすことができます。この場合、「親」コード ブロックに簡単にアクセスすることができます。親コード ブロックは、グラフ上の任意の場所に配置することができます。ワイヤは必要ありません。
最初の行に、キーワードの「def」と関数名を続けて入力し、入力データの名前を括弧で囲んで記述します。関数の本文を定義する場合は、波括弧 {} を使用します。値を返す場合は、「return =」を指定します。関数を定義する Code Block ノードは他の Code Block ノードから呼び出されるため、入力ポートと出力ポートはありません。
関数を呼び出すには、同じファイル内で別の Code Block ノードを使用して、呼び出す関数の名前と、親 Code Block ノードで定義されているものと同じ数の引数を指定します。これは、ライブラリ内に用意されているノードと同様に動作します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習では、点の入力リストから球体を生成する一般的な定義を作成します。これらの球体の半径は、各点の Z プロパティによってコントロールされます。
最初に、0 から 100 までの範囲内で 10 個の数値を作成しましょう。これらの数値を Point.ByCoordinates ノードに接続し、斜線を作成します。
Code Block ノードを作成して、定義を追加します。
次のコード行を使用します。
inputPt は、関数をコントロールする点を表す名前です。この時点では、この関数はまだ機能しませんが、これ以降の手順でこの関数を設定していきます。
Code Block ノードを使用して、この関数にコメントと sphereRadius 変数を入力します。この変数により、各点の Z 位置のクエリーが実行されます。inputPt.Z はメソッドであるため、引数を指定するための括弧は必要ありません。これは既存の要素のプロパティの クエリー であるため、入力は必要ありません。
ここで、別の Code Block ノードで作成した関数を呼び出してみましょう。キャンバスをダブルクリックして新しい Code Block ノードを作成し、sphereB と入力すると、既に定義されている sphereByZ 関数が候補として表示されます。これにより、前の手順で作成した関数が IntelliSense ライブラリに追加されていることがわかります。
関数を呼び出して Pt という変数を作成して、前の手順で作成した点を接続します。
出力されたリストを確認すると、値がすべて NULL になっていることがわかります。なぜでしょうか。これは、この関数を定義するときに sphereRadius 変数は計算しましたが、この関数が何を 出力 として 返す のかを定義しなかったためです。これについては、次の手順で修正します。
sphereByZ 関数に
return = sphereRadius;
というコード行を追加して、関数の出力を定義する必要があります。これは重要な手順です。Code Block ノードの出力は、各点の Z 座標です。
親 関数を編集して、実際に球体を作成してみましょう。
まず、次のコード行で球体を定義します。
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
次に、戻り値が sphereRadius から sphere となるように
return = sphere;
と記述します。これにより、Dynamo プレビューで非常に大きな球体が表示されます。
1.これらの球体のサイズを調整するには、
sphereRadius = inputPt.Z/20;
という除数を追加して sphereRadius 値を更新します。これで、各球体が離れて表示され、半径と Z 値との関係がわかるようになります。
Point.ByCoordinates ノードでレーシングを[最短リスト]から[直積]に変更して、点のグリッドを作成します。sphereByZ 関数により、すべての点で Z 値に基づいた半径の円が作成されます。
次に、Point.ByCoordinates ノードの X 入力に元の数値のリストを接続してみます。この操作により、球体によって構成される立方体が作成されます。
注: この処理に時間がかかる場合は、#10 を #5 などの値に変更してください。
ここで作成した sphereByZ 関数は汎用的な関数であるため、前の演習で作成したらせん構造を呼び出して、この関数を適用することができます。
最後に、半径の比をユーザ設定のパラメータでコントロールしてみましょう。これを行うには、関数に対して新しい入力を作成し、除数の 20 をパラメータで置き換える必要があります。
sphereByZ 関数の定義を、次のように更新します。
sphereByZ(Pt,ratio);
のように、子の Code Block ノードの入力に ratio 変数を追加して更新します。次に、新しく作成した Code Block ノードの入力に Number Slider ノードを接続し、半径の比に基づいて半径のサイズを変更します。
Dynamo のノード名に共通の形式があることにお気付きでしょうか。各ノードはスペースなしの「.」構文を使用しています。これは、各ノードの最上部にあるテキストがスクリプトの実際の構文を表しており、「.」(ドット表記)が呼び出し可能なメソッドと要素を区切っています。これにより、ビジュアル スクリプトから文字ベースのスクリプトに簡単に変換することができます。
ドット表記の一般的な使用例として、apple (リンゴ)というパラメータが Dynamo でどのように処理されるか見てみましょう。以下は、リンゴを食べる前にリンゴに対して実行するいくつかのメソッドを示しています。(注: これらは Dynamo の実際のメソッドではありません)。
読者がどう思われるかはわかりませんが、上記の表の出力から判断すると、私にはおいしいリンゴのように見えます。Apple.eat() を実行しようと思います。
リンゴの例を念頭に置きながら、Point.ByCoordinates で Code Block を使用して点を作成する方法を見てみましょう。
Code Block ノードの構文 Point.ByCoordinates(0,10);
は、Dynamo の Point.ByCoordinates ノードと同じ結果を生成します。ただし、1 つのノードを使用して点を作成できるという違いがあります。x 入力と y 入力に異なるノードを接続する必要がないため、より効率的です。
Code Block で Point.ByCoordinates を使用することにより、初期設定のままのノード (x,y) と同じ順番で入力を指定します。
ライブラリ内の通常のノードは、Code Block を通じて呼び出すことができます。ただし、特別なユーザ インタフェース機能を持つ特別な UI ノード は呼び出すことができません。たとえば、Circle.ByCenterPointRadius を呼び出すことはできますが、Watch 3D ノードを呼び出すことは意味がありません。
通常の(ライブラリのほとんどの)ノードは一般的に 3 つのタイプに分けられます。ライブラリはこれらのカテゴリに基づいて編成されています。これらの 3 つのタイプのメソッド(ノード)では、Code Block で呼び出されるときの処理がそれぞれ異なります。
Create - 何かを作成(または構築)します
Action - 何かに対してアクションを実行します
Query - 既に存在する何かのプロパティを取得します
[Create]カテゴリはジオメトリを一から構築します。Code Block には値を左から右に入力します。これらの入力の順番は、上から下に入力するノードの入力の順序と同じです。
Line.ByStartPointEndPoint ノードと、Code Block 内の対応する構文とでは、同じ結果が生成されます。
このタイプのオブジェクトに対してはアクションを行います。Dynamo は(多くのコーディング言語で一般的な) ドット表記 を使用して、対象に対してアクションを適用します。対象とするオブジェクトを決めたら、ドットに続けてアクション名を入力します。Action タイプのメソッドの入力は、Create タイプのメソッドと同様、括弧で囲んで指定されます。ただし、対応するノードの最初の入力を指定する必要はありません。代わりに、アクションの実行対象の要素を指定します。
Point.Add ノードは Action タイプのノードであるため、構文の動作が多少異なります。
入力は(1) point と、(2)その点に追加する vector の 2 つです。Code Block では、点(対象)に「pt」という名前を付けています。*“vec” *という名前のベクトルを「pt」に追加するには、pt.Add(vec)、つまり「対象、ドット、アクション」の形式で書き込みます。Add アクションの入力は 1 つのみであるか、または Point.Add ノードの最初の入力を除くすべての入力になります。Point.Add ノードの最初の入力は点自体です。
Query タイプのメソッドはオブジェクトのプロパティを取得します。オブジェクト自体が入力であるため、入力を指定する必要はありません。括弧は必要ありません。
ノードを使用するレーシングと、Code Block を使用するレーシングとは少々異なります。ノードを使用する場合、ユーザはノードを右クリックして、実行するレーシング オプションを選択します。Code Block を使用する場合、ユーザはデータを構築する方法をより詳しくコントロールできます。Code Block の省略表記では、複製ガイド を使用して、複数の 1 次元リストをペアリングする方法を設定します。山括弧「<>」内の数値(<1>、<2>、<3> など)は、生成するネストされたリストの階層を設定します。
この例では、省略表記で 2 つの範囲を設定します(省略表記については、この章の次のセクションで詳しく説明します)。つまり、
0..1;
は{0,1}
に相当し、-3..-7
は{-3,-4,-5,-6,-7}
に相当します。この結果、2 つの x 値と 5 つの y 値のリストが返されます。このような範囲が一致していないリストを持つ複製ガイドを使用しない場合は、2 つの点が含まれるリストが返され、リストの長さは短い方の長さになります。複製ガイドを使用すると、2 つの値と 5 つの値を組み合わせたすべての座標(または外積)を表示できます。構文 Point.ByCoordinates
(x_vals<1>,y_vals<2>);
を使用すると、それぞれ 5 つの項目を含む 2 つのリストが生成されます。構文 Point.ByCoordinates
(x_vals<2>,y_vals<1>);
を使用すると、それぞれ 2 つの項目を含む 5 つのリストが生成されます。
この表記では、5 つの項目を持つ 2 つのリストと 2 つの項目を持つ 5 つのリストのどちらを優先リストにするか指定することもできます。例では、複製ガイドの順番を変更することにより、グリッドの点の行のリストまたは列のリストを生成できます。
Code Block を使用する上記の方法を使用するには多少の慣れが必要ですが、Dynamo には処理を容易にする[ノードをコード化]という機能があります。この機能を使用するには、Dynamo グラフでノードの配列を選択し、キャンバスを右クリックして、[ノードをコード化]を選択します。Dynamo はこれらのノードを、すべての入力と出力を含め、1 つの Code Block に統合します。このツールは Code Block の学習に役立つだけでなく、より効率的でパラメトリックな Dynamo グラフの使用を可能にします。次の演習では最後に[ノードをコード化]を使用します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
Code Block の性能を紹介するため、既存のアトラクタ フィールドの設定を Code Block の形式に変換します。既存の設定を使用することにより、Code Block がビジュアル スクリプトとどのように関連付けられているかを確認し、DesignScript 構文について学習します。
まず、上記の画像の設定を再作成します(またはサンプル ファイルを開きます)。
Point.ByCoordinates ノードのレーシングが 外積 に設定されていることに注目してください。
グリッド内の各点は、参照点までの距離に基づいて Z の正の向きに移動します。
サーフェスが再作成されて厚みが付けられ、参照点までの距離を基準にしてジオメトリ内にふくらみが作成されます。
まず、参照点 Point.ByCoordinates
(x,y,0);
を定義します。参照点ノードの最上部で指定したものと同じ Point.ByCoordinates 構文を使用します。Code Block に変数 x と y が挿入され、スライダを使用してこれらを動的に更新できます。
-50 から 50 までの範囲の スライダ をいくつか Code Block ノードの入力に追加します。これにより、既定の Dynamo グリッド全体を使用できます。
Code Block ノードの 2 行目で、数値シーケンス ノードを置き換える省略表記を定義します。
coordsXY = (-50..50..#11);
これについては、次のセクションで詳しく説明します。ここでは、この省略表記がビジュアル スクリプトの Number Sequence ノードに相当していることを確認してください。
次に、coordsXY シーケンスから点のグリッドを作成します。これを行うには Point.ByCoordinates 構文を使用します。ただし、ビジュアル スクリプトで実行した場合と同様、リストにある 外積 を作成する必要もあります。これを行うには、行(
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);
)を入力します。山括弧は外積参照を意味します。Watch3D ノードには Dynamo のグリッド全体に点のグリッドが表示されます。
少し難しくなってきますが、ここで、点のグリッドを参照点までの距離に基づいて上方向に移動する必要があります。まず新しい点のセット transPts を呼び出しましょう。変換は既存の要素に対するアクションであるため、
Geometry.Translate...
ではなくgridPts.Translate
を使用します。キャンバス上の実際のノードから、3 つの入力があることが読み取れます。変換するジオメトリは既に宣言されています。この要素に対して、gridPts.Translate を使用してアクションを実行しているためです。残りの 2 つの入力は関数 direction と distance の括弧内に挿入されます。
方向の指定は簡単です。
Vector.ZAxis()
を使用して垂直方向に移動します。参照点と各グリッド間の距離は計算する必要があります。これは同様に、参照点に対するアクションとして実行します:
refPt.DistanceTo(gridPts)
。最後のコード行は、変換された点を示します:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
。
これで適切なデータ構造を持つ点のグリッドを使用して NURBS サーフェスを作成できます。
srf = NurbsSurface.ByControlPoints(transPts);
を使用してサーフェスを作成します。
最後に、サーフェスに深さを追加するため、
solid = srf.Thicken(5);
を使用してソリッドを構築します。ここではコードで 5 単位を指定して厚みを付けますが、これを変数として(thickness などの名前を付けて)宣言し、スライダを使用して値をコントロールすることも可能です。
[ノードをコード化]機能を使用すると、先ほど終了した演習全体を、ボタンをクリックするだけで自動化できます。このツールはカスタム設定や再利用可能な Code Block の作成に優れているだけでなく、Dynamo でスクリプトを作成する方法を学習するのにも役立ちます。
まず、この演習の手順 1 で使用したビジュアル スクリプトを操作してみます。すべてのノードを選択し、キャンバスを右クリックして、[ノードをコード化]を選択します。非常に簡単です。
Dynamo はビジュアル グラフ、レーシングなどの文字ベースのバージョンを自動化しています。これをビジュアル スクリプトでテストして、Code Block の性能をお試しください。
Dynamo の標準のジオメトリ ライブラリで最も単純なジオメトリ オブジェクトは、点です。すべてのジオメトリはコンストラクタという特別な関数を使用して作成され、各関数はその特定のジオメトリ タイプの新しいインスタンスを返します。Dynamo では、コンストラクタの名前はオブジェクトのタイプ(この場合は Point)で始まり、構築メソッドが続きます。X、Y、Z のデカルト座標で指定された 3 次元の点を作成するには、次のように ByCoordinates コンストラクタを使用します。
Dynamo では、コンストラクタは通常、接頭表記「By」を使用して指定され、これらの関数を呼び出すと、そのタイプの新しく作成されたオブジェクトを返します。この新しく作成されたオブジェクトは、等号の左側にある名前の変数に格納されます。
ほとんどのオブジェクトには、多種多様なコンストラクタがあり、次のように BySphericalCoordinates コンストラクタを使用すると、球の半径、1 番目の回転角度、2 番目の回転角度(度単位)を指定して、球体上の点を作成できます。
点を使用して、線分などのより高い次元のジオメトリを構築できます。次のように ByStartPointEndPoint コンストラクタを使用すると、2 つの点の間に Line オブジェクトを作成できます。
同様に、線分を使用してより高い次元のサーフェス ジオメトリを作成できます。たとえば、Loft コンストラクタを使用すると、一連の線分または曲線を使用してその間にサーフェスを補間します。
サーフェスを使用してより高い次元のソリッド ジオメトリを作成することもできます。たとえば指定した距離だけサーフェスに厚みを付けてソリッドを作成します。多くのオブジェクトには、メソッドと呼ばれる関数がアタッチされ、これを使用することでプログラマはその特定のオブジェクトに関するコマンドを実行できます。ジオメトリのすべてのピースに共通するメソッドには、Translate および Rotate があり、それぞれ指定した量だけジオメトリを移動および回転します。サーフェスには Thicken メソッドがあり、1 つの数字を入力してサーフェスの新しい厚みを指定します。
Intersection コマンドによって、高い次元のオブジェクトから低い次元のジオメトリを抽出できます。この抽出された低い次元のジオメトリは、ジオメトリの作成、抽出、再作成を繰り返すことで、高い次元のジオメトリの基盤を形成できます。この例では、生成されたソリッドを使用してサーフェスを作成し、そのサーフェスを使用して曲線を作成します。
Code Block にはデータ管理を 大幅に 容易にする基本的な省略表記方法がいくつかあります。ここでは基本の概要を示し、この省略表記をデータの作成とクエリーの両方に使用する方法を説明します。
基本的な省略表記を組み合わせることで、範囲とシーケンスを設定することができます。下記の画像を「..」構文のガイドとして参照し、Code Block を使用して数値データのリストを設定してみましょう。この表記に慣れると、数値データを効率的に作成できるようになります。
この例では、数値範囲を
beginning..end..step-size;
の基本的な Code Block 構文で置き換えて設定します。数値で表すと、0..10..1;
になります。構文
0..10..1;
は0..10;
と同等です。ステップサイズの 1 は、省略表記の既定値です。つまり、0..10;
はステップサイズが 1 であるシーケンス 0 から 10 を表しています。シーケンス の例も同様です。ただし、「#」を使用して、15 までの値を含むリストではなく、15 個の値を含むリストを指定しています。このケースでは、
beginning..#ofSteps..step-size:
を定義しています。シーケンスの実際の構文は0..#15..2
です。今度は前の手順の「#」を構文の step-size 部分に配置してみましょう。これで、数値範囲 は beginning から end に設定され、これらの 2 つの間の値が step-size 表記に指定された値で均等に分割されます:
beginning..end..#ofSteps
高度な範囲を作成すると、リストのリストを簡単な方法で使用できます。次の例では、メイン範囲の表記から変数を分離して、このリストに別の範囲を作成します。
1.ネストされた範囲を作成して、「#」が指定されている表記と指定されていない表記とを比較してみましょう。ロジックは基本的な範囲と同じですが、多少複雑になります。
2.サブ範囲はメイン範囲内の任意の場所に設定できます。また、2 つのサブ範囲を設定することもできます。
3.範囲内の「end」値をコントロールすることにより、長さが異なる範囲を追加で作成できます。
ロジックの演習として上記の 2 つの省略表記を比較し、サブ範囲 と # 表記が出力をどのようにコントロールしているかを読み解いてください。
リストは省略表記を使用して作成できる他、すばやく作成することも可能です。これらのリストには幅広い要素タイプを含めることができ、クエリーを実行することも可能です(リストはリスト自体がオブジェクトです)。簡単に言うと、Code Block でブラケット(角括弧)を使用してリストを作成し、リスト内の項目のクエリーを実行します。
1.文字列を使用してリストをすばやく作成し、項目のインデックスを使用してクエリーを実行します。
2.変数を使用してリストを作成し、範囲の省略表記を使用してクエリーを実行します。
ネストされたリストを管理するプロセスは同様です。リストの順番に配慮し、複数の角括弧のセットを使用します。
1.リストのリストを設定します。
2.1 つの角括弧の表記を使用してクエリーを実行します。
3.2 つの角括弧の表記を使用して項目のクエリーを実行します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
この演習では、新しい省略表記のスキルを使用して範囲と式を設定し、一風変わった卵型のサーフェスを作成します。この演習では、Code Block と既存の Dynamo ノードを並行して使用する方法を学習します。Dynamo ノードを視覚的に配置して設定を確認しながら、Code Block を使用して大きなデータを処理します。
まず上記のノードを接続してサーフェスを作成します。数値ノードを使用して幅と長さを設定する代わりに、キャンバスをダブルクリックして、Code Block に 100;
と入力します。
Code Block に
0..1..#50
と入力して、0 から 1 の範囲を 50 個に分割するように設定します。範囲を Surface.PointAtParameter ノードに接続します。これは 0 から 1 の範囲内にある u と v の値を取得してサーフェス全体に設定します。Surface.PointAtParameter ノードを右クリックし、レーシングを[外積]に変更します。
この手順では、最初の関数を適用して、グリッドを Z の正の向きに移動します。このグリッドは基盤となる関数に基づいて生成されるサーフェスをコントロールします。下図に示すように、新しいノードを追加します。
式ノードを使用する代わりに、Code Block を使用して
(0..Math.Sin(x*360)..#50)*5;
を指定します。この式を簡単に分割して説明するために、式内に範囲を設定します。この式は正弦関数です。正弦関数は Dynamo で角度(度)入力を受け取ります。このため、完全な正弦波を取得するには、x 値(0 から 1 までの入力範囲)を 360 で乗算します。次に、各行のコントロール グリッドの点と同じ数だけ分割するため、#50 を指定して 50 個のサブディビジョンを設定します。最後に、Dynamo プレビューで効果を確認できるようにするため、累乗の指数に 5 を指定して変換の振幅を大きくします。
以前の Code Block は正常に動作しましたが、完全にパラメータではありませんでした。動的にパラメータをコントロールするため、前の手順の行を
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;
に置き換えます。こうすることで、これらの値を入力に基づいて設定できるようになります。
スライダ(範囲 0 から 10)を変更して、どのような結果が生じるか確認します。
数値範囲を転置することにより、カーテン ウェーブの方向を反転します:
transposeList = List.Transpose(sineList);
。
sineList と tranposeList を追加すると、歪曲した卵型のサーフェスが生成されます:
eggShellList = sineList+transposeList;
。
以下に指定するスライダの値を変更して、このアルゴリズムをなだらかにします。
最後に、Code Block を使用して、データの一部のクエリーを実行しましょう。特定の範囲の点を指定してサーフェスを再生成するには、Geometry.Translate ノードと NurbsSurface.ByPoints ノードの間に上記の Code Block ノードを追加します。sineStrips[0..15..1];
が指定されています。これにより、50 行の最初の 16 行の点が選択されます。サーフェスを再作成すると、点のグリッドの一部が分離されて生成されていることがわかります。
最後の手順では、この Code Block をよりパラメトリックなものにするため、範囲 0 から 1 のスライダを使用してクエリーをコントロールします。これは、次のコード行で行います。
sineStrips[0..((List.Count(sineStrips)-1)*u)];
わかりにくいかもしれませんが、このコード行により、リストの長さを乗数 0 から 1 の値を使用してすばやくスケールできます。
スライダに 0.53
の値を設定すると、グリッドの中央をわずかに超えるサーフェスが作成されます。
想定どおり、スライダを 1
に設定すると、すべての点のグリッドを使用してサーフェスが作成されます。
ビジュアル プログラムを参照する際、Code Block をハイライト表示して Code Block ノードの各関数を確認できます。
1.最初の Code Block ノードは Number ノードを置き換えます。
2.2 番目の Code Block ノードは Number Range ノードを置き換えます。
3.3 番目の Code Block ノードは Formula ノード(および List.Transpose、List.Count、Number Range の各ノード)を置き換えます。
4.4 番目の Code Block ノードはリストのリストのクエリーを実行し、List.GetItemAtIndex ノードを置き換えます。
ミッションが達成されました。
データ タイプ
標準 Dynamo
Code Block の同等表記
数値
文字列
シーケンス
範囲
インデックスでの項目の取得
リストの作成
文字列の連結
条件ステートメント
ノード
Code Block の同等表記
注
演算子(+、&&、>=、Not など)
+、&&、>=、! など
「Not」は「!」になりますが、「Factorial」(階乗)と区別するためにノードは「Not」と呼ばれます
ブールの True
true;
小文字を使用します
ブールの False
false;
小文字を使用します
リンゴは何色ですか?
Apple.color
red
リンゴは熟していますか?
Apple.isRipe
true
リンゴの重さはどのくらいですか?
Apple.weight
6 oz
リンゴはどこで生まれましたか?
Apple.parent
tree
リンゴは何を作りますか?
Apple.children
seeds
このリンゴは地元で育てられましたか?
Apple.distanceFromOrchard
60 mi.
2 次元のアナログから NURBS 曲線への変換が NURBS 曲面であり、フリーフォーム NURBS 曲線のように、2 つの基本的な方法で NURBS 曲面を構築できます。その方法とは、基点のセットを入力して Dynamo によってその間を補間する方法と、サーフェスの制御点を明示的に指定する方法です。また、フリーフォーム曲線のように、補間によるサーフェスは、サーフェスが取るべき形状を設計者が正確に認識している場合や、サーフェスが拘束点を通過することが必要な設計の場合に便利です。一方、制御点によって作成されたサーフェスは、さまざまなスムージング レベルで実験的な設計を行う場合に便利です。
補間されたサーフェスを作成するには、サーフェスの形状を近似する 2 次元の点の集合を生成するだけです。集合は、長方形であることが必要です。つまり、ギザギザではありません。NurbsSurface.ByPoints メソッドで、これらの点からサーフェスが構築されます。
フリーフォーム NURBS 曲面も、サーフェスの基礎となる制御点を指定することで作成できます。NURBS 曲線のように、制御点は直線セグメントによる四角形のメッシュを表すと考えることができ、このメッシュはサーフェスの次数に応じてスムージングされて最終的なサーフェス形状となります。NURBS 曲面を制御点によって作成するには、2 つのパラメータを NurbsSurface.ByPoints に追加して、サーフェスの両方向での基礎となる曲線の次数を示します。
NURBS 曲面の次数を増やして、結果として得られるサーフェス ジオメトリを変更できます。
サーフェスは、一連の入力された点の間を補間することで作成できるのと同様に、一連のベースとなる曲線の間を補間することで作成できます。これをロフトと呼びます。ロフトによるサーフェスは、Surface.ByLoft コンストラクタを使用して、入力された曲線の集合のみをパラメータとして作成されます。
回転のサーフェスは別のタイプのサーフェスで、中心軸を中心にベースとなる曲線をスイープして作成されます。補間されたサーフェスが 2 次元のアナログから補間された曲線への変換だとすると、回転のサーフェスは、2 次元のアナログから円や円弧への変換です。
回転のサーフェスは、サーフェスの「エッジ」を表すベースとなる曲線、サーフェスの基点となる軸の原点、中心の「核」の方向となる軸方向、スイープの開始角度、およびスイープの終了角度によって指定されます。これらは Surface.Revolve コンストラクタへの入力として使用されます。
3 次元空間で X、Y、Z 座標を明示的に指定することで、特定のジオメトリ オブジェクトを作成できます。ただし、多くの場合、オブジェクト自体またはその基礎となる座標系でジオメトリ変換を使用して、ジオメトリを最終的な位置に移動します。
最も単純な幾何学的変換は移動であり、オブジェクトを X、Y、Z 軸方向に指定した単位の数だけ動かします。
Dynamo 内のすべてのオブジェクトは、オブジェクト名の末尾に .Translate メソッドを追加することで移動できますが、より複雑な変換では、基礎となる座標系から新しい座標系にオブジェクトを変換する必要があります。たとえば、オブジェクトを X 軸を中心にして 45 度回転させるには、回転していない既存の座標系から、.Transform メソッドで X 軸を中心にして 45 度回転した座標系にオブジェクトを移動します。
移動と回転に加えて、スケール変更やせん断変形された座標系も作成できます。座標系のスケールは .Scale メソッドを使用して変更できます。
せん断変形された座標系は、非直交ベクトルを CoordinateSystem コンストラクタに入力することで作成されます。
スケール変更とせん断変形は回転や移動よりも比較的複雑なジオメトリ変換であるため、すべての Dynamo オブジェクトで実行できるわけではありません。次の表は、スケールが均一でない座標系およびせん断変形された座標系を持つことができる Dynamo オブジェクトの概略です。
円弧
不可
不可
NURBS 曲線
可
可
NURBS 曲面
不可
不可
円
不可
不可
線分
可
可
平面
不可
不可
点
可
可
ポリゴン
不可
不可
ソリッド
不可
不可
サーフェス
不可
不可
文字
不可
不可
Dynamo でのフリーフォーム曲線の作成には、基本的な方法が 2 つあります。点の集合を指定して、Dynamo によってその間に滑らかな曲線を補間する方法と、特定の次数の曲線の基礎となる制御点を指定する、より低レベルのメソッドです。補間による曲線は、線分が取るべき形状を設計者が正確に認識している場合や、曲線が通過できる場所と通過できない場所に対する特定の拘束が設計に含まれている場合に便利です。制御点を介して指定された曲線は、本質的には一連の直線セグメントであり、アルゴリズムによってスムージングされて最終的な曲線形状となります。制御点を介して曲線を指定することは、さまざまな次数のスムージングで曲線形状を検討する場合や、曲線セグメント間でスムーズな連続性が必要な場合に便利です。
補間された曲線を作成するには、点の集合を NurbsCurve.ByPoints メソッドに渡すのみです。
生成された曲線は入力された点それぞれと交差し、集合の最初の点から始まり、最後の点で終わります。オプションの周期パラメータを使用すると、閉じた周期的な曲線を作成できます。Dynamo では欠落しているセグメントは自動的に入力されるので、重複する終了点(開始点と同一)は必要ありません。
NURBS 曲線はほぼ同じ方法で生成され、入力された点は直線セグメントの端点を表し、次数と呼ばれる 2 番目のパラメータによって、曲線のスムージングの量とタイプが指定されます。* 次数が 1 の曲線はスムーズな部分がなく、ポリラインとなります。
次数が 2 の曲線は、曲線が交差し、ポリライン セグメントの中点と正接するようにスムージングされます。
Dynamo では、次数 20 までの NURBS (Non-Uniform Rational B Spline、非一様有理 B スプライン)曲線がサポートされます。次のスクリプトは、スムージング レベルの増加が曲線の形状に与える効果を示します。
制御点の数は、曲線の次数よりも少なくとも 1 つ多くする必要があります。
制御頂点による曲線の構築には、個々の曲線セグメント間で正接状態を維持できるという利点もあります。最後の 2 つの制御点間の方向が抽出され、この方向がそれに続く曲線の最初の 2 つの制御点で継続されることによって正接を維持します。次の例では、別々であっても 1 つの曲線のようにスムーズな 2 つの NURBS 曲線が作成されます。
*これは、NURBS 曲線ジオメトリについての非常に簡単な説明です。より正確かつ詳細な説明については、Pottmann 氏その他(2007 年)の考察を参照してください。
計算設計ではオブジェクトが最終的な位置や形状で明示的に作成されることはほとんどなく、通常は既存のジオメトリに基づいて、移動、回転、およびその他の方法で配置されます。ベクトル計算は、幾何学的な足場の一種として機能することで方向およびジオメトリに対する向きを示し、視覚的に表示せずに 3D 空間での動きを概念化します。
最も基本的には、ベクトルは 3D 空間における位置を表し、通常は(0, 0, 0)の位置からその位置までの矢印の終了点と考えられます。ベクトルは ByCoordinates コンストラクタで、新しく作成される Vector オブジェクトの X、Y、Z の位置を指定することで作成できます。Vector オブジェクトはジオメトリ オブジェクトではないため、Dynamo ウィンドウには表示されません。ただし、新しく作成または修正されたベクトルに関する情報は、コンソール ウィンドウに出力されます。
一連の算術演算が Vector オブジェクトで定義されることによって数直線上の 1 次元空間で実数を移動するように、3 次元空間で加算、減算、乗算、およびその他の方法でオブジェクトを移動できます。
ベクトルの加算は、2 つのベクトルのコンポーネントの合計として定義され、2 つのコンポーネントのベクトルの矢印が「後端に先端が付く」形で配置された場合に結果として得られるベクトルと考えることができます。 ベクトルの加算は Add メソッドを使用して実行され、左側のダイアグラムで表示されます。
同様に、2 つの Vector オブジェクトは、Subtract メソッドを使用して互いに減算できます。ベクトルの減算は 1 番目のベクトルから 2 番目のベクトルへの方向と考えることができます。
ベクトルの乗算はベクトルの終了点がそのベクトル自身の方向に所定のスケール係数だけ移動すると考えることができます。
通常、ベクトルのスケールを変更する場合には、結果として得られるベクトルの長さをスケール変更された量と正確に同じにすることが求められます。これは、最初にベクトルを正規化する、つまり、ベクトルの長さが正確に 1 に等しくなるように設定することで、容易に実行できます。
c の長さは正確に 5 に等しいですが、a (1, 2, 3)と同じ方向を向いたままです。
ベクトル計算には 1 次元の計算とは明確な類似点のないメソッドがさらに 2 つあります。外積と内積です。外積は、2 つの既存のベクトルに対して(90 度で)直交するベクトルを生成する手段です。たとえば、X 軸と Y 軸の外積は Z 軸です。ただし、2 つの入力ベクトルが互いに直交している必要はありません。外積ベクトルは Cross メソッドを使用して計算されます。
ベクトル計算のさらに少し高度な関数が内積です。2 つのベクトル間の内積は、2 つのベクトル間の角度に関係する実数(Vector オブジェクトではない)ですが、角度そのものではありません。内積の便利なプロパティの 1 つとして、2 つのベクトルが垂直の場合、かつ垂直の場合に限り、そのベクトル間の内積が 0 となります。内積は Dot メソッドを使用して計算されます。
Dynamo が多様で複雑なジオメトリ形状を作成できる一方で、単純なジオメトリ プリミティブは、任意の計算設計の中核となり、設計された最終形状で直接表現されるか、より複雑なジオメトリを生成するための足場として使用されます。
厳密にはジオメトリの一部ではありませんが、CoordinateSystem はジオメトリを構築するための重要なツールです。CoordinateSystem オブジェクトは、位置および回転、せん断変形、スケーリングなどのジオメトリ変換の両方を把握します。
x = 0、y = 0、z = 0 の点を中心とし、回転、スケーリング、せん断変形などの変換がない CoordinateSystem の作成に必要なのは、Identity コンストラクタを呼び出すことのみです。
CoordinateSystem.ByOriginVectors という別のコンストラクタを使用すると、次のように特定の点に座標系を作成できますが、ジオメトリ変換された CoordinateSystem については、この章で説明しません。
最も単純なジオメトリ プリミティブは点であり、3 次元空間でゼロ次元の場所を表します。前に説明したように、特定の座標系での点の作成には、いくつかの異なる方法があります。Point.ByCoordinates は X、Y、Z 座標を指定して点を作成し、Point.ByCartesianCoordinates は特定の座標系で X、Y、Z 座標を指定して点を作成し、Point.ByCylindricalCoordinates は半径、回転角度、および高さを使用して円柱上にある点を作成し、Point.BySphericalCoordinates は半径と 2 つの回転角度を使用して球上にある点を作成します。
この例は、さまざまな座標系で作成された点を示しています。
次に高い次元の Dynamo プリミティブは線分セグメントで、2 つの端点間にある無限の数の点を表します。Line.ByStartPointEndPoint コンストラクタを使用して 2 つの境界点を明示的に指定するか、Line.ByStartPointDirectionLength で開始点、方向、およびその方向の長さを指定することで、線分を作成できます。
Dynamo には、最も基本的なタイプのジオメトリ プリミティブを 3 次元で表すオブジェクトがあります。Cuboid.ByLengths で作成される直方体、Cone.ByPointsRadius および Cone.ByPointsRadii で作成される円錐、Cylinder.ByRadiusHeight で作成される円柱、Sphere.ByCenterPointRadius で作成される球です。
計算設計では、曲線とサーフェスが、以降のジオメトリの構築の基礎となる足場として頻繁に使用されます。この初期のジオメトリを後のジオメトリの基盤として使用するために、オブジェクトの領域全体での位置や向きなどの属性を、スクリプトによって抽出できる必要があります。曲線とサーフェスの両方によってサポートされるこの抽出はパラメータ化と呼ばれます。
曲線上のすべての点は 0 から 1 までの範囲の一意のパラメータを持つと考えることができます。いくつかの制御点や補間された点に基づいて NURBS 曲線を作成する場合、最初の点のパラメータは 0、最後の点のパラメータは 1 となります。中間点の正確なパラメータを事前に知ることはできません。そのため、一連のユーティリティ関数で緩和されるものの、厳しい制限のように感じられるかもしれません。サーフェスのパラメータ化は曲線の場合と同様ですが、1 つではなく、u と v という 2 つのパラメータがあります。次の点を使用してサーフェスを作成する場合、
p1 のパラメータは u = 0 v = 0 で、p9 のパラメータは u = 1 v = 1 です。
パラメータ化は、曲線の生成に使用する点を決定する場合にはそれほど有用ではなく、主に、中間点が NurbsCurve コンストラクタおよび NurbsSurface コンストラクタで生成された場合にその位置を判断するために使用します。
曲線には PointAtParameter メソッドがあり、0 から 1 の double 型の引数を 1 つ使用して、そのパラメータの Point オブジェクトを返します。たとえば、このスクリプトでは、パラメータが 0、0.1、0.2、0.3、0.4、0.5、0.6、0.7、0.8、0.9、1 の点を見つけます。
同様に、サーフェスには PointAtParameter メソッドがあり、生成された点の u パラメータと v パラメータという 2 つの引数を使用します。
曲線上およびサーフェス上の個々の点を抽出することは便利ですが、スクリプトでは通常、曲線やサーフェスが向いている方向など、パラメータの特定の幾何学的特性を知る必要があります。CoordinateSystemAtParameter メソッドでは、曲線やサーフェスのパラメータでの位置だけでなく、方向が設定された座標系も見つかります。たとえば、次のスクリプトによって、回転サーフェスに沿って方向が設定された座標系が抽出され、その座標系の向きを使用して、サーフェスに垂直な線分が生成されます。
前に述べたように、曲線やサーフェスの長さ全体で常に均一にパラメータ化されるわけではありません。つまり、0.5 のパラメータが常に中点に対応したり、0.25 が常に曲線またはサーフェスの 1/4 の点に対応するわけではありません。この制限を回避するため、曲線にはパラメータ化のコマンドの追加のセットがあり、これによって、曲線に沿った特定の長さにある点を検索できます。
Intersect、Trim、および SelectTrim は、点、曲線、サーフェスなどの低い次元のジオメトリに主に使用されます。一方、ソリッド ジオメトリには、Trim と同様の方法でマテリアルを取り除くことおよび要素を結合して全体を大きくすることの両方によって構築後に形状を修正するための、一連のメソッドが追加されています。
Union メソッドでは、2 つのソリッド オブジェクトが使用され、両方のオブジェクトによってカバーされる空間から単一のソリッド オブジェクトが作成されます。オブジェクト間で重複する空間は最終形状に結合されます。この例では、球と直方体が結合して単一のソリッドの球-立方体形状となります。
Difference メソッドでは、Trim のように、ベースとなるソリッドから入力されたツールとなるソリッドの内容が取り除かれます。この例では、球から小さなくぼみが削り出されています。
Intersect メソッドでは、2 つのソリッド入力間の重複するソリッドが生成されます。次の例では、Difference が Intersect に変更され、結果として得られるソリッドは、最初に削り出されていた空間がなくなっています。
Dynamo のビジュアル プログラミング環境で、テキスト プログラミングを使用するのはなぜでしょうか。には、多くの利点があります。直感的なビジュアル インタフェースにより、特別な構文を学習することなくプログラムを作成することができます。ただし、ビジュアル プログラムは、処理が煩雑になったり、機能が不足することがあります。Python には、「if/then」の条件ステートメントやループを簡単に記述するための方法が用意されています。Python は、Dynamo の機能を拡張し、多数のノードを数行の簡潔なコード行で置き換えることができる強力なツールです。
ビジュアル プログラミング:
テキスト プログラム:
Code Block ノードと同様に、Python Script ノードはビジュアル プログラミング環境内のスクリプト インタフェースです。Python Script ノードは、ライブラリの[Script] > [Editor] > [Python Script]にあります。
このノードをダブルクリックすると、Python のスクリプト エディタが開きます。ノードを右クリックして[編集...]を選択することもできます。エディタ上部の定型文は、必要なライブラリを参照する際に役立ちます。Python Script ノードの入力値は、IN 配列に格納されます。値は、OUT 変数に割り当てられて Dynamo に返されます。
これらのメソッドには、ByCoordinates などのコンストラクタ、Add などのアクション、X、Y、Z 座標などのクエリーがあります。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この例では、Python Script ノードを記述してソリッド モジュールからパターンを作成し、カスタム ノードに変換します。最初に、Dynamo ノードを使用してソリッド モジュールを作成します。
Rectangle.ByWidthLength: ノードを使用して、ソリッドのベースとなる長方形を作成します。
Surface.ByPatch: ノードの closedCurve 入力に Rectangle 出力を接続し、下部サーフェスを作成します。
Geometry.Translate: ノードの geometry 入力に Rectangle 出力を接続し、長方形を上に移動します。次に、Code Block ノードを使用してソリッドの厚さを指定します。
Polygon.Points: ノードを使用して、変換された長方形に対してクエリーを実行し、頂点を抽出します。
Geometry.Translate: ノードを使用して、4 つの点に対応する 4 つの値のリストを作成します。この操作により、ソリッドの 1 つの頂点が上に移動します。
変換後の点を Polygon.ByPoints: ノードで使用して、上部ポリゴンを再作成します。
Surface.ByPatch: ノードを使用してポリゴンを結合し、上部サーフェスを作成します。
これで、上部サーフェスと下部サーフェスが作成されました。次に、2 つのプロファイルの間をロフトしてソリッドの側面を作成しましょう。
List.Create: ノードの index 入力に、底面の長方形と上面のポリゴンを接続します。
Surface.ByLoft: ノードを使用して 2 つのプロファイルをロフトし、ソリッドの側面を作成します。
List.Create: ノードの index 入力に上部サーフェス、側面サーフェス、下部サーフェスを接続して、サーフェスのリストを作成します。
Solid.ByJoinedSurfaces: ノードを使用してサーフェスを結合し、ソリッド モジュールを作成します。
これで、ソリッドが作成されました。次に、ワークスペースに Python Script ノードをドロップします。
ノード上の[+]アイコンをクリックし、ノードに入力を追加します。入力には IN[0]、IN[1]などの名前が付いています。これらはリスト内の項目を表しています。
最初に、入力と出力を定義しましょう。ノードをダブルクリックして、Python エディタを開きます。エディタ内のコードを修正するには、次のコードを実行します。
このコードの意味については、演習を進めながら説明していきます。ここで、ソリッド モジュールを配列化するためには、どのような情報が必要になるかを考慮する必要があります。最初に、移動距離を決定するために、ソリッドの寸法を知る必要があります。境界ボックスにはバグがあるため、境界ボックスを作成するにはエッジ曲線のジオメトリを使用する必要があります。
ここで、Dynamo の Python Script ノードを確認します。Dynamo のノードのタイトルと同じ構文が使用されていることがわかります。以下のコメント付きコードを確認してください。
ここでは、ソリッドのモジュールの移動と回転を行うため、Geometry.Transform の操作を使用しましょう。Geometry.Transform ノードを確認すると、ソリッドを変換するにはソース座標系とターゲット座標系が必要になることがわかります。この場合、ソース座標系はソリッドのコンテキストの座標系で、ターゲット座標系は配列化された各モジュールの別の座標系になります。そのため、x 値と y 値をループして、座標系を毎回異なる距離と方向で変換する必要があります。
[実行]をクリックし、コードを保存します。次のように、Python Script ノードを既存のスクリプトに接続します。
Solid.ByJoinedSurfaces からの出力を、Python Script ノードの最初の入力として接続し、Code Block を使用してその他の入力を定義します。
Topology.Edges ノードを作成し、Python Script ノードからの出力を入力として使用します。
最後に Edge.CurveGeometry ノードを作成し、Topology.Edges からの出力を入力として使用します。
シード値を変更すると、異なるパターンが作成されます。ソリッド モジュールのパラメータを変更して、異なるエフェクトを作成することもできます。
これで、便利な Python Script ノードが作成されました。このノードをカスタム ノードとして保存しましょう。Python Script ノードを選択し、ワークスペースを右クリックして、[カスタム ノードを作成]を選択します。
名前、説明、カテゴリを設定します。
この操作により、カスタム ノードを編集するための新しいワークスペースが開きます。
Inputs: 入力名をわかりやすい名前に変更し、データ タイプと既定値を追加します。
Output: 出力名を変更します。
ノードを .dyf ファイルとして保存すると、先ほど行った変更がカスタム ノードに反映されます。
Python は、シンプルな構文が特徴の、幅広く使用されているプログラミング言語です。構文が非常に読みやすいため、他の多くの言語より簡単に習得できます。Python はモジュールとパッケージをサポートしており、既存のアプリケーションに組み込むことができます。Python を実行する方法については、 のページを参照してください。
これまでの多くの例では、低い次元のオブジェクトから高い次元のジオメトリを構築することに注目してきました。交差メソッドを使用すると、この高い次元のジオメトリから低い次元のオブジェクトを生成でき、一方でトリム コマンドを選択すると、ジオメトリ形状を作成した後にスクリプトによって大幅に修正できます。
Intersect メソッドは Dynamo のジオメトリのすべてのピース上で定義されます。つまり、理論的にはジオメトリのどのピースもジオメトリの他の任意のピースと交差できます。点に関する交差では結果として得られるオブジェクトは常に入力された点そのものとなるなど、意味のない交差も当然あります。オブジェクト間での交差のその他の可能な組み合わせについて、次の表で概要を示します。次の表はさまざまな交差の操作の結果の概要を示しています。
次の非常に簡単な例では、平面と NURBS 曲面の交差を示しています。交差によって NURBS 曲線の配列が生成され、これを他の NURBS 曲線のように使用できます。
Trim メソッドは Intersect メソッドに非常によく似ており、ジオメトリのほぼすべてのピースに対して定義されます。ただし Trim には Intersect よりもはるかに多くの制限があります。
Trim メソッドについては、「選択」点が必要であることに注意が必要です。この点によってどのジオメトリを破棄してどの部分を保持するかが決まります。Dynamo は、選択点に最も近いトリムされたジオメトリを見つけて破棄します。
次の Python スクリプトは、点の配列を生成する例をいくつか示しています。これらは、次のように、Python Script ノードに貼り付ける必要があります。
python_points_1
python_points_2
python_points_3
python_points_4
python_points_5
Autodesk.DesignScript.Geometry ライブラリにより、Code Block ノードと同様のドット表記を使用することができます。Dynamo 構文の詳細については、「」および「」を参照してください(この PDF 文書をダウンロードするには、リンクを右クリックし、[名前を付けてリンク先を保存...]をクリックしてください)。「Point.」などのジオメトリ タイプを入力すると、点の作成や点のクエリーを実行するためのメソッドのリストが表示されます。
使用: 点
曲線
平面
サーフェス
ソリッド
対象: 曲線
可
不可
不可
不可
不可
ポリゴン
-
不可
可
不可
不可
サーフェス
-
可
可
可
可
ソリッド
-
-
可
可
可
前のセクションでは、Dynamo で Python スクリプトを使用する方法について説明しました。このセクションでは、スクリプティング環境に Revit ライブラリを接続する方法を見てみましょう。ここまでの手順で、次のコード ブロックの最初の 4 行を使用して、Python 標準ライブラリと Dynamo の Core ノードが既に読み込まれています。数行のコードを追加するだけで、Revit の各種のノード、要素、ドキュメント マネージャを読み込むことができます。
これにより、Revit API にアクセスし、任意の Revit タスクでカスタム スクリプトを使用できるようになります。ビジュアル プログラミングのプロセスと Revit API スクリプトを組み合わせることにより、コラボレーションやツールの開発が容易になります。たとえば、BIM マネージャと回路設計者が、同じグラフを使用して同時に作業することができます。こうしたコラボレーションにより、モデルの設計と施工を改善できます。
Dynamo プロジェクトの背景には、プラットフォーム実装のスコープを拡大するという計画があります。そのため、Dynamo には新しいプログラムが追加されていく予定になっています。ユーザは、Python スクリプティング環境からプラットフォーム固有の API にアクセスできるようになります。このセクションでは Revit を扱いますが、今後は章の数を増やして、別のプラットフォーム上でのスクリプト作成に関する説明を追加する予定です。また、さまざまな IronPython ライブラリにアクセスして Dynamo に読み込むことができるようになりました。
次の例では、Dynamo で Python を使用して、Revit 固有の操作を実行する方法について説明します。Python と Dynamo および Revit との関係の詳細については、Dynamo の Wiki ページを参照してください。Python と Revit のもう 1 つの便利なリソースは、Revit Python Shell プロジェクトです。
新しい Revit プロジェクトを作成します。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
これ以降の一連の演習では、Dynamo for Revit における基本的な Python スクリプトについて説明します。この演習では、Revit のファイルと要素を使用します。また、Revit と Dynamo 間の通信についても説明します。
ここでは、Dynamo セッションにリンクされた Revit ファイルの doc 、 uiapp 、 app を取得するための一般的な方法について説明します。Revit API を使用したことのある方ならば、Watch リストのような項目を見たことがあるかもしれません。これらの項目を見たことがなくても、特に問題はありません。これ以降の演習で、別の例を使用して説明します。
RevitServices を読み込み、Dynamo のドキュメント データを取得するには、次のようなスクリプトを記述します。
ここで、Dynamo の Python Script ノードを確認します。次のコードを参照することもできます。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習では、Dynamo の Python Script ノードを使用して、Revit 内に単純なモデル曲線を作成します。
最初に、Revit 内に新しいコンセプト マス ファミリを作成します。
コンセプト マス フォルダ を開き、Metric Mass.rft テンプレート ファイルを使用します。
Revit で、キーボード ショートカット un
を使用してプロジェクトの単位の設定を表示し、長さの単位をメートルに変更します。
Dynamo を起動し、下図に示す一連のノードを作成します。次に、Dynamo のノードを使用して、Revit 内に 2 つの参照点を作成します。
Code Block ノードを作成し、
"0;"
の値を設定します。この値を、ReferencePoint.ByCoordinates ノードの X、Y、Z 入力に接続します。
-100 ~ 100 の範囲内で、ステップ値が 1 の Number Slider ノードを 3 つ作成します。
各スライダを ReferencePoint.ByCoordinates ノードに接続します。
Python Script ノードをワークスペースに追加し、このノードの[+]ボタンをクリックして入力をもう 1 つ追加し、各入力に参照点を接続します。Python Script ノードを開きます。
ここで、Dynamo の Python Script ノードを確認します。下の完全なコードを見つけます。
System Array: Revit の入力には、Python リストではなく System.Array が必要です。これは 1 行のコードに過ぎませんが、引数のタイプに注意すると、Revit での Python プログラミングが容易になります。
ここまでの手順では、Dynamo で Python を使用して、線分で接続された 2 つの参照点を作成しました。次の演習で、さらに操作を進めてみましょう。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習では、簡単な操作を実行することにより、Revit と Dynamo 間で相互にデータやジオメトリを接続する場合の要点について説明します。最初に Revit-StructuralFraming.rvt を開き、次に Dynamo を起動して、Revit-StructuralFraming.dyn ファイルを開きます。
この Revit ファイルは、基本的なファイルです。レベル 1 とレベル 2 にそれぞれ 1 本ずつ、2 本の異なる参照曲線が描画されています。これらの曲線を Dynamo に読み込み、ライブ リンクを作成します。
このファイルでは、Python Script ノードの 5 つの入力に一連のノードが接続されています。
各 Select Model Element ノードの[選択]ボタンをクリックし、Revit 内の対応する曲線を選択します。
Code Block ノードで「
0..1..#x;
」という構文を使用して、 0 ~ 20 までの範囲を持つ Integer Slider ノードを x 入力に接続します。この操作により、2 本の曲線の間に作成する梁の数を指定します。Structural Framing Types ノードのドロップダウン メニューで、既定の W12x26 梁を選択します。
Levels ノードで、「Level 1」を選択します。
この Python コードは、これまでのコードよりも行数が多くなっていますが、コード行の前後のコメントを参照すると、プロセス内の処理内容を確認できます。
Revit で、2 つの曲線にわたる梁の配列が構造要素として作成されました。注: この構造要素は、Dynamo でネイティブの Revit インスタンスを作成する場合の例として使用しているもので、実際にはあり得ない構造要素であることに注意してください。
Dynamo でも、結果を確認できます。Watch3D ノードの梁は、Revit 要素からクエリーされたジオメトリを参照します。
このセクションでは、Revit 環境から Dynamo 環境にデータを変換する一連のプロセスを作成しました。このプロセスをまとめると、次のようになります。
Revit の要素を選択する
Revit の要素を Dynamo の曲線に変換する
Dynamo の曲線を一連の Dynamo の点に分割する
Dynamo の 2 つの曲線間の点を使用して Dynamo の線分を作成する
Dynamo の線分を参照することにより、Revit の梁を作成する
Revit の梁のジオメトリに対してクエリーを実行することにより、Dynamo のサーフェスを出力する
これは複雑なプロセスに見えるかもしれませんが、スクリプトを使用すると、Revit で曲線を編集してソルバを再実行するのと変わらないほど単純な処理になります(ただし、そのためには、元の梁を削除する必要があります)。これは、Python で梁を配置することによって、初期設定のままのノードにある関連付けが解除されるためです。
Revit で参照曲線を更新すると、梁の新しい配列が作成されます。
対象:
サーフェス
曲線
平面
ソリッド
サーフェス
曲線
点
点、曲線
サーフェス
曲線
点
点
点
曲線
平面
曲線
点
曲線
曲線
ソリッド
サーフェス
曲線
曲線
ソリッド
Dynamo 2.0 では、初めて Python ウィンドウを開く際に、既定で使用するテンプレート (.py extension)
を指定することができます。この機能があると、Dynamo 内で Python を効率よく使用できるため以前からご要望をいただいておりました。テンプレートを使用できる機能があるため、カスタム Python スクリプトを開発する際に既定のインポートをすぐに利用できます。
このテンプレートは、Dynamo をインストールした APPDATA
にあります。
通常は次のように計算されます。( %appdata%\Dynamo\Dynamo Core\{version}\ )
この機能を使用するには、 DynamoSettings.xml
ファイルで次の行を追加する必要があります。(メモ帳で編集します)
<PythonTemplateFilePath />
を見つけて、これを次のように置き換えるだけです。
注: CURRENTUSER を自分のユーザ名に置き換えてください
次に、使用する機能を組み込んだテンプレートを作成する必要があります。ここでは、Revit に関連するインポートおよび Revit で作業する際の他の一般的な項目の一部を組み込みます。
空のメモ帳を起動して、次のコードを貼り付けることができます。
貼り付けが完了したら、このファイルを PythonTemplate.py
という名前で APPDATA
フォルダ内に保存します。
Python テンプレートが定義されると、Python Script ノードが配置されるたびに、Dynamo はこのテンプレートを検索します。見つからない場合、既定の Python ウィンドウのように表示されます。
Python テンプレート(たとえばここで作成した Revit でのテンプレート)が見つかった場合、組み込んだ既定の項目がすべて表示されます。
この優れた追加機能(Radu Gidei 氏による)に関する詳細は、こちらを参照してください。https://github.com/DynamoDS/Dynamo/pull/8122
ビジュアル プログラミングは非常にクリエイティブな作業ですが、ワークスペースの複雑性やレイアウトの関係で、プログラム フローや主要なユーザ入力がすぐにわかりにくくなる場合があります。ここでは、プログラムの管理に関するベスト プラクティスをいくつか確認してみましょう。
ワークスペースにある程度の数のノードを追加した場合は、画面を見やすくするためにノードのレイアウトを再編成することをお勧めします。複数のノードを選択してワークスペースを右クリックすると、X と Y で位置合わせオプションや分配オプションを指定するための [選択を位置合わせ] メニューがポップアップ ウィンドウに表示されます。
複数のノードを選択します。
ワークスペースを右クリックします。
[選択を位置合わせ] オプションを使用します。
Dynamo の操作に慣れてくると、ノード名とプログラム フローを確認することにより、ビジュアル プログラムを「読む」ことができるようになります。経験のレベルを問わず、すべてのユーザにとって、わかりやすい名前と説明を入力することが重要になります。そのため、Dynamo には、編集可能なテキスト フィールドが含まれているノート ノードが用意されています。ノートをワークスペースに追加する方法は 2 つあります。
[編集] > [ノートを作成]メニューを参照します。
キーボード ショートカット[Ctrl]+[W]を使用します。
ワークスペースにノートが追加されると、ノート内のテキストを編集するためのテキスト フィールドがポップアップ表示されます。ノートが作成されると、ノート ノードをダブルクリックするか右クリックしてノートを編集できるようになります。
ビジュアル プログラムのサイズが大きい場合、大まかな実行手順が特定できると便利です。グループを使用してノードの集合をハイライト表示し、色付きの長方形にタイトルが表示されたラベルを付けることができます。複数のノードを選択してグループを作成する方法は 3 つあります。
[編集] > [グループを作成]メニューを参照します。
キーボード ショートカット[Ctrl]+[G]を使用します。
ワークスペースを右クリックし、[グループを作成]を選択します。
作成したグループについては、タイトルやカラーなどの設定を編集できます。
ヒント: ノードとグループの両方を使用すると、わかりやすい注釈をファイルに簡単に追加することができます。
ここで、ノートとグループを追加したプログラムの例を示します。
ノート: 「Grid Parameters」
ノート: 「Grid Points」
グループ:「Create a Grid of Points」
グループ:「Create an Attractor Point」
ノート: 「Calibrate Distance Values」
ノート: 「Variable Grid of Circles」
ビジュアル スクリプト環境内で、DesignScript、Python、ZeroTouch (C#)を使用してテキストベースのスクリプトを作成すると、機能性の高い視覚的な関係を構築することができます。同じワークスペース内で Python や C# を使用して、入力スライダなどの要素を画面上に表示したり、大規模な操作を DesignScript 内に集約したり、便利なツールやライブラリにアクセスすることができます。こうした方法を組み合わせて効率的に管理することにより、プログラム全体のカスタマイズ性、明確性、効率性が大幅に向上します。ここでは、テキスト スクリプトを使用してビジュアル スクリプトを拡張するための一連のガイドラインを紹介します。
テキスト スクリプトを使用すると、ビジュアル スクリプトよりも複雑な関係を記述することができます。ただし、テキスト スクリプトとビジュアル スクリプトの機能は多くの点で重複しています。事前にパッケージ化された便利なコードがビジュアル スクリプトのノードであるため、ビジュアル スクリプトで多くの機能が重複するのは避けられないことです。ビジュアル スクリプトを使用すると、Dynamo プログラム全体を DesignScript または Python で作成することができます。ただし、ノードとワイヤのインタフェースを使用すると、グラフィカルな情報を直感的なフローで作成できるため、Dynamo ではビジュアル スクリプトを使用しています。テキスト スクリプトの機能がビジュアル スクリプトの機能よりも優れている点について理解しておくと、ノードやワイヤの直感的な機能の代わりにテキスト スクリプトの機能を使用した方が効率的な場合を特定できるようになります。どのような場合にどの言語を使用してスクリプトを作成するかについては、次に示すガイドラインを参照してください。
テキスト スクリプトを使用するケース:
ループ
反復処理を記述する場合
外部ライブラリへのアクセス処理を記述する場合
言語の選択
ループ
反復
ノードの集約
外部ライブラリへのアクセス
省略表記
DesignScript
可
可
可
不可
可
Python
可
可
一部可
可
不可
ZeroTouch (C#)
不可
不可
不可
可
不可
各 Dynamo ライブラリでアクセスできるコンテンツのリストについては、「スクリプトの参照情報」を参照してください。
Dynamo でスクリプトを作成する場合は必ずパラメトリック環境で作業を行うことになるため、使用するノードとワイヤのフレームワークに関連する形で、構造化されたコードを記述することをお勧めします。例として、テキスト スクリプトが記述されているノードを考えてみます。このノードは、複数の入力、1 つの関数、予想される 1 つの出力が指定されている、プログラム内の他のノードと同じように構成されているとします。この場合、ノード内のコードにいくつかの作業用変数が即時に設定されます。これらの変数が、クリーンなパラメトリック システムの重要な要素になります。コードをビジュアル プログラムに統合するための適切な方法については、次のガイドラインを参照してください。
外部変数を特定する
設計内で使用するパラメータを特定します。これにより、対象のデータから直接作成されるモデルを構築できるようになります。
コードを記述する前に、次の変数を特定します。
入力の最小セット
目的の出力
定数
一部の変数については、コードを記述する前に既に定義されています。
降雨のシミュレーションを実行するサーフェス。
必要な雨粒の数(エージェント)。
雨粒の移動距離。
最も急なパスの下降とサーフェス横断との切り替え。
各入力の番号が指定された Python Script ノード。
返された曲線が青で表示されるコード ブロック。
内部的な関係を設計する
パラメトリシズム機能で特定のパラメータや変数を編集することにより、計算式やシステムの最終結果を操作または変更できます。
スクリプト内のエンティティが論理的に関連付けられている場合は、常にそれらのエンティティを相互の関数として定義します。この場合、一方の関数を変更すると、その変更内容に応じてもう一方の関数が更新されます。
重要なパラメータだけを表示し、入力の数を最小限に抑えます。
追加の親パラーメータから一連のパラメータを継承できる場合は、それらの親パラメータだけをスクリプトの入力として表示してください。こうすることにより、インタフェースの複雑さが軽減されるため、スクリプトが使いやすくなります。
上記のコードは、Python Script ノードの「modules」というサンプル コードです。
入力。
スクリプト内で使用される変数。
上記の入力と変数を使用して関数を実行するループ。
ヒント: スクリプトの結果だけでなく、途中のプロセスも非常に重要です。どちらにも同じように重点を置いてください。
スクリプト内で同じ処理を複数の方法で記述すると、いずれかのタイミングで、重複するコード記述間における整合性が取れなくなることがあります。その結果、保守作業に時間がかかったり、コードの解析効率が落ちたり、システム内部の不整合が発生する可能性があります。
DRY 原則は、「すべての情報は、システム内において、ただ 1 つの明確な信頼できる表現を持っている」ということを表す原則です。
この原則を正しく適用することにより、スクリプト内の関連要素が予期したとおりに統一して変更されます。関連しない要素については、相互に論理的な影響が及ぶことはありません。
ヒント: 上記の「BAD」の例では定数を記述していますが、スクリプト内でエンティティを複製する前に、ソースにリンクさせることができないかどうかを検討することをお勧めします。
コードが長くなってより複雑になるにつれて、スクリプトの目的や全体的なアルゴリズムが分かりにくくなります。また、特定の処理の内容や、特定の処理が記述されている箇所を簡単に追跡できなくなり、エラーが発生した場合も、その原因となるバグを見つけることが難しくなります。さらに、他のコードへの統合や開発作業の割り当てについても、困難になります。こうした困難を避けるため、モジュール単位でコードを記述することをお勧めします。この方法では、コードで実行する処理に基づいて、コードを組織的に分割して記述します。ここでは、モジュール化の手法を使用して、スクリプトを簡単に管理するためのヒントをいくつか紹介します。
モジュール単位でコードを記述する
「モジュール」とは、特定の処理を実行するコードの集まりで、ワークスペース内の Dynamo ノードに似ています。
モジュールは、隣接するコードから視覚的に離れた位置に記述します(関数、クラス、入力のグループ、読み込むライブラリなどがモジュールになります)。
モジュール単位でコードを記述すると、視覚的で直感的なノードの利点を活用できるだけなく、テキスト スクリプトでしか記述できない複雑な関係を使用することもできます。
上記のループ処理では、「agent」というクラスを呼び出しています。このクラスは、次の演習で作成します。
各エージェントの開始点を定義するコード モジュール。
エージェントを更新するコード モジュール。
エージェントのパスの基準線を描画するコード モジュール。
複数の箇所に記述されている同じコードを関数としてまとめる
同じ処理(または非常に類似した処理)を実行するコードが複数の箇所に記述されている場合は、呼び出し可能な関数としてそれらのコードをまとめます。
「Manager」関数は、プログラム フローをコントロールします。この関数には主に、構造間でのデータ移動などの低レベル詳細の動作を処理する「Worker」関数に対する呼び出しが格納されます。
上記の例では、中心点の Z 値に基づき、半径と色を指定して球体を作成しています。
中心線の Z 値に基づき、半径と表示色を指定して球体を作成する 2 つの「Worker」親関数。
2 つの Worker 関数を組み合わせる「Manager」親関数。この関数を呼び出すと、この関数に含まれている 2 つの Worker 関数が呼び出されることになります。
必要な要素だけを表示する
モジュールのインタフェースには、そのモジュールで指定されている必要な要素が表示されます。
ユニット間のインタフェースを定義すると、各ユニットの詳細設計を個別に進めることができるようになります。
モジュールの分離や置き換え
モジュール間には相互の関係はないため、必要に応じて分離や置き換えを行うことができます。
モジュール化の一般的な形式
コードをグループ化する場合は、次のように記述します。
関数は、次のように記述します。
クラスは、次のように記述します。
Dynamo でテキスト スクリプトを開発する場合は、目的とする結果と、実際に作成される結果を頻繁に確認することをお勧めします。こうすることにより、構文エラー、論理的な矛盾点、不正確な値、正しくない出力など、予期しない状況をすばやく検出し、そのたびに修正することができます。最後にまとめて修正するよりも、効率的に作業を進めることができます。テキスト スクリプトは、キャンバス上のノード内でアクティブになっているため、ビジュアル プログラムのデータ フローに既に統合された状態になっています。そのため、出力データを割り当ててプログラムを実行し、Watch ノードを使用してスクリプトからのフローを評価するだけで、スクリプトを継続的にモニタリングすることができます。ここでは、スクリプトを作成しながら、そのスクリプトを継続的に検査する場合のヒントをいくつか紹介します。
スクリプトを開発しながらテストを行う
機能を実行するためのコードの記述が完了するたびに、次の点を確認します。
コードの内容を客観的に確認します。
コードの内容を批判的に確認します。たとえば、共同作業を行っている他のメンバーがこのコードの内容を理解できるかどうか、この処理は本当に必要なのかどうか、この機能をさらに効率的に記述することができないかどうか、不要な重複コードや依存コードが記述されていないかどうか、などを確認します。
正しいデータが返されるかどうかを簡単にテストします。
スクリプト内で使用する最新のデータを出力として割り当てます。これにより、スクリプトを更新するたびに、関連するデータがノードによって常に出力されるようになります。
ソリッドのすべてのエッジが、境界ボックスを作成するための曲線として返されるかどうかを確認します。
Count 入力が正しく Range に変換されるかどうかを確認します。
座標系が適切に変換され、ループ内で回転するかどうかを確認します。
極端な条件を想定してテストを行う
スクリプトの作成中に、割り当てられているドメインの最小値と最大値に入力パラメータを設定すると、極端な条件下でもプログラムが正常に機能するかどうかを確認することができます。
最小値や最大値を指定して正常にプログラムが機能する場合であっても、予期しない Null 値、空の値、ゼロが返されることがないかどうかを確認する必要があります。
こうした極端な条件を設定しないと、スクリプト内に存在する問題を示すバグやエラーが見つからないことがあります。
エラーの原因を特定し、エラーを内部的に修正する必要があるのかどうか、またはパラメータ ドメインを調整してエラーを回避する必要があるのかどうかを判断します。
ヒント: ユーザは、使用可能なすべての入力値のあらゆる組み合わせを使用するということを常に想定しておく必要があります。これにより、予期しない問題が発生するのを防ぐことができます。
デバッグとは、スクリプトからバグをなくすためのプロセスのことです。エラー、非効率な処理、不正確な値、予期しない結果などをまとめて「バグ」と呼びます。バグの修正は、変数名のスペルミスを修正するような単純なものもあれば、スクリプトの構成に関する問題のように、広範囲にわたるものもあります。スクリプトを作成しながら、早い段階で潜在的な問題を検出して修正するのが理想的な方法ですが、この方法でも、バグのまったくないスクリプトを作成できるという保証はありません。ここでは、バグを系統的な方法で修正するためのベスト プラクティスをいくつか紹介します。これらのベスト プラクティスは、優先度の高い順に記載されています。
ウォッチ バルーンを使用する
返されるデータを OUT 変数に割り当てて、コード内の複数の場所でそのデータを確認します。これは、スクリプトを作成しながらバグを修正する方法に似ています。
分かりやすいコメントを書く
コードをモジュール化して、目的とする結果をコメントとして明確に記述すると、デバッグが簡単になります。
通常、コメント行と空白行は余分な情報ですが、デバッグを行う場合は、コードを細分化して内容を追跡できるため、便利です。
モジュール化されたコードの利点を活用する
分離された特定のモジュール内に問題の原因が存在している場合があります。
問題のあるモジュールを特定できれば、問題の修正が非常に簡単になります。
プログラムを修正する必要がある場合、コードがモジュール化されていれば、非常に簡単に修正を行うことができます。
プログラムの他の部分を変更することなく、新しいモジュールやデバッグ済みのモジュールを既存のプログラムに挿入することができます。
Python Script ノードのサンプル ファイルをデバックすると、次のようになります。
自分よりも大きな境界ボックスを返す入力ジオメトリ(これを確認するには、xDist と yDist の値を OUT 変数に割り当てます)。
xDist と yDist の正しい距離が設定された適切な境界ボックスを返す入力ジオメトリのエッジ曲線。
xDist と yDist の値に関する問題に対応するための「module」コード(これは、これまでの説明で挿入したコードです)。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプル ファイルの一覧については、付録を参照してください。
上で説明したテキスト スクリプトのベスト プラクティスを意識しながら、降雨シミュレーション スクリプトを作成してみましょう。「見やすいプログラムを作成するためのガイドライン」の演習では、ベスト プラクティスに従い、構造化されていないビジュアル プログラムを見やすく整理することができましたが、テキスト スクリプトの場合、それは非常に難しくなります。テキスト スクリプトで記述された論理的な関係は、視覚的に把握するのが難しいため、複雑なコードになると、関係を解読するのがほとんど不可能になる場合もあります。そのため、テキスト スクリプトの高度な機能を使用する場合は、組織的に記述する必要性が高くなります。この演習では、ステップごとに操作を確認しながら、ベスト プラクティスについて説明していきます。
アトラクタが変形しているサーフェスに適用されるスクリプト
最初に、必要な Dynamo ライブラリを読み込みます。これにより、Python 内で Dynamo の機能にグローバルにアクセスできるようになります。
この段階で、必要なライブラリをすべて読み込む必要があります。
次に、スクリプトの入力と出力を定義する必要があります。定義した入力は、ノード上で入力ポートとして表示されます。これらの外部入力が、このスクリプトの基礎となり、パラメトリック環境を構築するための重要なデータになります。
Python スクリプト内の変数に対応する入力を定義する必要があります。これらの入力により、目的とする出力が設定されます。
ベースとなるサーフェス。
使用するエージェントの数。
エージェントが進むことができるステップの最大数。
サーフェスからの最短距離のパスを取得するためのオプション(または、サーフェスを横断するためのオプション)。
スクリプト IN[0] とスクリプト IN[1] の入力に対応する入力 ID が設定された Python ノード。
異なる色で表示可能な出力曲線。
では、モジュール化の手法を使用して、スクリプトの本文を作成してみましょう。複数の始点に対して、サーフェスからの最短パスのシミュレーションを実行するのは、複数の関数が必要になる複雑な作業です。そのため、スクリプト内の異なる場所で異なる関数を呼び出すのではなく、それらの関数をエージェントの 1 つのクラスとしてまとめることにより、コードをモジュール化します。このクラス(モジュール)の各関数は、それぞれ異なる変数を使用して呼び出すことができます。また、別のスクリプト内で再利用することもできます。
サーフェス上を下降するエージェントに対して、その動作を指示するクラスを定義する必要があります。このクラスを使用して、エージェントがステップを進むたびに、最も急な方向へ移動することを選択します。
名前。
すべてのエージェントが共有するグローバル属性。
各エージェント固有のインスタンス属性。
ステップを進むための関数。
各ステップの位置を基準線リストにカタログ化するための関数。
ここで、エージェントの開始位置を指定して、エージェントを初期化しましょう。それに合わせて、スクリプトの調整を行い、エージェント クラスが正しく機能するかどうかを確認します。
サーフェスを下降するすべてのエージェントをインスタンス化し、それらのエージェントの初期属性を定義する必要があります。
新しい空の基準線リスト。
サーフェス上での下降の開始を指定するためのコード。
エージェント リストを出力として割り当て、スクリプトから返される情報を確認するための Watch ノード。エージェントの正確な数が返されていますが、後でスクリプトをもう一度編集して、スクリプトから返されるジオメトリを確認します。
ステップごとにそれぞれのエージェントを更新します。次に、エージェントとステップごとに、ネストされたループ処理を記述し、エージェントとステップの位置を更新してそれぞれの基準線リストに記録します。また、各ステップで、エージェントがサーフェス上の最終的な位置(それ以上は下降できない位置)にまだ到達していないことを確認します。エージェントがサーフェス上の最終的な位置に到達したら、エージェントの移動を停止します。
これで、各エージェントが完全に更新されました。次に、これらのエージェントを表すジオメトリを返してみましょう。すべてのエージェントが、それ以上は下降できない位置にまで達したことを確認した後で(または、ステップの最大数に達したことを確認した後で)、各エージェントの基準線リスト内の点を通過するポリカーブを作成し、そのポリカーブの基準線を出力します。
最も急なパスを探すためのスクリプト。
ベースとなるサーフェス上の降雨をシミュレーションするためのプリセット。
最も急なパスを探す代わりに、エージェントを切り替えて、ベースとなるサーフェスを横断することもできます。
最終的な Python のテキスト スクリプトはこのようになります。
ここでは、さまざまなベスト プラクティスを紹介します。これらのベスト プラクティスは、これまでの経験と調査によって得たいくつかの方策が、品質の高いパラメトリック ワークフローを構築するために最も効果的であることを明らかにしています。設計者やプログラマ同様、オートデスクが評価する品質の基準は、主にツールの保守性、信頼性、利便性、効率性です。ここで紹介するベスト プラクティスでは、ビジュアルベースまたはテキストベースのスクリプト作成における具体的な例を挙げていますが、これらの原則は、すべてのプログラミング環境に適用でき、さまざまな計算ワークフローを示すことができます。
このリファレンス ページでは、「スクリプト作成のガイドライン」のページで紹介したベスト プラクティスを、コード ライブラリ、ラベル付け、スタイル設定によってさらに拡張する方法について説明します。ここでは、Python を使用して次に示す概念を説明しますが、Python だけでなく C#(Zerotouch)についても、同じ概念が異なる構文で適用されます。
標準ライブラリは Dynamo の外部に存在し、プログラミング言語の Python や C# (Zerotouch)の内部で使用されます。Dynamo には、ノード階層に直接対応する専用のライブラリ セットも用意されています。これらの専用ライブラリにより、ノードとワイヤを使用して作成したコード内で、あらゆる処理を記述することができます。ここからは、各 Dynamo ライブラリの内容と、どのような場合に標準ライブラリを使用するかについて説明します。
標準ライブラリと Dynamo ライブラリ
Dynamo 環境内で Python と C# の標準ライブラリを使用すると、高度なデータ構造とフロー構造を定義できます。
Dynamo ライブラリは、ジオメトリなどの Dynamo オブジェクトを作成するためのノード階層に直接対応しています。
Dynamo ライブラリ
ProtoGeometry*
機能: 円弧、境界ボックス、円、円錐、座標系、立方体、曲線、円柱、エッジ、楕円、楕円弧、面、ジオメトリ、らせん、インデックス グループ、線分、メッシュ、NURBS 曲線、NURBS サーフェス、平面、点、ポリゴン、長方形、ソリッド、球体、サーフェス、トポロジ、T スプライン、UV、ベクトル、頂点。
読み込み方法: import Autodesk.DesignScript.Geometry
``
DSCoreNodes
機能: 色、色範囲(2D)、日時、期間、I/O、式、ロジック、リスト、数式、クアッドツリー、文字列、スレッド。
読み込み方法: import DSCore
モザイク模様
機能: 凸型ハル、ドローネー、ボロノイ図。
読み込み方法: import Tessellation
DSOffice
機能: Excel。
読み込み方法: import DSOffice
*注: Python または C# で ProtoGeometry を使用すると、非管理オブジェクト(メモリを手動で管理する必要があるオブジェクト)が作成されることに注意してください。詳細については、「非管理オブジェクト」のセクションを参照してください。
スクリプトを作成する際には、頻繁に識別子を使用して、変数、タイプ、関数などのエンティティを区別する必要があります。アルゴリズムの作成時に、文字列から構成されるラベルを付けることにより、アルゴリズムの内容が分かりやすくなります。コードを記述する際に分かりやすい名前を付けると、他のメンバーがそのコードの内容を簡単に理解できるようになるだけでなく、後から自分でコードを読む場合にも役立ちます。スクリプト内でエンティティに名前を付ける場合のヒントをいくつか紹介します。
略語を使用する場合は、その略語の意味をコメントで記述する:
冗長な名前は付けない:
If 文で変数名を記述する場合は、If not 文を使用しない:
単語を連結した変数を使用する場合は、「主語_形容詞」という順にする:
このように形式を統一すると、意味がさらに分かりやすくなります。
長い名前を繰り返し使用する場合は、エイリアスを使用する:
ただし、頻繁にエイリアスを使用すると、非常に混乱した分かりにくいプログラムになる場合があります。
必要な単語だけを使用する:
「ものごとはできるかぎりシンプルにすべきだ。しかし、シンプルすぎてもいけない」 - アルバート・アインシュタイン
プログラムを作成する方法は 1 つだけではないため、スクリプトを記述する場合は「個人的なスタイル」を基準として、さまざまなことを判断しながらスクリプトを記述していくことになります。そのため、コード内のスタイルが統一されているかどうか、一般的な形式のスタイルに準拠しているかどうかが、コードの読みやすさと保守作業の容易さに直接影響することになります。一般的に、同じコードが 2 箇所で記述されている場合、それらのコードは同じように機能すると考えられます。ここで、スタイルが統一された分かりやすいコードを記述するためのヒントをいくつか紹介します。
命名規則: (次に示すいずれかの命名規則に従って、コード内の各種タイプのエンティティに名前を付けてください)
変数、関数、メソッド、パッケージ、モジュール:
lower_case_with_underscores
クラス、例外:
CapWords
保護されているメソッド、内部関数:
_single_leading_underscore(self, ...)
プライベート メソッド:
__double_leading_underscore(self, ...)
定数:
ALL_CAPS_WITH_UNDERSCORES
ヒント: 非常に短いコード ブロック内で、明確な文脈で意味がはっきりと理解できる場合を除き、1 文字だけの変数は使用しないでください(特に、l、O、I の使用は避けてください)。
空白行を使用する:
最上位関数とクラス定義の前後に、2 行の空白行を挿入してください。
クラス内に記述されているメソッド定義の場合は、その前後に空白行を 1 行挿入します。
空白行を挿入して、関連する関数グループを区別してもかまいません(ただし、あまり多くの空白行を挿入しないようにしてください)。
余分な空白を挿入しない:
丸括弧、角括弧、中括弧の内側に、空白を挿入しないでください。
カンマ、セミコロン、コロンの直前に、空白を挿入しないでください。
関数呼び出しの引数リストが記述されている括弧の直前に、空白を挿入しないでください。
インデックスまたはスライシングが記述された括弧の直前に、空白を挿入しないでください。
次に示すバイナリ演算子については、必ず前後に空白を 1 つずつ挿入してください。
行の長さに注意する:
1 行の長さは 79 文字以内にしてください。
使用するエディタ ウィンドウの幅を制限することにより、複数のファイルを並べて表示できるようになるため、2 つのバージョンを並べて表示するコード レビュー ツールを使用して作業を行う場合に便利です。
複数の式が記述されている長い行の場合は、式を丸括弧で囲んで改行すると、1 行を複数の行に分割することができます。
余分なコメントや冗長なコメントを記述しない:
コメントを少なくした方が、コードが読みやすくなる場合があります。特に、コメントの代わりに分かりやすい名前を使用すると効果的です。
適切な方法でコードを記述することにより、必要以上にコメントを入力することがなくなります。
ヒント: コードの内容が簡単に理解できるようなコメントを入力し、処理内容が明確に理解できるようなコードを記述することが重要です。
オープン ソース コードを確認する:
オープン ソース プロジェクトというプロジェクトがありますが、これは、多くの開発者が協力して立ち上げたプロジェクトです。これらのプロジェクトでは、チーム内で可能な限り効率的に作業を進めることができるように、読みやすいコードを記述することが求められます。そのため、これらのプロジェクトで使用されているソース コードを参照すると、開発者がどのようなコードを記述しているのかを確認することができます。
次の項目を確認することにより、命名規則を改善することができます。
ニーズに適した命名規則になっているかどうか。
命名規則が原因で、機能や効率性に影響していないかどうか。
次に示す各 Wiki ページで、Dynamo で C# (Zerotouch)を記述する場合のガイド情報を参照できます。
この 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
破棄する必要があるのは、プログラム内に返されることがない非管理オブジェクト、または参照情報が格納されない非管理オブジェクトだけです。ここからは、こうしたオブジェクトのことを「中間ジオメトリ」と呼ぶことにします。次のサンプル コードでは、例として、このようなオブジェクトのクラスが記述されています。このコードに記述されている Zero Touch の C# 関数である singleCube は、立方体を 1 つだけ返しますが、この関数の実行中に 10000 個の立方体が作成されます。この処理は、他のジオメトリが一部の中間構築ジオメトリとして使用されたものと想定することができます。
この Zero Touch 関数を実行すると、かなりの確率で Dynamo がクラッシュします。 このコードでは 10000 個の立方体が作成されますが、格納されてプログラムに返されるのは、そのうちの 1 つのみです。代わりに、プログラムに返す 1 つを除いて、残りの中間立方体をすべて破棄する必要があります。プログラムに返す立方体は、プログラム内に伝播されて他のノードで使用されるため、ここでは破棄しません。
修正後のコードは次のようになります。
通常、破棄する必要があるジオメトリは、Surfaces
、Curves
、Solids
のみです。ただし、念のため、すべてのタイプのジオメトリ(Vectors
、Points
、CoordinateSystems
)を破棄することをお勧めします。
この章に入る前に、Dynamo の強力なビジュアル スクリプト機能の実装方法について説明しました。これらの機能を正しく理解することが、堅固なビジュアル プログラムを開発するための基礎となり、第一歩となります。実際の現場でビジュアル プログラムを使用する場合、チーム メンバーとビジュアル プログラムを共有する場合、エラーのトラブルシューティングを行う場合、制限値のテストを行う場合などは、新たな問題が発生します。自分が作成したプログラムを他のメンバーが使用する場合や、今から 6 ヵ月後にプログラムを起動するような場合は、外観的な面でも論理的な面でも、すぐに理解できるようなプログラムを作成する必要があります。Dynamo には、複雑なプログラムを管理するためのさまざまなツールが用意されています。この章では、そうしたツールを使用する場合のガイドラインについて説明します。
Dynamo でプログラムを作成したり、アイデアをテストする場合、そのサイズと複雑さが急激に増大することがあります。正しく機能するプログラムを作成することはもちろん重要なことですが、可能な限り簡潔なプログラムを作成することも同様に重要です。簡潔なプログラムを作成することにより、プログラムの処理速度と精度が上がるだけでなく、後で他のメンバーとともにコードを解析する場合も、ロジックを簡単に追うことができるようになります。ここでは、プログラムのロジックを分かりやすく記述するための方法をいくつか紹介します。
プログラムの作成時にグループを使用して、機能別に異なるパーツを作成することができます。
グループを使用すると、各モジュールとその配置を維持しながら、プログラム内の大きなパーツを移動することができます。
グループの色を変えて、各グループの用途(入力や関数など)を区別することができます。
グループを使用してプログラムを整理し、カスタム ノードの作成を簡素化することができます。
このプログラムでは、各グループの用途を色で示しています。この方法により、開発するプログラムの標準やテンプレート内で階層を作成することができます。
関数グループ(青)
入力グループ(オレンジ色)
スクリプト グループ(緑)
グループの使用方法については、「プログラムを管理する」を参照してください。
必要に応じてコード ブロックを使用すると、検索するよりも速く、数値メソッドやノード メソッドを入力することができます(Point.ByCoordinates、Number、String、Formula)。
DesignScript でカスタム関数を定義してプログラム内のノードの数を減らす場合は、コード ブロックを使用すると便利です。
1 と 2 は、どちらも同じ関数を実行します。各ノードを個別に検索して追加するよりも、コードを何行か入力する方が、ずっと速く作業を進めることができます。また、コード ブロックのサイズもずっと小さくなります。
コード ブロックを使用して記述した設計スクリプト
ノードを使用して同じスクリプトを記述した場合
コード ブロックの使用方法については、「コード ブロックとは」を参照してください。
[ノードをコード化]機能を使用して、画面上の煩雑さを軽減することができます。この機能では、複数の単純なノードを 1 つにまとめることにより、それらのノードに対応する DesignScript が 1 つのコード ブロック内で記述されます。
[ノードをコード化]機能を使用すると、プログラムの明確性を損なうことなく、コードをまとめることができます。
[ノードをコード化]機能を使用するメリットには、次のようなものがあります。
コードを編集可能な 1 つのコンポーネントとして簡単に集約できる
画面上の大部分を簡素化できる
小さなプログラムを頻繁に編集する必要がない場合に便利である
関数など、他のコード ブロック機能を組み込む場合に便利である
[ノードをコード化]機能を使用するデメリットには、次のようなものがあります。
一般的な命名規則が使用されるため、コードの内容が多少わかりにくくなる
他のユーザにとって、コードの理解が難しくなる
元のビジュアル プログラムに簡単に戻すことができない
既存のプログラム
[ノードをコード化]機能によって作成されたコード ブロック
[ノードをコード化]機能の使用方法については、「DesignScript 構文」を参照してください。
List.Map ノードと List.Combine ノードはキャンバス上で大きなスペースを占有する場合がありますが、List@Level 機能を使用してこれらのノードを置き換えることにより、画面上の煩雑さを軽減することができます。
List@Level 機能を使用すると、ノードの入力ポートからリスト内の任意のレベルに直接アクセスできるため、List.Map ノードや List.Combine ノードを使用するよりも速くノード ロジックを記述できます。
CountTrue ノードの list 入力で List@Level 機能を有効にすると、BoundingBox.Contains ノードから返される True 値の数と、その True 値を返すリストを確認できます。List@Level 機能により、入力データの取得元となるレベルを特定することができます。List.Map ノードと List.Combine ノードを使用する場合、List@Level 機能は、他の方法よりも柔軟で効率的な方法です。これらのノードで作業を行う場合は、List@Level 機能を使用することを強くお勧めします。
リスト レベル 2 で True 値の数をカウント
リスト レベル 3 で True 値の数をカウント
List@Level 機能の使用方法については、「リストのリスト」を参照してください。
可能な限り簡潔で効率的なプログラムを作成するには、見やすいプログラムを作成するということに重点を置く必要があります。論理的にグループ化された直感的なプログラムを作成した場合であっても、データ間の関係性が分かりにくくなることがあります。グループ内に簡単な注記を記載したり、スライダー名を分かりやすい名前に変更すると、自分だけでなく他のメンバーも、名前などで混乱したり、画面上を無駄に移動することがなくなります。ここでは、プログラム全体で一貫した外観を保つための方法をいくつか紹介します。
プログラム作成後の作業量を減らすには、プログラムの作成時に頻繁にノードの配置を調整して、ノードのレイアウトを見やすく整える必要があります。
自分が作成したプログラムで他のメンバーが作業を行う場合は、ワイヤが自然な方向に流れるように各ノードを配置する必要があります。
ノードを配置するには、[ノードのレイアウトをクリーンアップ]機能を使用してノードの配置を自動的に調整します。ただし、手動で調整する場合と比べて、多少精度が下がることに注意してください。
ノードが整理されていない画面
ノードが整理されている画面
ノードの配置を調整する方法については、「プログラムを管理する」を参照してください。
入力の名前を変更することにより、自分が作成したプログラムを他のメンバーが使用する場合でも、内容を簡単に理解できるようになります。特に、入力の接続先ノードが画面からはみ出してしまうような場合は、入力名からそのノードの内容を推測できるため、 分かりやすい名前を付けておくと便利です。
入力以外のノード名を変更する場合は、注意が必要です。 その場合は、別の方法として、ノード クラスタからカスタム ノードを作成し、そのカスタム ノードの名前を変更します。こうすることにより、そのノードの内容は、他のノードとは異なっているということを示すことができます。
サーフェスを操作するための入力
建築設計パラメータ用の入力
排水シミュレーション スクリプト用の入力
ノード名を変更するには、変更するノード名を右クリックして[ノードの名前を変更...]を選択します。
ノードでは表現できないような分かりやすい説明をプログラムに挿入する必要がある場合は、ノートと呼ばれる注記を追加します。
ノードの集合やグループのサイズが大きすぎて(または複雑すぎて)簡単には理解できない場合は、ノートを追加することをお勧めします。
行の移動距離を返すプログラムの特定の箇所を説明するためのノート
上記の移動距離の値を正弦波にマッピングするコードを説明するためのノート
ノートの追加方法については、「プログラムを管理する」を参照してください。
ビジュアル スクリプトを作成する場合、正しい値がスクリプトから返されるかどうかを確認することが重要になります。すべてのエラーが、プログラムの即時停止につながるエラーというわけではありません。特に、Null 値やゼロの値に関するエラーは、プログラムの下流部分に影響する場合があるため、注意が必要です。この方法は、「スクリプト作成のガイドライン」の章でも、テキスト スクリプトに関連する形で記載されています。次の演習では、正しい結果を得る方法について確認していきます。
プログラムの作成時にウォッチ バルーンまたはプレビュー バルーンを使用すると、重要な出力データが正しく返されるかどうかを確認することができます。
この例では、Watch ノードを使用して、次のデータを比較しています。
行の移動距離
正弦式から渡された値
Watch ノードの使用方法については、「ライブラリ」を参照してください。
自分が他のメンバーとは別の作業を行っている場合であっても、自分が作成したプログラムを後で他のメンバーが使用するというのは非常によくあることです。そうした場合に備えて、入力データと出力データから、プログラムの内容と結果を短時間で把握できるようにしておく必要があります。これは特に、カスタム ノードを開発して Dynamo コミュニティで共有し、他のメンバーが作成したプログラム内でそのカスタム ノードを使用する場合に重要になります。こうすることにより、簡単に再利用できる堅固なプログラムとノードを作成することができます。
プログラムの読みやすさと拡張性を確保するため、入力と出力は可能な限り少なくすることをお勧めします。
キャンバス上でノードを追加する前に、ロジックの概要を組み立ててから、そのロジックをどのように作成していくかを検討するようにしてください。概要を組み立てる際に、スクリプト内で使用する入力と出力を検討する必要があります。
特定のオプションや条件をプログラム内に組み込む場合は、プリセットを使用すると、迅速に作業を進めることができます。
また、長期間実行されるプログラム内でプリセットを使用して特定のスライダ値をキャッシュすると、プログラムの複雑さを軽減することができます。
プリセットの使用方法については、「プリセットを使用してデータを管理する」を参照してください。
プログラムを構成する各ノードを 1 つのコンテナ内に収集できる場合は、カスタム ノードを使用することをお勧めします。
他のプログラム内で一部のコードを頻繁に再利用する場合は、カスタム ノードを使用することをお勧めします。
Dynamo コミュニティ内で特定の機能を共有する場合は、カスタム ノードを使用することをお勧めします。
点の移動プログラムを構成する各ノードをカスタム ノード内に収集すると、移植可能で堅固な一意のプログラムを作成することができます。また、プログラムの内容も簡単に理解できるようになります。入力ポートに分かりやすい名前を付けると、他のメンバーがそのプログラムを使用する際に、ノードの使用方法を簡単に理解できるようになります。すべての入力について、説明と必要なデータ タイプを追加してください。
既存のアトラクタ プログラム
上記のプログラムを構成する各ノードを収集するためのカスタム ノード「PointGrid」
カスタム ノードの使用方法については、「カスタム ノードの概要」を参照してください。
テンプレートを作成してビジュアル プログラム全体の外観的な標準を定義することにより、すべてのチーム メンバーが標準化された方法でプログラムを理解できるようになります。
テンプレートを作成する際に、グループの色とフォント サイズを標準化して、ワークフローやデータ操作のタイプを分類することができます。
テンプレートを作成する際に、プログラム内のワークフローのフロントエンドとバックエンドとの差異について、ラベルを付けたり、色を付けたり、スタイルを設定することもできます。
プログラムの UI (フロントエンド)。プロジェクト名、入力スライダ、読み込みジオメトリが表示されます。
プログラムのバックエンド。
グループ(一般的な設計、入力、Python スクリプト、読み込まれたジオメトリ)を区別するための色分け。
下のリンクをクリックして、サンプル ファイルをダウンロードします。
すべてのサンプルファイルの一覧については、付録を参照してください。
この演習では、上で説明したベスト プラクティスを構造化されていないプログラムに適用してみましょう。このプログラムでは、屋根を正しく作成することができますが、計画的に作成されたものではないため、構造化されていない状態になっています。各ノードの配置は整理されておらず、ノードの用途を示す説明も入力されていません。このプログラムの作成者以外のユーザもこのプログラムの内容を理解できるように、ノード配置の整理、説明の追加、プログラムの解析について、ベスト プラクティスを適用する手順を順に見ていきましょう。
このプログラムは正しく機能しますが、ノードが乱雑に配置されているため、見にくくなっています。
最初に、プログラムから返されるデータとジオメトリを確認しましょう。
論理的な単位であるモジュールを作成する場合、データが大きく変更されるタイミングを把握することが非常に重要になります。Watch ノードを使用してプログラムを検査し、ノードのグループ化を検討してから、次のステップに進むようにしてください。
このコード ブロックには数式が記述されているため、プログラムの重要な部分を構成していると考えられます。Watch ノードを使用すると、プログラムから返される移動距離のリストを表示することができます。
これらのノードの用途については、一見しただけではよくわかりません。BoundingBox.Contains ノードのリスト レベル L2 の True 値の配置と、List.FilterByBoolMask ノードが使用されていることから考えると、点構成グリッドの一部をサンプリングしていることが推測できます。
プログラム内の各要素の内容が理解できたら、それらの要素をグループ化します。
ノードをグループ化することにより、プログラムを構成するパーツを視覚的に区別できるようになります。
3D サイト モデルを読み込むグループ
正弦式に基づいて点構成グリッドを移動するグループ
点構成グリッドの一部をサンプリングするグループ
建築設計で使用する屋根のサーフェスを作成するグループ
ガラス カーテン ウォールを作成するグループ
グループ化が完了したら、ノードの配置を調整して、プログラム全体の流れを見やすく整理します。
プログラムの流れを見やすく整理することにより、プログラムの構造と各ノード間の暗黙的な関係を把握できるようになります。
プログラムをさらに見やすくするため、外観的な情報を追加してみましょう。ここでは、プログラムの特定の領域がどのように機能するかを示すためのノートを追加し、入力のカスタム名を設定し、グループのタイプを区別するための色を割り当てます。
これらの外観的な情報を追加することにより、プログラムの内容がさらに分かりやすくなります。グループを色分けすると、関数から渡される入力を簡単に区別することができます。
ノート
分かりやすい名前が設定された入力
プログラムの集約を開始する前に、プログラムのどの位置に Python スクリプトの排水シミュレータを組み込むかについて確認しましょう。スケーリングされた最初の屋根のサーフェスの出力を、それぞれのスクリプト入力に接続します。
ここでは、上図の位置にスクリプトを組み込みます。これにより、元の屋根のサーフェス上で排水シミュレーションを実行できるようになります。このサーフェスはプレビュー表示されていませんが、このサーフェスにより、面取りされたポリサーフェスの上部サーフェスを選択する必要がなくなります。
スクリプト入力のソース ジオメトリ
Python ノード
入力スライダ
オン/オフ スイッチ
これですべての準備が整ったので、プログラムを集約してみましょう。
[ノードをコード化]と[カスタム ノード]を使用してプラグラムを集約すると、プログラムのサイズが大幅に削減されます。屋根のサーフェスと壁を作成するグループは、このプログラムにとって非常に重要な機能を実行するグループであるため、コードに変換されています。点を移動するグループは、他のプログラムでも使用できるように、カスタム ノード内に集約されています。このサンプル ファイルで、点を移動するグループを使用して、独自のカスタム ノードを作成してみてください。
点構成グリッドを移動するグループを格納するためのカスタム ノード
建築設計で使用する屋根のサーフェスとカーテン ウォールを作成するグループを集約するための[ノードをコード化]機能
最後に、サンプルの屋根形状用のプリセットを作成します。
上図の各入力が、屋根形状の主要な駆動要素になります。これらの入力を確認することにより、プログラムの概要を把握することができます。
2 つのプリセットは、次のようなビューとして表示されます。
屋根の排水パターンを指定することにより、それぞれのプリセットをさまざまな角度から解析することができます。