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 ist eine visuelle Programmieranwendung, die Sie herunterladen und entweder im Standalone-Modus (Sandbox) oder als Plug-In für andere Software wie Revit, FormIt oder Civil 3D ausführen können.
Erfahren Sie mehr über die Unterschiede zwischen Dynamo Core/Revit/Sandbox.
In Dynamo haben Sie die Möglichkeit, in einem visuellen Programmierprozess zu arbeiten, wobei Sie Elemente miteinander verbinden und dadurch die Beziehungen und Abfolgen von Aktionen definieren, aus denen sich benutzerdefinierte Algorithmen zusammensetzen. Ihre Algorithmen können Sie für ein breites Spektrum an Verwendungszwecken von der Verarbeitung von Daten bis zum Generieren von Geometrie einsetzen – in Echtzeit und ohne eine einzige Zeile code
zu schreiben.
Blöcke und Drähte sind die wichtigsten Komponenten in Dynamo zur Unterstützung eines visuellen Programmierungsprozesses. Sie helfen beim Aufbau starker visueller und systemischer Beziehungen zwischen den Teilen eines Entwurfs. Verwenden Sie einen einfachen Mausklick, um die Blöcke während der Entwicklung und Optimierung Ihres Entwurfsarbeitsablaufs einfach zu verbinden.
Ob Sie die visuelle Programmierung für Arbeitsabläufe in Projekten nutzen oder eigene Werkzeuge entwickeln: Dynamo ist unverzichtbarer Bestandteil in einer Vielzahl möglicher Anwendungen.
Dieser Leitfaden enthält Kapitel, die mit Mode Lab entwickelt wurden. In diesen Kapiteln liegt der Schwerpunkt auf den Grundlagen, die Sie zum Entwickeln Ihrer eigenen visuellen Programme mit Dynamo benötigen, und auf wichtigen Einblicken in die weiteren Schritte mit Dynamo.
Dieser Leitfaden richtet sich an Leser mit unterschiedlichen Hintergründen und Kenntnisstufen. Eine allgemeine Einführung in die Einrichtung von Dynamo, die Benutzeroberfläche und die wichtigsten Konzepte finden Sie in den folgenden Abschnitten. Wir empfehlen neuen Benutzern, die folgenden Themen zu behandeln:
Für Benutzer, die ein tieferes Verständnis der einzelnen Elemente, z. B. bestimmter Blöcke und des Konzepts dahinter entwickeln möchten, werden die Grundlagen in einem eigenen Kapitel behandelt.
Wenn Sie eine Demonstration der Dynamo-Arbeitsabläufe sehen möchten, finden Sie einige Diagramme im Abschnitt Beispielarbeitsabläufe. Befolgen Sie die angehängten Anweisungen, um Ihre eigenen Dynamo-Diagramme zu erstellen.
In den folgenden Kapiteln finden Sie themenspezifische Übungen, die sich mit unterschiedlichen Themen zu Dynamo befassen. Übungen finden Sie normalerweise im letzten Abschnitt jeder Seite.
Ohne seine starke Community engagierter Benutzer und aktiver Beitragender hätte sich Dynamo nie so weit entwickelt. Engagieren auch Sie sich in der Community, indem Sie den Blog lesen, Ihre Arbeiten zur Galerie hinzufügen oder an Forumsdiskussionen zu Dynamo teilnehmen.
Dynamo ist als visuelles Programmierwerkzeug für Designer konzipiert. Dies ermöglicht es, Tools zu entwickeln, die externe Bibliotheken oder beliebige Autodesk-Produkte nutzen, in denen eine API zur Verfügung steht. In Dynamo Sandbox können Sie Programme in einer Sandbox-ähnlichen Anwendung entwickeln. Das Dynamo-Ökosystem wächst jedoch nach wie vor weiter.
Da der Quellcode für dieses Projekt als Open Source zur Verfügung steht, können Sie seine Funktionen ganz nach Ihren Vorstellungen erweitern. Besuchen Sie das Projekt auf GitHub und sehen Sie sich die laufenden Beiträge der Benutzer an, die Dynamo anpassen.
Durchsuchen, Verzweigen und Erweitern von Dynamo für Ihre Anforderungen
Dynamo ist eine Open-Source-Plattform zur visuellen Programmierung, die für Konstrukteure konzipiert ist.
Sie haben gerade Dynamo Primer geöffnet, die umfassende Einführung in die visuelle Programmierung in Autodesk Dynamo. Bei diesem Primer handelt es sich um ein laufendes Projekt zum Austauschen der Grundlagen der Programmierung. Zu den enthaltenen Themen gehören die Verwendung der Dynamo-Plattform für rechnerische Geometrie (Computational Geometry), Best Practices für regelbasierte Konstruktionen, interdisziplinäre Programmierungsanwendungen und andere.
Der Leistungsumfang von Dynamo spiegelt sich in einer breiten Palette von konstruktionsbezogenen Aktivitäten wider. Dynamo bietet eine umfassende Reihe an leicht zugänglichen Möglichkeiten für den ersten Einstieg, die ständig erweitert wird:
Erste Schritte mit der visuellen Programmierung erkunden
Arbeitsabläufe in verschiedenen Softwareanwendungen verbinden
Eine aktive Community an Benutzern, Beitragenden und Entwicklern einbeziehen
Eine Open-Source-Plattform für die fortlaufende Optimierung entwickeln
Vor dem Hintergrund dieser Aktivitäten und den aufregenden Möglichkeiten, die uns die Arbeit mit Dynamo bietet, benötigen wir ein Dokument desselben Kalibers: Dynamo Primer.
Im Dynamo Primer-Benutzerhandbuch finden Sie Informationen zu den in dieser Einführung enthaltenen Themen.
Wir verbessern Dynamo ständig, sodass einige Funktionen möglicherweise anders aussehen als in dieser Einführung beschrieben. Alle Funktionsänderungen werden jedoch korrekt dargestellt.
Dynamo Primer ist ein Open-Source-Projekt. Wir haben uns dazu verpflichtet, hochwertige Inhalte bereitzustellen, und begrüßen daher jegliche Art von Feedback von Ihnen. Wenn Sie ein Problem melden möchten, posten Sie es auf unserer GitHub-Fehler-Seite: https://github.com/DynamoDS/DynamoPrimer/issues
Wenn Sie sich mit einem neuen Abschnitt, Änderungen oder etwas anderem an diesem Projekt beteiligen möchten, navigieren Sie zum GitHub-Repository, um loszulegen: https://github.com/DynamoDS/DynamoPrimer.
Dynamo Primer ist ein Open-Source-Projekt, das von Matt Jezyk und dem Dynamo-Entwicklungsteam bei Autodesk initiiert wurde.
Mode Lab wurde damit beauftragt, die erste Version dieser Einführung zu verfassen. Wir bedanken uns bei allen für ihre Arbeit beim Zusammenstellen dieses wichtigen Nachschlagewerks.
John Pierson von Parallax Team wurde damit beauftragt, die Einführung mit den Änderungen an Dynamo 2.0 zu aktualisieren.
Matterlab wurde damit beauftragt, die Einführung um die Revisionen von Dynamo 2.13. zu ergänzen.
Archilizer wurde damit beauftragt, die Einführung um die Revisionen von Dynamo 2.17. zu ergänzen.
Wood Rodgers wurde damit beauftragt, die Einführung mit Inhalten für Dynamo for Civil 3D zu aktualisieren.
Ein besonderer Dank geht an Ian Keough für die Initiierung und Begleitung des Dynamo-Projekts.
Vielen Dank auch an Matt Jezyk, Ian Keough, Zach Kron, Racel Amour und Colin McCrone für die tolle Zusammenarbeit und die Möglichkeit zur Teilnahme an einer breiten Palette von Dynamo-Projekten.
Dynamo Die aktuelle stabile Version von Dynamo finden Sie auf den folgenden Websites.
http://dynamobim.com/download/ oder http://dynamobuilds.com
*Anmerkung: Beginnend mit Revit 2020 ist Dynamo im Paket der Revit-Versionen enthalten, sodass keine manuelle Installation erforderlich ist. Weitere Informationen finden Sie in diesem Blog-Post.
DynamoBIM Die beste Quelle für zusätzliche Informationen, Lerninhalte und Foren ist die DynamoBIM-Website.
http://dynamobim.org
Dynamo GitHub Dynamo ist ein Open-Source-Entwicklungsprojekt auf GitHub. Um zu dem Projekt beizutragen, gehen Sie zu DynamoDS.
https://github.com/DynamoDS/Dynamo
Kontakt Informieren Sie uns über Probleme mit diesem Dokument.
Dynamo@autodesk.com
Copyright 2023 Autodesk
Lizenziert unter der Apache-Lizenz, Version 2.0 ("Lizenz"); Sie dürfen diese Datei nur in Übereinstimmung mit der Lizenz verwenden. Sie erhalten die Lizenz unter:
http://www.apache.org/licenses/LICENSE-2.0
Außer wenn durch geltendes Recht gefordert oder mit schriftlicher Genehmigung, wird die Software unter der Lizenz "WIE BESEHEN" bereitgestellt, OHNE ausdrückliche oder stillschweigende GARANTIEN ODER BEDINGUNGEN JEGLICHER ART. Informationen zu spezifischen sprachenrelevanten Rechten und Einschränkungen finden Sie in der Lizenz.
Die Benutzeroberfläche (UI) für Dynamo ist in fünf Hauptbereiche unterteilt. Wir verschaffen uns hier kurz einen Überblick und erläutern den Arbeitsbereich und die Bibliothek in den folgenden Abschnitten näher.
Menüs
Werkzeugkasten
Bibliothek
Arbeitsbereich
Ausführungsleiste
Hier finden Sie Menüs für die grundlegenden Funktionen der Dynamo-Anwendung. Wie bei den meisten Windows-Programmen beziehen sich die ersten beiden Menüs auf die Verwaltung von Dateien, die Auswahl und die Bearbeitung von Inhalten. Die übrigen Menüs sind spezifisch für Dynamo.
Allgemeine Informationen und Einstellungen finden Sie im Dropdown-Menü Dynamo.
Info: Hier sehen Sie, welche Version von Dynamo auf Ihrem Computer installiert ist.
Vereinbarung zur Erfassung von Benutzerdaten: Hier können Sie Ihre Benutzerdaten freigeben, um Dynamo zu verbessern.
Einstellungen: Enthält Einstellungen wie die Definition der Dezimalpunktgenauigkeit der Anwendung und die Renderqualität der Geometrie.
Dynamo beenden
Wenn Sie nicht weiterkommen, verwenden Sie das Menü Hilfe. Sie können über Ihren Internetbrowser auf eine der Referenz-Websites von Dynamo zugreifen.
Erste Schritte: Eine kurze Einführung in die Verwendung von Dynamo.
Interaktiver Leitfaden:
Beispiele: Beispieldateien als Referenz.
Dynamo-Wörterbuch: Ressource mit Dokumentation für alle Blöcke.
Dynamo-Website: Anzeigen des Dynamo-Projekts auf GitHub.
Dynamo-Projekt-Wiki: Im Wiki erhalten Sie Entwicklungsinformationen mithilfe der Dynamo-API, unterstützenden Bibliotheken und Tools.
Startseite anzeigen: Kehren Sie von einem Dokument aus zur Dynamo-Startseite zurück.
Fehler melden: Melden Sie ein Problem auf GitHub.
Der Werkzeugkasten von Dynamo enthält eine Reihe von Schaltflächen für den Schnellzugriff zum Arbeiten mit Dateien sowie die Befehle Rückgängig [Ctrl + Z] und Wiederholen [Ctrl + Y]. Ganz rechts befindet sich eine weitere Schaltfläche, über die Sie einen Snapshot des Arbeitsbereichs exportieren können. Dies ist für die Dokumentation und die gemeinsame Bearbeitung mit anderen äußerst nützlich.
Die Dynamo-Bibliothek ist eine Sammlung funktionaler Bibliotheken, in der jede Bibliothek Blöcke enthält, die nach Kategorie gruppiert sind. Sie besteht aus grundlegenden Bibliotheken, die während der Vorgabeinstallation von Dynamo hinzugefügt werden. Während die Verwendung des Programms weiter vorgestellt wird, wird gezeigt, wie die Basisfunktionen um benutzerdefinierte Blöcke und zusätzliche Pakete erweitert werden können. Der Abschnitt Bibliothek enthält eine ausführlichere Anleitung zur Verwendung der Bibliothek.
Im Arbeitsbereich erstellen wir unsere visuellen Programme. Sie können auch die Vorschaueinstellung ändern, um die 3D-Geometrien hier anzuzeigen. Weitere Informationen finden Sie unter Arbeitsbereich.
Führen Sie das Dynamo-Skript von hier aus. Klicken Sie auf das Dropdown-Symbol auf der Schaltfläche Ausführung, um zwischen den verschiedenen Modi zu wechseln.
Automatisch: Führt das Skript automatisch aus. Änderungen werden in Echtzeit aktualisiert.
Manuell: Das Skript wird nur ausgeführt, wenn Sie auf die Schaltfläche Ausführen klicken. Nützlich, wenn Sie Änderungen an einem komplizierten und "schweren" Skript vornehmen.
Periodisch: Diese Option ist vorgabemäßig abgeblendet. Nur verfügbar, wenn der DateTime.Now-Block verwendet wird. Sie können festlegen, dass das Diagramm in einem bestimmten Intervall automatisch ausgeführt wird.
Die Bibliothek enthält alle geladenen Blöcke, einschließlich der zehn vorgabemäßigen Kategorieblöcke, die zum Lieferumfang gehören, sowie der zusätzlich geladenen benutzerdefinierten Blöcke und Pakete. Die Blöcke in der Bibliothek sind hierarchisch in Bibliotheken, Kategorien und gegebenenfalls Unterkategorien angeordnet.
Basisblöcke: Im Lieferumfang der Vorgabeinstallation enthalten.
Benutzerdefinierte Blöcke: Speichern Sie häufig verwendete Routinen oder spezielle Diagramme als benutzerdefinierte Blöcke. Sie können Ihre benutzerdefinierten Blöcke auch für die Community freigeben.
Blöcke aus Package Manager: Sammlung von veröffentlichten benutzerdefinierten Blöcken.
Wir sehen uns die Kategorien für die Hierarchie der Blöcke an und zeigen, wie Sie schnell in der Bibliothek suchen können. Außerdem werden einige der häufig verwendeten Blöcke vorgestellt.
Das Durchsuchen dieser Kategorien stellt die schnellste Möglichkeit dar, um die Hierarchie dessen zu verstehen, was Sie zu Ihrem Arbeitsbereich hinzufügen können, und um neue Blöcke zu entdecken, die Sie niemals zuvor verwendet haben.
Durchsuchen Sie die Bibliothek, indem Sie durch die Menüs klicken, um die einzelnen Kategorien und ihre Unterkategorien zu erweitern.
Am besten untersuchen Sie zunächst die Menüs unter Geometry, da sie die größte Anzahl an Blöcken enthalten.
Bibliothek
Kategorie
Unterkategorie
Block
Mit diesen werden die Blöcke weiter in derselben Unterkategorie kategorisiert, je nachdem, ob die Blöcke Daten erstellen, eine Aktion ausführen oder Daten abfragen.
Bewegen Sie den Mauszeiger über einen Block, um weitere Informationen über seinen Namen und sein Symbol hinaus anzuzeigen. Dadurch können Sie schnell nachvollziehen, welche Aktion der Block ausführt, welche Eingaben erforderlich sind und was von dem Block ausgegeben wird.
Beschreibung: Kurze Beschreibung des Blocks
Symbol: Größere Version des Symbols im Menü Bibliothek
Eingabe(n): Name, Datentyp und Datenstruktur
Ausgabe(n): Datentyp und Struktur
Wenn Sie relativ genau wissen, welchen Block Sie zu Ihrem Arbeitsbereich hinzufügen möchten, geben Sie etwas in das Feld Suchen ein, um alle passenden Blöcke zu suchen.
Treffen Sie Ihre Auswahl, indem Sie auf den hinzuzufügenden Block klicken, oder drücken Sie die EINGABETASTE, um die markierten Blöcke in der Mitte des Arbeitsbereichs hinzuzufügen.
Neben der Verwendung von Schlüsselwörtern zum Suchen von Blöcken können Sie auch die Hierarchie getrennt durch einen Punkt im Suchfeld oder mithilfe von Codeblöcken (in denen die Textsprache von Dynamo verwendet wird) eingeben.
Die Hierarchie der einzelnen Bibliotheken spiegelt sich im Namen der Blöcke wider, die dem Arbeitsbereich hinzugefügt wurden.
Durch die Eingabe verschiedener Teile der Position des Blocks in der Bibliothekshierarchie im Format library.category.nodeName
werden unterschiedliche Ergebnisse zurückgegeben.
library.category.nodeName
category.nodeName
nodeName
oder keyword
In der Regel wird der Name eines Blocks im Arbeitsbereich im Format category.nodeName
gerendert, wobei einige Ausnahme insbesondere bei der Eingabe- und Ansichtskategorie bestehen.
Beachten Sie bei ähnlich benannten Blöcken den Kategorieunterschied:
Blöcke aus den meisten Bibliotheken schließen das Kategorieformat ein.
Point.ByCoordinates
und UV.ByCoordinates
weisen denselben Namen auf, stammen jedoch aus unterschiedlichen Kategorien.
Zu den wichtigsten Ausnahmen gehören Built-in Functions, Core.Input, Core.View und Operators.
Welche der zahlreichen Blöcke, die zum Lieferumfang der Basisinstallation von Dynamo gehören, sind für die Entwicklung visueller Programme von grundlegender Bedeutung? Konzentrieren Sie sich zunächst auf jene, mit denen Sie die Parameter Ihres Programms definieren (Input), die Ergebnisse der Aktion eines Blocks anzeigen (Watch) und die Eingaben oder Funktionen mithilfe einer Verknüpfung definieren (Code Block).
Eingabeblöcke stellen das primäre Mittel für die Benutzer eines visuellen Programms – sowohl für Sie selbst als auch für andere Benutzer – zur Verwendung der Schlüsselparameter dar. Hier sehen Sie einige, die in der Core-Bibliothek verfügbar sind:
Die Beobachtungsblöcke sind für die Verwaltung der Daten, die ein visuelles Programm durchlaufen, von grundlegender Bedeutung. Sie können das Ergebnis eines Blocks in der Datenvorschau des Blocks anzeigen, indem Sie den Mauszeiger über den Block bewegen.
Es ist hilfreich, sie in einem Watch-Block offen zu halten.
Sie können die Geometrieergebnisse auch über einen Watch3D-Block anzeigen.
Beide Blöcke sind in der Kategorie View der Core-Bibliothek enthalten.
Tipp: Die 3D-Vorschau kann bisweilen unübersichtlich sein, wenn Ihr visuelles Programm viele Blöcke enthält. Ziehen Sie in diesem Fall in Betracht, im Einstellungsmenü die Option zum Anzeigen der Hintergrundvorschau zu deaktivieren und einen Watch3D-Block zu verwenden, um eine Vorschau der Geometrie anzuzeigen.
Code Block-Blöcke können verwendet werden, um einen Codeblock mit Linien durch Semikolons getrennt zu definieren. Dies kann ganz einfach sein: X/Y
.
Wir können auch Codeblöcke als Abkürzung verwenden, um einen Number Input-Block zu definieren oder eine andere Funktion des Blocks aufzurufen. Die Syntax hierfür entspricht der Namenskonvention der textuellen Sprache von Dynamo, DesignScript.
Hier sehen Sie eine einfache Demonstration (mit Anweisungen) zur Verwendung von Codeblöcken in Ihrem Skript.
Doppelklicken Sie, um einen Code Block-Block zu erstellen.
Circle.ByCenterPointRadius(x,y);
Typ
Klicken Sie auf den Arbeitsbereich, um die Auswahl aufzuheben und automatisch x
- und y
-Eingaben hinzuzufügen.
Erstellen Sie einen Point.ByCoordinates-Block und einen Number Slider und verbinden Sie sie anschließend mit den Eingaben des Codeblocks.
Das Ergebnis der Ausführung des visuellen Programms wird in der 3D-Vorschau als Kreis dargestellt.
Der Dynamo-Arbeitsbereich besteht aus vier Hauptelementen.
Alle aktiven Registerkarten.
Vorschaumodus
Steuerelemente zum Zoomen/Schwenken
Block im Arbeitsbereich
Wenn Sie eine neue Datei öffnen, wird vorgabemäßig ein neuer Start-Arbeitsbereich geöffnet.
Sie können einen benutzerdefinierten Block erstellen und ihn in einem Arbeitsbereich für benutzerdefinierte Blöcke öffnen.
In jedem Dynamo-Fenster ist nur ein Start-Arbeitsbereich zulässig, auf den Registerkarten können jedoch mehrere Arbeitsbereiche für benutzerdefinierte Blöcke geöffnet sein.
Es gibt 3 Methoden zum Wechseln zwischen verschiedenen Vorschauen:
a. Verwenden Sie die Symbole oben rechts.
b. Klicken Sie mit der rechten Maustaste in den Arbeitsbereich.
Wechseln von der 3D-Vorschau zur Diagrammvorschau
Wechseln von der Diagrammvorschau zur 3D-Vorschau
c. Verwenden Sie den Tastaturbefehl (Strg+B).
Sie können in beiden Arbeitsbereichen Symbole oder eine Maus zum Navigieren verwenden.
a. Im Modus Diagrammvorschau
Mit Symbolen:
Mit der Maus:
Linksklick – Auswählen
Linksklicken und ziehen – Auswahlfeld zur Auswahl mehrerer Blöcke
Mausrad nach oben/unten drehen – Vergrößern/Verkleinern
Klicken und ziehen mit der mittleren Maustaste – Schwenken
Klicken mit der rechten Maustaste auf eine beliebige Stelle im Ansichtsbereich – Suche im Ansichtsbereich öffnen
b. Im 3D-Vorschaumodus
Mit Symbolen:
Mit der Maus:
Mausrad nach oben/unten drehen – Vergrößern/Verkleinern
Klicken und ziehen mit der mittleren Maustaste – Schwenken
Klicken mit der rechten Maustaste und ziehen – Umkreisen
Klicken Sie mit der linken Maustaste, um einen beliebigen Block auszuwählen.
Um mehrere Blöcke auszuwählen, klicken Sie und ziehen Sie, um einen Auswahlrahmen zu erstellen.
Als visuelle Programmierumgebung bietet Dynamo Ihnen die Möglichkeit, die Art und Weise, in der Daten verarbeitet werden, selbst zu gestalten. Daten sind Zahlen oder Text. Geometrie gehört ebenfalls dazu. Aus der Perspektive des Computers ist Geometrie – auch als Computational Geometry bezeichnet – nicht anderes als die Daten, aus denen Sie wunderschöne, komplexe oder funktionsorientierte Modelle erstellen können. Hierzu müssen Sie die Eigenschaften der verschiedenen Typen von Geometrie kennen, die zur Verfügung stehen.
Ein Vektor ist eine Darstellung der Größe und Richtung. Sie können sich diesen als einen Pfeil vorstellen, der mit einer bestimmten Geschwindigkeit in eine bestimmte Richtung beschleunigt. Vektoren stellen eine wichtige Komponente für Modelle in Dynamo dar. Beachten Sie, dass Sie zur abstrakten Kategorie der "Helfer" gehören. Wenn Sie also einen Vektor erstellen, wird nichts in der Hintergrundvorschau angezeigt.
Sie können eine Linie zur Darstellung einer Vektorvorschau verwenden.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Eine Ebene ist eine zweidimensionale Fläche. Sie können sich diese als eine flache Oberfläche vorstellen, die sich unendlich ausdehnt. Jede Ebene verfügt über einen Ursprung, eine X-Richtung, eine Y-Richtung und eine Z-Richtung (nach oben).
Ebenen sind zwar abstrakt, verfügen aber über eine Ursprungsposition, damit sie im Raum lokalisiert werden können.
In Dynamo werden Ebenen in der Hintergrundvorschau gerendert.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Ein Koordinatensystem ist ein System zur Bestimmung der Position von Punkten oder anderen geometrischen Elementen. In der folgenden Abbildung wird erläutert, wie die Darstellung in Dynamo aussieht und welche Bedeutung die einzelnen Farben haben.
Koordinatensysteme sind zwar abstrakt, verfügen aber über eine Ursprungsposition, damit sie im Raum lokalisiert werden können.
In Dynamo werden Koordinatensysteme in der Hintergrundvorschau als Punkt (Ursprung) und Linien gerendert, die die Achsen definieren (gemäß folgender Konvention: X ist rot, Y ist grün und Z ist blau).
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Vektoren, Ebenen und Koordinatensysteme bilden die primäre Gruppe der abstrakten Geometrietypen. Sie helfen uns dabei, die Position und Ausrichtung sowie den räumlichen Kontext für andere Geometrien zu definieren, die Formen beschreiben. Wenn Sie sagen, dass Sie sich in New York City an der Kreuzung zwischen der 42nd Street und dem Broadway (Koordinatensystem) auf Straßenniveau (Ebene) befinden und nach Norden (Vektor) blicken, habe Sie gerade diese "Helfer" verwendet, um zu definieren, wo Sie stehen. Dasselbe gilt für das Gehäuse eines Telefons oder einen Wolkenkratzer – Sie benötigen diesen Kontext für die Entwicklung eines Modells.
Ein Vektor ist eine geometrische Größe, die die Richtung und den Betrag beschreibt. Vektoren sind abstrakt, d. h. sie stellen eine Größe dar, kein geometrisches Element. Vektoren können leicht mit Punkten verwechselt werden, da beide aus Wertelisten bestehen. Es gibt jedoch einen wesentlichen Unterschied: Punkte beschreiben eine Position in einem bestimmten Koordinatensystem, während Vektoren einen relativen Positionsunterschied beschreiben, also die "Richtung".
Wenn Ihnen die Idee des relativen Unterschieds verwirrend erscheint, stellen Sie sich einen Vektor AB folgendermaßen vor: Sie stehen an Punkt A und sehen zu Punkt B. Die Richtung von A zu B entspricht Ihrem Vektor.
Aufgliedern von Vektoren in Ihre Bestandteile mit derselben AB-Notation:
Der Startpunkt von Vektoren wird als Basis bezeichnet.
Der Endpunkt von Vektoren wird als Spitze oder Ausrichtung bezeichnet.
Vektor AB entspricht nicht Vektor BA, der in die entgegengesetzte Richtung weist.
Wenn Sie in Bezug auf Vektoren (und ihrer abstrakten Definition) jemals einer komischen Entlastung bedürfen, sehen Sie sich die klassische Komödie "Die unglaubliche Reise in einem verrückten Flugzeug" an und hören auf die häufig zitierte, humorvolle Aussage:
Roger, Roger. Was ist unser Vektor, Viktor?
Ebenen sind zweidimensionale abstrakte "Helfer". Genauer gesagt sind Ebenen konzeptuell gesehen "flach" und erstrecken sich unendlich in zwei Richtungen. In der Regel werden sie als ein kleineres Rechteck in der Nähe ihres Ursprungs gerendert.
Sie denken möglicherweise: "Stopp! Ursprung? Das klingt nach einem Koordinatensystem, das ich auch zum Modellieren in meiner CAD-Software verwende!"
Und Sie haben recht! In Modellierungssoftware werden häufig Konstruktionsebenen verwendet, um einen lokalen, zweidimensionalen Kontext zu definieren, in dem Entwürfe erstellt werden können. XY-, XZ-, YZ- bzw. Nord- oder Südostebene klingen möglicherweise vertrauter. Dies sind alles Ebenen, die einen unendlichen "flachen" Kontext definieren. Ebenen haben keine Tiefe, aber sie helfen uns auch, die Richtung zu beschreiben.
Sobald Sie mit Ebenen vertraut sind, ist es nur noch ein kleiner Schritt hin zu Koordinatensystemen. Eine Ebene weist dieselben Bestandteile wie ein Koordinatensystem auf, solange es sich um ein "euklidisches" oder "XYZ"-Koordinatensystem handelt.
Darüber hinaus gibt es jedoch auch alternative Koordinatensysteme wie Zylinder- oder Kugelkoordinatensysteme. Wie Sie in späteren Abschnitten sehen werden, können Koordinatensysteme auch auf andere Geometrietypen angewendet werden, um eine Position in der Geometrie zu definieren.
Hinzufügen alternativer Koordinatensysteme – Zylinder- oder Kugelkoordinatensystem
Ein wird lediglich durch einen oder mehrere Werte, die sogenannten Koordinaten, definiert. Die Anzahl der Koordinatenwerte, die zum Definieren des Punkts benötigt werden, ist vom Koordinatensystem oder Kontext abhängig, in dem er sich befindet.
In Dynamo werden größtenteils Punkte verwendet, die sich im dreidimensionalen Weltkoordinatensystem befinden und drei Koordinaten [x,y,z] aufweisen (3D-Punkt in Dynamo).
Ein 2D-Punkt in Dynamo hat zwei Koordinaten: [x,y].
Die Parameter für Kurven und Flächen sind kontinuierlich und erstrecken sich über die Kante der angegebenen Geometrie hinaus. Da die Formen, die den Parameterraum definieren, sich im dreidimensionalen Weltkoordinatensystem befinden, können parametrische Koordinaten jederzeit in Weltkoordinaten konvertiert werden. Der Punkt [0.2, 0.5] auf der Oberfläche entspricht beispielsweise dem Punkt [1.8, 2.0, 4.1] in Weltkoordinaten.
Punkt in angenommenen Weltkoordinaten (xyz)
Punkt relativ zu einem angegebenen Koordinatensystem (zylindrisch)
Punkt in UV-Koordinaten auf einer Oberfläche
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Wenn Geometrie gewissermaßen die Sprache für ein Modell ist, sind Punkte das Alphabet. Punkte sind die Grundlage für die Erstellung aller anderen Geometrie: Sie benötigen mindestens zwei Punkte, um eine Kurve zu erstellen, mindestens drei Punkte für ein Polygon oder eine Netzfläche usw. Indem Sie die Position, Anordnung und Beziehung zwischen Punkten angeben (z. B. mithilfe einer Sinusfunktion), können Sie Geometrie höherer Ordnung definieren, die etwa als Kreise oder Kurven zu erkennen ist.
Ein Kreis, der die Funktionen
x=r*cos(t)
undy=r*sin(t)
verwendetEine Sinuskurve, die die Funktionen
x=(t)
undy=r*sin(t)
verwendet
Punkte können auch in zweidimensionalen Koordinatensystemen vorhanden sein. Für unterschiedliche Räume bestehen unterschiedliche Notationskonventionen: So wird etwa bei einer Ebene [X,Y], bei einer Oberfläche jedoch [U,V] verwendet.
Punkt in euklidischen Koordinatensystem: [x,y,z]
Punkt in einem Koordinatensystem mit Kurvenparameter: [t]
Punkt in Koordinatensystem mit Oberflächenparametern: [U,V]
In diesem Abschnitt stellen wir die wichtigsten Blöcke vor, die in der Dynamo-Bibliothek verfügbar sind und mit denen Sie Ihr eigenes visuelles Programm wie ein Profi erstellen können.
: Wie arbeite ich mit geometrischen Elementen in Dynamo? Lernen Sie mehrere Möglichkeiten zum Erstellen einfacher oder komplexer Geometrien aus Grundkörpern kennen.
: Was sind Daten, und was sind einige grundlegende Typen, mit deren Verwendung ich in meinen Programmen beginnen kann? Darüber hinaus erfahren Sie mehr über die Integration von mathematischen und logischen Operationen in Ihren Konstruktionsarbeitsablauf.
: Wie verwalte und koordiniere ich meine Datenstrukturen? Lernen Sie, das Konzept von Listen besser zu verstehen, und verwenden Sie es zur effizienten Verwaltung Ihrer Konstruktionsdaten.
: Was sind Wörterbücher? Erfahren Sie, wie Sie mithilfe von Wörterbüchern bestimmte Daten und Werte aus vorhandenen Ergebnissen abrufen können.
Dieser Index enthält weitere Informationen zu allen in dieser Einführung verwendeten Blöcken sowie zu anderen Komponenten, die für Sie eventuell nützlich sind. Dabei ist dies nur eine Einführung in die über 500 Blöcke, die in Dynamo zur Verfügung stehen.
**Mit anderen Worten: Wenn Sie einen Quader mit einer Länge von 10 (X-Achse) erstellen und ihn in ein CoordinateSystem mit der 2-fachen Skalierung von X umwandeln, beträgt die Breite immer noch 10. ASM lässt nicht zu, dass Sie die Scheitelpunkte eines Körpers in vorhersehbarer Reihenfolge extrahieren. Es ist daher nicht möglich, die Bemaßungen nach einer Transformation zu bestimmen.
Dynamo ist ein aktives Open Source-Entwicklungsprojekt. Hier finden Sie eine .
Dynamo ist im Lieferumfang von Software wie Revit3D, FormIt, Civil3D usw. enthalten.
Weitere Informationen zur Verwendung von Dynamo mit einer bestimmten Software finden Sie in den folgenden Abschnitten:
Wenn Sie Dynamo als eigenständige Anwendung verwenden möchten. Lesen Sie weiter, um Anweisungen zum Herunterladen der Sandbox zu erhalten.
Wenn Sie nach früheren oder aktuellen Entwicklungsversionen suchen, finden Sie alle Versionen im unteren Bereich derselben Seite.
Aktuelle Entwicklungsversionen können einige neue und experimentelle Funktionen enthalten, die noch nicht vollständig getestet wurden und daher instabil sein können. Durch die Verwendung dieser Versionen können Sie Fehler oder Probleme entdecken und uns helfen, die Anwendung zu verbessern, indem Sie Probleme an unser Team melden.
Einsteiger sollten die offizielle stabile Version herunterladen.
Bevor Sie eine Version starten, die Sie heruntergeladen haben, müssen Sie den Inhalt in den ausgewählten Ordner extrahieren.
Klicken Sie mit der rechten Maustaste auf die ZIP-Datei, und wählen Sie Alle extrahieren …
Wählen Sie ein Ziel zum Entpacken aller Dateien.
Doppelklicken Sie im Zielordner auf DynamoSandbox.exe, um die Anwendung zu starten.
Der Startbildschirm von Dynamo Sandbox wird wie folgt angezeigt.
Sie haben die Einrichtung für die Verwendung von Dynamo Sandbox abgeschlossen!
Geometry ist eine zusätzliche Funktion in Dynamo Sandbox, die nur Benutzern mit einem aktuellen Abonnement oder einer Lizenz für die folgende Autodesk-Software zur Verfügung steht: Revit, Robot Structural Analysis, FormIt und Civil 3D. Geometry ermöglicht Benutzern das Importieren, Erstellen, Bearbeiten und Exportieren von Geometrie aus Dynamo Sandbox.
Geometrie ist die Sprache der Konstruktion. Wenn eine Programmiersprache oder Programmierungsumgebung in seinem Kern einen geometrischen Kernel aufweist, können Sie die Möglichkeiten für die Konstruktion präziser und robuster Modelle, die Automatisierung von Konstruktionsroutinen und die Generierung von Konstruktionsiterationen mit Algorithmen erschließen.
Durch das Verstehen der Geometrietypen und der , können Sie leichter durch die Sammlung der Geometry-Blöcke navigieren, die in der Bibliothek für Sie verfügbar sind. Die Geometrieblöcke sind in alphabetischer Reihenfolge im Gegensatz zu hierarchischen angeordnet. Sie werden hier also ähnlich wie in ihrem Layout in der Dynamo Benutzeroberfläche angezeigt.
Darüber hinaus sollte das Erstellen von Modellen in Dynamo und das Verbindung der Vorschau in der Hintergrundvorschau mit dem Datenstrom in unserem Diagramm im Laufe der Zeit intuitiver werden.
Beachten Sie das angenommene Koordinatensystem, das durch das Raster und die farbigen Achsen dargestellt wird.
Die ausgewählten Knoten rendern die entsprechende Geometrie (wenn der Knoten Geometrie erstellt) im Hintergrund in der Hervorhebungsfarbe.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Die Geometrie ist nach traditioneller Definition die Studie der Form, Größe, relativen Position von Zahlen und der Eigenschaften im Raum. Dieser Bereich weist eine reiche Geschichte auf, die Tausende von Jahren zurückreicht. Mit dem Aufkommen und der Verbreitung des Computers verfügen Sie über ein leistungsstarkes Werkzeug für die Definition, Erforschung und Generierung von Geometrie. Es ist heute ein Leichtes, das Ergebnis komplexer geometrischer Interaktionen zu berechnen. Die Tatsache, dass dies getan wird, ist fast transparent.
Wenn Sie neugierig sind und mithilfe Ihres Computers herausfinden wollen, wie vielfältig und komplex Geometrie sein kann, führen Sie eine schnelle Internetsuche nach dem Stanford Bunny durch – einem kanonischen Modell zum Testen von Algorithmen.
Das Verstehen von Geometrie im Kontext von Algorithmen, Berechnungen und Komplexität kann wie eine gewaltige Aufgabe erscheinen, es gibt jedoch einige wichtige und relativ einfachen Prinzipien, die als Grundlagen für weitergehende Anwendungen etabliert werden können:
Geometrie sind Daten: Für den Computer und Dynamo unterscheidet sich ein Bunny nicht wesentlich von einer Zahl.
Geometrie basiert auf Abstraktion – grundsätzlich werden geometrische Elemente durch Zahlen, Beziehungen und Formeln innerhalb eines bestimmten räumlichen Koordinatensystems beschrieben.
Geometrie verfügt über eine Hierarchie – Punkte werden verbunden, um Linien zu bilden, Linien werden verbunden, um Flächen zu bilden, usw.
Geometrie beschreibt gleichzeitig sowohl das Bauteil als auch das Ganze – bei einer Kurve handelt es sich sowohl um die Form als auch um alle möglichen Punkte entlang der Kurve
In der Praxis bedeutet dies, dass uns bewusst sein muss, womit wir arbeiten (welche Art von Geometrie, wie sie erzeugt wurde usw.), damit wir fließend unterschiedliche Geometrien zusammenstellen, zerlegen und neu zusammensetzen können, um komplexere Modelle zu entwickeln.
Nehmen Sie sich etwas Zeit, um die Beziehung zwischen der abstrakten und hierarchischen Beschreibung von Geometrie näher zu betrachten. Da diese beiden Konzepte miteinander verbunden, aber nicht immer auf den ersten Blick ersichtlich sind, können Sie schnell in eine konzeptuelle Sackgasse gelangen, sobald Sie damit beginnen, tiefergehende Arbeitsabläufe oder Modelle zu entwickeln. Verwenden Sie zunächst Dimensionalität als eine einfache Beschreibung des "Zeugs", das Sie modellieren. Die Anzahl der Bemaßungen, die erforderlich sind, um eine Form zu beschreiben, verdeutlicht, wie Geometrie hierarchisch aufgebaut ist.
Ein Punkt (definiert durch Koordinaten) verfügt über keine Bemaßungen, sondern weist nur Zahlen auf, die die einzelnen Koordinaten beschreiben.
Eine Linie (definiert durch zwei Punkte) verfügt jetzt über eine Bemaßung – Sie können sich vorwärts (in positiver Richtung) oder rückwärts (in negativer Richtung) entlang der Linie bewegen.
Eine Ebene (definiert durch zwei Linien) verfügt über zwei Bemaßungen – Sie können sich jetzt weiter nach links oder nach rechts bewegen.
Ein Quader (definiert durch zwei Ebenen) verfügt über drei Bemaßungen – Sie können eine Position relativ zu oben oder unten definieren.
Dimensionalität stellt eine praktische Möglichkeit zum Kategorisieren von Geometrie dar, jedoch nicht unbedingt die beste. Schließlich verwenden wir zum Modellieren nicht nur Punkte, Linien, Ebenen und Quader, sondern auch mal etwas Gekrümmtes? Darüber hinaus gibt es eine vollkommen andere Kategorie der geometrischen Typen, die vollständig abstrakt sind, d. h. die Eigenschaften wie Ausrichtung, Volumen und Beziehungen zwischen Bauteilen definieren. Ein Vektor ist nicht wirklich greifbar. Wie kann er also relativ zu dem definiert werden, was im Raum angezeigt wird? Eine detailliertere Kategorisierung der geometrischen Hierarchie sollte den Unterschied zwischen abstrakten Typen und "Helfern" berücksichtigen, die jeweils danach gruppiert werden können, welche Schritte sie unterstützen, und nach den Typen, die die Beschreibung der Form von Modellelementen unterstützen.
Das Erstellen von Modellen in Dynamo ist nicht darauf beschränkt, was mit Knoten generiert werden kann. Im Folgenden sind einige wichtige Möglichkeiten aufgeführt, wie Sie Ihren Prozess mit Geometrie auf die nächste Stufe stellen können:
Dynamo ermöglicht das Importieren von Dateien. Versuchen Sie, CSV-Dateien für Punktewolken zu verwenden, oder SAT-Dateien für das Einbeziehen von Flächen.
Bei Verwendung von Revit können Revit-Elemente für die Verwendung in Dynamo referenziert werden.
sind der erste geometrische Datentyp, den wir abgedeckt haben, die einen vertrauteren Satz an beschreibenden Eigenschaften für die Form aufweisen: Wie kurvig oder gerade? Wie lange oder kurz? Und denken Sie daran, dass Punkte weiterhin unsere Bausteine für die Definition von allem darstellen, von einer Linie zu einem Spline und zu allen Kurvenarten dazwischen.
Linie
Polylinie
Bogen
Kreis
Ellipse
NURBS-Kurve
Polykurve
NurbsCurve.ByControlPoints verwendet die Liste der Punkte als Steuerpunkte.
NurbsCurve.ByPoints zeichnet eine Kurve durch die Liste der Punkte.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Der Begriff Kurve ist im Allgemeinen ein Oberbegriff für all die unterschiedlichen Typen von gekrümmten (auch geraden) Formen. Kurve heißt deshalb auch die übergeordnete Kategorisierung für all diese Formen – Linien, Kreise, Splines usw. Technisch betrachtet beschreibt eine Kurve jeden möglichen Punkt, der durch die Eingabe von "t" in eine Sammlung von Funktionen gefunden werden kann, von einfachen Funktionen wie x = -1.26*t, y = t
bis hin zu Funktionen mit Calculi. Unabhängig davon, mit welcher Art von Kurve Sie arbeiten, handelt es sich bei dem Parameter mit dem Namen "t" um eine Eigenschaft, die bewertet werden kann. Darüber hinaus haben alle Kurven unabhängig vom Aussehen der Form einen Startpunkt und einen Endpunkt, die zufälligerweise mit dem Mindest- und dem Höchstwert von t zusammenfallen, die zum Erzeugen der Kurve verwendet wurden. Dies hilft Ihnen auch dabei, ihre Direktionalität zu verstehen.
Es ist wichtig zu beachten, dass Dynamo davon ausgeht, dass die Domäne der Werte "t" für eine Kurve 0.0 bis 1.0 beträgt.
Alle Kurven besitzen auch eine Reihe von Eigenschaften oder Merkmalen, die verwendet werden können, um sie zu beschreiben oder zu analysieren. Wenn der Abstand zwischen dem Start- und dem Endpunkt null beträgt, ist die Kurve "geschlossen". Außerdem weist jede Kurve eine Reihe von Steuerpunkten auf. Wenn sich diese Punkte alle in derselben Ebene befinden, ist die Kurve "planar". Einige Eigenschaften gelten für die Kurve als Ganzes, während andere nur für bestimmte Punkte auf der Kurve gelten. Die Ebenheit ist beispielsweise eine globale Eigenschaft, während ein tangentialer Vektor an einem bestimmten Wert t eine lokale Eigenschaft ist.
Linien sind die einfachste Form von Kurven. Sie sehen möglicherweise nicht gekrümmt aus, sind jedoch tatsächlich Kurven – nur ohne Krümmung. Es gibt mehrere Möglichkeiten zum Erstellen von Linien, die intuitivste davon zwischen den Punkten A und B. Die Form der Linie AB erstreckt sich zwischen den beiden Punkten, mathematisch betrachtet geht sie jedoch in beide Richtungen unendlich weiter.
Wenn Sie zwei Linien miteinander verbinden, erhalten Sie eine Polylinie. Im Folgenden ist auf einfache Weise dargestellt, was ein Steuerpunkt ist. Durch das Bearbeiten der Position eines dieser Punkte ändert sich die Form der Polylinie. Wenn die Polylinie geschlossen ist, erhalten Sie ein Polygon. Wenn die Kantenlängen des Polygons gleich sind, wird von einem regelmäßigen Polygon gesprochen.
Um mehr Komplexität zu den parametrischen Funktionen hinzuzufügen, die eine Form definieren, können Sie mit einem weiteren Schritt aus einer Linie einen Bogen, Kreis, Ellipsenbogen oder eine Ellipse erstellen, indem Sie einen oder zwei Radien beschreiben. Dabei besteht der Unterschied zwischen der Bogenversion sowie der Kreis- oder Ellipsenversion darin, ob die Form offen oder geschlossen ist.
NURBS (nicht-uniforme rationale B-Splines) sind mathematische Darstellungen, mit denen jede beliebige Form von einfachen zweidimensionalen Linien, Kreisen, Bogen oder Rechtecken bis hin zu den komplexesten dreidimensionalen organischen Freiformkurven präzise modelliert werden kann. Aufgrund ihrer Flexibilität (relativ wenige Steuerpunkte, aber eine glatte Interpolation basierend auf Gradeinstellungen) und Genauigkeit (durch eine robuste Mathematik) können NURBS-Modelle in jedem beliebigen Prozess von der Illustration über die Animation bis hin zur Fertigung verwendet werden.
Grad: Der Grad einer Kurve bestimmt den Einflussbereich, den die Steuerpunkte auf eine Kurve haben. Dabei gilt: je höher der Grad, desto größer der Bereich. Der Grad ist eine positive ganze Zahl. Er lautet normalerweise 1, 2, 3 oder 5, es kann sich dabei aber um jede beliebige ganze Zahl handeln. NURBS-Linien und -Polylinien weisen normalerweise den Grad 1 und die meisten Freiformkurven den Grad 3 oder 5 auf.
Steuerpunkte: Steuerpunkte sind eine Liste mit mindestens einem Grad und einem Punkt. Eine der einfachsten Möglichkeiten zum Ändern der Form einer NURBS-Kurve besteht im Verschieben der Steuerpunkte.
Gewichtung: Steuerpunkten ist eine Zahl zugewiesen, die als Gewichtung bezeichnet wird. Gewichtungen werden in der Regel als positive Zahlen angegeben. Wenn die Steuerpunkte einer Kurve alle dieselbe Gewichtung aufweisen (normalerweise 1), wird die Kurve als nichtrational, andernfalls als rational bezeichnet. Die meisten NURBS-Kurven sind nichtrational.
Blöcke: Blöcke sind eine Liste mit (Grad+N-1) Zahlen, wobei N der Anzahl an Steuerpunkten entspricht. Die Blöcke werden zusammen mit den Gewichtungen verwendet, um den Einfluss der Steuerpunkte auf die resultierende Kurve zu steuern. Eine Verwendung von Blöcken besteht darin, Knicke an bestimmten Punkten in der Kurve zu erzeugen.
Grad = 1
Grad = 2
Grad = 3
Beachten Sie, dass je höher der Gradwert ist, desto mehr Steuerpunkte werden verwendet, um die resultierende Kurve zu interpolieren.
Dynamo wurde ursprünglich als Zusatzmodul für Building Information Modeling in Revit entwickelt, ist seitdem gewachsen und kann auf vielfältige Weise genutzt werden. In erster Linie ist Dynamo eine Plattform, die es Designern ermöglicht, mit visueller Programmierung zu experimentieren, Probleme zu lösen und eigene Werkzeuge zu entwickeln. Zu Beginn dieser Einführung finden Sie hier eine Beschreibung des Kontexts für Dynamo: Was ist dieses Programm und wie können Sie es verwenden?
Im Bereich der computergestützten Modellierung stellen eine der am weitesten verbreiteten Formen für die Darstellung von 3D-Geometrie dar. Netzgeometrie besteht im Allgemeinen aus einer Sammlung von Vierecken oder Dreiecken. Sie kann eine einfache und flexible Alternative zum Arbeiten mit NURBS sein, und Netze werden in praktisch allen Bereichen verwendet, von Renderings und Visualisierungen bis hin zur digitalen Fertigung und zum 3D-Druck.
Dynamo definiert Netze mit einer Flächen-Scheitelpunkt-Datenstruktur. Auf elementarster Ebene handelt es sich bei dieser Struktur einfach um eine Sammlung von Punkten, die in Polygonen gruppiert sind. Die Punkte eines Netzes werden als Scheitelpunkte bezeichnet, während die oberflächenartigen Polygone als Flächen bezeichnet werden.
Um ein Netz zu erstellen, benötigen Sie eine Liste von Scheitelpunkten und ein System für die Gruppierung dieser Scheitelpunkte in Flächen. Dies wird auch als Indexgruppe bezeichnet.
Liste von Scheitelpunkten
Liste von Indexgruppen zum Definieren von Flächen
Die Bibliothek enthält auch Werkzeuge zum Ändern und Reparieren von Netzen sowie zum Extrahieren horizontaler Scheiben zur Verwendung in der Fertigung.
Ein Netz ist eine Sammlung von Vierecken und Dreiecken, die eine Oberfläche oder einen Volumenkörper darstellt. Wie bei Volumenkörpern enthält auch die Struktur von Netzobjekten Scheitelpunkte, Kanten und Flächen. Darüber hinaus gibt es weitere Eigenschaften, die Netze eindeutig machen, z. B. Normalen.
Netzscheitelpunkte
Netzkanten *Kanten mit nur einer angrenzenden Fläche werden als "nackt" bezeichnet. Alle anderen Kanten sind "angezogen".
Netzflächen
Die Scheitelpunkte eines Netzes entsprechen einfach einer Liste von Punkten. Der Index der Scheitelpunkte ist beim Konstruieren eines Netzes oder Abrufen von Informationen über die Struktur eines Netzes sehr wichtig. Für jeden Scheitelpunkt gibt es auch eine entsprechende Scheitelpunktnormale (Vektor), die die durchschnittliche Richtung der verbundenen Flächen beschreibt und Sie dabei unterstützt, die nach innen und nach außen gerichtete Orientierung des Netzes zu verstehen.
Scheitelpunkte
Scheitelpunktnormalen
Eine Fläche ist eine geordnete Liste von drei oder vier Scheitelpunkten. Die "Oberflächendarstellung" einer Netzfläche ist deshalb gemäß der Position der indizierten Scheitelpunkte impliziert. Sie verfügen bereits über die Liste der Scheitelpunkte, die ein Netz bilden. Statt also individuelle Punkte anzugeben, um eine Fläche zu definieren, verwenden Sie einfach den Index der Scheitelpunkte. Dies ermöglicht Ihnen auch die Verwendung desselben Scheitelpunkts in weiteren Flächen.
Quadratische Fläche, die aus den Indizes 0, 1, 2 und 3 erstellt wurde
Dreieckige Fläche, die aus den Indizes 1, 4 und 2 erstellt wurde. Beachten Sie, dass die Indexgruppen in ihrer Reihenfolge verschoben werden können – solange die Sequenz gegen den Uhrzeigersinn angeordnet ist, ist die Fläche korrekt definiert
Welche Unterschiede bestehen zwischen Netz- und NURBS-Geometrie? Wann möchten Sie die eine Geometrie anstelle der anderen verwenden?
In einem früheren Kapitel haben wir gesehen, dass NURBS-Oberflächen durch eine Reihe von NURBS-Kurven in zwei Richtungen definiert werden. Diese Richtungen werden als U
und V
bezeichnet und ermöglichen, dass eine NURBS-Oberfläche gemäß einer zweidimensionalen Oberflächendomäne parametrisiert wird. Die Kurven selbst werden als Gleichungen im Computer gespeichert, sodass die resultierenden Oberflächen auf einen beliebigen, verhältnismäßig kleinen Genauigkeitsbereich berechnet werden können. Es kann jedoch schwierig sein, mehrere NURBS-Oberflächen miteinander zu kombinieren. Das Verbinden von zwei NURBS-Oberflächen führt zu einem Flächenverband, in dem verschiedene Bereiche der Geometrie unterschiedliche UV-Parameter und Kurvendefinitionen aufweisen.
Oberfläche
Isoparametrische (Isoparm) Kurve
Steuerpunkt der Oberfläche
Steuerpunkt des Flächenverbands
Isoparametrischer Punkt
Oberflächenrahmen
Netz
Nackte Kante
Maschennetz
Netzkanten
Scheitelpunktnormale
Netzfläche/Netzflächennormale
Netze auf der anderen Seite bestehen aus einer diskreten Anzahl von genau definierten Scheitelpunkten und Flächen. Das Netzwerk von Scheitelpunkten kann im Allgemeinen nicht durch einfache UV
-Koordinaten definiert werden. Da die Anzahl an Flächen diskret ist, bestimmt sich daraus auch der Genauigkeitsgrad des Netzes, der nur geändert werden kann, indem das Netz neu definiert und weitere Flächen hinzugefügt werden. Das Fehlen der mathematischen Beschreibungen ermöglicht Netzen die flexiblere Handhabung komplexer Geometrie innerhalb eines einzelnen Netzes.
Ein weiterer wichtiger Unterschied ist das Ausmaß, in dem sich eine lokale Änderung der Netz- oder NURBS-Geometrie auf die gesamte Form auswirkt. Das Verschieben von einem Scheitelpunkt eines Netzes wirkt sich nur auf die an diesen Scheitelpunkt angrenzenden Flächen aus. In NURBS-Oberflächen ist das Ausmaß des Einflusses wesentlich komplizierter und richtet sich sowohl nach dem Grad der Oberfläche als auch nach den Gewichtungen und Knoten der Steuerpunkte. Allgemein wird durch das Verschieben eines einzelnen Steuerpunkts in einer NURBS-Oberfläche eine glattere, umfassendere Änderungen in der Geometrie erzeugt.
NURBS-Oberfläche: Das Verschieben eines Steuerpunkts wirkt sich über die Form hinaus aus.
Netzgeometrie – Das Verschieben eines Scheitelpunkts wirkt sich nur auf die angrenzenden Elemente aus.
Eine Analogie, die hilfreich sein kann, besteht im Vergleich eines Vektorbilds (bestehend aus Linien und Kurven) mit einem Rasterbild (bestehend aus einzelnen Pixeln). Wenn Sie die Anzeige eines Vektorbilds vergrößern, sind die Kurven weiterhin klar und deutlich zu sehen, während das Vergrößern eines Rasterbilds dazu führt, dass die einzelnen Pixel größer werden. In dieser Analogie können NURBS-Oberflächen mit einem Vektorbild verglichen werden, da eine glatte mathematische Beziehung besteht, während sich ein Netz ähnlich wie ein Rasterbild mit einer festgelegten Auflösung verhält.
In Dynamo stellen Blöcke die Objekte dar, die zum Bilden eines visuellen Programms miteinander verbunden werden. Jeder Block führt einen Vorgang aus – vom einfachen Speichern einer Zahl bis hin zu komplexen Aktionen wie dem Erstellen oder Abfragen von Geometrie.
In Dynamo setzen sich die meisten Blöcke aus fünf Teilen zusammen. Abgesehen von einigen Ausnahmen (z. B. Eingabeblöcke) kann die Anatomie eines jeden Blocks wie folgt beschrieben werden:
Name: Der Name des Blocks gemäß
Category.Name
-BenennungskonventionHauptkörper: Der Hauptkörper des Blocks. Durch Klicken mit der rechten Maustaste auf diesen Bereich werden Optionen für den gesamten Block angezeigt.
Anschlüsse (eingehend und ausgehend): Die Rezeptoren für Drähte, über die die eingegebenen Daten sowie die Ergebnisse von Blockaktionen an Blöcke geliefert werden.
Vorgabewert: Klicken Sie mit der rechten Maustaste auf einen Eingabeanschluss. Einige Blöcke verfügen über Vorgabewerte, die verwendet werden können, aber nicht verwendet werden müssen.
Die Eingaben und Ausgaben für Blöcke werden als Anschlüsse bezeichnet. Sie fungieren als Kontakte für Drähte. Daten gelangen über die Anschlüsse auf der linken Seite in Blöcke und strömen auf der rechten Seite wieder aus den Blöcken hinaus, nachdem der entsprechende Vorgang ausgeführt wurde.
Anschlüsse erwarten Daten eines bestimmten Typs. Das Verbinden einer Zahl wie 2,75 mit den Anschlüssen eines Point By Coordinates-Blocks führt beispielsweise dazu, dass ein Punkt erfolgreich erstellt wird. Wenn jedoch Rot an denselben Anschluss geliefert wird, tritt ein Fehler auf.
Tipp: Bewegen Sie den Cursor auf einen Anschluss, um eine QuickInfo mit dem erwarteten Datentyp aufzurufen.
Anschlussbezeichnung
QuickInfo
Datentyp
Vorgabewert
Dynamo gibt einen Hinweis auf den Status der Ausführung eines visuellen Programms aus, indem Blöcke mit unterschiedlichen Farbschemata basierend auf dem Status der einzelnen Blöcke gerendert werden. Die Hierarchie der Status ist wie folgt: Fehler > Warnung > Info > Vorschau.
Durch Bewegen des Cursors auf den Namen bzw. die Anschlüsse oder durch Klicken mit der rechten Maustaste darauf werden zusätzliche Informationen und Optionen angezeigt.
Erfüllte Eingaben: Ein Block mit blauen vertikalen Leisten über den Eingabeanschlüssen ist ordnungsgemäß verbunden, und alle Eingaben wurden erfolgreich verbunden.
Nicht erfüllte Eingaben: Bei einem Block mit einer roten vertikalen Leiste über einem oder mehreren Eingabeanschlüssen müssen diese Eingaben verbunden werden.
Funktion: Ein Block, der eine Funktion ausgibt und über einem Ausgabeanschluss eine graue vertikale Leiste hat, ist ein Funktionsblock.
Ausgewählt: Aktuell ausgewählte Blöcke weisen einen aquamarinblau hervorgehobenen Rand auf.
Eingefroren: Ein durchscheinender blauer Block wird eingefroren, wodurch die Ausführung des Blocks unterbrochen wird.
Warnung: Eine gelbe Statusleiste unter dem Block zeigt einen Warnstatus an, d. h., es fehlen Eingabedaten für den Block oder es sind möglicherweise falsche Datentypen vorhanden.
Fehlerstatus: Eine rote Statusleiste unter dem Block gibt an, dass der Block einen Fehlerstatus aufweist.
Info: Die blaue Statusleiste unter dem Block zeigt den Status Info an, in dem nützliche Informationen zu Blöcken markiert sind. Dieser Status kann ausgelöst werden, wenn ein vom Block unterstützter Maximalwert erreicht wird, indem ein Block in einer Weise verwendet wird, die sich auf die Leistung auswirken kann, usw.
Tipp: Untersuchen Sie vor dem Hintergrund dieser QuickInfo die vorgelagerten Blöcke, um zu sehen, ob der erforderliche Datentyp oder die erforderliche Datenstruktur fehlerhaft ist.
QuickInfo zu Warnung: "Null" oder keine Daten können nicht als Double verstanden werden, d. h. als Zahl.
Verwenden Sie den Watch-Block, um die Eingabedaten zu untersuchen.
Der vorgelagerte Number-Block speichert "Rot", keine Zahl.
In einigen Situationen ist es möglicherweise empfehlenswert, die Ausführung bestimmter Blöcke in Ihrem visuellen Programm zu verhindern. Sie können dies tun, indem Sie den Block "anhalten". Dies ist eine Option im Kontextmenü des Blocks.
Durch das Anhalten eines Blocks werden auch die untergeordneten Blöcke angehalten. Mit anderen Worten werden alle Blöcke, die von der Ausgabe eines angehaltenen Blocks abhängen, ebenfalls angehalten.
Drähte verbinden Blöcke miteinander, um Beziehungen zu erstellen und den Ablauf eines visuellen Programms festzulegen. Sie können sie sich buchstäblich als elektrische Drähte vorstellen, die Datenimpulse von einem Objekt zum nächsten transportieren.
Drähte verbinden den Ausgabeanschluss eines Blocks mit dem Eingabeanschluss eines anderen Blocks. Diese Direktionalität legt den Datenfluss im visuellen Programm fest.
Die Eingabeanschlüsse befinden sich auf der linken Seite, die Ausgabeanschlüsse auf der rechten Seite der Blöcke. Daher kann man allgemein sagen, dass der Programmablauf von links nach rechts verläuft.
Erstellen Sie einen Draht, indem Sie mit der linken Maustaste auf einen Anschluss und anschließend mit der linken Maustaste auf den Anschluss eines anderen Blocks klicken, um eine Verbindung zu erstellen. Während der Herstellung der Verbindung wird der Draht gestrichelt angezeigt. Nachdem die Verbindung erfolgreich hergestellt wurde, erscheint er als durchgezogene Linie.
Die Daten fließen immer von Ausgabe zu Eingabe durch diesen Draht. Sie können den Draht jedoch in beliebiger Richtung erstellen, die dadurch definiert wird, in welcher Reihenfolge Sie auf die Anschlüsse klicken.
Es kommt häufig vor, dass Sie den Programmablauf in Ihrem visuellen Programm anpassen müssen, indem Sie die durch Drähte dargestellten Verbindungen bearbeiten. Um einen Draht zu bearbeiten, klicken Sie mit der linken Maustaste auf den Eingabeanschluss eines Blocks, der bereits verbunden ist. Sie haben jetzt zwei Möglichkeiten:
Um die Verbindung zu einem Eingabeanschluss zu ändern, klicken Sie mit der linken Maustaste auf einen anderen Eingabeanschluss.
Um den Draht zu entfernen, ziehen Sie ihn weg und klicken mit der linken Maustaste in den Arbeitsbereich.
Um mehrere Drähte erneut zu verbinden, nutzen Sie Umschalt+Linksklick.
Um einen Draht zu duplizieren, nutzen Sie STRG+Linksklick.
Standardmäßig werden Drähte in der Vorschau mit einem grauen Strich angezeigt. Wenn ein Block ausgewählt wird, werden alle Verbindungsdrähte wie der Block in aquamarinblau hervorgehoben.
Hervorgehobener Draht
Standarddraht
Drähte vorgabemäßig ausblenden
Falls Sie es vorziehen, die Drähte im Diagramm auszublenden, können Sie diese Option über Ansicht > Connectors > Connectors anzeigen deaktivieren.
Mit dieser Einstellung werden nur die ausgewählten Blöcke und die verbindenden Drähte in hellem Aquamarin hervorgehoben.
Sie können auch nur ausgewählte Drähte ausblenden, indem Sie mit der rechten Maustaste auf die Blockausgabe klicken und Drähte ausblenden auswählen.
Um die Entwicklung visueller Programme detaillierter kennenzulernen, benötigen Sie ein genaueres Verständnis der hierfür verwendeten Grundbausteine. In diesem Kapitel werden die Grundbegriffe zum Thema Daten vorgestellt: zu den Informationen, die durch die Verbindungen von Dynamo-Programmen geleitet werden.
Wenn wir komplexere Modelle erstellen möchten, die nicht aus einer einzelnen Fläche erstellt werden können, oder wenn wir ein explizites Volumen definieren möchten, müssen wir uns in den Bereich der (und PolySurfaces) vorwagen. Selbst ein einfacher Würfel ist so komplex, dass er sechs Oberflächen erfordert, eine pro Seite. Volumenkörper ermöglichen den Zugriff auf zwei wichtige Konzepte, den Oberflächen nicht bieten – eine verfeinerte topologische Beschreibung (Flächen, Kanten, Scheitelpunkte) und boolesche Operationen.
Sie können verwenden, um Volumenmodelle zu ändern. Führen Sie mehrere boolesche Operationen aus, um einen Noppenball zu erstellen.
Sphere.ByCenterPointRadius: Der Basisvolumenkörper wird erstellt.
Topology.Faces, Face.SurfaceGeometry: Die Flächen des Volumenkörpers werden abgefragt und die Oberflächengeometrie wird konvertiert – in diesem Fall weist die Kugel nur eine Fläche auf.
Cone.ByPointsRadii: Mithilfe von Punkten auf der Oberfläche werden Kegel konstruiert.
Solid.UnionAll: Die Kegel und die Kugel werden vereinigt.
Topology.Edges: Die Kanten des neuen Volumenkörpers werden abgefragt.
Solid.Fillet: Die Kanten des Noppenballs werden abgerundet.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Boolesche Operationen sind sehr komplex und ihre Berechnung kann möglicherweise viel Zeit in Anspruch nehmen. Sie können die Anhaltfunktion verwenden, um die Ausführung der ausgewählten Blöcke und der betroffenen untergeordneten Blöcke zu unterbrechen.
1. Verwenden Sie das Kontextmenü, um den Vorgang Vereinigung für einen Volumenkörper anzuhalten.
2. Der ausgewählte Block und alle untergeordneten Blöcke werden in einem hellgrauen halbtransparenten Modus in einer Vorschau angezeigt und die betroffenen Drähte werden als gestrichelte Linien angezeigt. Die betroffene Geometrievorschau wird ebenfalls halbtransparent angezeigt. Sie können jetzt vorgelagerte Werte ändern, ohne die boolesche Vereinigung zu berechnen.
3. Um die Ausführung der Blöcke fortzusetzen, klicken Sie mit der rechten Maustaste und deaktivieren "Anhalten".
4. Alle betroffenen Blöcke und die zugehörigen Geometrievorschauen werden aktualisiert und wieder im standardmäßigen Vorschaumodus angezeigt.
Volumenkörper bestehen aus einer oder mehreren Oberflächen, die ein Volumen durch eine geschlossene Berandung enthalten, die "drinnen" oder "draußen" definiert. Unabhängig davon, wie viele dieser Oberflächen vorhanden sind, müssen Sie ein "wasserdichtes" Volumen bilden, um als Volumenkörper zu gelten. Volumenkörper können erstellt werden, indem Oberflächen oder Flächenverbände miteinander verbunden werden oder durch Verwendung von Vorgängen wie Ausformung, Extrusion und Drehung. Die Grundkörper Kugel, Würfel, Kegel und Zylinder sind ebenfalls Volumenkörper. Ein Würfel, von dem mindestens eine Fläche entfernt wurde, gilt als Flächenverband mit ähnlichen Eigenschaften wie ein Volumenkörper, aber nicht mehr als Volumenkörper selbst.
Eine Ebene besteht aus einer einzelnen Oberfläche und ist kein Volumenkörper.
Eine Kugel besteht aus einer einzelnen Oberfläche, ist aber ein Volumenkörper.
Ein Kegel besteht aus zwei Oberflächen, die miteinander verbunden sind, um einen Volumenkörper zu bilden.
Ein Zylinder besteht aus drei Oberflächen, die miteinander verbunden sind, um einen Volumenkörper zu bilden.
Ein Würfel besteht aus sechs Oberflächen, die miteinander verbunden sind, um einen Volumenkörper zu bilden.
Volumenkörper bestehen aus drei Typen von Elementen: Scheitelpunkten, Kanten und Flächen. Flächen sind die Oberflächen, die einen Volumenkörper bilden. Kanten sind die Kurven, die die Verbindung zwischen angrenzenden Flächen definieren, und Scheitelpunkte sind die Start- und Endpunkte der Kurven. Diese Elemente können mit den Topologieblöcken abgefragt werden.
Flächen
Kanten
Scheitelpunkte
Volumenkörper können geändert werden, indem ihre Kanten abgerundet oder gefast werden, um scharfe Ecken und Winkel zu entfernen. Durch den Fasvorgang wird eine Regeloberfläche zwischen zwei Flächen erzeugt, während durch eine Abrundung ein Übergang zwischen Flächen erzeugt wird, um Tangentialität beizubehalten.
Volumenkörperwürfel
Gefaster Würfel
Abgerundeter Würfel
Boolesche Operationen für Volumenkörper sind Methoden zum Kombinieren von zwei oder mehr Volumenkörpern. Bei einer einzelnen booleschen Operation werden eigentlich vier Vorgänge durchgeführt:
Zwei oder mehr Objekte überschneiden.
Die Objekte an den Schnittpunkten teilen.
Unerwünschte Teile der Geometrie löschen.
Alles wieder miteinander verbinden.
Vereinigung: Die überlappenden Teile der Volumenkörper werden entfernt und sie werden zu einem einzelnen Volumenkörper verbunden.
Differenz: Ein Volumenkörper wird von einem anderen abgezogen. Der abzuziehende Volumenkörper wird als Werkzeug bezeichnet. Beachten Sie, dass Sie umschalten können, bei welchem Volumenkörper es sich um das Werkzeug handelt, um das inverse Volumen beizubehalten.
Schnitt: Nur das überschneidende Volumen der beiden Volumenkörper wird beibehalten.
UnionAll: Vereinigungsvorgang mit Kugel und nach außen gerichteten Kegeln
DifferenceAll: Differenzvorgang mit Kugel und nach innen gerichteten Kegeln
Wir verwenden im Modell, um Objekte darzustellen, die wir in unserer dreidimensionalen Welt sehen. Kurven sind zwar nicht immer planar, d. h. sie können dreidimensional verlaufen. Der durch sie definierte Raum ist jedoch immer an nur eine Dimension gebunden. Mit Oberflächen kommen eine weitere Dimension und damit eine Reihe weiterer Eigenschaften hinzu, die Sie in anderen Modellierungsvorgängen nutzen können.
Importieren Sie eine Oberfläche in Dynamo und werten Sie sie an einer Parameterposition aus, um zu sehen, welche Informationen Sie extrahieren können.
Surface.PointAtParameter gibt den Punkt an der angegebenen UV-Koordinatenposition zurück.
Surface.NormalAtParameter gibt den Normalenvektor an der angegebenen UV-Koordinatenposition zurück.
Surface.GetIsoline gibt die isoparametrische Kurve an der U- oder V-Koordinatenposition zurück. Beachten Sie die isoDirection-Eingabe.
Laden Sie die Beispieldateien herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Eine Oberfläche ist eine durch eine Funktion und zwei Parameter definierte mathematische Form. Der entsprechende Parameterraum wird nicht wie bei Kurven durch t
, sondern durch U
und V
beschrieben. Das bedeutet, dass bei der Arbeit mit dieser Art von Geometrie mehr geometrische Daten genutzt werden können. So sind z. B. bei Kurven Tangentenvektoren und Normalenebenen (die über die Länge der Kurve hinweg gedreht werden können), bei Oberflächen hingegen Normalenvektoren und Tangentialebenen vorhanden, deren Ausrichtung unverändert bleibt.
Oberfläche
U-Isokurve
V-Isokurve
UV-Koordinaten
Senkrechte Ebene
Normalenvektor
Oberflächendomäne: Die Domäne einer Oberfläche ist als der Bereich von UV-Parametern definiert, die als dreidimensionale Punkte auf der Oberfläche ausgewertet werden können. Die Domäne für jede der Dimensionen (U oder V) wird normalerweise in Form zweier Zahlen (U Min bis U Max) und (V Min bis V Max) beschrieben.
Die Kontur der Oberfläche ist dem Augenschein nach nicht unbedingt "rechteckig" und das Netz der Isokurven kann lokal eng- oder weitmaschiger sein; der durch die Domäne definierte "Raum" ist jedoch immer zweidimensional. In Dynamo wird immer angenommen, dass die Domäne einer Oberfläche durch den Mindestwert 0.0 und den Höchstwert 1.0 sowohl in U- als auch in V-Richtung definiert ist. Bei planaren oder gestutzten Oberflächen sind andere Domänen möglich.
Isokurve (oder isoparametrische Kurve): Eine durch einen konstanten U- oder V-Wert auf der Oberfläche und eine Domäne für die Werte in der dazugehörigen U- bzw. V-Richtung definierte Kurve.
UV-Koordinaten: Punkt im UV-Parameterraum, definiert durch U, V und manchmal W.
Senkrechte Ebene: Ebene, die an einer gegebenen UV-Koordinatenposition sowohl zur U- als auch zur V-Isokurve senkrecht steht.
Normalenvektor: Vektor, der die Aufwärtsrichtung relativ zur senkrechten Ebene definiert.
NURBS-Oberflächen sind NURBS-Kurven sehr ähnlich. NURBS-Oberflächen sind vorstellbar als aus NURBS-Kurven gebildete Raster mit zwei Richtungen. Die Form einer NURBS-Oberfläche wird durch eine Reihe von Steuerpunkten und den Grad der Oberfläche in U- und V-Richtung definiert. Dieselben Algorithmen zur Berechnung von Form, Normalen, Tangenten, Krümmungen und anderer Eigenschaften mithilfe von Steuerpunkten, Gewichtungen und Grad kommen auch hier zum Einsatz.
Bei NURBS-Oberflächen werden zwei Richtungen für die Geometrie angenommen, da diese Oberflächen ungeachtet der sichtbaren Form rechtwinklige Raster von Steuerpunkten sind. Diese Richtungen liegen relativ zum Weltkoordinatensystem oft beliebig. Sie werden dennoch häufig zur Analyse von Modellen oder zum Generieren weiterer Geometrie auf Basis der Oberfläche verwendet.
Grad (U,V) = (3,3)
Grad (U,V) = (3,1)
Grad (U,V) = (1,2)
Grad (U,V) = (1,1)
PolySurfaces setzen sich aus an einer Kante verbundenen Oberflächen zusammen. PolySurfaces bieten mehr als zweidimensionale UV-Definitionen: Sie können sich jetzt anhand der Topologie durch die verbundenen Formen bewegen.
"Topologie" beschreibt in der Regel die Verbindungen und Beziehungen zwischen Teilen. In Dynamo ist Topologie darüber hinaus auch ein Typ von Geometrie. Sie ist, genauer, die übergeordnete Kategorie für Oberflächen, PolySurfaces und Körper.
Durch Zusammenfügen von Oberflächen (manchmal als "Pflasterung" bezeichnet) können komplexere Formen erstellt und Details entlang der Naht definiert werden. Beispielsweise können Sie die Kanten einer PolySurface mit Abrundungen oder Fasen versehen.
Neu: Neue DYN-Datei erstellen
Öffnen: Öffnet eine vorhandene DYN-Datei (Arbeitsbereich) oder DYF-Datei (benutzerdefinierter Block).
Speichern/Speichern unter: Aktive DYN- oder DYF-Datei speichern
Rückgängig: Die letzte Aktion rückgängig machen
Wiederholen: Die nächste Aktion wiederherstellen
Arbeitsbereich als Bild exportieren: Den angezeigten Arbeitsbereich als PNG-Datei exportieren
Erstellen: Erstellt oder konstruiert eine Geometrie von Grund auf neu. Beispiel: Kreis.
Aktion: Führt eine Aktion für ein Objekt aus. Beispiel: Skalieren eines Kreises.
Abfrage: Ruft eine Eigenschaft eines bereits vorhandenen Objekts ab. Beispiel: Abrufen des Radius eines Kreises.
Block | Block | ||
---|---|---|---|
Diagrammvorschau
3D-Vorschau
Zoom Grenzen
Vergrößern
Verkleinern
Schwenken
Zoom Grenzen
Vergrößern
Verkleinern
Schwenken
Orbit
Um Dynamo zu verwenden, starten Sie es über die Gruppe Werkzeugkasten. Je nachdem, welche Software Sie verwenden, befindet sich das Startsymbol in der Regel unter Menü > Registerkarte Verwalten. Klicken Sie auf das Dynamo-Symbol , um die Anwendung zu starten.
Die Dynamo-Anwendung ist auf der verfügbar. Sowohl offizielle als auch frühere oder vorab veröffentlichte Versionen sind auf der Download-Seite verfügbar. Besuchen Sie die Seite , und klicken Sie auf Download, um die offizielle veröffentlichte Version herunterzuladen.
Laden Sie für diesen Schritt auf Ihren Computer herunter, und installieren Sie es.
Der Dynamo Package Manager bietet zusätzliche Funktionen wie das für erweiterte Geometrietypen und Vorgänge.
Eine besteht aus einer Reihe von Punkten, jede Linie verfügt über mindestens zwei Punkte. Eine der häufigsten Methoden zum Erstellen von Linien in Dynamo ist die Verwendung von Line.ByStartPointEndPoint
, um eine Linie in Dynamo zu erstellen.
ist ein Modell, das zur exakten Darstellung von Kurven und Oberflächen verwendet wird. Eine Sinuskurve in Dynamo mit zwei unterschiedlichen Methoden, um NURBS-Kurven zu erstellen und die Ergebnisse zu vergleichen.
Der Funktionsumfang in Bezug auf Netze von Dynamo kann durch die Installation des Pakets erweitert werden. Das Dynamo Mesh Toolkit bietet Werkzeuge zum Importieren von Netzen aus externen Dateiformaten, zum Erstellen von Netzen aus Dynamo Geometrieobjekten und zum manuellen Erstellen von Netzen aus ihren Scheitelpunkten und Indizes.
Ein Beispiel zur Verwendung dieses Pakets finden Sie in den .
Symbol Vergitterung: Zeigt die Option an, die für übereinstimmende Listeneingaben angegeben ist (mehr dazu später).
Vorschau aus: Eine graue Statusleiste unter dem Block und ein Augensymbol zeigen an, dass die Geometrievorschau für den Block deaktiviert ist.
Wenn Ihr visuelles Programm Warnungen oder Fehler aufweist, gibt Dynamo zusätzliche Informationen zu dem Problem an. Alle Blöcke, die in gelb angezeigt werden, verfügen auch über eine QuickInfo über dem Namen. Bewegen Sie zum Erweitern den Mauszeiger über das QuickInfo-Symbol der Warnung oder des Fehlers .
Weitere Informationen zum Anhalten von Blöcken finden Sie im Abschnitt .
Dadurch werden boolesche Operationen für Volumenkörper zu einem leistungsstarken und zeitsparenden Prozess. Es gibt drei boolesche Operationen für Volumenkörper, die unterscheiden, welche Teile der Geometrie beibehalten werden.
Zusätzlich zu diesen drei Vorgänge sind in Dynamo die Blöcke Solid.DifferenceAll und Solid.UnionAll verfügbar, mit denen Differenz- und Schnittvorgänge mit mehreren Volumenkörpern ausgeführt werden können.
Boolean
Zahl
String
Number Slider
Verzeichnispfad
Integer Slider
File Path
ERSTELLEN |
Color.ByARGB Erstellt eine Farbe über Alpha-, Rot-, Grün- und Blau-Komponenten. |
Color Range Ruft eine Farbe aus einem Farbverlauf zwischen einer Anfangs- und einer Endfarbe ab. |
AKTIONEN |
Color.Brightness Ruft den Helligkeitswert für die Farbe ab. |
Color.Components Listet die Komponenten für die Farbe in der Reihenfolge Alpha, Rot, Grün, Blau auf. |
Color.Saturation Ruft den Sättigungswert für die Farbe ab. |
Color.Hue Ruft den Farbtonwert für die Farbe ab. |
ABFRAGE |
Color.Alpha Alpha-Komponente der Farbe ermitteln: 0 bis 255. |
Color.Blue Blaue Komponente der Farbe ermitteln: 0 bis 255. |
Color.Green Grüne Komponente der Farbe ermitteln: 0 bis 255. |
Color.Red Rote Komponente der Farbe ermitteln: 0 bis 255. |
ERSTELLEN |
GeometryColor.ByGeometryColor Zeigt die Geometrie mithilfe einer Farbe an. |
AKTIONEN |
View.Watch Visualisierung der Ausgabe des Blocks |
View.Watch 3D Zeigt eine dynamische Vorschau der Geometrie an. |
AKTIONEN |
Boolean Auswahl zwischen True und False. |
Code Block Ermöglicht die direkte Erstellung von DesignScript-Code. |
Directory Path Ermöglicht die Auswahl einen Verzeichnisses auf dem System, um seinen Pfad abzurufen. |
File Path Ermöglicht die Auswahl einer Datei auf dem System, um ihren Dateinamen abzurufen. |
Integer Slider Ein Schieberegler zur Erzeugung ganzzahliger Werte. |
Nummer Erstellt eine Zahl. |
Number Slider Ein Schieberegler zur Erzeugung numerischer Werte. |
Zeichenfolge Erstellt eine Zeichenfolge. |
Object.IsNull Bestimmt, ob das angegebene Objekt Null ist. |
ERSTELLEN |
List.Create Erstellt eine neue Liste aus der angegebenen Eingaben. |
List.Combine Wendet einen Kombinator auf jedes Element in zwei Folgen an. |
Number Range Erstellt eine Folge von Zahlen im angegebenen Bereich. |
Number Sequence Erstellt eine Folge von Zahlen. |
AKTIONEN |
List.Chop Zerlegt eine Liste in eine Gruppe von Listen, jeweils mit der angegebenen Anzahl an Einträgen. |
List.Count Gibt die Anzahl der Elemente in der angegebenen Liste zurück. |
List.Flatten Vereinfacht eine verschachtelte Liste von Listen um eine bestimmte Anzahl von Ebenen. |
List.FilterByBoolMask Filtert eine Sequenz durch Abrufen entsprechender Indizes in einer separaten Liste boolescher Werte. |
List.GetItemAtIndex Ruft ein Element aus der angegebenen Liste am angegebenen Index ab. |
List.Map Wendet eine Funktion für alle Elemente einer Liste an und erstellt aus den Ergebnissen eine neue Liste. |
List.Reverse Erstellt eine neue Liste mit den Elementen der angegebenen Liste, jedoch in umgekehrter Reihenfolge. |
List.ReplaceItemAtIndex Ersetzt ein Element am angegebenen Index in der angegebenen Liste. |
List.ShiftIndices Verschiebt die Indizes in der Liste um den angegebenen Betrag nach rechts. |
List.TakeEveryNthItem Ruft unter Einhaltung des angegebenen Versatzes Elemente aus der angegebenen Liste ab, deren Indizes Vielfache des angegebenen Werts sind. |
List.Transpose Vertauscht Zeilen und Spalten in einer Liste von Listen. Wenn einige Zeilen kürzer als die übrigen sind, werden Nullwerte als Platzhalter in das resultierende Array eingefügt, sodass dieses immer rechteckig ist. |
AKTIONEN |
If Bedingte Anweisung. Prüft den Booleschen Wert des eingegebenen Tests. Wenn der eingegebene Test den Wert True hat, wird als Ergebnis der zur Alternative True gehörige Wert ausgegeben, andernfalls der zur Alternative False gehörige Wert. |
AKTIONEN |
Math.Cos Ermittelt den Kosinus eines Winkels. |
Math.DegreesToRadians Konvertiert einen Winkel in Grad in einen Winkel in Bogenmaß. |
Math.Pow Potenziert eine Zahl mit dem angegebenen Wert. |
Math.RadiansToDegrees Konvertiert einen Winkel in Bogenmaß in einen Winkel in Grad. |
Math.RemapRange Passt den Bereich einer Liste von Zahlen an, wobei deren Verteilung erhalten bleibt. |
Math.Sin Ermittelt den Sinus eines Winkels. |
Formula Wertet mathematische Formeln aus. Dabei wird NCalc für die Auswertung verwendet. Weitere Informationen finden Sie unterhttp://ncalc.codeplex.com. |
Karte Ordnet einen Wert für einen Eingabebereich zu. |
AKTIONEN |
String.Concat Verkettet mehrere Zeichenfolgen zu einer einzigen Zeichenfolge. |
String.Contains Bestimmt, ob die angegebene Zeichenfolge die angegebene Teilzeichenfolge enthält. |
String.Join Verkettet mehrere Zeichenfolgen zu einer einzigen Zeichenfolge und fügt dabei das angegebene Trennzeichen zwischen den einzelnen verbundenen Zeichenfolgen ein. |
String.Split Teilt eine einzelne Zeichenfolge in eine Liste von Zeichenfolgen auf, wobei die Unterteilungen durch die angegebenen Trennzeichenfolgen bestimmt werden. |
String.ToNumber Konvertiert eine Zeichenfolge in einen integer- oder double-Wert. |
ERSTELLEN |
Circle.ByCenterPointRadius Erstellt einen Kreis durch Eingabe von Mittelpunkt und Radius in der XY-Ebene des Weltkoordinatensystems mit Welt-Z als Normaler. |
Circle.ByPlaneRadius Erstellt einen Kreis zentriert am Ursprung der Eingabeebene, innerhalb der Eingabeebene und mit dem angegebenen Radius. |
ERSTELLEN |
CoordinateSystem.ByOrigin Erstellt ein CoordinateSystem mit Ursprung am eingegebenen Punkt mit X- und Y-Achse als X- und Y-Achse des WKS. |
CoordinateSystem.ByCyclindricalCoordinates Erstellt ein CoordinateSystem mit den angegebenen zylindrischen Koordinatenparametern in Bezug auf das angegebene Koordinatensystem. |
ERSTELLEN |
Cuboid.ByLengths Erstellt einen Quader mit Mittelpunkt am WKS-Ursprung sowie Breite, Länge und Höhe. |
Cuboid.ByLengths (Ursprung) Erstellt einen Quader mit Mittelpunkt am Eingabepunkt und Angaben für Breite, Länge und Höhe. |
Cuboid.ByLengths (coordinateSystem) Erstellt einen Quader mit Mittelpunkt am WKS-Ursprung sowie Breite, Länge und Höhe. |
Cuboid.ByCorners Erstellt einen Quader vom tiefsten zum höchsten Punkt. |
Cuboid.Length Gibt die Eingabeabmessungen des Quaders zurück, NICHT die Maße in der realen Welt. |
Cuboid.Width Gibt die Eingabeabmessungen des Quaders zurück, NICHT die Maße in der realen Welt. |
Cuboid.Height Gibt die Eingabeabmessungen des Quaders zurück, NICHT die Maße in der realen Welt. |
BoundingBox.ToCuboid Ruft den Begrenzungsrahmen als quaderförmigen Volumenkörper ab. |
AKTIONEN |
Curve.Extrude (Abstand) Extrudiert eine Kurve in Richtung des Normalenvektors. |
Curve.PointAtParameter Ruft einen Punkt auf der Kurve am angegebenen Parameter zwischen StartParameter() und EndParameter() ab. |
AKTIONEN |
Geometry.DistanceTo Ruft den Abstand zwischen dieser und anderer Geometrie ab. |
Geometry.Explode Trennt zusammengesetzte oder nicht getrennte Elemente in die Teile, aus denen sie bestehen. |
Geometry.ImportFromSAT Liste der importierten Geometrien |
Geometry.Rotate (basePlane) Dreht ein Objekt um einen angegebenen Winkel in Grad um den Ursprung und die Normale der Ebene. |
Geometry.Translate Verschiebt Geometrie beliebigen Typs um die angegebenen Entfernung in die angegebene Richtung. |
ERSTELLEN |
Line.ByBestFitThroughPoints Erstellt eine Linie mit der bestmöglichen Annäherung an ein Streudiagramm aus Punkten. |
Line.ByStartPointDirectionLength Erstellt eine gerade Linie mit der angegebenen Länge vom Startpunkt ausgehend in Vektorrichtung. |
Line.ByStartPointEndPoint Erstellt eine gerade Linie zwischen zwei eingegebenen Punkten. |
Line.ByTangency Erstellt eine zur eingegebenen Kurve tangentiale Linie am Parameterpunkt der eingegebenen Kurve. |
ABFRAGE |
Line.Direction Die Richtung der Kurve. |
Erstellen |
NurbsCurve.ByControlPoints Erstellt ein BSplineCurve über explizite Steuerpunkte. |
NurbsCurve.ByPoints Erstellt eine BSplineCurve durch Interpolation zwischen Punkten. |
Erstellen |
NurbsSurface.ByControlPoints Erstellt eine NurbsSurface über explizite Steuerpunkte mit angegebenem U- und V-Grad. |
NurbsSurface.ByPoints Erstellt eine NurbsSurface mit angegebenen interpolierten Punkten und U- und V-Graden. Die resultierende Oberfläche verläuft durch alle Punkte. |
ERSTELLEN |
Plane.ByOriginNormal Erstellt eine am Ursprungspunkt zentrierte Ebene mit eingegebenem Normalenvektor. |
Plane.XY Erstellt eine Ebene in der Welt-XY-Ebene. |
ERSTELLEN |
Point.ByCartesianCoordinates Legt einen Punkt im angegebenen Koordinatensystem mithilfe dreier kartesischer Koordinaten fest. |
Point.ByCoordinates (2D) Legt einen Punkt in der XY-Ebene nach Angabe zweier kartesischer Koordinaten fest. Die Z-Komponente hat den Wert 0. |
Point.ByCoordinates (3D) Legt einen Punkt nach Angabe dreier kartesischer Koordinaten fest. |
Point.Origin Ruft den Ursprung ab (0,0,0). |
AKTIONEN |
Point.Add Fügt einem Punkt einen Vektor hinzu. Dies ist identisch mit Translate(Vector). |
ABFRAGE |
Point.X Ruft die X-Komponente des Punkts ab. |
Point.Y Ruft die Y-Komponente des Punkts ab. |
Point.Z Ruft die Z-Komponente des Punkts ab. |
ERSTELLEN |
Polycurve.ByPoints Erstellt PolyCurve aus einer Folge von Linien durch Verbinden von Punkten. Für geschlossene Kurven muss der letzte Punkt sich an derselben Stelle befinden wie der erste. |
ERSTELLEN |
Rectangle.ByWidthLength(Ebene) Erstellt ein Rectangle zentriert am Ursprung der eingegebenen Plane mit der eingegebenen Breite (X-Achse) und Länge (Y-Achse). |
ERSTELLEN |
Sphere.ByCenterPointRadius Erstellt einen kugelförmigen Volumenkörper mit dem eingegebenen Punkt als Mittelpunkt und dem angegebenen Radius. |
ERSTELLEN |
Surface.ByLoft Erstellt eine Oberfläche durch Erhebung zwischen den eingegebenen Querschnittskurven. |
Surface.ByPatch Erstellt eine Oberfläche durch Ausfüllen des Bereichs innerhalb einer durch die eingegebenen Kurven definierten geschlossenen Begrenzung. |
AKTIONEN |
Surface.Offset Versetzt die Oberfläche in Richtung ihrer Normalen um den angegebenen Abstand. |
Surface.PointAtParameter Gibt den Punkt für die angegebenen U- und V-Parameter zurück. |
Surface.Thicken Wandelt eine Oberfläche durch Extrusion in Richtung ihrer Normalen auf beiden Seiten in einen Volumenkörper um. |
ERSTELLEN |
UV.ByCoordinates Erstellt UV aus zwei double-Werten. |
ERSTELLEN |
Vector.ByCoordinates Bildet einen Vektor durch 3 euklidische Koordinaten. |
Vector.XAxis Ruft den kanonischen Vektor der X-Achse ab (1,0,0). |
Vector.YAxis Ruft den kanonischen Vektor der Y-Achse ab (0,1,0). |
Vector.ZAxis Ruft den kanonischen Vektor der Z-Achse ab (0,0,1). |
AKTIONEN |
Vector.Normalized Ruft die normalisierte Version eines Vektors ab. |
ERSTELLEN |
CoordinateSystem.ByOrigin Erstellt ein CoordinateSystem mit Ursprung am eingegebenen Punkt mit X- und Y-Achse als X- und Y-Achse des WKS. |
CoordinateSystem.ByCyclindricalCoordinates Erstellt ein CoordinateSystem mit den angegebenen zylindrischen Koordinatenparametern in Bezug auf das angegebene Koordinatensystem. |
+ Addition |
- Subtraktion |
* Multiplikation |
/ Division |
% Die ganzzahlige Division ermittelt den bei der Division der ersten Eingabe durch die zweite verbleibenden Rest. |
< Kleiner als |
> Größer als |
== Gleichheitstest: Vergleich zweier Werte. |
Eine Zeichenfolge ist in der Fachsprache eine Folge von Zeichen, die für eine Literalkonstante oder verschiedene Typen von Variablen steht. Im Zusammenhang mit Programmierung ist "Zeichenfolge" eine Bezeichnung für Text. Sie haben bereits Zahlen (Ganzzahlen und Dezimalzahlen) zur Steuerung von Parametern verwendet. Dasselbe ist auch mit Text möglich.
Zeichenfolgen können auf vielfältige Weise eingesetzt werden. Dazu gehören das Definieren benutzerdefinierter Parameter, Beschriftungen für Dokumentation sowie die Analyse mithilfe textbasierter Datensätze. Der String-Block befindet sich in der Kategorie Core > Input.
Die oben gezeigten Blöcke sind Zeichenfolgen. Zeichenfolgen können Zahlen, Buchstaben oder ganze Textabschnitte sein.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Sie können große Datenmengen rasch analysieren, indem Sie Zeichenfolgen abfragen. In diesem Abschnitt werden einige grundlegende Vorgänge behandelt, die Arbeitsabläufe beschleunigen und die Interoperabilität von Software verbessern können.
Die folgende Abbildung zeigt eine Folge von Daten aus einer externen Kalkulationstabelle. Diese Zeichenfolge steht für die Scheitelpunkt eines Rechtecks in der xy-Ebene. In dieser kurzen Übung wird die Zeichenfolge geteilt:
Das Trennzeichen ";" trennt die einzelnen Scheitelpunkte des Rechtecks voneinander. Dadurch erhalten Sie eine Liste mit drei Einträgen für die einzelnen Scheitelpunkte.
Durch Klicken auf "+" in der Mitte des Blocks erstellen Sie ein neues Trennzeichen.
Fügen Sie einen String-Block mit der Angabe "," in den Ansichtsbereich ein und verbinden Sie ihn mit der neuen separator-Eingabe.
Als Ergebnis erhalten Sie jetzt eine Liste mit zehn Einträgen. In diesem Block wird die Liste zuerst entsprechend separator0 und dann entsprechend separator1 geteilt.
Die Einträge in der oben gezeigten Liste sehen zwar wie Zahlen aus, werden jedoch in Dynamo nach wie vor als einzelne Zeichen betrachtet. Damit Sie Punkte erstellen können, müssen Sie ihren Datentyp aus Zeichenfolgen in Zahlen konvertieren. Dazu verwenden Sie den String.ToNumber-Block.
Dieser Block ist einfach zu verwenden. Verbinden Sie das Ergebnis von String.Split mit der Eingabe. Die Ausgabe sieht genau so aus wie zuvor, der Datentyp ist jetzt jedoch number anstelle von string.
Mit einigen weiteren grundlegenden Operationen wird am Ursprungspunkt ein Dreieck gezeichnet, dem die Zeichenfolge aus der ursprünglichen Eingabe zugrunde liegt.
Da Zeichenfolgen allgemeine Textobjekte sind, eignen sie sich für eine Vielzahl von Verwendungszwecken. In diesem Abschnitt werden einige der wichtigsten Aktionen in der Kategorie Core > String in Dynamo beschrieben:
Die folgende Methode verbindet zwei Zeichenfolgen in der angegebenen Reihenfolge. Dabei werden die einzelnen Literalzeichenfolgen in einer Liste zu einer einzigen Zeichenfolge zusammengeführt.
Die folgende Abbildung zeigt die Verkettung dreier Zeichenfolgen:
Mithilfe der Schaltflächen + und - in der Mitte des Blocks können Sie der Verkettung weitere Zeichenfolgen hinzufügen oder sie daraus entfernen.
Die Ausgabe zeigt die aus der Verkettung resultierende Zeichenfolge einschließlich Leerzeichen und Satzzeichen.
Die Verbindung ist der Verkettung ähnlich, wobei das Ergebnis jedoch zusätzlich gegliedert wird.
Aus der Arbeit mit Excel sind Sie wahrscheinlich mit CSV-Dateien vertraut. Dies steht für kommagetrennte Werte. Sie könnten im String.Join-Block ein Komma (oder in diesem Fall zwei Bindestriche) als Trennzeichen verwenden, um eine ähnliche Datenstruktur zu erhalten.
Die folgende Abbildung zeigt die Verbindung zweier Zeichenfolgen:
Die separator-Eingabe ermöglicht es, eine Zeichenfolge zu erstellen, die als Trennzeichen zwischen den verbundenen Zeichenfolgen steht.
In dieser Übungslektion zerlegen Sie die letzte Strophe von Robert Frosts Gedicht Stopping By Woods on a Snowy Evening mithilfe von Methoden zum Abfragen und Bearbeiten von Zeichenfolgen. Diese zugegebenermaßen nicht unbedingt praxisnahe Anwendung verdeutlicht die grundlegenden Aktionen für Zeichenfolgen durch Anwendung auf die Zeilen mit ihrem Rhythmus und Reim, wie sie im Gedicht erscheinen.
Als Erstes teilen Sie einfach die Zeichenfolge, die die Strophe bildet. Zunächst fällt auf, dass der Text durch Kommas gegliedert ist. Anhand dieses Formats definieren Sie jede Zeile als eigenen Eintrag.
Fügen Sie die Ausgangszeichenfolge in einen String-Block ein.
Legen Sie mithilfe eines zweiten String-Blocks das Trennzeichen fest. Verwenden Sie in diesem Fall ein Komma.
Fügen Sie im Ansichtsbereich einen String.Split-Block hinzu und verbinden Sie ihn mit den beiden String-Blöcken.
Die Ausgabe zeigt die einzelnen Zeilen als separate Einträge.
Betrachten Sie jetzt den besten Teil des Gedichts – die letzten beiden Zeilen. Die ursprüngliche Strophe war ein einziges Datenelement. Diese Daten haben Sie im ersten Schritt in einzelne Einträge aufgeteilt. Als Nächstes müssen Sie nach dem gewünschten Text suchen. In diesem Fall können Sie dies zwar erreichen, indem Sie die letzten beiden Einträge in der Liste auswählen. In einem ganzen Buch wäre es jedoch unrealistisch, dieses komplett durchzulesen und die Elemente manuell zu isolieren.
Verwenden Sie daher, anstatt manuell zu suchen, einen String.Contains-Block für die Suche nach einer Gruppe von Zeichen. Diese Funktion ist dem Befehl Suchen in Textverarbeitungsprogrammen ähnlich. In diesem Falle erhalten Sie True oder False als Ergebnis, je nachdem, ob die betreffende Teilzeichenfolge in einem Eintrag gefunden wurde.
Definieren Sie in der searchFor-Eingabe die Teilzeichenfolge, nach der Sie in der Strophe suchen. Verwenden Sie dazu einen String-Block mit dem Text "And miles".
Die Ausgabe zeigt eine Liste von True- und False-Werten. Im nächsten Schritt filtern Sie die Elemente mithilfe dieser Booleschen Logik.
Mit einem List.FilterByBoolMask-Block bereinigen Sie die True- und False-Werte. Die in-Ausgabe gibt die Aussagen mit dem Wert True für die mask-Eingabe zurück, die out-Ausgabe diejenigen mit dem Wert False.
Die in-Ausgabe zeigt wie erwartet die letzten beiden Zeilen der Strophe.
Heben Sie jetzt die Wiederholung in der Strophe hervor, indem Sie diese beiden Zeilen zusammenführen. In der Ausgabe aus dem vorigen Schritt sehen Sie eine Liste mit zwei Einträgen.
Mithilfe zweier List.GetItemAtIndex-Blöcke können Sie die Einträge durch Angabe der Werte 0 bzw. 1 für die index-Eingabe isolieren.
Die Ausgabe jedes Blocks zeigt die letzten beiden Zeilen in der angegebenen Reihenfolge.
Verwenden Sie zum Zusammenführen der beiden Einträge einen String.Join-Block:
Nachdem Sie den String.Join-Block hinzugefügt haben, zeigt sich, dass ein Trennzeichen benötigt wird.
Fügen Sie zum Erstellen des Trennzeichens im Ansichtsbereich einen String-Block hinzu und geben Sie ein Komma ein.
In der letzten Ausgabe wurden beide Einträge zu einem zusammengeführt.
Dieser Vorgang zum Isolieren der letzten beiden Zeilen mag recht aufwendig erscheinen. Für Operationen mit Zeichenfolgen sind in der Tat zuweilen einige Vorarbeiten nötig. Diese Operationen sind jedoch skalierbar und können relativ leicht auf große Datensätze angewendet werden. Berücksichtigen Sie bei der parametrischen Arbeit mit Kalkulationstabellen und Interoperabiltät die Operationen für Zeichenfolgen.
Eine Liste ist eine Sammlung von Elementen oder Einträgen. Ein Beispiel kann z. B. ein Bündel Bananen sein. Jede Banane ist ein Eintrag in der Liste (bzw. im Bündel). Ein Bündel Bananen ist leichter aufzuheben als die einzelnen Bananen. Dasselbe gilt für die Gruppierung von Elementen durch parametrische Beziehungen in einer Datenstruktur.
Foto von Augustus Binu.
Beim Einkaufen packen Sie alle gekauften Artikel in eine Tasche. Auch diese Tasche ist eine Liste. Angenommen, Sie benötigen drei Bündel Bananen, um (eine große Menge) Bananenbrot zu backen. Damit stellt die Tasche eine Liste mit Bananenbündeln und jedes Bündel eine Liste mit Bananen dar. Die Tasche ist eine Liste von Listen (zweidimensional) und jedes Bananenbündel ist eine Liste (eindimensional).
In Dynamo sind Listendaten geordnet und der erste Eintrag in einer Liste hat immer den Index "0". Weiter unten wird beschrieben, wie Listen in Dynamo definiert werden und welche Beziehungen zwischen mehreren Listen möglich sind.
Auf den ersten Blick scheint es ungewohnt, dass der erste Index einer Liste immer 0 und nicht 1 lautet. Wenn also vom ersten Eintrag in einer Liste die Rede ist, ist damit der Eintrag mit dem Index 0 gemeint.
Wenn Sie etwa die Finger an Ihrer rechten zählen, würden Sie von 1 bis 5 zählen. In einer Liste in Dynamo hätten Ihre Finger jedoch die Indizes 0–4. Für Einsteiger in die Programmierung ist dies eventuell zunächst ungewohnt. Nullbasierte Indizes sind jedoch die in den meisten Rechensystemen gebräuchliche Praxis.
Beachten Sie, dass die Liste nach wie vor 5 Einträge enthält, sie werden nur beginnend mit 0 gezählt. Die Einträge in Listen müssen nicht unbedingt Zahlen sein. Vielmehr können alle in Dynamo unterstützten Datentypen verwendet werden: Punkte, Kurven, Oberflächen, Familien usw.
a. Index
b. Punkt
c. Element
Die einfachste Möglichkeit, den Typ der in einer Liste enthaltenen Daten sichtbar zu machen, besteht oft darin, einen Watch-Block mit der Ausgabe eines anderen Blocks zu verbinden. Im Watch-Block werden per Vorgabe alle Indizes automatisch links und die Datenelemente rechts in der Liste angezeigt.
Diese Indizes sind ein entscheidendes Element bei der Arbeit mit Listen.
Ein- und Ausgaben behandeln Listen abhängig vom verwendeten Block unterschiedlich. In diesem Beispiel wird die ausgegebene Liste mit fünf Punkten mit zwei verschiedenen Dynamo-Blöcken verbunden: PolyCurve.ByPoints und Circle.ByCenterPointRadius:
Die points-Eingabe von PolyCurve.ByPoints sucht nach "Point[]". Dies entspricht einer Liste von Punkten.
Die Ausgabe von PolyCurve.ByPoints ist eine einzelne Polykurve, die aus den fünf Punkten aus der Liste erstellt wird.
Die centerPoint-Eingabe für Circle.ByCenterPointRadius verlangt "Point".
Die Ausgabe für Circle.ByCenterPointRadius ist eine Liste mit fünf Kreisen, deren Mittelpunkte den Punkten aus der ursprünglichen Liste entsprechen.
In PolyCurve.ByPoints und in Circle.ByCenterPointRadius wurden dieselben Daten eingegeben; mit dem PolyCurve.ByPoints-Block erhalten Sie jedoch nur eine Polykurve, während der Circle.ByCenterPointRadius-Block fünf Kreise um die einzelnen Punkte ausgibt. Intuitiv ist dies einleuchtend: Die Polykurve wird als Kurve gezeichnet, die die fünf Punkte verbindet, bei den Kreisen hingegen wird um jeden Punkt ein eigener Kreis erstellt. Was geschieht dabei mit den Daten?
Wenn Sie den Mauszeiger auf die points-Eingabe von Polycurve.ByPoints setzen, sehen Sie, dass "Point[]" als Eingabe verlangt wird. Beachten Sie die Klammern am Ende. Dies steht für eine Liste von Punkten. Um eine einzelne Polykurve zu erstellen, wird eine Liste benötigt. Das bedeutet, dass dieser Block jede eingegebene Liste zu einer PolyCurve zusammenfasst.
Im Gegensatz dazu verlangt die centerPoint-Eingabe für Circle.ByCenterPointRadius den Typ "Point". Dieser Block sucht nach einem einzelnen Punkt als einem eigenständigen Eintrag, um den Mittelpunkt des Kreises zu definieren. Aus diesem Grund erhalten Sie fünf Kreise aus den Eingabedaten. Die Kenntnis dieser Unterschiede bei den Eingaben in Dynamo erleichtert das Verständnis der Funktionsweise der Blöcke bei der Verarbeitung von Daten.
Für die Zuordnung von Daten gibt es keine eindeutige Lösung. Dieses Problem tritt auf, wenn in einem Block Eingaben von unterschiedlicher Größe verwendet werden. Die Verwendung unterschiedlicher Algorithmen zur Datenzuordnung kann zu äußerst unterschiedlichen Ergebnissen führen.
Angenommen, ein Block erstellt Liniensegmente zwischen Punkten (Line.ByStartPointEndPoint). Hierfür werden zwei Eingabeparameter verwendet. Beide stellen Punktkoordinaten bereit:
Die einfachste Möglichkeit besteht darin, jedem Wert genau einen Wert aus der anderen Eingabe zuzuordnen, bis das Ende einer der Folgen erreicht ist. Dieser Algorithmus wird als "Kürzeste Liste" bezeichnet. Dies ist das vorgegebene Verhalten in Dynamo-Blöcken:
Der Algorithmus "Längste Liste" verbindet weiterhin Eingaben und verwendet gegebenenfalls Elemente mehrfach, bis alle Folgen aufgebraucht sind.
Mit der Methode "Kreuzprodukt" werden sämtliche möglichen Verbindungen hergestellt.
Es ist leicht zu erkennen, dass es mehrere Möglichkeiten gibt, Linien zwischen diesen Punktgruppen zu zeichnen. Um die Vergitterungsoptionen aufzurufen, klicken Sie mit der rechten Maustaste in die Mitte eines Blocks und wählen das Menü Vergitterung.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Zur Demonstration der unten beschriebenen Vergitterungsoptionen werden anhand dieser Basisdatei die kürzeste und die längste Liste sowie das Kreuzprodukt definiert.
Dabei ändern Sie die Vergitterung für Point.ByCoordinates, nehmen jedoch keine weiteren Änderungen im oben gezeigten Diagramm vor.
Wenn Sie Kürzeste Liste als Vergitterungsoption (entspricht der Vorgabeoption) wählen, erhalten Sie eine einfache diagonale Linie, die aus fünf Punkten besteht. Die kürzere Liste umfasst fünf Einträge. Aus diesem Grund endet die Vergitterung Kürzeste Liste, sobald das Ende dieser Liste erreicht ist.
Mit der Vergitterung Längste Liste erhalten Sie eine diagonale Linie, die vertikal endet. Der letzte Eintrag in der 5 Einträge langen Liste wird genau wie im Übersichtsdiagramm so lange wiederholt, bis auch das Ende der längeren Liste erreicht ist.
Bei der Vergitterung Kreuzprodukt erhalten Sie jede mögliche Kombination der beiden Listen. Dadurch entsteht ein Raster aus 5 x 10 Punkten. Diese Datenstruktur entspricht der Darstellung des Kreuzprodukts im Übersichtsdiagramm oben, allerdings wurden die Daten dabei in eine Liste von Listen umgewandelt. Durch Verbinden einer PolyCurve wird sichtbar, dass jede Liste durch ihren x-Wert definiert ist. Damit entsteht eine Reihe mit fünf vertikalen Linien.
Die Daten werden mithilfe von Listen geordnet. Im Betriebssystem des Computers befinden sich Dateien und Ordner. In Dynamo können diese als Einträge bzw. Listen betrachtet werden. Wie in Ihrem Betriebssystem stehen viele Möglichkeiten zum Erstellen, Ändern und Abfragen von Daten zur Verfügung. In diesem Kapitel wird die Verwaltung von Listen in Dynamo im Einzelnen beschrieben.
Daten sind das Material unserer Programme. Sie fließen als Eingaben durch "Drähte" in Blöcke, wo sie verarbeitet und in eine neue Form von Ausgabedaten umgewandelt werden. Hier sollen zunächst die Definition und Struktur von Daten betrachtet werden, bevor Sie damit beginnen, sie in Dynamo zu verwenden.
Unter Daten versteht man eine Gruppe von Werten für qualitative oder quantitative Variable. Die einfachste Form von Daten sind Zahlen wie z. B. 0
, 3.14
oder 17
. Es gibt jedoch eine Reihe unterschiedlicher Datentypen: Variable, die für veränderliche Zahlen stehen (height
), Zeichen (myName
), Geometrie (Circle
) oder eine Liste von Datenelementen (1,2,3,5,8,13,...
).
In Dynamo geben wir Daten in die Eingabeanschlüsse von Blöcken ein: Daten können ohne Aktionen existieren, aber die Aktionen, die durch die Blöcke dargestellt werden, können nur durchgeführt werden, wenn Daten vorhanden sind. Wenn Sie im Arbeitsbereich einen Block hinzufügen, ohne Eingaben bereitzustellen, ist das Ergebnis eine Funktion, nicht das Ergebnis der eigentlichen Aktion.
Einfache Daten
Daten und Aktion (Block): erfolgreiche Ausführung
Aktion (Block) ohne Daten gibt eine allgemeine Funktion zurück
Vorsicht vor Nullwerten: Der Typ 'null'
steht für das Fehlen von Daten. Dies ist zwar ein abstraktes Konzept, dem Sie jedoch bei der Arbeit mit visueller Programmierung sehr wahrscheinlich begegnen werden. Wenn eine Aktion kein gültiges Ergebnis erstellt, gibt der Block Null zurück.
Das Ermitteln und Entfernen von Nullwerten aus Datenstrukturen ist ein entscheidender Schritt zum Erstellen stabiler Programme.
Bei der visuellen Programmierung können sehr schnell große Datenmengen generiert werden. Aus diesem Grund benötigen Sie ein Verfahren zur Verwaltung von deren Hierarchie. Dies ist die Funktion der Datenstrukturen, der organisatorischen Schemata, in denen Daten gespeichert werden. Die Charakteristika der Datenstrukturen und ihrer Verwendung sind von Programmiersprache zu Programmiersprache unterschiedlich.
in Dynamo werden Daten mithilfe von Listen hierarchisch geordnet. Dies wird in den weiteren Kapiteln ausführlich erläutert. Am Anfang sollen einige einfache Beispiele stehen:
Eine Liste für eine Sammlung von Elementen, die in einer Struktur von Daten abgelegt wurden:
Sie haben fünf Finger (Elemente) an einer Hand (Liste).
Zehn Häuser (Elemente) stehen entlang einer Straße (Liste).
Ein Number Sequence-Block definiert eine Liste von Zahlen mithilfe der Eingaben start, amount und step. Mithilfe dieser Blöcke wurden zwei separate Listen mit je zehn Zahlen – 100–109 und 0–9 erstellt.
Mithilfe des Blocks List.GetItemAtIndex wird das Element an einer bestimmten Indexposition ausgewählt. Wenn Sie 0 wählen, wird das erste Element in der Liste (in diesem Fall 100) abgerufen.
In der zweiten Liste erhalten Sie mit demselben Verfahren den Wert 0, das erste Element in der Liste.
Als Nächstes führen Sie die beiden Listen mithilfe eines List.Create-Blocks zu einer zusammen. Mit diesem Block wird eine Liste von Listen erstellt. Dies verändert die Struktur der Daten.
Wenn Sie List.GetItemAtIndex erneut mit dem Index 0 verwenden, erhalten Sie die erste der in der übergeordneten Liste enthaltenen Listen. Dieses Beispiel verdeutlicht, wie Listen behandelt werden: Sie gelten – anders als in anderen Skriptsprachen – als Objekte. Listenbearbeitung und Datenstruktur werden in den später folgenden Kapiteln genauer beschrieben.
Als wichtigstes Prinzip zum Verständnis der Datenhierarchie in Dynamo gilt: Innerhalb der Datenstruktur gelten Listen als Elemente. In anderen Worten: In Dynamo kommt ein hierarchisch von oben nach unten geordneter Prozess für Datenstrukturen zum Einsatz. Was bedeutet das? Das folgende Beispiel soll dies verdeutlichen:
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In diesem ersten Beispiel erstellen Sie zur Demonstration der in diesem Abschnitt behandelten Geometriehierarchie einen Zylinder und geben seine Wandstärke an.
1. Fügen Sie Point.ByCoordinates hinzu: Nachdem Sie diesen Block im Ansichtsbereich hinzugefügt haben, wird ein Punkt am Ursprung des Rasters in der Dynamo-Vorschau angezeigt. Die Vorgabewerte der Eingaben für x, y und z sind 0.0, wodurch ein Punkt an dieser Position definiert wird.
2. Plane.ByOriginNormal: Die nächste Stufe in der Geometriehierarchie ist eine Ebene. Es gibt mehrere Möglichkeiten für die Konstruktion einer Ebene: Hier werden ein Ursprung und eine Normale als Eingaben verwendet. Der Ursprung ist der Punkt, den Sie mithilfe des Blocks im vorigen Schritt erstellt haben.
Vector.ZAxis: Dies ist ein Vektor mit Einheiten in z-Richtung. Hier sind keine Eingaben, sondern nur ein Vektor mit dem Wert [0,0,1] vorhanden. Dieser wird für die normal-Eingabe des Plane.ByOriginNormal-Blocks verwendet. In der Dynamo-Vorschau wird daraufhin eine rechteckige Ebene angezeigt.
3. Circle.ByPlaneRadius: Eine Stufe höher in der Hierarchie erstellen Sie aus der Ebene, die Sie im letzten Schritt erstellt haben, eine Kurve. Nachdem Sie den Block verbunden haben, erhalten Sie einen Kreis um den Ursprungspunkt. Als Radius ist in diesem Block der Wert 1 vorgegeben.
4. Curve.Extrude: In diesem Schritt wandeln Sie dieses Objekt in einen 3D-Körper um. Dieser Block erstellt durch Extrusion eine Oberfläche aus einer Kurve. Der vorgegebene Abstand im Block beträgt 1 und im Ansichtsfenster ist jetzt ein Zylinder zu sehen.
5. Surface.Thicken: Mit diesem Block erhalten Sie einen geschlossenen Körper, indem die Oberfläche um den angegebenen Wert versetzt und die entstehende Form geschlossen wird. Der Vorgabewert für die Verdickung ist 1. Im Ansichtsfenster wird ein Zylinder mit der entsprechenden Wandstärke angezeigt.
6. Number Slider: Anstatt die Vorgabewerte für alle diese Eingaben zu verwenden, können Sie dem Modell auch Funktionen zur parametrischen Steuerung hinzufügen.
Domänenbearbeitung: Nachdem Sie den Number-Slider im Ansichtsbereich hinzugefügt haben, klicken Sie auf die Pfeilspitze oben links, um die Domänenoptionen anzuzeigen.
Min/Max/Step: Ändern Sie die Werte für min, max und step in 0,2 und 0.01. Mit diesen Angaben steuern Sie die Gesamtgröße der Geometrie.
7. Number Slider-Blöcke: Erstellen Sie mehrere Kopien dieses Number Slider-Blocks (indem Sie ihn auswählen und anschließend zuerst Strg+C und dann Strg+V drücken), bis für alle Eingaben anstelle der bisherigen Vorgaben nun Verbindungen zu den Number Sliders verwendet werden. Manche Werte für diese Schieberegler müssen größer als Null sein, damit die Definition verwendbar ist. So wird beispielsweise eine Tiefe für die Extrusion benötigt, damit eine Oberfläche entsteht, die verdickt werden kann.
8. Sie haben jetzt mithilfe dieser Regler einen parametrischen Zylinder mit Angabe einer Wandstärke erstellt. Experimentieren Sie mit einigen dieser Parameter und beobachten Sie die dynamische Veränderung der Geometrie im Dynamo-Ansichtsfenster.
Number Sliders-Blöcke: In einem weiteren Schritt wurden etliche weitere Number Sliders im Ansichtsbereich hinzugefügt und die Benutzeroberfläche des neu erstellten Werkzeugs muss übersichtlicher gestaltet werden. Klicken Sie mit der rechten Maustaste nacheinander auf die einzelnen Schieberegler, wählen Sie Umbenennen und ändern Sie den Namen jedes Schiebereglers in den Namen des dazugehörigen Parameters (Dicke, Radius, Höhe usw.).
9. Zum jetzigen Zeitpunkt haben Sie einen perfekten verdickten Zylinder erstellt. Dies ist jedoch nur ein einzelnes Objekt. Im nächsten Schritt wird gezeigt, wie Sie ein Array von Zylindern erstellen, die dynamisch miteinander verbunden bleiben. Zu diesem Zweck arbeiten Sie nicht mit einem einzelnen Element, sondern erstellen eine Liste von Zylindern.
Addition (+): Neben dem eben erstellten Zylinder soll eine Reihe weiterer Zylinder hinzugefügt werden. Um einen Zylinder direkt neben dem vorhandenen hinzuzufügen, müssen Sie sowohl dessen Radius als auch die Stärke seiner Wand berücksichtigen. Diesen Wert erhalten Sie durch Addition der Werte aus den beiden Schiebereglern.
10. Dieser Schritt ist etwas komplexer und wird daher im Einzelnen erläutert: Erstellt werden soll eine Liste mit Zahlen, die die Positionen der einzelnen Zylinder in einer Reihe definieren.
a. Multiplikation: Als Erstes müssen Sie den Wert aus dem vorigen Schritt mit 2 multiplizieren. Der Wert aus dem vorherigen Schritt gibt den Radius an, der Zylinder muss jedoch um den vollständigen Durchmesser verschoben werden.
b. Number Sequence: Mithilfe dieses Blocks erstellen Sie ein Array von Zahlen. Die erste Eingabe ist der Wert des multiplication-Blocks aus dem vorigen Schritt in den step-Wert. Als start-Wert können Sie 0.0 festlegen. Verwenden Sie hierfür einen number-Block.
c. Integer Slider: Verbinden Sie für den amount-Wert einen Integer-Schieber. Diese Funktion definiert, wie viele Zylinder erstellt werden.
d. Ausgabe: Diese Liste zeigt den Abstand, um den die einzelnen Zylinder im Array versetzt werden. Sie wird parametrisch durch die ursprünglichen Schieberegler gesteuert.
11. Dieser Schritt ist einfach: Verbinden Sie die im letzten Schritt erstellte Sequenz mit der x-Eingabe des ursprünglichen Point.ByCoordinates. Dies ersetzt den Schieberegler pointX, den Sie löschen können. Im Ansichtsfenster wird jetzt ein Array von Zylindern angezeigt (achten Sie darauf, dass im Integer Slider ein Wert größer als Null angegeben ist).
12. Die Kette der Zylinder ist weiterhin dynamisch mit allen Schiebereglern verknüpft. Experimentieren Sie mit den Schiebereglern, und beobachten Sie, wie die Definition aktualisiert wird.
Zahlen stellen die einfachste Form von Daten dar und sind am einfachsten durch mathematische Operationen zu verknüpfen. Von einfachen Operatoren etwa zur Division über trigonometrische Funktionen bis hin zu komplexen Formeln: Mathematische Operationen eignen sich ausgezeichnet zur Analyse von Zahlenverhältnissen und -mustern.
Operatoren sind Komponenten für algebraische Funktionen, die zwei Eingabewerte benötigen, um einen Ausgabewert zu erhalten (etwa bei der Addition, Subtraktion, Multiplikation, Division usw.). Sie finden die Operatoren unter Operators > Actions.
Symbol | Name (Syntax) | Eingaben | Ausgaben |
---|---|---|---|
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Kombinieren Sie Operatoren und Variablen, um mithilfe von Formeln eine komplexere Beziehung zu bilden. Verwenden Sie die Schieberegler, um eine Formel zu erstellen, die mit Eingabeparametern gesteuert werden kann.
1. Wir erstellen eine Zahlenfolge, die für die Angabe "t" in der parametrischen Gleichung steht. Wir benötigen daher eine Liste mit genügend Werten zum Definieren einer Spirale.
Number Sequence: Definieren Sie eine Zahlenfolge mithilfe von drei Eingaben: start, amount und step.
2. Mit dem oben beschriebenen Schritt haben Sie eine Liste von Zahlen erstellt, die die parametrische Domäne definieren. Als Nächstes erstellen Sie eine Gruppe von Blöcken, die die Goldene Spirale-Gleichung darstellen.
Die Goldene Spirale ist durch die folgende Gleichungen definiert:
Die folgende Abbildung zeigt die goldene Spirale in visueller Programmierung. Beachten Sie bei der Betrachtung dieser Blockgruppe die Entsprechungen zwischen dem visuellen Programm und der schriftlichen Gleichung.
a. Number Slider: Fügen Sie im Ansichtsbereich zwei Number Sliders ein. Diese Schieberegler steuern die Variablen a und b in der parametrischen Gleichung. Sie stehen für einstellbare Konstanten bzw. Parameter, die Sie anpassen können, um das gewünschte Ergebnis zu erhalten.
b. Multiplication (*): Der Block für die Multiplikation wird mit einem Sternchen dargestellt. Er kommt hier mehrmals zum Einsatz, um Variablen miteinander zu multiplizieren.
c. Math.RadiansToDegrees: Die Werte für "t" müssen in Grad umgewandelt werden, damit sie in den trigonometrischen Funktionen verwendet werden können. Dynamo verwendet per Vorgabe Grad zur Auswertung dieser Funktionen.
d. Math.Pow: Als Funktion von "t" und der Zahl "e" erstellt dieser Block die Fibonacci-Folge.
e. Math.Cos und Math.Sin: Diese beiden trigonometrischen Funktionen differenzieren die x- und y-Koordinaten der einzelnen parametrischen Punkte.
f. Watch: Als Ausgabe erhalten Sie zwei Listen mit Werten für die x- und y-Koordinaten der Punkte, aus denen die Spirale erstellt wird.
Die Gruppe von Blöcken aus dem letzten Schritt funktioniert einwandfrei, erfordert jedoch erheblichen Aufwand. Einen effizienteren Arbeitsablauf finden Sie unter DesignScript. Dort wird beschrieben, wie Sie eine Reihe von Dynamo-Ausdrücken in ein und demselben Block definieren können. In den nächsten Schritten zeichnen Sie mithilfe der parametrischen Gleichung die Fibonacci-Spirale.
Point.ByCoordinates: Verbinden Sie den oberen Multiplikationsblock mit der x-Eingabe und den unteren mit der y-Eingabe. Dadurch wird auf dem Bildschirm eine parametrische Spirale aus Punkten angezeigt.
Polycurve.ByPoints: Verbinden Sie Point.ByCoordinates aus dem vorigen Schritt mit points. Für connectLastToFirst wird keine Eingabe benötigt, da Sie keine geschlossene Kurve erstellen. Dadurch wird eine durch die im vorigen Schritt erstellten Punkte verlaufende Spirale erstellt.
Damit haben Sie die Fibonacci-Spirale erstellt. Dies entwickeln Sie in zwei weiteren Übungen weiter, die hier als "Nautilus" und "Sonnenblume" bezeichnet werden. Dabei handelt es sich um Abstraktionen aus Systemen, die in der Natur vorkommen und gute Beispiele für zwei verschiedene Verwendungsweisen der Fibonacci-Spirale darstellen.
Circle.ByCenterPointRadius: Verwenden Sie hier einen Circle-Block mit denselben Eingaben wie im vorigen Schritt. Als Radius ist der Wert 1.0 vorgegeben, d. h., Sie sehen sofort die ausgegebenen Kreise. Die zunehmende Entfernung der Punkte vom Ursprung ist sofort ersichtlich.
Number Sequence: Dies ist das Original-Array für "t". Die Verbindung mit dem Radiuswert Circle.ByCenterPointRadius bewirkt, dass die Mittelpunkte der Kreise sich nach wie vor vom Ursprung entfernen, wobei jedoch auch ihr Radius zunimmt. Sie erhalten eine recht originelle Fibonacci-Grafik.
Versuchen Sie, dies in 3D darzustellen!
Muster: Nachdem Sie eine Nautilusmuschel aus Kreisen erstellt haben, betrachten Sie jetzt parametrische Raster. Durch einfaches Drehen der Fibonacci-Spirale erstellen Sie ein Fibonacci-Raster. Das Ergebnis ist anhand des Wachstums vom Sonnenblumensamen modelliert.
Beginnen Sie mit demselben Schritt wie in der vorigen Übung, d. h., indem Sie mithilfe des Point.ByCoordinates-Blocks ein spiralförmiges Array aus Punkten erstellen.
![](../images/5-3/2/math-part IV-01.jpg)
Als Nächstes führen Sie diese kleinen Schritte aus, um eine Reihe von Spiralen mit verschiedenen Drehungen zu erstellen.
a. Geometry.Rotate: Es stehen mehrere Optionen für Geometry.Rotate zur Verfügung. Achten Sie darauf, den Block mit den Eingaben geometry,basePlane und degrees zu wählen. Verbinden Sie Point.ByCoordinates mit der geometry-Eingabe. Klicken Sie mit der rechten Maustaste auf diesen Block, und vergewissern Sie sich, dass die Vergitterung auf Kartesisches Produkt festgelegt ist.
b. Plane.XY: Verbinden Sie dies mit der basePlane-Eingabe. Das Zentrum der Drehung ist der Ursprung, d. h. derselbe Punkt wie die Basis der Spirale.
c. Number Range: Sie benötigen mehrere Drehungen für die degree-Eingabe. Dies erreichen Sie schnell mit der Komponente für den Zahlenbereich. Verbinden Sie diese mit der degrees-Eingabe.
d. Number: Fügen Sie im Ansichtsbereich drei Zahlenblöcke übereinander ein, um den Zahlenbereich zu definieren. Weisen Sie diesen von oben nach unten die Werte 0.0,360.0, und 120.0 zu. Diese Werte steuern die Drehung der Spirale. Beachten Sie die Ergebnisse der Ausgabe aus dem Number Range-Block, nachdem Sie die drei Zahlenblöcke mit ihm verbunden haben.
Die Ausgabe nimmt eine gewisse Ähnlichkeit mit einem Wirbel an. Passen Sie jetzt einige der für Number Range verwendeten Parameter an und beobachten Sie, wie sich die Ergebnisse verändern.
Ändern Sie die Schrittgröße für den Number Range-Block von 120.0 in 36.0. Damit erhalten Sie mehr Drehungen und daher ein dichteres Raster.
Ändern Sie die Schrittgröße für den Number Range-Block von 36.0 in 3.6. Dadurch erhalten Sie ein wesentlich dichteres Raster und die Richtung der Spiralen ist nicht mehr erkennbar. Damit haben Sie ein Sonnenblumenmuster erstellt.
In diesem Abschnitt kommt eine weitere Ebene zur Hierarchie hinzu. Für den Einstieg wurde ein Stapel Karten als Beispiel betrachtet. Angenommen, eine Schachtel enthält mehrere solche Stapel. In diesem Fall entspricht die Schachtel einer Liste von Stapeln und jeder Stapel einer Liste von Karten. Dies ist eine Liste von Listen. Als Analogie für diesen Abschnitt zeigt das Bild unten eine Liste von Münzstapeln, wobei jeder Stapel einer Liste von Münzen entspricht.
Foto von Dori.
Welche Abfragen sind in der Liste von Listen möglich? Dies ermöglicht den Zugriff auf vorhandene Eigenschaften.
Anzahl von Münzarten? 2.
Wert der Münzarten? $0,01 und $0,25.
Material der Vierteldollars? 75 % Kupfer und 25 % Nickel.
Material der Cents? 97,5 % Zink und 2,5 % Kupfer.
Welche Aktionen können in der Liste von Listen durchgeführt werden? Diese Aktionen bewirken Änderungen in der Liste von Listen entsprechend der jeweiligen Operation.
Wählen Sie einen bestimmten Stapel von Vierteldollars oder Cents aus.
Wählen Sie einen bestimmten Vierteldollar oder Cent aus.
Ordnen Sie den Stapel aus Vierteldollars und Cents neu.
Mischen Sie die Stapel zusammen.
Auch in diesem Fall steht in Dynamo für jeden der oben genannten Vorgänge ein entsprechender Block zur Verfügung. Da allerdings keine realen Objekte, sondern abstrakte Daten verarbeitet werden, sind Regeln zum Navigieren in der Datenhierarchie erforderlich.
Die bei der Arbeit mit Listen von Listen verwendeten Daten sind komplex und umfassen mehrere Ebenen, was aber auch die Möglichkeit für äußerst wirkungsvolle parametrische Operationen eröffnet. Im Folgenden werden zunächst die Grundlagen im Einzelnen erläutert und in weiteren Lektionen einige weitere Operationen betrachtet.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Das in diesem Abschnitt eingeführte Grundprinzip lautet: Dynamo behandelt auch Listen als Objekte. Diese Hierarchie von oben nach unten wurde im Hinblick auf objektorientierte Programmierung entwickelt. Anstatt Unterelemente mithilfe eines Befehls wie etwa List.GetItemAtIndex auszuwählen, wählt Dynamo den entsprechenden Index in der Hauptliste innerhalb der Datenstruktur. Dieses Element kann eine weitere Liste sein. Ein Beispielbild soll dies verdeutlichen:
Im Codeblock wurden zwei Bereiche definiert:
0..2; 0..3;
Diese Bereiche sind mit einem Point.ByCoordinates-Block unter Verwendung der Vergitterung "Kreuzprodukt" verbunden. Dadurch wird ein Raster von Punkten erstellt und zugleich wird eine Liste von Listen als Ausgabe zurückgegeben.
Beachten Sie, dass im Watch-Block 3 Listen mit jeweils 4 Elementen angezeigt werden.
Bei Verwendung von List.GetItemAtIndex mit dem Index 0 wählt Dynamo die erste Liste sowie ihren gesamten Inhalt aus. In anderen Programmen wird eventuell das erste Element jeder Liste in der Datenstruktur ausgewählt, Dynamo verwendet jedoch eine von oben nach unten geordnete Hierarchie zur Verarbeitung der Daten.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Der Befehl Flatten entfernt alle Datenebenen aus einer Datenstruktur. Dies ist hilfreich, wenn Sie für Ihre Operationen keine Datenhierarchien benötigen, birgt jedoch auch Risiken, da Informationen entfernt werden. Das folgende Beispiel zeigt das Ergebnis nach der Vereinfachung einer Liste mit Daten.
Fügen Sie im Codeblock eine Zeile mit Code zum Definieren eines Bereichs ein:
-250..-150..#4;
Der Codeblock wird mit den x- und y-Eingaben eines Point.ByCoordinates-Blocks verbunden, wobei die Vergitterung "Kreuzprodukt" verwendet wird, um ein Raster aus Punkten zu erhalten.
Im Watch-Block wird angezeigt, dass eine Liste von Listen erstellt wurde.
Ein PolyCurve.ByPoints-Block referenziert die einzelnen Listen und erstellt die entsprechenden Polykurven. Die Dynamo-Vorschau zeigt vier Polykurven für die einzelnen Zeilen im Raster.
Durch Einfügen von flatten vor dem Block für die Polykurven entsteht eine einzelne Liste, die sämtliche Punkte enthält. Der PolyCurve.ByPoints-Block referenziert diese Liste und erstellt nur eine Kurve. Da alle Punkte in derselben Liste enthalten sind, entsteht eine zickzackförmige Polykurve, die durch sämtliche Punkten aus der Liste verläuft.
Darüber hinaus stehen auch Optionen zum Vereinfachen isolierter Datenebenen zur Verfügung. Mithilfe des List.Flatten-Blocks können Sie festlegen, wie viele Datenebenen unterhalb der ersten Hierarchieebene vereinfacht werden sollen. Dies ist sehr hilfreich bei komplexen Datenstrukturen, die für Ihren Arbeitsablauf nicht unbedingt erforderlich sind. Eine weitere Möglichkeit besteht darin, den Flatten-Block als Funktion in List.Map einzusetzen. Weitere Informationen zu List.Map finden Sie weiter unten.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Bei der parametrischen Modellierung ist es zuweilen erforderlich, die Datenstruktur einer bestehenden Liste zu ändern. Hierfür stehen ebenfalls zahlreiche Blöcke zur Verfügung, wobei Chop die einfachste Version darstellt. Mit Chop können Sie eine Liste in Unterlisten mit der angegebenen Anzahl Elemente unterteilen.
Der Befehl Chop teilt Listen gemäß der angegebenen Listenlänge. In gewisser Weise stellt Chop das Gegenteil zu Flatten dar: Der Datenstruktur werden neue Ebenen hinzugefügt, anstatt dass vorhandene entfernt werden. Dieses Werkzeug ist hilfreich für geometrische Operationen wie im Beispiel unten gezeigt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Mit List.Map/Combine wird eine angegebene Funktion auf die eingegebene Liste angewendet, allerdings geschieht dies eine Ebene tiefer in der Hierarchie. Kombinationen fungieren genau wie Maps. Allerdings sind für Kombinationen mehrere Eingaben entsprechend der Eingabe einer gegebenen Funktion möglich.
Anmerkung: Diese Übung wurde mit einer früheren Version von Dynamo erstellt. Die Funktion List.Map lässt sich großenteils durch die neu hinzugefügte Funktion List@Level ersetzen. Weitere Informationen finden Sie nachfolgend unter List@Level.
Ziehen Sie als kurze Einführung den List.Count-Block aus dem vorigen Abschnitt heran.
Der List.Count-Block zählt alle Elemente in einer Liste. An diesem Beispiel wird die Funktionsweise von List.Map gezeigt.
Fügen Sie zwei Zeilen Code in den Codeblock ein:
-50..50..#Nx; -50..50..#Ny;
Nach der Eingabe dieses Codes werden im Codeblock zwei Eingaben für Nx und Ny erstellt.
Definieren Sie mit zwei Integer Slidern die Werte für Nx und Ny, indem Sie die Schieberegler mit dem Codeblock verbinden.
Verbinden Sie jede Zeile des Codeblocks mit der entsprechenden X- bzw. Y-Eingabe eines Point.ByCoordinates-Blocks. Klicken Sie mit der rechten Maustaste auf den Block und wählen Sie zuerst Vergitterung und dann "Kreuzprodukt". Dadurch wird ein Raster aus Punkten erstellt. Da der Bereich zwischen -50 und 50 definiert wurde, umfasst er das vorgabemäßige Raster von Dynamo.
In einem Watch-Block werden die erstellten Punkte angezeigt. Beachten Sie die Datenstruktur. Es wurde eine Liste von Listen erstellt. Jede Liste entspricht einer Reihe von Punkten im Raster.
Verbinden Sie einen List.Count-Block mit der Ausgabe des Watch-Blocks aus dem vorigen Schritt.
Verbinden Sie einen Watch-Block mit der Ausgabe des List.Count-Blocks.
Der List.Count-Block gibt den Wert 5 aus. Dieser Wert ist gleich dem Wert der im Codeblock definierten Variablen Nx. Dies geschieht aus dem folgenden Grund:
Im Point.ByCoordinates-Block wird die x-Eingabe als primäre Eingabe zum Erstellen von Listen verwendet. Für Nx = 5 und Ny = 3 ergibt sich daher eine Liste, die fünf Listen mit je 3 Elementen enthält.
Da Listen in Dynamo als Objekte behandelt werden, wird der List.Count-Block auf die Hauptliste in der Hierarchie angewendet. Das Ergebnis ist der Wert 5, d. h. die Anzahl der Listen in der Hauptliste.
Mithilfe eines List.Map-Blocks bewegen Sie sich eine Ebene tiefer in die Hierarchie und führen dort eine "Funktion" aus.
Beachten Sie, dass der List.Count-Block keine Eingabe hat. Er wird als Funktion eingesetzt, d. h., der List.Count-Block wird auf jede einzelne Liste eine Ebene unterhalb der Hauptliste in der Hierarchie angewendet. Die leere Eingabe von List.Count entspricht der Listeneingabe von List.Map.
Als Ergebnis von List.Count erhalten Sie jetzt eine Liste mit fünf Elementen, jeweils mit dem Wert 3. Dies entspricht der Länge jeder Unterliste.
Anmerkung: Diese Übung wurde mit einer früheren Version von Dynamo erstellt. Die Funktionalität von List.Combine lässt sich großenteils durch die neu hinzugefügte Funktion List@Level ersetzen. Weitere Informationen finden Sie weiter unten unter List@Level.
In dieser Übung verwenden wir List.Combine, um zu zeigen, wie damit eine Funktion auf separate Listen von Objekten angewendet werden kann.
Beginnen Sie, indem Sie zwei Listen von Punkten einrichten.
Verwenden Sie den Sequence-Block, um 10 Werte zu generieren, von denen jeder ein Inkrement von 10 Schritten aufweist.
Verbinden Sie das Ergebnis mit der x-Eingabe eines Point.ByCoordinates-Blocks. Dadurch wird eine Liste von Punkten in Dynamo erstellt.
Fügen Sie einen zweiten Point.ByCoordinates-Block zum Arbeitsbereich hinzu, verwenden Sie dieselbe Sequence-Ausgabe als x-Eingabe, verwenden Sie jedoch einen Integer Slider als y-Eingabe, und legen Sie den Wert auf 31 fest, sodass die 2 Punktsätze nicht überlappen. (Es kann ein beliebiger Wert sein, solange er nicht mit dem ersten Satz von Punkten überlappt).
Als Nächstes wenden Sie mit List.Combine eine Funktion auf Objekte in 2 separaten Listen an. In diesem Fall handelt es sich um eine einfache Funktion zum Zeichnen von Linien.
Fügen Sie List.Combine zum Arbeitsbereich hinzu, und verbinden Sie die 2 Punktsätze als list0- und list1-Eingabe.
Verwenden Sie Line.ByStartPointEndPoint als Eingabefunktion für List.Combine.
Nach Abschluss werden die 2 Punktgruppen mithilfe einer Line.ByStartPointEndPoint-Funktion komprimiert/gekoppelt, sodass in Dynamo 10 Zeilen zurückgegeben werden.
In der Übung zu n-dimensionalen Listen finden Sie ein weiteres Beispiel für die Verwendung von List.Combine.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Die Funktion List@Level kann als Alternative zu List.Map eingesetzt werden und ermöglicht es, die Listenebene, mit der Sie arbeiten möchten, direkt am Eingabeanschluss auszuwählen. Diese Funktion kann für jeden Eingabeanschluss eines Blocks angewendet werden und ermöglicht einen schnelleren und einfacheren Zugriff auf die Ebenen in Listen als andere Methoden. Geben Sie im Block einfach an, welche Ebene der Liste Sie als Eingabe verwenden möchten, und überlassen Sie die Ausführung dem Block.
In dieser Übung isolieren Sie mithilfe der Funktion List@Level eine bestimmte Datenebene.
Sie beginnen mit einem einfachen 3D-Raster von Punkten.
Das Raster wurde mit Bereichen für X, Y und Z konstruiert, und es ist bekannt, dass drei Datenstufen vorhanden ist, jeweils eine Liste für X, Y und Z.
Diese Stufen entsprechen verschiedenen Ebenen. Die Ebenen werden im unteren Bereich des Vorschaufensters angezeigt. Die Spalten für die Listenebenen entsprechen den oben angegebenen Listendaten und erleichtern es, die Ebene zu finden, auf der Sie arbeiten möchten.
Die Ebenen sind in umgekehrter Reihenfolge geordnet, d. h., die unterste Datenebene ist immer "L1". Dadurch wird sichergestellt, dass Ihre Diagramme wie geplant funktionieren, auch wenn vorangehende Schritte geändert werden.
Um die Funktion List@Level zu verwenden, klicken Sie auf ">". In diesem Menü werden zwei Kontrollkästchen angezeigt.
Ebenen verwenden: Aktiviert die Funktion List@Level. Nach dem Klicken auf diese Option können Sie durch die Eingabelistenebenen navigieren und die Ebene auswählen, die der Block verwenden soll. Über dieses Menü können Sie durch Navigieren nach oben oder unten rasch Optionen für verschiedene Ebenen testen.
Listenstruktur beibehalten: Ist dies aktiviert, haben Sie die Möglichkeit, die Ebenenstruktur der Eingabe beizubehalten. In manchen Fällen haben Sie eventuell Ihre Daten absichtlich in Unterlisten geordnet. Indem Sie diese Option aktivieren, können Sie Ihre Listenstruktur beibehalten, sodass keine Informationen verloren gehen.
In diesem einfachen 3D-Raster können Sie auf die Listenstruktur zugreifen und sie visualisieren, indem Sie durch die Listenebenen blättern. Mit jeder Kombination aus Listenebene und Index erhalten Sie eine andere Untergruppe von Punkten aus der ursprünglichen 3D-Punktmenge.
Mit der Angabe "@L2" in DesignScript wählen Sie ausschließlich die Liste auf Ebene 2 aus. Die Liste auf Ebene 2 mit dem Index 0 enthält nur die Gruppe von Punkten mit dem ersten Y-Wert, d. h. nur das XZ-Raster.
Wenn Sie den Ebenenfilter in "L1" ändern, sind sämtliche Daten auf der ersten Listenebene sichtbar. Die Liste auf Ebene 1 mit dem Index 0 enthält alle 3D-Punkte in einer unstrukturierten Liste.
Mit "L3" werden nur die Punkte auf der dritten Listenebene angezeigt. Die Liste auf Ebene 3 mit dem Index 0 enthält nur die Gruppe von Punkten mit dem ersten Z-Wert, d. h. nur das XY-Raster.
Mit "L4" werden nur die Punkte auf der dritten Listenebene angezeigt. Die Liste auf Ebene 4 mit dem Index 0 enthält nur die Gruppe von Punkten mit dem ersten X-Wert, d. h. nur das YZ-Raster.
Obwohl dieses Beispiel auch mithilfe von List.Map erstellt werden kann, bietet List@Level eine wesentlich einfachere Interaktion und erleichtert dadurch den Zugriff auf die Daten des Blocks. Unten sehen Sie die Methoden List.Map und List@Level im Vergleich:
Beide Methoden ermöglichen den Zugriff auf dieselben Punkte, mit List@Level ist jedoch der mühelose Wechsel zwischen Datenlayern innerhalb desselben Blocks möglich.
Für den Zugriff auf ein Punktraster mithilfe von List.Map benötigen Sie außer dem eigentlichen List.Map-Block einen List.GetItemAtIndex-Block. Für jeden Schritt auf eine tiefere Listenebene benötigen Sie einen weiteren List.Map-Block. Dies könnte je nach Komplexität Ihrer Listen bedeuten, dass Sie Ihrem Diagramm eine größere Anzahl von List.Map-Blöcken hinzufügen müssen, um die richtige Informationsebene zu erreichen.
In diesem Beispiel gibt der List.GetItemAtIndex-Block zusammen mit dem List.Map-Block dieselbe Punktgruppe mit derselben Listenstruktur zurück wie List.GetItemAtIndex mit der Auswahl "@L3".
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Transpose gehört zu den Grundfunktionen bei der Arbeit mit Listen von Listen. Mit Transpose werden genau wie in Tabellenkalkulationsprogrammen die Spalten und Zeilen einer Datenstruktur vertauscht. Dies wird in einer einfachen Matrix unten gezeigt. Im darauf folgenden Abschnitt wird beschrieben, wie Sie mithilfe von Transpose geometrische Beziehungen erstellen können.
Löschen Sie die List.Count-Blöcke aus der vorhergegangenen Übungslektion, sodass Sie mit Geometrie arbeiten und die Struktur der Daten sehen können.
Verbinden Sie einen PolyCurve.ByPoints-Block mit der Ausgabe des Beobachtungsblocks für Point.ByCoordinates.
Die Ausgabe zeigt 5 Polykurven, die auch in der Dynamo-Vorschau angezeigt werden. Der Dynamo-Block sucht nach einer Liste von Punkten (bzw. in diesem Fall nach einer Liste von Listen von Punkten) und erstellt jeweils eine Polykurve. Dies bedeutet, dass jede Liste in eine Kurve in der Datenstruktur umgewandelt wurde.
Ein List.Transpose-Block vertauscht sämtliche Elemente mit allen Listen in einer Liste von Listen. Dies wirkt kompliziert, folgt aber derselben Logik wie die Funktion Transponieren in Microsoft Excel: Spalten und Zeilen in einer Datenstruktur werden vertauscht.
Im abstrakten Ergebnis ist zu sehen, dass Transpose die Listenstruktur aus 5 Listen mit je 3 Elementen in 3 Listen mit je 5 Elementen umgewandelt hat.
Das geometrische Ergebnis aus PolyCurve.ByPoints zeigt 3 Polykurven, die rechtwinklig zu den Originalkurven liegen.
In der Codeblock-Notation wird "[]" zum Definieren einer Liste verwendet. Mit diesem Verfahren können Sie Listen wesentlich schneller und flexibler erstellen als mithilfe des List.Create-Blocks. Codeblöcke werden ausführlich in Codeblöcke und DesignScript behandelt. Die folgende Abbildung zeigt, wie Sie eine Liste mit mehreren Ausdrücken in einem Codeblock definieren können.
Die Codeblock-Notation verwendet eckige Klammern ("[]") als schnelle und einfache Möglichkeit zur Auswahl bestimmter Elemente, die aus einer komplexen Datenstruktur abgerufen werden sollen. Codeblöcke werden im Kapitel Codeblöcke und DesignScript ausführlicher behandelt. Die folgende Abbildung zeigt, wie Sie mithilfe von Codeblöcken eine Liste mit mehreren Datentypen abfragen können.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übungslektion wird ein Teil der in der vorigen Lektion erstellten Logik zum Bearbeiten einer Oberfläche verwendet. Die Navigation in der Datenstruktur ist etwas komplexer, obwohl das angestrebte Ergebnis intuitiv wirkt. Die Oberfläche soll durch Verschieben eines Steuerpunkts strukturiert werden.
Beginnen Sie mit der oben gezeigten Folge von Blöcken. Dadurch wird eine einfache, das vorgegebene Dynamo-Raster umfassende Oberfläche erstellt.
Fügen Sie mithilfe eines Codeblocks diese beiden Codezeilen ein und verbinden Sie sie mit den u- und v-Eingaben von Surface.PointAtParameter:
-50..50..#3;
-50..50..#5;
Achten Sie darauf, als Vergitterung von Surface.PointAtParameter die Option Kreuzprodukt zu wählen.
Im Watch-Block wird eine Liste aus drei Listen mit je fünf Elementen angezeigt.
In diesem Schritt fragen Sie den Mittelpunkt des eben erstellten Rasters ab. Dazu wird die mittlere Zeile der mittleren Liste ausgewählt, was irgendwie Sinn ergibt, nicht wahr?
Sie können auch nacheinander auf die Elemente im Beobachtungsblock klicken, um sicherzustellen, dass dies der richtige Punkt ist.
Schreiben Sie im Codeblock eine einfache Codezeile zum Abfragen einer Liste von Listen:
points[1][2];
Verschieben Sie mithilfe von Geometry.Translate den ausgewählten Punkt in Z-Richtung um 20 Einheiten nach oben.
Wählen Sie mithilfe eines List.GetItemAtIndex-Blocks auch die mittlere Reihe von Punkten aus. Anmerkung: Ähnlich wie im vorigen Schritt können Sie die Liste auch mithilfe eines Codeblocks abfragen, wobei Sie die Zeile
points[1];
eingeben.
Damit haben Sie den Mittelpunkt abgefragt und ihn nach oben verschoben. Als Nächstes müssen Sie den verschobenen Punkt in die ursprüngliche Datenstruktur einfügen.
Dazu ersetzen Sie zuerst das Listenelement, das Sie zuvor isoliert haben.
Mit List.ReplaceItemAtIndex ersetzen Sie das mittlere Element mit dem Index "2" durch das Ersatzelement, das mit dem verschobenen Punkt (Geometry.Translate) verbunden ist.
Die Ausgabe zeigt, dass der verschobene Punkt in das mittlere Element der Liste eingegeben wurde.
Jetzt müssen Sie die geänderte Liste in die ursprüngliche Datenstruktur, d. h. die Liste von Listen, einfügen.
Ersetzen Sie nach demselben Prinzip die mittlere Liste mithilfe von List.ReplaceItemAtIndex durch die geänderte Liste.
Beachten Sie, dass in den Codeblöcken, die die Indizes für diese beiden Blöcke definieren, die Werte 1 und 2 angegeben wurde, was der ursprünglichen Abfrage aus dem Codeblock (points[1][2]) entspricht.
Wenn Sie die Liste mit index 1 auswählen, wird die Datenstruktur in der Dynamo-Vorschau hervorgehoben. Damit haben Sie den verschobenen Punkt in die ursprüngliche Datenstruktur aufgenommen.
Es gibt viele Möglichkeiten zum Erstellen einer Oberfläche aus dieser Punktgruppe. In diesem Fall erstellen Sie die Oberfläche durch Erheben und Verbinden von Kurven.
Erstellen Sie einen NurbsCurve.ByPoints-Block und verbinden Sie ihn mit der neuen Datenstruktur, um drei Nurbs-Kurven zu erstellen.
Verbinden Sie einen Surface.ByLoft-Block mit der Ausgabe von NurbsCurve.ByPoints. Damit haben Sie eine geänderte Oberfläche erstellt. Sie können den ursprünglichen Z-Wert der Geometrie ändern. Beobachten Sie, wie die Geometrie durch diese Verschiebung aktualisiert wird.
Der Datentyp Farbe eignet sich ausgezeichnet zum Erstellen beeindruckender Präsentationen sowie zur Darstellung von Unterschieden in der Ausgabe Ihres Grafikprogramms. Bei der Arbeit mit abstrakten Daten und veränderlichen Zahlen ist es zuweilen schwierig, zu erkennen, was sich in welchem Umfang verändert. Dies ist ein nützlicher Anwendungsbereich für Farben.
Farben werden in Dynamo mithilfe von ARGB-Eingaben erstellt. Dies entspricht den Angaben Alpha, Rot, Grün und Blau. Der Alpha-Kanal gibt die Transparenz der Farbe an, während die drei anderen Angaben als Primärfarben zur Darstellung des gesamten Farbspektrums verwendet werden.
Symbol | Name (Syntax) | Eingaben | Ausgaben |
---|---|---|---|
Mithilfe der Farben in der Tabelle unten werden die Eigenschaften zum Definieren von Farben abgefragt: Alpha, Rot, Grün und Blau. Beachten Sie, dass der Block Color.Components alle vier unterschiedlichen Ausgaben bereitstellt. Diesem Block ist daher für die Abfrage der Eigenschaften einer Farbe der Vorzug zu geben.
Symbol | Name (Syntax) | Eingaben | Ausgaben |
---|---|---|---|
Die Farben in der Tabelle unten entsprechen dem HSB-Farbraum. Die Interpretation einer anhand von Farbton, Sättigung und Helligkeit definierten Farbe mag intuitiver scheinen: Welche Farbe ist gemeint? Wie intensiv soll sie sein? Wie hell oder dunkel soll die Farbe sein? Dies ist die Differenzierung nach Farbton, Sättigung und Helligkeit.
Symbol | Name (Syntax) | Eingaben | Ausgaben |
---|---|---|---|
Der Farbbereich ist dem Remap Range-Block aus der Übung in #part-ii-from-logic-to-geometry ähnlich: Eine Liste von Zahlen wird in einer anderen Domäne neu zugeordnet. Allerdings wird sie nicht einer number-Domäne, sondern anhand eingegebener Zahlenwerte zwischen 0 und 1 einem Farbverlauf zugeordnet.
Der derzeit verwendete Block funktioniert problemlos, seine Funktionsweise ist jedoch anfangs möglicherweise sehr ungewohnt. Die beste Möglichkeit, mit dem Farbverlauf vertraut zu werden, besteht darin, ihn in der Praxis auszuprobieren. Die folgende kurze Übung zeigt, wie Sie einen Farbverlauf mit Ausgabe der Farben anhand von Zahlen erstellen können.
Definieren Sie drei Farben: Definieren Sie mithilfe eines Code Block-Blocks Rot, Grün und Blau, indem Sie die jeweiligen Kombinationen von 0 und 255 verbinden.
Liste erstellen: Führen Sie die drei Farben zu einer Liste zusammen.
Definieren Sie Indizes: Erstellen Sie eine Liste zum Definieren der Griffpositionen für jede Farbe (von 0 bis 1). Beachten Sie, dass für Grün der Wert 0.75 festgelegt wurde. Dadurch wird die Farbe Grün an der Position bei 3/4 der Strecke des horizontalen Verlaufs im Schieberegler für den Farbbereich platziert.
Code Block: Geben Sie Werte (zwischen 0 und 1) zum Versetzen der Farben ein.
Der Display.ByGeometry-Block ermöglicht die farbige Darstellung von Geometrie im Ansichtsfenster. Dies ist hilfreich zur Unterscheidung verschiedenartiger Geometrie, zur Verdeutlichung eines parametrischen Konzepts oder zum Definieren einer Analyselegende für die Simulation. Die Eingaben sind einfach: geometry und color. Um einen Farbverlauf wie in der Abbildung oben gezeigt zu erstellen, wird die color-Eingabe mit dem Color Range-Block verbunden.
Der Display.BySurfaceColors-Block ermöglicht die Zuordnung von Daten auf einer Oberfläche mithilfe von Farben. Mithilfe dieser Funktion können Sie durch diskrete Auswertung gewonnene Daten, etwa zu Sonneneinstrahlung, Energie und Entfernung, überzeugend veranschaulichen. Die Anwendung von Farben auf eine Oberfläche in Dynamo ist der Anwendung von Texturen auf Materialien in anderen CAD-Umgebungen ähnlich. Die folgende kurze Übung demonstriert die Verwendung dieses Werkzeugs.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung soll Farbe zusammen mit Geometrie parametrisch gesteuert werden. Die Geometrie ist eine einfache, wie unten gezeigt in einem Code Block definierte Schraubenform. Dies ist ein schnelles und einfaches Verfahren zum Erstellen parametrischer Funktionen. Da das Thema dieses Abschnitts nicht Geometrie, sondern Farbe ist, wird die Helix auf effiziente Weise mithilfe des Codeblocks erstellt, ohne dass zu viel Platz im Ansichtsbereich beansprucht wird. Codeblöcke werden in den weiteren Kapiteln dieses Handbuchs bei der Behandlung komplexerer Themen häufiger verwendet.
Code Block: Definieren Sie die beiden Codeblöcke mit den oben gezeigten Formeln. Dies ist eine schnelle parametrische Methode zum Erstellen einer Helix.
Point.ByCoordinates: Verbinden Sie die drei Ausgaben des Codeblocks mit den Koordinaten dieses Blocks.
Daraufhin wird ein Array aus Punkten angezeigt, das eine Helixform bildet. Im nächsten Schritt erstellen Sie zur Visualisierung der Helix eine Kurve durch diese Punkte.
PolyCurve.ByPoints: Verbinden Sie die Point.ByCoordinates-Ausgabe mit der points-Eingabe für den Block. Sie erhalten eine schraubenförmige Kurve.
Curve.PointAtParameter: Verbinden Sie die PolyCurve.ByPoints-Ausgabe mit der curve-Eingabe. Mithilfe dieses Schritts erstellen Sie einen geometrischen Attraktorpunkt, der entlang der Kurve verschoben werden kann. Da die Kurve einen Punkt an einer Parameterposition auswertet, müssen Sie einen param-Wert zwischen 0 und 1 eingeben.
Number Slider: Nachdem Sie diesen Block im Ansichtsbereich hinzugefügt haben, ändern Sie seinen min-Wert in 0.0, den max-Wert in 1.0 und den step-Wert in .01. Verbinden Sie die Ausgabe des Schiebereglers mit der param-Eingabe für Curve.PointAtParameter. Daraufhin wird auf der Helix ein Punkt angezeigt, dessen Position durch die Prozentangabe im Schieberegler definiert wird (0 am Startpunkt, 1 am Endpunkt).
Nachdem Sie den Referenzpunkt erstellt haben, vergleichen Sie die Abstände vom Referenzpunkt zu den Originalpunkten, durch die die Helix definiert ist. Der Wert für diesen Abstand bestimmt sowohl die Geometrie als auch die Farbe.
Geometry.DistanceTo: Verbinden Sie die Ausgabe von Curve.PointAtParameter mit der other-Eingabe. Verbinden Sie Point.ByCoordinates mit der geometry-Eingabe.
Watch: Die Ausgabe zeigt als Ergebnis eine Liste der Abstände von jedem der Punkte auf der Helix zum Referenzpunkt.
Im nächsten Schritt soll die Liste der Abstände zwischen den Helixpunkten und dem Referenzpunkt zur Steuerung von Parametern genutzt werden. Mithilfe dieser Werte werden die Radien einer Reihe von Kugeln entlang der Kurve definiert. Damit die Kugeln die richtige Größe annehmen, müssen Sie die Werte der Abstände mithilfe von remap neu zuordnen.
Math.RemapRange: Verbinden Sie die Ausgabe von Geometry.DistanceTo mit der numbers-Eingabe.
Code Block: Verbinden Sie einen Codeblock mit dem Wert 0.01 mit der newMin-Eingabe und einen zweiten Codeblock mit dem Wert 1 mit der newMax-Eingabe.
Watch: Verbinden Sie die Ausgabe von Math.RemapRange mit einem solchen Block und die Ausgabe von Geometry.DistanceTo mit einem zweiten. Vergleichen Sie die Ergebnisse.
Mit diesem Schritt haben Sie die Liste der Abstände auf einen kleineren Bereich reduziert. Sie können die Werte für newMin und newMax wie gewünscht bearbeiten. Die Werte werden neu zugeordnet, wobei ihre proportionale Verteilung im Bereich erhalten bleibt.
Sphere.ByCenterPointRadius: Verbinden Sie die Ausgabe von Math.RemapRange mit der radius-Eingabe und die ursprüngliche Ausgabe von Point.ByCoordinates mit der centerPoint-Eingabe.
Ändern Sie den Wert im Schieberegler und beobachten Sie, wie die Größe der Kugeln aktualisiert wird. Damit haben Sie eine parametrische Schablone erstellt.
Die Größe der Kugeln zeigt das parametrische Array, das durch den Referenzpunkt entlang der Kurve definiert wird. Als Nächstes soll die Farbe der Kugeln nach demselben Prinzip wie ihr Radius bestimmt werden.
Color Range: Fügen Sie diesen Block im Ansichtsbereich hinzu. Wenn Sie den Mauszeiger auf die value-Eingabe setzen, fällt auf, dass die angeforderten Zahlenwerte zwischen 0 und 1 liegen. Sie müssen die Zahlen aus der Geometry.DistanceTo-Ausgabe neu zuordnen, damit sie mit diesem Bereich kompatibel sind.
Sphere.ByCenterPointRadius: Deaktivieren Sie vorübergehend die Vorschau für diesen Block (Rechtsklick > Vorschau).
Math.RemapRange: Dieser Vorgang sollte Ihnen bekannt vorkommen. Verbinden Sie die Ausgabe von Geometry.DistanceTo mit der numbers-Eingabe.
Code Block: Erstellen Sie ähnlich wie in einem der vorigen Schritte den Wert 0 für die newMin-Eingabe und den Wert 1 für die newMax-Eingabe. In diesem Fall können Sie zwei Ausgaben aus demselben Codeblock erstellen.
Color Range: Verbinden Sie die Math.RemapRange-Ausgabe mit der value-Eingabe.
Color.ByARGB: Mithilfe dieses Blocks erstellen Sie zwei Farben. Dieser Prozess wirkt eventuell etwas umständlich, unterscheidet sich jedoch nicht von den RGB-Farben in anderen Programmen. Er wird hier lediglich mithilfe visueller Programmierung durchgeführt.
Code Block: Erstellen Sie die beiden Werte 0 und 255. Verbinden Sie die beiden Ausgaben mit den Eingaben der beiden Color.ByARGB-Blöcke wie in der Abbildung oben gezeigt (oder definieren Sie ganz nach Wunsch Ihre eigenen Farben).
Color Range: Für die colors-Eingabe ist eine Liste von Farben erforderlich. Diese Liste müssen Sie aus den beiden im vorigen Schritt erstellten Farben erstellen.
List.Create: Führen Sie die beiden Farben zu einer Liste zusammen. Verbinden Sie die Ausgabe mit der colors-Eingabe von Color Range.
Display.ByGeometryColor: Verbinden Sie Sphere.ByCenterPointRadius mit der geometry-Eingabe und Color Range mit der color-Eingabe. Damit erhalten Sie einen fließenden Farbübergang über die Länge der Kurve.
Wenn Sie den Wert im Number Slider aus einem früheren Schritt in der Definition ändern, werden die Farben und Größen aktualisiert. Zwischen den Farben und den Radien besteht in diesem Fall ein direkter Zusammenhang: Damit haben Sie eine visuelle Verknüpfung zweier Parameter erstellt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Als Erstes müssen Sie eine Oberfläche erstellen (oder referenzieren), die als Eingabe für den Display.BySurfaceColors-Block verwendet werden soll. In diesem Beispiel wird dies durch Erhebung zwischen einer Sinus- und einer Kosinuskurve erreicht.
Die oben gezeigte Gruppe von Blöcken erstellt Punkte entlang der z-Achse und verschiebt sie anschließend unter Verwendung von Sinus- und Kosinusfunktionen. Aus den beiden Punktlisten werden anschließend Nurbs-Kurven erstellt.
Surface.ByLoft: Dieser Block erstellt eine interpolierte Oberfläche zwischen den Nurbs-Kurven in der Kurvenliste.
File Path: Wählen Sie die Bilddatei, aus der Samples für die in den folgenden Schritten zu verwendenden Pixeldaten entnommen werden sollen.
Konvertieren Sie mithilfe von File.FromPath den Dateipfad in eine Datei und übergeben Sie diese an Image.ReadFromFile, sodass ein Bild für das Sampling ausgegeben wird.
Image.Pixels: Geben Sie ein Bild ein und legen Sie die Sample-Werte für die x- und y-Richtung des Bilds fest.
Schieberegler: Verwenden Sie diese zum Angeben der Sample-Werte für Image.Pixels.
Display.BySurfaceColors: Dieser Block ordnet das Array der Farbwerte den Positionen auf der Oberfläche in x- und y-Richtung zu.
Detailansicht: Vorschau der ausgegebenen Oberfläche mit der Auflösung 400 x 300 Samples
Im vorigen Kapitel wurde definiert, was unter einer Liste zu verstehen ist. Thema des folgenden Kapitels sind die Vorgänge, die für Listen durchgeführt werden können. Eine Liste lässt sich mit einem Stapel Spielkarten vergleichen. Der Stapel ist die Liste und jede Spielkarte steht für ein Element.
Foto von Christian Gidlöf.
Welche Abfragen sind in der Liste möglich? Dies ermöglicht den Zugriff auf vorhandene Eigenschaften.
Anzahl der Karten im Stapel? 52.
Anzahl der Farben? 4.
Material? Papier.
Länge? 3.5" bzw. 89 mm.
Breite? 2.5" bzw. 64 mm.
Welche Aktionen können für die Liste durchgeführt werden? Diese bewirken Änderungen in der Liste entsprechend der angegebenen Operation.
Sie können den Stapel neu mischen.
Sie können den Stapel nach Wert sortieren.
Sie können den Stapel nach Farben sortieren.
Sie können den Stapel teilen.
Sie können den Stapel unterteilen, indem Sie die Karten an verschiedene Spieler ausgeben.
Sie können eine bestimmte Karte im Stapel auswählen.
In Dynamo sind Blöcke vorhanden, die den oben genannten Vorgängen entsprechen und die Arbeit mit Listen von allgemeinen Daten ermöglichen. Die Lektionen weiter unten demonstrieren einige der grundlegenden Operationen, die für Listen durchgeführt werden können.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Die folgende Abbildung zeigt das Basisdiagramm, in dem Linien zwischen zwei Kreisen gezeichnet werden, um einfache Listenoperationen darzustellen. Wir werden die Verwaltung von Daten in einer Liste genauer betrachten und die visuellen Ergebnisse anhand der unten aufgeführten Aktionen veranschaulichen.
Beginnen Sie mit einem Code Block mit dem Wert
500;
.Verbinden Sie ihn mit der x-Eingabe eines Point.ByCoordinates-Blocks.
Verbinden Sie den Block aus dem vorigen Schritt mit der origin-Eingabe eines Plane.ByOriginNormal-Blocks.
Verbinden Sie in einem Circle.ByPlaneRadius-Block den Block aus dem vorigen Schritt mit dem plane-Eingang.
Legen Sie mithilfe eines Code Block-Blocks den Wert
50;
als Radius fest. Dadurch erstellen Sie den ersten Kreis.Verschieben Sie mithilfe eines Geometry.Translate-Blocks den Kreis um 100 Einheiten nach oben in z-Richtung.
Definieren Sie mithilfe eines Code Block-Blocks einen Bereich von 10 Zahlen zwischen 0 und 1, wobei Sie die folgende Zeile verwenden:
0..1..#10;
Verbinden Sie den Codeblock aus dem vorigen Schritt mit der param-Eingabe zweier Curve.PointAtParameter-Blöcke. Verbinden Sie Circle.ByPlaneRadius mit der curve-Eingabe des oberen Blocks und Geometry.Translate mit der curve-Eingabe des Blocks darunter.
Verbinden Sie in einem Line.ByStartPointEndPoint-Block die beiden Curve.PointAtParameter-Blöcke.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Der Block List.Count ist einfach: Er zählt die in einer Liste enthaltenen Werte und gibt ihre Anzahl zurück. Bei der Arbeit mit Listen von Listen gestaltet sich die Verwendung dieses Blocks differenzierter. Dies wird in weiter unten folgenden Abschnitten gezeigt.
Der List.Count****-Block gibt die Anzahl der Linien aus dem Line.ByStartPointEndPoint-Block zurück. In diesem Fall beträgt dieser Wert 10. Dies stimmt mit der Anzahl der Punkte überein, die mithilfe des ursprünglichen Code Block-Blocks erstellt wurden.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
List.GetItemAtIndex ist ein grundlegendes Verfahren zum Abrufen von Elementen in der Liste.
Klicken Sie zuerst mit der rechten Maustaste auf den Line.ByStartPointEndPoint-Block, um dessen Vorschau zu deaktivieren.
Mithilfe von List.GetItemAtIndex wird der Index "0" bzw. das erste Element in der Liste der Linien ausgewählt.
Ändern Sie den Schieberegler auf einen Wert zwischen 0 und 9, um mithilfe von List.GetItemAtIndex ein anderes Element auszuwählen.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
List.Reverse kehrt die Reihenfolge aller Elemente in der Liste um.
Erstellen Sie für eine deutlichere Darstellung der Linienliste in umgekehrter Reihenfolge weitere Linien, indem Sie den Code Block in
0..1..#50;
ändern.Duplizieren Sie den Line.ByStartPointEndPoint-Block, und fügen Sie einen List.Reverse-Block zwischen Curve.PointAtParameter und dem zweiten Line.ByStartPointEndPoint-Block ein.
Verwenden Sie Watch3D-Blöcke, um eine Vorschau von zwei verschiedenen Ergebnissen anzuzeigen. Der erste zeigt das Ergebnis ohne umgekehrte Liste. Die Linien verlaufen vertikal und verbinden benachbarte Punkte. Die Umkehrung einer der Listen bewirkt jedoch, dass alle Punkte in entgegengesetzter Reihenfolge mit Punkten in der anderen Liste verbunden werden.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
List.ShiftIndices ist ein geeignetes Werkzeug zum Erstellen verdrehter oder schraubenförmiger Muster oder für ähnliche Datenverarbeitungen. Dieser Block verschiebt die Elemente in einer Liste um die angegebene Anzahl von Indexpositionen.
Fügen Sie auf dieselbe Weise wie beim Umkehren der Liste einen List.ShiftIndices-Block zwischen Curve.PointAtParameter und Line.ByStartPointEndPoint ein.
Verwenden Sie einen Codeblock, dem Sie den Wert "1" zuweisen, zum Verschieben der Liste um eine Indexposition.
Sie erhalten keine extreme Veränderung, aber sämtliche Linien im unteren Watch3D-Block wurden bei der Verbindung mit der anderen Punktgruppe um eine Indexposition versetzt.
Wenn Sie im Codeblock einen größeren Wert, z. B. "30" festlegen, ist ein deutlicher Unterschied in den diagonalen Linien zu erkennen. Die Verschiebung hat in diesem Fall dieselbe Wirkung wie die Irisblende einer Kamera und bewirkt eine Verdrehung der ursprünglichen Zylinderform.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
List.FilterByBooleanMask entfernt bestimmte Elemente anhand einer Liste boolescher Werte bzw. der Werte "true" oder "false".
Um eine Liste mit true- und false-Werten zu erstellen, sind einige weitere Schritte erforderlich.
Definieren Sie mithilfe eines Codeblocks einen Ausdruck mit der folgenden Syntax:
0..List.Count(list);
. Verbinden Sie den Curve.PointAtParameter-Block mit der list-Eingabe. Diese Einrichtung wird im Kapitel zu Codeblöcken genauer behandelt. In diesem Fall erhalten Sie mit dieser Codezeile eine Liste mit sämtlichen Indizes aus dem Curve.PointAtParameter-Block.Fügen Sie einen %-Block** (Modulo)** ein und verbinden Sie die Ausgabe des Codeblocks mit der x-Eingabe und den Wert 4 mit der y-Eingabe. Dadurch erhalten Sie den Rest bei der Division der Indizes in der Liste durch 4. Die Modulo-Funktion ist sehr hilfreich beim Erstellen von Mustern. Alle Werte werden als mögliche Reste für 4 ausgegeben: 0, 1, 2, 3.
Aus dem %-Block (Modulo) ergibt sich, dass Indizes mit dem Wert 0 durch 4 teilbar sind (0, 4, 8... usw.). Mithilfe eines ==-Blocks kann die Teilbarkeit durch Vergleich mit dem Wert 0 geprüft werden.
Der Watch-Block zeigt genau dieses Ergebnis, d. h. das folgende true/false-Muster: true,false,false,false....
Verbinden Sie die Ausgabe mit diesem true/false-Muster mit der mask-Eingabe zweier List.FilterByBooleanMask-Blöcke.
Verbinden Sie jeweils den Curve.PointAtParameter-Block mit der list-Eingaben des List.FilterByBooleanMask-Blocks.
Die Ausgaben von Filter.ByBooleanMask lauten "in" und "out". "In" steht für Werte mit dem Maskenwert "true", "out" für Werte mit dem Wert "false". Indem Sie die "in"-Ausgaben mit den startPoint- und endPoint-Eingaben eines Line.ByStartPointEndPoint-Blocks verbinden, erhalten Sie eine gefilterte Liste von Linien.
Im Watch3D-Block ist zu erkennen, dass weniger Linien als Punkte vorhanden sind. Durch Filtern ausschließlich der true-Werte wurden lediglich 25 % der Punkte ausgewählt.
Logik, genauer Bedingungslogik ermöglicht die Angabe einer Aktion oder einer Gruppe von Aktionen unter Verwendung einer Prüfung. Die Auswertung der Prüfung ergibt einen booleschen Wert für True
oder False
, der zur Steuerung des Programmablaufs verwendet werden kann.
Numerische Variablen können für eine Vielzahl unterschiedlicher Zahlen stehen. Boolesche Variablen hingegen können nur zwei Werte annehmen, die als True oder False, Ja oder Nein, 1 oder 0 wiedergegeben werden. Booleschen Operationen werden wegen ihrer begrenzten Möglichkeiten nur selten zum Durchführen von Berechnungen verwendet.
Die "If"-Anweisung ist ein wichtiges Konzept in der Programmierung: "Wenn dies zutrifft (True), dann geschieht das, andernfalls geschieht etwas anderes. Die aus der Anweisung resultierende Aktion wird durch einen booleschen Wert gesteuert. In Dynamo stehen mehrere Möglichkeiten zum Definieren von If-Anweisungen zur Verfügung:
Symbol | Name (Syntax) | Eingaben | Ausgaben |
---|---|---|---|
Die folgenden kurzen Beispiele zeigen die Funktionsweise dieser drei Blöcke in der If-Bedingungsanweisung.
In dieser Abbildung wurde für Boolean die Option true eingestellt, d. h., das Ergebnis ist die Zeichenfolge: "this is the result if true". Die drei möglichen Blöcke, mit deren Hilfe die If-Anweisung erstellt werden kann, funktionieren hier auf dieselbe Weise.
Auch in diesem Fall funktionieren die Blöcke auf dieselbe Weise. Wenn Sie den Boolean-Wert in False ändern, wird als Ergebnis die Zahl Pi ausgegeben, wie in der ursprünglichen If-Anweisung festgelegt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In diesem Beispiel teilen Sie eine Liste von Zahlen in eine Liste mit geraden und eine Liste ungeraden Zahlen auf.
a. Range: Definieren Sie im Ansichtsbereich einen Zahlenbereich.
b. Number: Fügen Sie im Ansichtsbereich drei Number-Blöcke ein. Legen Sie in diesen Blöcken die folgenden Werte fest: 0.0 für start, 10.0 für end und 1.0 für step.
c. Ausgabe: Die Ausgabe zeigt eine Liste mit 11 Zahlen von 0-10.
d. Modulo (%): Verbinden Sie Number Range mit x und 2.0 mit y. Mit dieser Funktion wird für jede Zahl aus der Liste der Rest bei Division durch 2 berechnet. Die Ausgabe für diese Liste ist eine Liste, die abwechselnd die Werte 0 und 1 enthält.
e. Gleichheitsprüfung (==): Fügen Sie im Ansichtsbereich einen Block für die Gleichheitsprüfung hinzu. Verbinden Sie die Ausgabe des Modulo-Blocks mit der x-Eingabe und 0.0 mit der y-Eingabe.
f. Watch: Die Gleichheitsprüfung gibt eine Liste aus, die abwechselnd die Werte true und false enthält. Mithilfe dieser Werte werden die Einträge aus der Zahlenliste eingeordnet. Dabei steht 0 (bzw. true) für gerade und (1 bzw. false) für ungerade Zahlen.
g. List.FilterByBoolMask: Dieser Block filtert die Werte anhand der eingegebenen Booleschen Operation in zwei Listen. Verbinden Sie den ursprünglichen Number Range mit der list-Eingabe und die Ausgabe von Equality Test mit der mask-Eingabe. Die in-Ausgabe enthält die true-Werte, die out-Ausgabe die false-Werte.
h. Watch: Als Ergebnis erhalten Sie eine Liste mit geraden und eine Liste mit ungeraden Zahlen. Damit haben Sie mithilfe logischer Operatoren Listen anhand eines Musters aufgeteilt.
In diesem Schritt wenden Sie die in der ersten Übung erstellte Logik auf einen Modellierungsvorgang an.
2. Beginnen Sie mit den Blöcken aus der letzten Übung. Die einzigen Ausnahmen (zusätzlich zum Ändern des Formats) sind:
a. Verwenden Sie einen Sequence-Block mit diesen Eingabewerten.
b. Die in-Listeneingabe für List.FilterByBoolMask wurde entfernt. Diese Blöcke werden momentan nicht benötigt, kommen aber weiter unten in dieser Übung zum Einsatz.
3. Erstellen Sie zunächst eine separate Gruppe von Diagrammen, wie in der Abbildung oben gezeigt. Diese Gruppe von Blöcken stellt eine parametrische Gleichung zum Definieren einer Sinuskurve dar. Einige Hinweise:
a. Der erste Number Slider-Block repräsentiert die Frequenz der Welle. Er sollte einen Mindestwert von 1, einen Höchstwert von 4 und eine Schrittweite von 0.01 haben.
b. Der zweite Number Slider-Block repräsentiert die Amplitude der Welle. Er sollte einen Mindestwert von 0, einen Höchstwert von 1 und eine Schrittweite von 0.01 haben.
c. PolyCurve.ByPoints: Indem Sie das oben gezeigte Blockdiagramm kopieren, erhalten im Ansichtsfenster der Dynamo-Vorschau eine Sinuskurve.
Für die Eingaben gilt hier folgende Regel: Verwenden Sie Zahlenblöcke für statische und Schieberegler für veränderliche Eigenschaften. Der anfangs definierte ursprüngliche Zahlenbereich soll erhalten bleiben. Für die Sinuskurve, die hier erstellt werden soll, wird jedoch mehr Flexibilität benötigt. Mithilfe dieser Schieberegler können Sie die Frequenz und Amplitude der Kurve ändern.
4. Die Schritte dieser Definition werden hier nicht nacheinander beschrieben. Hier wird zunächst das Endergebnis gezeigt, um eine Vorstellung der fertigen Geometrie zu vermitteln. Die ersten beiden Schritte wurden separat durchgeführt und müssen jetzt zusammengeführt werden. Die Position der reißverschlussähnlichen Bauteile soll durch die zugrunde liegende Sinuskurve gesteuert werden, wobei mithilfe der True/False-Logik abwechselnd große und kleine Quader eingefügt werden.
a. Math.RemapRange: Erstellen Sie aus der in Schritt 02 erstellten Zahlenfolge eine neue Zahlenfolge, indem Sie den Bereich neu zuordnen. In Schritt 01 wurden Zahlen von 0 – 100 festgelegt. Diese Zahlen liegen zwischen 0 und 1, wie mithilfe der Eingaben newMin und newMax festgelegt.
5. Erstellen Sie einen Curve.PointAtParameter-Block, und verbinden Sie dann die Math.RemapRange-Ausgabe aus Schritt 04 als param-Eingabe.
Mithilfe dieses Schritts erstellen Sie Punkte entlang der Kurve. Die Zahlen mussten dem Bereich 0 bis 1 neu zugeordnet werden, da als Eingabe für param Werte in diesem Bereich verlangt werden. Der Wert 0 steht für den Startpunkt, der Wert 1 für die Endpunkte. Die Auswertung aller dazwischen liegenden Zahlen ergibt Werte im Bereich [0,1].
6. Verbinden Sie die Ausgabe von Curve.PointAtParameter mit List.FilterByBoolMask, um die Liste der ungeraden und geraden Indizes zu trennen.
a. List.FilterByBoolMask: Verbinden Sie Curve.PointAtParameter aus dem vorigen Schritt mit der list-Eingabe.
b. Watch: Die Watch-Blöcke für in und out zeigen, dass zwei Listen für gerade bzw. ungerade Indizes erstellt wurden. Diese Punkte sind auf dieselbe Weise entlang der Kurve angeordnet, wie im folgenden Schritt gezeigt.
7. Als Nächstes verwenden Sie das Ausgabeergebnis von List.FilterByBoolMask in Schritt 05, um Geometrien mit Größen entsprechend ihrer Indizes zu generieren.
Cuboid.ByLengths: Stellen Sie die in der Abbildung oben gezeigten Verbindungen wieder her, um eine reißverschlussähnliche Struktur entlang der Kurve zu erhalten. Sie erstellen hier einfache Quader, deren Größe jeweils durch ihren auf der Kurve liegenden Mittelpunkt definiert wird. Die Logik der Aufteilung in gerade und ungerade Werte wird damit im Modell deutlich.
a. Liste der Quader mit geraden Indizes.
b. Liste der Quader mit ungeraden Indizes.
Geschafft! Sie haben soeben einen Prozess zum Definieren der Geometriebemaßungen entsprechend der in dieser Übung dargestellten logischen Operation programmiert.
In den vorigen Abschnitten wurde gezeigt, wie das MapToSurface-Paket sich aus benutzerdefinierten Blöcken und Beispieldateien zusammensetzt. Aber wie veröffentlichen Sie ein Paket, das lokal entwickelt wurde? Diese Fallstudie zeigt, wie Sie ein Paket aus einer Gruppe von Dateien in einem lokalen Ordner publizieren können.
Es gibt mehrere Möglichkeiten zum Publizieren von Paketen. Im Folgenden wird der von uns empfohlene Prozess beschrieben: Sie publizieren lokal, entwickeln lokal und publizieren schließlich online. Sie beginnen mit einem Ordner, der sämtliche Dateien im Paket enthält.
Bevor Sie mit der Veröffentlichung des MapToSurface-Pakets beginnen, deinstallieren Sie das Paket aus der vorigen Lektion, falls Sie es installiert haben. Dadurch vermeiden Sie, mit identischen Paketen zu arbeiten.
Beginnen Sie, indem Sie zu Pakete > Package Manager > Registerkarte Installierte Pakete navigieren. Klicken Sie neben MapToSurface auf das Menü mit den drei Punkten und dann auf Löschen.
Starten Sie dann Dynamo erneut. Wenn Sie beim erneuten Öffnen das Fenster Pakete verwalten überprüfen, darf MapToSurface dort nicht mehr vorhanden sein. Jetzt können Sie den Vorgang von Anfang an durchführen.
Sie können benutzerdefinierte Blöcke und Pakete aus Dynamo Sandbox in Version 2.17 und höher publizieren, sofern diese keine Abhängigkeiten zur Host-API aufweisen. In älteren Versionen ist das Publizieren von benutzerdefinierten Blöcken und Paketen nur in Dynamo for Revit und Dynamo for Civil 3D aktiviert.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Sie übermitteln Ihr Paket zum ersten Mal und alle Beispieldateien und benutzerdefinierten Blöcke befinden sich im selben Ordner. Nachdem dieser Ordner vorbereitet ist, können Sie jetzt auf Dynamo Package Manager hochladen.
Der Ordner enthält fünf benutzerdefinierte Blöcke (.dyf).
Er enthält außerdem fünf Beispieldateien (.dyn) und eine importierte Vektordatei (.svg). Diese Dateien dienen als einführende Übungen, die dem Benutzer die Arbeit mit den benutzerdefinierten Blöcken erläutern sollen.
Klicken Sie in Dynamo zunächst auf Pakete > Package Manager > Registerkarte Neues Paket publizieren.
Füllen Sie auf der Registerkarte Paket publizieren die entsprechenden Felder auf der linken Seite des Fensters aus.
Als Nächstes fügen wir Paketdateien hinzu. Sie können Dateien einzeln oder ganze Ordner mit Dateien hinzufügen, indem Sie Verzeichnis hinzufügen (1) auswählen. Um Dateien hinzuzufügen, die keine DYF-Dateien sind, ändern Sie den Dateityp im Browser-Fenster in Alle Dateien(.). Beachten Sie, dass sämtliche Dateien ohne Unterscheidung zwischen benutzerdefinierten Blöcken (.dyf) und Beispieldateien (.dyn) hinzugefügt werden. Dynamo ordnet diese Objekte beim Publizieren des Pakets in Kategorien ein.
Sobald Sie den Ordner MapToSurface ausgewählt haben, zeigt Package Manager den Inhalt des Ordners an. Wenn Sie Ihr eigenes Paket mit einer komplexen Ordnerstruktur hochladen und nicht möchten, dass Dynamo Änderungen an der Ordnerstruktur vornimmt, können Sie die Option Ordnerstruktur beibehalten aktivieren. Diese Option ist für erfahrene Benutzer gedacht. Wenn Ihr Paket nicht absichtlich auf eine bestimmte Weise konfiguriert ist, sollten Sie diese Option deaktiviert lassen und Dynamo erlauben, die Dateien bei Bedarf zu organisieren. Klicken Sie auf Weiter, um fortzufahren.
Hier können Sie eine Vorschau der Organisation Ihrer Paketdateien in Dynamo vor dem Publizieren anzeigen. Klicken Sie zum Fortfahren auf Fertig stellen.
Publizieren Sie das Paket, indem Sie auf Lokal publizieren (1) klicken. Achten Sie darauf, auf Lokal publizieren und nicht auf Online publizieren zu klicken, um zu vermeiden, dass Duplikate im Package Manager erstellt werden.
Nach dem Publizieren werden die benutzerdefinierten Blöcke in der Gruppe DynamoPrimer oder in Ihrer Dynamo-Bibliothek angezeigt.
Sehen wir jetzt im Stammverzeichnis nach, wie Dynamo das eben erstellte Paket formatiert hat. Navigieren Sie dazu zur Registerkarte Installierte Pakete, klicken Sie neben MapToSurface auf das Menü mit den drei Punkten, und wählen Sie Stammverzeichnis anzeigen aus.
Das Stammverzeichnis befindet sich am lokalen Speicherort des Pakets (da Sie es lokal veröffentlicht haben). Dynamo greift derzeit zum Lesen benutzerdefinierter Blöcke auf diesen Ordner zu. Aus diesem Grund müssen Sie das Verzeichnis lokal an einem dauerhaften Speicherort ablegen (d. h. nicht auf Ihrem Desktop). Der Ordner mit dem Dynamo-Paket ist wie folgt gegliedert.
Im Ordner bin befinden sich DLL-Dateien, die mit C#- oder Zero Touch-Bibliotheken erstellt wurden. Dieses Paket enthält keine solchen Dateien; dieser Ordner ist also in diesem Beispiel leer.
Im Ordner dyf befinden sich die benutzerdefinierten Blöcke. Wenn Sie ihn öffnen, werden alle benutzerdefinierten Blöcke (DYF-Dateien) für das Paket angezeigt.
Im Ordner extra befinden sich alle zusätzlichen Dateien. Dies sind wahrscheinlich Dynamo-Dateien (.dyn) oder sonstige erforderliche Zusatzdateien (.svg, .xls, .jpeg, .sat usw.).
Die Datei pkg ist eine einfache Textdatei, die die Einstellungen des Pakets definiert. Diese Datei wird in Dynamo automatisch erstellt, Sie können Sie jedoch bearbeiten, wenn Sie detaillierte Einstellungen benötigen.
Anmerkung: Führen Sie diesen Schritt bitte nicht aus, es sei denn, Sie möchten tatsächlich ein eigenes Paket veröffentlichen.
Wenn Sie zum Publizieren bereit sind, wählen Sie im Fenster Pakete > Package Manager > Installierte Pakete die Schaltfläche rechts neben dem Paket, das Sie publizieren möchten, und dann Publizieren aus.
Um ein bereits veröffentlichtes Paket zu aktualisieren, wählen Sie Version veröffentlichen. Dynamo aktualisiert dann Ihr Paket online mit den neuen Dateien im Stammverzeichnis des Pakets. Dieser einfache Schritt genügt.
Wenn Sie die Dateien im Stammverzeichnis des publizierten Pakets aktualisieren, können Sie über Version veröffentlichen... auf der Registerkarte Meine Pakete auch eine neue Version des Pakets publizieren. Auf diese Weise können Sie nahtlos erforderliche Aktualisierungen Ihrer Inhalte vornehmen und sie für die Community bereitstellen. Die Funktion Version veröffentlichen kann nur verwendet werden, wenn Sie der Verwalter des Pakets sind.
Dynamo 2.0 führt das Konzept der Trennung des Datentyps Wörterbuch und des Datentyps Liste ein. Diese Neuerung bewirkt einige wichtige Änderungen hinsichtlich der Art und Weise, wie Sie Daten erstellen und in Ihren Arbeitsabläufen verwenden. Vor Version 2.0 waren Wörterbücher und Listen ein kombinierter Datentyp. Kurz gesagt: Listen waren eigentlich Wörterbücher mit ganzzahligen Schlüsseln.
Bei einem Wörterbuch handelt es sich um einen Datentyp, der aus einer Sammlung von Schlüssel-Wert-Paaren besteht. Jeder Schlüssel in einer Sammlung ist eindeutig. In einem Wörterbuch gibt es keine Reihenfolge. Im Prinzip "schlagen Sie Dinge nach", indem Sie einen Schlüssel anstelle eines Indexwerts in einer Liste verwenden. In Dynamo 2.0 können Schlüssel nur Zeichenfolgen sein.
Bei einer Liste handelt es sich um einen Datentyp, der aus einer Sammlung von sortierten Werten besteht. In Dynamo verwenden Listen Ganzzahlen als Indexwerte.
Durch die Trennung von Wörterbüchern und Listen werden Wörterbücher zu wichtigen Datentypen, mit denen Sie schnell und einfach Werte speichern und nachschlagen können, ohne die Indexwerte kennen oder eine exakte Listenstruktur durch Ihre Arbeitsabläufe beibehalten zu müssen. Während der Benutzertests sahen wir eine erhebliche Reduzierung der Diagrammgröße, wenn Wörterbücher anstatt mehrerer GetItemAtIndex
-Blöcke verwendet wurden.
Es wurden Änderungen an der Syntax vorgenommen. Die Initialisierung und Verwendung von Wörterbüchern und Listen in Codeblöcken funktioniert jetzt anders.
Wörterbücher verwenden die folgende Syntax: {key:value}
Listen verwenden die folgende Syntax: [value,value,value]
Es wurden neue Blöcke in der Bibliothek eingeführt, mit denen Sie einfacher Wörterbücher erstellen, ändern und abfragen können.
Listen, die in v1.x-Codeblöcken erstellt wurden, werden automatisch beim Laden des Skripts zur neuen Listensyntax migriert, die eckige [ ]
anstelle von geschweiften Klammern { }
verwendet. \
In der Computerwissenschaft handelt es sich bei Wörterbüchern – wie bei Listen – um Sammlungen von Objekten. Während Listen jedoch in einer bestimmten Reihenfolge erstellt werden, sind die Sammlungen in Wörterbüchern nicht sortiert. Es sind keine Nummernsequenzen (Indizes) erforderlich. Stattdessen werden Schlüssel verwendet.
In der folgenden Abbildung sehen Sie eine mögliche Verwendung eines Wörterbuchs. Wörterbücher werden häufig genutzt, um zwei Teile von Daten zu verbinden, die vielleicht keine direkte Beziehung zueinander aufweisen. In unserem Fall verbinden wir die spanische Version eines Worts mit der englischen Version, so dass wir das Wort später nachschlagen können.
Erstellt ein Wörterbuch, um die beiden Daten miteinander zu verknüpfen.
Ruft den Wert mit dem angegebenen Schlüssel ab.
Dynamo 2.0 stellt eine Reihe von Wörterbuch-Blöcken für die Verwendung bereit. Dies umfasst die Blöcke für Erstellen, Aktion und Abfragen.
Dictionary.ByKeysValues
erstellt ein Wörterbuch mit den bereitgestellten Werten und Schlüsseln. (Die Anzahl der Einträge entspricht der Länge der kürzesten Liste.)
Dictionary.Components
erstellt die Komponenten des Eingabe-Wörterbuchs. (Dieser Vorgang ist die Umkehrung der Block-Erstellung.)
Dictionary.RemoveKeys
erzeugt ein neues Wörterbuch-Objekt und entfernt die Eingabe-Schlüssel.
Dictionary.SetValueAtKeys
erzeugt ein neues Wörterbuch anhand der eingegebenen Schlüssel und Werte und ersetzt den aktuellen Wert in den entsprechenden Schlüsseln.
Dictionary.ValueAtKey
gibt den Wert am Eingabeschlüssel zurück.
Dictionary.Count
gibt an, wie viele Schlüssel-Wert-Paare sich im Wörterbuch befinden.
Dictionary.Keys
gibt zurück, welche Schlüssel derzeit im Wörterbuch gespeichert sind.
Dictionary.Values
gibt zurück, welche Werte derzeit im Wörterbuch gespeichert sind.
Die Möglichkeit, Daten allgemein mit Wörterbücher in Beziehung zu setzen, ist eine großartige Alternative zur vorherigen Verwendung von Indizen und Listen.
In der Blockbibliothek von Dynamo steht eine Vielfalt vorgegebener Funktionen zur Verfügung. Wenn Sie bestimmte Routinen häufig einsetzen oder spezielle Diagramme an die Community weitergeben möchten, bietet Ihnen Dynamo mit benutzerdefinierten Blöcken und Paketen noch weiterreichende Möglichkeiten.
Dynamo bietet zahlreiche Core-Blöcke für eine Vielfalt von Aufgaben in der visuellen Programmierung. In manchen Fällen erhalten Sie jedoch schnellere, elegantere oder leichter weiterzugebende Lösungen, indem Sie Ihre eigenen Blöcke konstruieren. Diese können in verschiedenen Projekten wiederverwendet werden, tragen dazu bei, Diagramme klarer und übersichtlicher zu gestalten, und können an den Package Manager übergeben und mit der globalen Dynamo-Community geteilt werden.
Wollten Sie jemals etwas in Revit anhand eines Datenelements nachschlagen?
Wahrscheinlich haben Sie bereits etwas wie das folgende Beispiel durchgeführt.
In der Abbildung unten sammeln wir alle Räume im Revit-Modell, rufen den Index des gewünschten Raum (nach Raumnummer) ab, und erhalten schließlich die Indexnummer des Raums.
Alle Räume im Modell sammeln.
Zu suchende Raumnummer.
Rufen Sie die Raumnummer ab und ermitteln Sie, an welchem Index sie sich befindet.
Rufen Sie den Raum am Index ab.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Lassen Sie uns das nun mit Wörterbüchern probieren. Zuerst müssen wir alle Räume in das Revit-Modell sammeln.
Wir wählen wir die Revit-Kategorie, die wir verwendenden möchten (in diesem Fall Räume).
Wir weisen Dynamo an, alle diese Elemente zu sammeln.
Die Daten, die wir verwenden, ist die Raumnummer.
Jetzt erstellen wir das Wörterbuch mit den angegebenen Schlüsseln und Elementen.
Der Block Dictionary.ByKeysValues erstellt ein Wörterbuch anhand der entsprechenden Eingaben.
Bei
Keys
muss es sich um eine Zeichenfolge handelt, abervalues
können verschiedene Objekttypen sein.
Jetzt können wir einen Raum aus dem Wörterbuch über seine Raumnummer abrufen.
String
ist der Schlüssel, den wir verwenden, um ein Objekt im Wörterbuch nachzuschlagen.Dictionary.ValueAtKey ruft das Objekt aus dem Wörterbuch ab.
Mit derselben Wörterbuch-Logik können wir auch Wörterbücher mit gruppierten Objekten erstellen. Wenn wir zum Beispiel alle Räume auf einer bestimmten Ebene nachschlagen möchten, können wir das obige Diagramm folgendermaßen verändern.
Anstatt die Zimmernummer als Schlüssel zu nutzen, können wir nun einen Parameterwert verwenden (in diesem Fall Ebene).
Jetzt können wir die Räume nach der Ebene gruppieren, auf der sie sich befinden.
Wir haben die Elemente nach Ebene gruppiert. Jetzt können wir die gemeinsam verwendeten Schlüssel (eindeutige Schlüssel) als Schlüssel für das Wörterbuch und die Listen der Räume als die Elemente verwenden.
Letztendlich können wird die Ebenen im Revit-Modell nutzen, um zu ermitteln, welche Räume sich auf dieser Ebene im Wörterbuch befinden.
Dictionary.ValueAtKey
nimmt den Ebenennamen und gibt die Raumobjekte auf dieser Ebene wieder.
Mit dem Wörterbuch stehen uns praktisch unbeschränkte Möglichkeiten zur Verfügung. Die Möglichkeit, eine Beziehung zwischen Ihren BIM-Daten in Revit und dem eigentlichen Element herzustellen, ermöglicht zahlreiche Anwendungsfälle.
Sie können der Hierarchie weitere untergeordnete Ebenen hinzufügen. Datenstrukturen können Listen von Listen mit weit mehr als zwei Dimensionen umfassen. Da Listen in Dynamo als Objekte behandelt werden, können Sie Daten mit so vielen Dimensionen erstellen, wie es möglich ist.
Als Metapher für diese Funktionen eignen sich ineinander verschachtelte russische Matrjoschka-Puppen. Jede Liste kann ein Container betrachtet werden, der mehrere Elemente enthält. Jede Liste verfügt über eigene Eigenschaften und wird als eigenständiges Objekt angesehen.
Die verschachtelten Matrjoschka-Puppen (Foto: ) sind eine Metapher für n-dimensionale Listen. Jede Ebene steht für eine Liste und jede Liste enthält Elemente. In Dynamo kann jeder Container seinerseits mehrere Container enthalten (die den Elementen der jeweiligen Liste entsprechen).
Die visuelle Veranschaulichung n-dimensionaler Listen ist schwierig. In diesem Kapitel finden Sie jedoch eine Reihe von Übungslektionen für die Arbeit mit Listen, die mehr als zwei Dimensionen enthalten.
Mapping ist der wohl komplexeste Aspekt der Datenverwaltung in Dynamo. Bei der Arbeit mit komplexen Listenhierarchien kommt ihm besondere Bedeutung zu. In den folgenden Übungslektionen wird gezeigt, wann Mapping und Kombinationen für mehrdimensionale Daten eingesetzt werden sollten.
Eine vorbereitende Einführung zu List.Map und List.Combine finden Sie im vorigen Abschnitt. In der letzten Übungslektion werden diese Blöcke für eine komplexe Datenstruktur angewendet.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Dies ist die erste von drei Übungslektionen zur Strukturierung importierter Geometrie. In den Teilen dieser Übungsreihe werden nach und nach komplexere Datenstrukturen verwendet.
Sie beginnen mit der SAT-Datei aus dem Ordner mit den Übungsdateien. Diese Datei können Sie mithilfe des File Path-Blocks abrufen.
Mit Geometry.ImportFromSAT wird die Geometrie in Form zweier Oberflächen in die Dynamo-Vorschau importiert.
In dieser Übung wird der Einfachheit halber nur eine der Oberflächen verwendet.
Wählen Sie den Index 1, um die obere Oberfläche auszuwählen. Verwenden Sie dazu den List.GetItemAtIndex-Block.
Deaktivieren Sie die Geometrievorschau für Geometry.ImportFromSAT.
Im nächsten Schritt unterteilen Sie die Oberfläche mithilfe eines Rasters aus Punkten.
1. Fügen Sie in einem Codeblock die beiden folgenden Codezeilen ein:
0..1..#10;
0..1..#5;
2. Verbinden Sie in Surface.PointAtParameter die beiden Codeblock-Werte mit u und v. Ändern Sie die Vergitterung dieses Blocks in "Kreuzprodukt ".
3. In der Ausgabe und in der Dynamo-Vorschau wird die Datenstruktur angezeigt.
Als Nächstes verwenden Sie die Punkte aus dem letzten Schritt, um zehn Kurven entlang der Oberfläche zu erstellen.
Um den Aufbau der Datenstruktur zu verdeutlichen, verbinden Sie einen NurbsCurve.ByPoints-Block mit der Ausgabe von Surface.PointAtParameter.
Sie können die Vorschau des List.GetItemAtIndex-Blocks für ein besser sichtbares Ergebnis deaktivieren.
Mit einer einfachen List.Transpose-Operation vertauschen Sie die Spalten und Zeilen einer Liste von Listen.
Indem Sie die Ausgabe des List.Transpose-Blocks mit einem NurbsCurve.ByPoints-Blocks verbinden, erhalten Sie fünf Kurven, die horizontal auf der Oberfläche verlaufen.
Sie können die Vorschau des NurbsCurve.ByPoints-Blocks im vorherigen Schritt deaktivieren, um das gleiche Ergebnis im Bild zu erzielen.
In diesem Schritt erhöhen Sie die Komplexität. Angenommen, an den Kurven aus der vorigen Übungslektion soll eine Operation durchgeführt werden. Vielleicht sollen die Kurven auf eine andere Oberfläche bezogen und eine Erhebung zwischen ihnen erstellt werden. Die hierfür erforderliche Datenstruktur erfordert mehr Aufwand, wobei jedoch dieselbe Logik zugrunde liegt.
Beginnen Sie mit demselben Schritt wie in der vorherigen Übung, indem Sie die obere der beiden Oberflächen der importierten Geometrie mithilfe des List.GetItemAtIndex-Blocks isolieren.
Versetzen Sie die Oberfläche mithilfe von Surface.Offset um den Wert 10.
Definieren Sie auf dieselbe Weise wie in der vorigen Übung einen Codeblock mit den folgenden beiden Codezeilen:
0..1..#10;
0..1..#5;
Verbinden Sie diese Ausgaben mit zwei Surface.PointAtParameter-Blöcken, jeweils mit der Vergitterung "Kreuzprodukt". Verbinden Sie einen dieser Blöcke mit der ursprünglichen und den anderen mit der versetzten Oberfläche.
Deaktivieren Sie die Vorschau dieser Oberflächen.
Verbinden Sie wie in der vorigen Übungslektion die Ausgaben mit zwei NurbsCurve.ByPoints-Blöcken. Das Ergebnis zeigt Kurven, die zwei Oberflächen entsprechen.
Mithilfe von List.Create können Sie die beiden Kurvengruppen in einer Liste von Listen kombinieren.
Die Ausgabe zeigt zwei Listen mit je zehn Elementen für die beiden Gruppen verbundener Nurbs-Kurven.
Mithilfe von Surface.ByLoft können Sie diese Datenstruktur visuell verdeutlichen. Mithilfe dieses Blocks verbinden Sie sämtliche Kurven in jeder der beiden Unterlisten durch eine Erhebung.
Deaktivieren Sie die Vorschau des Surface.ByLoft-Blocks aus dem vorherigen Schritt.
Mithilfe von List.Transpose werden die Spalten und Zeilen vertauscht. Dadurch werden zwei Listen mit je zehn Kurven in zehn Listen mit je zwei Kurven umgewandelt. Damit haben Sie für jede Nurbs-Kurve eine Beziehung zu ihrer Nachbarkurve auf der anderen Oberfläche erstellt.
Mit Surface.ByLoft erhalten Sie eine gerippte Struktur.
Als Nächstes werden wir einen alternativen Prozess vorstellen, um dieses Ergebnis zu erzielen.
Bevor wir beginnen, deaktivieren Sie die Vorschau für Surface.ByLoft aus dem vorherigen Schritt, um Verwirrung zu vermeiden.
Als Alternative zu List.Transpose können Sie List.Combine verwenden. Damit wird ein "Kombinator" für die beiden Unterlisten ausgeführt.
In diesem Fall wird List.Create als "Kombinator" verwendet, um eine Liste der Elemente innerhalb der Unterlisten zu erstellen.
Mithilfe des Surface.ByLoft-Blocks erhalten Sie dieselben Oberflächen wie im vorigen Schritt. Transpose ist in diesem Falle einfacher zu verwenden, bei komplexeren Datenstrukturen erweist sich List.Combine jedoch als zuverlässiger.
Sie können in einem der vorigen Schritte die Richtung der Kurven in der gerippten Struktur ändern, indem Sie List.Transpose vor der Verbindung zu NurbsCurve.ByPoints einfügen. Dadurch werden Spalten und Zeilen vertauscht und Sie erhalten 5 horizontale Rippen.
In diesem Abschnitt gehen Sie einen Schritt weiter. Sie arbeiten in dieser Übungslektion mit beiden importierten Oberflächen und erstellen eine komplexe Datenhierarchie. Dabei soll dieselbe Operation nach wie vor unter Verwendung derselben zugrunde liegenden Logik durchgeführt werden.
Beginnen Sie mit der Datei aus der vorherigen Übungslektion.
Verwenden Sie wie in der vorigen Übungslektion den Surface.Offset-Block, um einen Versatz mit dem Wert 10 zu erstellen.
Die Ausgabe zeigt, dass Sie mithilfe des Versatzblocks zwei Oberflächen erstellt haben.
Definieren Sie auf dieselbe Weise wie in der vorigen Übung einen Codeblock mit den folgenden beiden Codezeilen:
0..1..#20;
0..1..#20;
Verbinden Sie diese Ausgaben mit zwei Surface.PointAtParameter-Blöcken, jeweils mit der Vergitterung "Kreuzprodukt". Verbinden Sie einen dieser Blöcke mit den ursprünglichen und den anderen mit den versetzten Oberflächen.
Verbinden Sie wie in der vorigen Übungslektion die Ausgaben mit zwei NurbsCurve.ByPoints-Blöcken.
Die Ausgabe der NurbsCurve.ByPoints-Blöcke ist eine Liste aus zwei Listen mit komplexerer Struktur als bei denjenigen in der vorigen Übungslektion. Die Daten werden durch die zugrunde liegende Oberfläche kategorisiert: Damit haben Sie der Datenstruktur eine weitere Ebene hinzugefügt.
Im Surface.PointAtParameter-Block ist eine komplexere Struktur zu erkennen: Sie haben eine Liste aus Listen von Listen erstellt.
Bevor wir fortfahren, deaktivieren Sie die Vorschau der vorhandenen Oberflächen.
Führen Sie mithilfe des List.Create-Blocks die Nurbs-Kurven zu ein und derselben Datenstruktur zusammen, wobei eine Liste aus Listen von Listen entsteht.
Durch Verbinden eines Surface.ByLoft-Blocks erhalten Sie eine Version der ursprünglichen Oberflächen, die in ihrer eigenen Liste wie aus der ursprünglichen Datenstruktur erstellt erhalten bleiben.
In der vorigen Übung konnten Sie mithilfe von List.Transpose eine gerippte Struktur erstellen. Dies ist hier nicht möglich. Die Funktion Transpose ist für zweidimensionale Listen vorgesehen. Hier liegt eine dreidimensionale Liste vor, die ein "Vertauschen von Spalten und Zeilen" nicht ohne Weiteres zulässt. Da Listen Objekte sind, können mit List.Transpose zwar die Listen mit den Unterlisten vertauscht werden, die Nurbs-Kurven, die sich eine Ebene tiefer in der Hierarchie befinden, bleiben dabei jedoch unverändert.
In diesem Fall ist List.Combine besser geeignet. Für komplexere Datenstrukturen sollten List.Map- und List.Combine-Blöcke zum Einsatz kommen.
Mit List.Create als "Kombinator" erhalten Sie eine Datenstruktur, die in diesem Fall besser verwendbar ist.
Die Datenstruktur muss auf der nächsttieferen Ebene der Hierarchie nach wie vor vertauscht werden. Verwenden Sie hierfür List.Map. Dies funktioniert auf dieselbe Weise wie List.Combine, wobei jedoch nur eine Liste anstelle mehrerer eingegeben wird.
Als Funktion für List.Map wird List.Transpose eingegeben, wodurch die Spalten und Zeilen der Unterlisten innerhalb der Hauptliste vertauscht werden.
Schließlich können Sie die Nurbs-Kurven in der vorgesehenen Datenhierarchie durch eine Erhebung miteinander verbinden und erhalten eine gerippte Struktur.
Fügen Sie der Geometrie mithilfe eines Surface.Thicken-Blocks mit den angezeigten Eingabeeinstellungen Tiefe hinzu.
Es ist vorteilhaft, eine Oberfläche zur Unterstützung dieser Struktur hinzuzufügen. Fügen Sie daher einen weiteren Surface.ByLoft-Block hinzu und verwenden Sie die erste Ausgabe von NurbsCurve.ByPoints aus einem früheren Schritt als Eingabe.
Da die Vorschau unübersichtlich wird, deaktivieren Sie die Vorschau für diese Blöcke, indem Sie mit der rechten Maustaste auf jeden Block klicken und die Option Vorschau deaktivieren, um das Ergebnis besser sehen zu können.
Mit der Verstärkung dieser ausgewählten Oberflächen ist die Untergliederung vollständig.
Das Ergebnis ist vielleicht kein sonderlich bequemer Schaukelstuhl, aber er enthält erhebliche Datenmengen.
Im letzten Schritt kehren Sie die Richtung der Rippen um. Bei diesem Vorgang wird in ähnlicher Weise wie in der vorigen Übungslektion die Funktion Transpose verwendet.
Da in der Hierarchie eine weitere Ebene vorhanden ist, müssen Sie List.Map zusammen mit List.Transpose als Funktion verwenden, um die Richtung der Nurbs-Kurven zu ändern.
Es ist eventuell sinnvoll, die Anzahl der Rippen zu erhöhen. Ändern Sie daher den Codeblock wie folgt:
0..1..#20;
0..1..#30;
Während die erste Version des Schaukelstuhls eher elegant wirkte, punktet das zweite Modell durch robuste, sportliche Qualitäten.
Wörterbücher stehen für eine Sammlung von Daten, die in Bezug zu einem anderen Datenelement stehen, das als Schlüssel bezeichnet wird. Wörterbücher bieten die Möglichkeit, Daten zu suchen, zu löschen und in eine Sammlung einzufügen.
Im Prinzip ist ein Wörterbuch eine wirklich clevere Methode, etwas nachzuschlagen.
Die Wörterbuch-Funktionalität ist schon seit einiger Zeit in Dynamo verfügbar, aber in Dynamo 2.0 haben Sie neue Möglichkeiten, diesen Datentyp zu verwalten.
Bis hierher wurde die Bearbeitung eines einfachen Gebäudekörpers behandelt. Im Folgenden wird die Verknüpfung zwischen Revit und Dynamo am Beispiel der Bearbeitung zahlreicher Elemente in ein und demselben Vorgang ausführlicher erläutert. Anpassungen in größerem Rahmen sind etwas komplizierter, da für die Datenstrukturen komplexere Listenoperationen durchgeführt werden müssen. Deren Ausführung folgt jedoch grundsätzlich denselben Prinzipien. Im Folgenden werden einige Analysemöglichkeiten ausgehend von einer Gruppe adaptiver Bauteile beschrieben.
Angenommen, Sie haben eine Gruppe adaptiver Bauteile erstellt und möchten deren Parameter anhand ihrer Punktpositionen bearbeiten. Mithilfe dieser Punkte könnten Sie z. B. einen Parameter für die Dicke in Verbindung mit der Fläche des Elements steuern. Oder Sie könnten einen Parameter für die Opazität in Abhängigkeit von der Sonneneinstrahlung im Jahresverlauf steuern. Dynamo ermöglicht die Verbindung zwischen Analysen und Parametern in wenigen einfachen Schritten. Die folgende Übung zeigt eine grundlegende Version hiervon.
Fragen Sie die adaptiven Punkte eines ausgewählten adaptiven Bauteils mithilfe des AdaptiveComponent.Locations-Blocks ab. Dadurch können Sie eine abstrakte Version eines Revit-Elements für die Analyse nutzen.
Indem Sie die Positionen der Punkte adaptiver Bauteile extrahieren, können Sie eine Reihe von Analysen für dieses Element ausführen. Mithilfe eines adaptiven Bauteils mit vier Punkten können Sie beispielsweise die Ebenenabweichung eines gegebenen Dachelements analysieren.
Ordnen Sie mithilfe der Neuzuordnungsfunktion einen Datensatz einem Parameterbereich zu. Dies ist eines der wichtigsten Werkzeuge für parametrische Modelle, wie in der unten folgenden Übung gezeigt.
In Dynamo können Sie über die Positionen der Punkte von adaptiven Bauteilen eine optimale Ebene für jedes einzelne Element erstellen. Darüber hinaus können Sie den Sonnenstand aus der Revit-Datei abfragen und die Ausrichtung der Ebene relativ zur Sonne mit derjenigen anderer adaptiver Bauteile vergleichen. In der folgenden Übung richten Sie dies ein, indem Sie eine algorithmische Dachform erstellen.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung entwickeln Sie die im vorigen Abschnitt entwickelten Verfahren weiter. In diesem Fall definieren Sie eine parametrische Oberfläche aus Revit-Elementen, instanziieren adaptive Bauteile mit vier Punkten und bearbeiten diese anschließend anhand ihrer Ausrichtung relativ zur Sonne.
Beginnen Sie, indem Sie mithilfe eines Select Edge-Blocks zwei Kanten auswählen. Die beiden Kanten sind die Längsseiten des Foyers.
Fassen Sie die beiden Kanten mithilfe eines List.Create-Blocks in einer Liste zusammen.
Erstellen Sie mithilfe eines Surface.ByLoft-Blocks eine Oberfläche zwischen den beiden Kanten.
Definieren Sie in einem Code Block einen Bereich von 0 bis 1 mit 10 gleichmäßig verteilten Werten:
0..1..#10;
Verbinden Sie den Code Block mit den u- und v-Eingaben eines Surface.PointAtParameter-Blocks und verbinden Sie den Surface.ByLoft-Block mit der surface-Eingabe. Klicken Sie mit der rechten Maustaste auf den Block und ändern Sie die Vergitterung in Kreuzprodukt. Dadurch erhalten Sie ein Raster aus Punkten auf der Oberfläche.
Die Punkte in diesem Raster werden als Steuerpunkte für eine parametrisch definierte Oberfläche genutzt. Als Nächstes extrahieren Sie die u- und v-Positionen dieser Punkte, damit Sie sie mit einer parametrischen Formel verbinden und dabei die bestehende Datenstruktur beibehalten können. Dies ist durch Abfragen der Parameterpositionen der eben erstellten Punkte möglich.
Fügen Sie einen Surface.ParameterAtPoint-Block in den Ansichtsbereich ein und verbinden Sie seine Eingaben wie oben gezeigt.
Fragen Sie die u-Werte dieser Parameter mithilfe eines UV.U-Blocks ab.
Fragen Sie die v-Werte dieser Parameter mithilfe eines UV.V-Blocks ab.
Die Ausgaben zeigen die u- bzw. v-Werte der einzelnen Punkte in der Oberfläche. Dadurch erhalten Sie für beide Werte jeweils einen Bereich zwischen 0 und 1 in der benötigten Datenstruktur. Jetzt können Sie einen parametrischen Algorithmus anwenden.
Fügen Sie im Ansichtsbereich einen Code Block hinzu und geben Sie den folgenden Code ein:
Math.Sin(u*180)*Math.Sin(v*180)*w;
. Mit dieser parametrischen Funktion wird aus der flachen Oberfläche eine durch Sinusfunktionen definierte Wölbung erstellt.Verbindet UV.U mit der u-Eingabe und UV.V mit der v-Eingabe.
Die w-Eingabe steht für die Amplitude der Form. Verbinden Sie daher einen Number Slider mit ihr.
Dadurch erhalten Sie eine Liste mit durch den Algorithmus definierten Werten. Verwenden Sie diese Werteliste, um die Punkte nach oben, d. h. in +Z-Richtung, zu verschieben. Hierfür verwenden Sie Geometry.Translate: Verbinden Sie den *Codeblock *mit zTranslation und Surface.PointAtParameter mit der geometry-Eingabe. Die neuen Punkte sollten in der Dynamo-Vorschau angezeigt werden.
Schließlich erstellen Sie eine Oberfläche, indem Sie den Block aus dem vorigen Schritt mit der points-Eingabe eines NurbsSurface.ByPoints-Blocks verbinden. Damit haben Sie eine parametrische Oberfläche erstellt. Wenn Sie den Schieberegler ziehen, können Sie beobachten, wie die Oberfläche sich wölbt und abflacht.
Diese parametrische Oberfläche muss jetzt in Felder unterteilt werden, damit adaptive Bauteile mit vier Punkten darauf angeordnet werden können. Dynamo verfügt nicht über integrierte Funktionen zum Unterteilen von Oberflächen. Suchen Sie daher in der Community nach geeigneten Dynamo-Paketen.
Wechseln Sie zu Pakete > Suchen nach Paket.
Suchen Sie nach LunchBox und installieren Sie LunchBox for Dynamo. Die hier enthaltenen Werkzeuge sind äußerst hilfreich bei geometrischen Operationen wie dieser.
Nach dem Herunterladen haben Sie vollen Zugriff auf die LunchBox-Suite. Suchen Sie nach Quad Grid und wählen Sie LunchBox Quad Grid By Face. Verbinden Sie die parametrische Oberfläche mit der surface-Eingabe und legen Sie als Unterteilungen für U und V jeweils 15 fest. In der Dynamo-Vorschau sollte jetzt eine in viereckige Elemente unterteilte Oberfläche zu sehen sein.
Wenn Sie an der Programmstruktur des LunchBox-Blocks interessiert sind, können Sie sie durch Doppelklicken auf den Block anzeigen.
Kehren Sie zu Revit und zum hier verwendeten adaptiven Bauteil zurück. Ohne allzu sehr ins Einzelne zu gehen: Dies ist das zu instanziierende Dachelement. Dieses adaptive Bauteil mit vier Punkten ist eine grobe Darstellung eines EFTE-Systems. Die Öffnung des Abzugskörpers in der Mitte wird durch einen Parameter namens ApertureRatio gesteuert.
Da hier große Mengen von Geometrie in Revit instanziiert werden, achten Sie darauf, den Dynamo-Solver auf Manuell einzustellen.
Fügen Sie im Ansichtsbereich einen Family Types-Block ein und wählen Sie "ROOF-PANEL-4PT".
Fügen Sie im Ansichtsbereich einen AdaptiveComponent.ByPoints-Block ein und verbinden Sie die Panel Pts-Ausgabe des LunchBox Quad Grid by Face-Blocks mit der points-Eingabe. Verbinden Sie den Family Types-Block mit der familySymbol-Eingabe.
Klicken Sie auf Ausführen. Revit benötigt etwas Zeit zum Erstellen der Geometrie. Wenn dies zu lange dauert, reduzieren Sie den Codeblock-Wert 15 auf eine kleinere Zahl. Dadurch erhalten Sie weniger Elemente auf dem Dach.
Anmerkung: Falls die Berechnung von Blöcken in Dynamo sehr lange dauert, können Sie die Blockfunktionen anhalten ("einfrieren") und damit die Ausführung von Revit-Vorgängen unterbrechen, während Sie Ihr Diagramm entwickeln. Weitere Informationen zum Anhalten von Blöcken finden Sie im entsprechenden Abschnitt im Kapitel Körper.
In Revit sind die Elemente jetzt auf dem Dach angeordnet.
Wenn Sie die Ansicht vergrößern, erhalten Sie einen genaueren Eindruck der Eigenschaften der Oberfläche.
Als Nächstes entwickeln Sie dies weiter, um die Öffnung der einzelnen Elemente in Abhängigkeit von der Sonneneinstrahlung an seiner Position zu steuern. Wenn Sie die Darstellung in Revit vergrößern und eines der Elemente auswählen, wird in der Eigenschaftenleiste der Parameter Aperture Ratio angezeigt. Die Familie wurde so eingerichtet, dass Öffnungsgrade zwischen ungefähr 0.05 und 0.45 möglich sind.
Wenn Sie die Sonnenbahn aktivieren, wird der aktuelle Sonnenstand in Revit angezeigt.
Diesen Sonnenstand können Sie mithilfe des SunSettings.Current-Blocks referenzieren.
Verbinden Sie die Sonneneinstellungen mit Sunsetting.SunDirection, um den Solarvektor zu erhalten.
Erstellen Sie ausgehend von den Panel Pts, aus denen Sie die adaptiven Bauteile erstellt haben, mithilfe von Plane.ByBestFitThroughPoints annähernde Ebenen für die Bauteile.
Rufen Sie die normal für diese Ebene ab.
Berechnen Sie mithilfe des Skalarprodukts die Sonnenrichtung. Das Skalarprodukt ist eine Formel zur Bestimmung der Parallelität oder Antiparallelität zweier Vektoren. Sie vergleichen also die Ebenennormale jedes einzelnen adaptiven Bauteils mit dem Solarvektor, um eine ungefähre Simulation des Winkels gegenüber der Sonnenstrahlung zu erhalten.
Ermitteln Sie absoluten Wert des Ergebnisses. Dadurch wird die Richtigkeit des Skalarprodukts für den Fall sichergestellt, dass die Ebenennormale in die entgegengesetzte Richtung zeigt.
Klicken Sie auf Ausführen.
Für das Skalarprodukt wird ein großer Zahlenbereich ausgegeben. Die relative Verteilung dieser Zahlen soll verwendet werden, ihr Bereich muss jedoch auf den geeigneten Bereich für den Parameter Aperture Ratio, der bearbeitet werden soll, verdichtet werden.
Hierfür ist Math.RemapRange hervorragend geeignet. Diese Funktion übernimmt eine eingegebene Liste und ordnet ihre Grenzwerte zwei Zielwerten zu.
Definieren Sie die Zielwerte 0.15 und 0.45 in einem Code Block.
Klicken Sie auf Ausführen.
Verbinden Sie die neu zugeordneten Werte mit einem Element.SetParameterByName-Block.
Verbinden Sie die Zeichenfolge "Aperture Ratio" mit der parameterName-Eingabe.
Verbinden Sie die adaptiven Bauteile mit der element-Eingabe.
Klicken Sie auf Ausführen.
In Revit ist die Auswirkung des Sonnenwinkels auf die Öffnung der EFTE-Elemente auch aus größerer Entfernung zu erkennen.
Wenn Sie die Ansicht vergrößern, ist zu sehen, dass die der Sonne zugewandten EFTE-Elemente stärker geschlossen sind. In diesem Fall soll eine Überhitzung durch Sonneneinstrahlung vermieden werden. Wenn Sie den Lichteinfall in Abhängigkeit von der Sonneneinstrahlung steuern wollten, könnten Sie dafür einfach die Domäne im Math.RemapRange-Block ändern.
Dynamo bietet eine große Anzahl sofort einsatzbereiter Funktionen und verfügt außerdem über eine umfangreiche Paketbibliothek, mit der sich die Funktionen von Dynamo erheblich erweitern lassen. Ein Paket ist eine Sammlung benutzerdefinierter Blöcke oder zusätzlicher Funktionen. Der Dynamo Package Manager ist ein Community-Portal, aus dem Sie beliebige Pakete herunterladen können, die online publiziert wurden. Diese Toolsets werden von externen Anbietern entwickelt und stellen Erweiterungen der Hauptfunktionen von Dynamo dar. Sie stehen für alle Benutzer zur Verfügung und können durch einfaches Klicken auf eine Schaltfläche heruntergeladen werden.
Community-Engagement wie dieses ist die Grundlage des Erfolgs von Open Source-Projekten wie Dynamo. Dank der Arbeit dieser hochmotivierten externen Entwickler kann Dynamo für Arbeitsabläufe in zahlreichen verschiedenen Branchen genutzt werden. Aus diesem Grund hat das Dynamo-Team sich geschlossen bemüht, die Entwicklung und Veröffentlichung von Paketen zu vereinheitlichen. (Dies wird in den folgenden Abschnitten detaillierter beschrieben.)
Die einfachste Methode zum Installieren eines Pakets ist die Verwendung der Menüoption Pakete in der Dynamo-Benutzeroberfläche. Diese Methode wird im Folgenden beschrieben. In diesem Beispiel installieren Sie ein häufig verwendetes Paket zum Erstellen viereckiger Felder in einem Raster.
Wechseln Sie in Dynamo zu Pakete > Package Manager...
Suchen Sie mithilfe der Suchleiste nach "quads from rectangular grid". Nach kurzer Zeit sollten alle Pakete, die dieser Suchabfrage entsprechen, angezeigt werden. Sie müssen in diesem Fall das erste Paket mit passendem Namen auswählen.
Klicken Sie auf Installieren, um dieses Paket zu Ihrer Bibliothek hinzuzufügen, und bestätigen Sie anschließend den Vorgang. Fertig!
In der Dynamo-Bibliothek wird jetzt eine weitere Gruppe namens buildz angezeigt. Dieser Name bezieht sich auf den Entwickler des Pakets und der benutzerdefinierte Block wird in dieser Gruppe abgelegt. Sie können ihn sofort verwenden.
Verwenden Sie den Codeblock, um schnell ein rechteckiges Raster zu definieren, und geben Sie das Ergebnis als Polygon.ByPoints-Block und anschließend als Surface.ByPatch-Block aus, um die Liste der rechteckigen Elemente anzuzeigen, die Sie gerade erstellt haben.
Das Paket im vorigen Beispiel enthält nur einen benutzerdefinierten Block. Pakete, die mehrere benutzerdefinierte Blöcke und die unterstützenden Datendateien enthalten, werden jedoch auf dieselbe Weise heruntergeladen. Dies wird hier an einem umfassenderen Paket demonstriert: Dynamo Unfold.
Beginnen Sie wie im Beispiel oben, indem Sie Pakete > Package Manager... wählen.
Dieses Mal suchen wir nach DynamoUnfold (in einem Wort geschrieben). Wenn die Pakete angezeigt werden, laden Sie sie herunter, indem Sie auf Installieren klicken, um Dynamo Unfold Ihrer Dynamo-Bibliothek hinzuzufügen.
Die Dynamo-Bibliothek enthält jetzt die Gruppe DynamoUnfold mit mehreren Kategorien und benutzerdefinierten Blöcken.
Als Nächstes betrachten Sie die Dateistruktur des Pakets genauer.
Navigieren Sie zunächst zu Pakete > Package Manager > Installierte Pakete.
Klicken Sie anschließend auf Stammverzeichnis anzeigen, um den Stammordner für dieses Paket zu öffnen.
Dadurch gelangen Sie zum Stammverzeichnis des Pakets. Hier sind drei Ordner und eine Datei vorhanden.
Im Ordner bin werden DLL-Dateien gespeichert. Dieses Dynamo-Paket wurde mit Zero-Touch entwickelt, d. h., die benutzerdefinierten Blöcke wurden in diesem Ordner abgelegt.
Im Ordner dyf befinden sich die benutzerdefinierten Blöcke. Da dieses Paket nicht mithilfe benutzerdefinierter Dynamo-Blöcke entwickelt wurde, ist dieser Ordner in diesem Paket leer.
Der Ordner extra enthält alle zusätzlichen Dateien, darunter Ihre Beispieldateien.
Die Datei pkg ist eine einfache Textdatei, die die Einstellungen des Pakets definiert. Sie können diese Datei für den Augenblick ignorieren.
Wenn Sie den Ordner extra öffnen, sehen Sie eine Reihe von Beispieldateien, die mit der Installation heruntergeladen wurden. Beispieldateien stehen nicht in allen Paketen zur Verfügung. Falls sie jedoch vorhanden sind, finden Sie sie in diesem Ordner.
Öffnen Sie SphereUnfold.
Nachdem Sie die Datei geöffnet und im Solver auf Ausführen geklickt haben, erhalten Sie das Netz einer Kugel! Beispieldateien wie diese erleichtern den Einstieg in die Arbeit mit einem neuen Dynamo-Paket.
Mithilfe der Sortier- und Filteroptionen auf der Registerkarte Nach Paketen suchen können Sie im Package Manager nach Paketen suchen. Es stehen verschiedene Filter für das Host-Programm und den Status (neu, veraltet oder nicht veraltet) zur Verfügung, bzw. dafür, ob das Paket Abhängigkeiten aufweist.
Durch Sortieren der Pakete können Sie die hoch bewerteten oder die am häufigsten heruntergeladenen Pakete ermitteln bzw. Pakete mit aktuellen Updates suchen.
Sie können auch auf weitere Details zu jedem Paket zugreifen, indem Sie auf Details anzeigen klicken. Dadurch wird eine Seitenleiste im Package Manager geöffnet, in der Sie Informationen wie Versionierung und Abhängigkeiten, Website- oder Repository-URL, Lizenzinformationen usw. finden.
Wenn Sie wissen möchten, wo Ihre Paketdateien gespeichert sind, klicken Sie in der oberen Navigationsleiste auf Dynamo > Voreinstellungen > Paketeinstellungen > Dateispeicherorte für Blöcke und Pakete. Hier finden Sie das aktuelle Stammordnerverzeichnis.
Pakete werden vorgabemäßig unter einem Speicherort ähnlich dem folgenden installiert: C:/Benutzer/[Benutzername]/AppData/Roaming/Dynamo/[Dynamo-Version].
Die Dynamo-Community wächst laufend und entwickelt sich dabei weiter. Besuchen Sie Dynamo Package Manager von Zeit zu Zeit, um über neue inspirierenden Entwicklungen auf dem Laufenden zu bleiben. In den folgenden Abschnitten werden Pakete eingehender behandelt, wobei sowohl auf die Perspektive des Endbenutzers eingegangen als auch die Entwicklung eigener Dynamo-Pakete behandelt wird.
Dynamo bietet mehrere Methoden zum Erstellen benutzerdefinierter Blöcke. Sie können benutzerdefinierte Blöcke neu, aus bestehenden Diagrammen oder explizit in C# erstellen. In diesem Abschnitt wird die Erstellung eines benutzerdefinierten Blocks in der Benutzeroberfläche von Dynamo aus einem bestehenden Diagramm beschrieben. Dieses Verfahren eignet sich ausgezeichnet dazu, den Arbeitsbereich übersichtlicher zu gestalten und Gruppen von Blöcken zur Wiederverwendung zusammenzufassen.
In der unten gezeigten Abbildung wird ein Punkt aus einer Oberfläche mithilfe von UV-Koordinaten einer anderen zugeordnet. Nach diesem Prinzip erstellen Sie eine in Elemente aufgeteilte Oberfläche, die Kurven in der xy-Ebene referenziert. In diesem Fall erstellen Sie viereckige Elemente für die Unterteilung. Nach derselben Logik können Sie jedoch mithilfe der UV-Zuordnung eine große Vielfalt von Elementen erstellen. Es bietet sich an, hier einen benutzerdefinierten Block zu entwickeln, da Sie auf diese Weise ähnliche Vorgänge in diesem Diagramm oder in anderen Dynamo-Arbeitsabläufen leichter wiederholen können.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Code Block: Verwenden Sie diese Zeile, um einen Bereich mit 10 Zahlen zwischen -45 und 45 zu erstellen.
45..45..#10;
Point.ByCoordinates: Verbinden Sie die Ausgaben des Codeblocks mit den x- und y-Eingaben und legen Sie Kreuzprodukt als Vergitterung fest. Sie haben nun ein Raster von Punkten.
Plane.ByOriginNormal: Verbinden Sie die Point-Ausgabe mit der origin-Eingabe, um an jeder der Punktpositionen eine Ebene zu erstellen. Dabei wird der vorgegebene Normalenvektor (0,0,1) verwendet.
Rectangle.ByWidthLength: Verbinden Sie die Ebenen aus dem vorigen Schritt mit der plane-Eingabe und legen Sie mithilfe eines Codeblocks jeweils 10 als Breite und Länge fest.
Daraufhin müsste ein Raster aus Rechtecken angezeigt werden. Diese Rechtecke ordnen Sie mithilfe von UV-Koordinaten einer Zieloberfläche zu.
Polygon.Points: Verbinden Sie die Rectangle.ByWidthLength-Ausgabe aus dem vorigen Schritt mit der polygon-Eingabe, um die Eckpunkte der einzelnen Rechtecke zu extrahieren. Diese Punkte werden wird dann der Zieloberfläche zuordnen.
Rectangle.ByWidthLength: Legen Sie mithilfe eines Codeblocks mit dem Wert 100 die Breite und Länge eines Rechtecks fest. Dies definiert die Begrenzung der Basisfläche.
Surface.ByPatch: Verbinden Sie den Rectangle.ByWidthLength-Block aus dem vorigen Schritt mit der closedCurve-Eingabe, um eine Basisoberfläche zu erstellen.
Surface.UVParameterAtPoint: Verbinden Sie die Point-Ausgabe des Polygon.Points-Blocks und die Surface-Ausgabe des Surface.ByPatch-Blocks, um die UV-Parameter an den einzelnen Punkten zu erhalten.
Damit haben Sie eine Basisoberfläche und einen Satz UV-Koordinaten erstellt. Jetzt können Sie eine Zieloberfläche importieren und die Punkte auf den Oberflächen zuordnen.
File Path: Wählen Sie den Dateipfad der Oberfläche aus, den Sie importieren möchten. Die Datei muss eine SAT-Datei sein. Klicken Sie auf die Schaltfläche Durchsuchen und navigieren Sie zur Datei UVmapping_srf.sat aus der im oben beschriebenen Schritt heruntergeladenen ZIP-Datei.
Geometry.ImportFromSAT: Verbinden Sie den Dateipfad, um die Oberfläche zu importieren. Die importierte Oberfläche sollte in der Geometrievorschau angezeigt werden.
UV: Verbinden Sie die Ausgabe der UV-Parameter mit einem UV.U- und einem UV.V-Block.
Surface.PointAtParameter: Verbinden Sie die importierte Oberfläche sowie die U- und V-Koordinaten. Damit sollte ein Raster von 3D-Punkten auf der Zieloberfläche angezeigt werden.
Der letzte Schritt besteht darin, mithilfe der 3D-Punkte rechteckige Oberflächenelemente zu erstellen.
PolyCurve.ByPoints: Verbinden Sie die Punkte auf der Oberfläche, um eine durch die Punkte verlaufende Polykurve zu konstruieren.
Boolean: Fügen Sie im Ansichtsbereich einen Boolean-Block hinzu, verbinden Sie ihn mit der connectLastToFirst-Eingabe und legen Sie True fest, um die Polykurven zu schließen. Die Oberfläche sollte jetzt in rechteckige Felder unterteilt sein.
Surface.ByPatch: Verbinden Sie die Polykurven mit der closedCurve-Eingabe, um die Oberflächenfelder zu erstellen.
Als Nächstes wählen Sie die Blöcke aus, die in einem benutzerdefinierten Block verschachtelt werden sollen, wobei Sie berücksichtigen, welche Ein- und Ausgaben Sie für Ihren Block benötigen. Der benutzerdefinierte Block soll so flexibel wie möglich sein, d. h., es sollten nicht nur Rechtecke, sondern beliebige Polygone zugeordnet werden können.
Wählen Sie die folgenden Blöcke (beginnend mit Polygon.Points) aus, klicken Sie mit der rechten Maustaste auf den Arbeitsbereich, und wählen Sie Benutzerdefinierten Block erstellen aus.
Weisen Sie im Dialogfeld Eigenschaften für den benutzerdefinierten Block einen Namen, eine Beschreibung und eine Kategorie zu.
Name: MapPolygonsToSurface
Beschreibung: Zuordnung von Polygonen von einer Basis- zu einer Zieloberfläche
Add-On-Kategorie: Geometry.Curve
Der Ansichtsbereich ist mit dem benutzerdefinierten Block wesentlich übersichtlicher. Den Namen der Ein- und Ausgaben wurden die entsprechenden Angaben aus den Originalblöcken zugrunde gelegt. Bearbeiten Sie den benutzerdefinierten Block, um aussagekräftigere Namen anzugeben.
Doppelklicken Sie auf den benutzerdefinierten Block, um ihn zu bearbeiten. Dadurch öffnen Sie einen Arbeitsbereich mit gelbem Hintergrund, der darauf hinweist, dass Sie im Inneren eines Blocks arbeiten.
Eingaben: Ändern Sie die Namen der Eingaben zu baseSurface und targetSurface.
Ausgaben: Fügen Sie eine zusätzliche Ausgabe für die zugeordneten Polygone hinzu.
Speichern Sie den benutzerdefinierten Block, und kehren Sie zur Ausgangsansicht zurück. Beachten Sie, wie im MapPolygonsToSurface-Block die eben vorgenommenen Änderungen übernommen wurden.
Um den benutzerdefinierten Block noch zuverlässiger zu gestalten, können Sie außerdem benutzerdefinierte Kommentare hinzufügen. Kommentare können Aufschluss über den Typ der Ein- und Ausgaben geben oder Erläuterungen zur Funktionsweise des Blocks enthalten. Kommentare werden angezeigt, wenn der Benutzer den Cursor auf eine Eingabe oder Ausgabe eines benutzerdefinierten Blocks setzt.
Doppelklicken Sie auf den benutzerdefinierten Block, um ihn zu bearbeiten. Dadurch wird erneut der Arbeitsbereich mit dem gelben Hintergrund geöffnet.
Beginnen Sie mit der Bearbeitung des Eingabe-Codeblocks. Um mit einem Kommentar zu beginnen, geben Sie "//" und anschließend den Kommentartext ein. Geben Sie Informationen ein, die das Verständnis des Blocks erleichtern können. In diesem Fall wird targetSurface beschrieben.
Legen Sie außerdem den Vorgabewert für inputSurface fest, indem Sie als Eingabetyp einen Wert vorgeben. In diesem Fall wird als Vorgabewert das ursprüngliche Surface.ByPatch angegeben.
Kommentare können auch auf Ausgaben angewendet werden.
Bearbeiten Sie den Text im Ausgabe-Codeblock. Geben Sie "//" gefolgt vom Kommentartext ein. In diesem Fall werden die Ausgaben Polygons und surfacePatches mit ausführlicheren Beschreibungen erläutert.
Setzen Sie den Cursor auf die Eingaben des benutzerdefinierten Blocks, um die Kommentare anzuzeigen.
Da für inputSurface ein Vorgabewert festgelegt ist, können Sie die Definition auch ohne Eingabewert für die Oberfläche ausführen.
Sie haben einen benutzerdefinierten Block erstellt und ihn auf einen bestimmten Prozess im Dynamo-Diagramm angewendet. Da dieser Block sehr nützlich ist, möchten Sie ihn in die Dynamo-Bibliothek aufnehmen, damit er in anderen Diagrammen referenziert werden kann. Dazu müssen Sie den Block lokal veröffentlichen. Sie gehen dabei auf ähnliche Weise vor wie beim Veröffentlichen von Paketen, das im nächsten Kapitel im Detail behandelt wird.
Indem Sie den Block lokal veröffentlichen, stellen Sie ihn in Ihrer Dynamo-Bibliothek bereit und können darauf zugreifen, wenn Sie eine neue Sitzung öffnen. Wenn ein Block nicht publiziert wird, muss er für ein Dynamo-Diagramm, das diesen benutzerdefinierten Block referenziert, in dessen Ordner enthalten sein (oder über Datei > Bibliothek importieren in Dynamo importiert werden).
Sie können benutzerdefinierte Blöcke und Pakete aus Dynamo Sandbox in Version 2.17 und höher publizieren, sofern diese keine Abhängigkeiten zur Host-API aufweisen. In älteren Versionen ist das Publizieren von benutzerdefinierten Blöcken und Paketen nur in Dynamo for Revit und Dynamo for Civil 3D aktiviert.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Verwenden Sie weiterhin den benutzerdefinierten Block, den Sie im vorigen Abschnitt erstellt haben. Nachdem Sie den benutzerdefinierten PointsToSurface-Block geöffnet haben, wird das Diagramm im Editor für benutzerdefinierte Blöcke von Dynamo angezeigt. Sie können einen benutzerdefinierten Block auch durch Doppelklicken im Diagrammeditor von Dynamo öffnen.
Um einen benutzerdefinierten Block lokal zu veröffentlichen, klicken Sie mit der rechten Maustaste in den Ansichtsbereich und wählen Sie Diesen benutzerdefinierten Block veröffentlichen.
Geben Sie wie in der Abbildung oben gezeigt die nötigen Informationen ein und wählen Sie Lokal publizieren. Beachten Sie, dass das Feld Gruppe den Haupteintrag angibt, der über das Dynamo-Menü aufgerufen wird.
Wählen Sie einen Ordner, in dem alle benutzerdefinierten Blöcke gespeichert werden sollen, die Sie lokal veröffentlichen werden. Dynamo prüft diesen Ordner jedes Mal beim Laden der Anwendung. Achten Sie daher darauf, dass der Ordner sich an einem dauerhaften Speicherort befindet. Navigieren Sie zu diesem Ordner und wählen Sie Ordner auswählen. Damit haben Sie den Dynamo-Block lokal publiziert. Er steht jetzt jedes Mal, wenn Sie das Programm laden, in der Dynamo-Bibliothek zur Verfügung.
Um den Speicherort des benutzerdefinierten Blocks zu überprüfen, wechseln Sie zu Dynamo > Voreinstellungen > Paketeinstellungen > Pfade für Blöcke und Pakete.
In diesem Fenster wird eine Liste von Pfaden angezeigt.
Documents\DynamoCustomNodes... gibt den Speicherort der von Ihnen lokal veröffentlichten benutzerdefinierten Blöcke an.
AppData\Roaming\Dynamo... bezieht sich auf den vorgegebenen Speicherort der online installierten Dynamo-Pakete.
Es ist sinnvoll, den Pfad des lokalen Ordners in der Liste nach unten zu verschieben (indem Sie auf den nach unten zeigenden Pfeil links neben dem Pfadnamen klicken). Der zuoberst stehende Ordner ist die Vorgabe für die Installation von Paketen. Indem Sie den vorgegebenen Installationspfad für Dynamo-Pakete als Vorgabe beibehalten, stellen Sie daher sicher, dass Online-Pakete und Ihre lokal veröffentlichten Blöcke separat abgelegt werden.
Hier wurde die Reihenfolge der Pfadnamen vertauscht, damit Pakete unter dem Vorgabepfad von Dynamo installiert werden.
Wenn Sie zu diesem lokalen Ordner navigieren, finden Sie den ursprünglichen benutzerdefinierten Block im Ordner dyf. Dies ist die Erweiterung von Dateien für benutzerdefinierte Dynamo-Blöcke. Sie können die Datei in diesem Ordner bearbeiten. Der Block wird dann in der Benutzeroberfläche aktualisiert. Sie können auch weitere Blöcke im Ordner DynamoCustomNode hinzufügen. Diese werden beim Neustart von Dynamo Ihrer Bibliothek hinzugefügt.
Wenn Sie Dynamo jetzt laden, wird der Block PointsToSurface jedes Mal in der Gruppe DynamoPrimer Ihrer Dynamo-Bibliothek angezeigt.
Benutzerdefinierte Blöcke werden durch Verschachteln anderer Blöcke und benutzerdefinierter Blöcke in einem benutzerdefinierten Dynamo-Block konstruiert. Dieser ist im Prinzip ein Container. Bei der Ausführung dieses Container-Blocks im Diagramm werden sämtliche darin enthaltenen Funktionen ausgeführt. Dies ermöglicht die Wiederverwendung und Weitergabe nützlicher Kombinationen von Blöcken.
Wenn mehrere Kopien eines benutzerdefinierten Blocks im Diagramm vorhanden sind, können Sie alle diese Kopien aktualisieren, indem Sie den zugrunde liegenden benutzerdefinierten Block aktualisieren. Dadurch können Sie das Diagramm nahtlos entsprechend eventuellen Änderungen in Ihrem Arbeitsablauf oder Entwurf aktualisieren.
Zu den größten Vorteilen benutzerdefinierter Blöcke gehören wohl ihre Möglichkeiten zur Arbeitsteilung. Wenn ein "Power-User" ein komplexes Dynamo-Diagramm erstellt und dies an einen Designer weitergibt, der noch nicht mit Dynamo gearbeitet hat, kann er das Diagramm auf die wesentlichen, für die Interaktion erforderlichen Angaben komprimieren. Der benutzerdefinierte Block kann geöffnet werden, um das Diagramm in seinem Inneren zu bearbeiten, wobei der Container jedoch einfach bleibt. Benutzerdefinierte Blöcke ermöglichen auf diese Weise den Dynamo-Benutzern die Entwicklung klarer und intuitiver Diagramme.
Im Folgenden erstellen Sie in der Umgebung für benutzerdefinierte Blöcke einen einfachen Block zur Berechnung eines Prozentwerts. Die Umgebung für benutzerdefinierte Blöcke unterscheidet sich zwar von der Umgebung für Diagramme in Dynamo, die Interaktion läuft jedoch im Wesentlichen auf dieselbe Weise ab. Mit diesen Informationen können Sie damit beginnen, Ihren ersten benutzerdefinierten Block zu erstellen.
Um einen neuen benutzerdefinierten Block zu erstellen, starten Sie Dynamo und wählen Sie Benutzerdefinierter Block oder geben Sie Strg + Umschalt + N im Ansichtsbereich ein.
Weisen Sie im Dialogfeld Eigenschaften für benutzerdefinierten Block einen Namen, eine Beschreibung und eine Kategorie zu.
Name: Prozentsatz
Beschreibung: Berechnung des Prozentsatzes eines Werts relativ zu einem anderen.
Kategorie: Mathematikfunktionen
Dadurch wird ein Ansichtsbereich mit gelbem Hintergrund geöffnet, der darauf hinweist, dass Sie in einem benutzerdefinierten Block arbeiten. In diesem Ansichtsbereich haben Sie Zugriff auf alle Core-Blöcke von Dynamo sowie die Blöcke Input und Output, die zum Benennen der in den benutzerdefinierten Block und aus ihm heraus fließenden Daten dienen. Sie finden sie unter Eingabe > Einfach.
Eingaben: Input-Blöcke erstellen die Eingaben des benutzerdefinierten Blocks. Die Syntax für einen Input-Block lautet input_name : datatype = default_value(optional).
Sie können diesen benutzerdefinierten Block als DYF-Datei (im Gegensatz den Standard-DYN-Dateien) speichern. Er wird dann automatisch der laufenden und zukünftigen Sitzungen hinzugefügt. Sie finden den benutzerdefinierten Block in Ihrer Bibliothek im Abschnitt Zusatzmodule.
Damit haben Sie Ihren ersten benutzerdefinierten Block erstellt. In den nächsten Abschnitten werden die Funktionen benutzerdefinierter Blöcke und die Veröffentlichung allgemeiner Arbeitsabläufe genauer betrachtet. Thema des folgenden Abschnitts ist die Entwicklung eines benutzerdefinierten Blocks, der Geometrie von einer Oberfläche auf eine andere überträgt.
Nachdem Sie einige benutzerdefinierte Blöcke erstellt haben, beginnen Sie im nächsten Schritt damit, sie zu ordnen und in Form von Paketen zu veröffentlichen: eine einfache Methode, Ihre Blöcke zu speichern und in der Dynamo-Community bereitzustellen.
Das Dynamo Mesh Toolkit enthält Werkzeuge zum Importieren von Netzen aus externen Dateiformaten, zum Erstellen von Netzen aus Dynamo-Geometrieobjekten und zum manuellen Erstellen von Netzen aus ihren Scheitelpunkten und Indizes. In der Bibliothek stehen außerdem Werkzeuge zum Ändern oder Reparieren von Netzen sowie zum Extrahieren horizontaler Segmente zur Verwendung in der Fertigung zur Verfügung.
Das Dynamo Mesh Toolkit ist Bestandteil der von Autodesk durchgeführten laufenden Forschungsarbeiten zu Netzen und wird daher in den kommenden Jahren weiter ausgebaut. Sie können damit rechnen, dass häufig neue Methoden zu diesem Toolkit hinzukommen. Falls Sie Kommentare oder Vorschläge haben oder Fehler melden möchten, ist das Dynamo-Team jederzeit für Sie da.
Wechseln Sie in Dynamo in der oberen Menüleiste zu Pakete > Package Manager... Geben Sie im Suchfeld MeshToolkit ein (in einem Wort geschrieben). Klicken Sie auf Installieren, und akzeptieren Sie die Bestätigungen, um den Download zu starten. Dieser einfache Schritt genügt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In diesem Beispiel verwenden Sie den Intersect-Block innerhalb von Mesh Toolkit. Sie importieren ein Netz und schneiden es mit einer Reihe eingegebener Ebenen, um Segmente zu erhalten. Davon ausgehend kann das Modell für die Fertigung auf einem Laser- oder Wasserstrahlwerkzeug oder einer CNC-Fräse vorbereitet werden.
Öffnen Sie zunächst Mesh-Toolkit_Intersect-Mesh.dyn in Dynamo.
Dateipfad: Suchen Sie die zu importierende Netzdatei (stanford_bunny_tri.obj). Unterstützte Dateitypen sind .mix und .obj.
Mesh.ImportFile: Verbinden Sie den Dateipfad, um das Netz zu importieren.
Point.ByCoordinates: Legen Sie einen Punkt fest. Dieser wird als Mittelpunkt eines Bogens verwendet.
Arc.ByCenterPointRadiusAngle: Konstruieren Sie einen Bogen um den Punkt. Mithilfe dieser Kurve wird eine Reihe von Ebenen platziert. __ Die Einstellungen sind wie folgt: __
radius: 40, startAngle: -90, endAngle:0
Erstellen Sie eine Reihe von Ebenen, die entlang des Bogens ausgerichtet sind.
Code Block: Erstellen Sie 25 Zahlen zwischen 0 und 1.
Curve.PointAtParameter: Verbinden Sie den Bogen mit der curve-Eingabe und die Ausgabe des Codeblocks mit der param-Eingabe, um eine Reihe von Punkten entlang der Kurve abzurufen.
Curve.TangentAtParameter: Verbinden Sie die Eingaben auf dieselbe Weise wie beim vorigen Block.
Plane.ByOriginNormal: Verbinden Sie die Punkte mit der origin-Eingabe und die Vektoren mit der normal-Eingabe, um eine Reihe von Ebenen an den einzelnen Punkten zu erstellen.
Diese Ebenen verwenden Sie als Nächstes zum Schneiden des Netzes.
Mesh.Intersect: Schneiden Sie die Ebenen mit dem importierten Netz, sodass eine Reihe von Polykurvenkonturen entsteht. Klicken Sie mit der rechten Maustaste auf den Block, und legen Sie die Vergitterung auf longest fest.
PolyCurve.Curves: Teilen Sie die Polykurven in ihre Kurvenfragmente auf.
Curve.EndPoint: Extrahieren Sie die Endpunkte der einzelnen Kurven.
NurbsCurve.ByPoints: Konstruieren Sie mithilfe der Punkte eine Nurbs-Kurve. Schließen Sie die Kurven mithilfe eines Boolean-Blocks mit dem Wert True.
Bevor wir fortfahren, deaktivieren Sie die Vorschau für einige der Blöcke, z. B. Mesh.ImportFile, Curve.EndPoint, Plane.ByOriginNormal und Arc.ByCenterPointRadiusAngle, um das Ergebnis besser sehen zu können.
Surface.ByPatch: Konstruieren Sie Oberflächenfelder für die einzelnen Konturen, um das Netz in Segmente aufzuteilen.
Fügen Sie eine zweite Segmentierung hinzu, um einen gitter- oder eierkartonähnlichen Effekt zu erzielen.
Ihnen ist vielleicht aufgefallen, dass die Schnittvorgänge für Netze schneller berechnet werden als für vergleichbare Volumenkörper. Arbeitsabläufe wie der in dieser Übung beschriebene eignen sich gut für die Arbeit mit Netzen.
In Dynamo steht eine Reihe von Verfahren zum Entwickeln von Paketen zur Verfügung, die Sie für Ihre eigenen Zwecke verwenden oder für die Dynamo-Community bereitstellen können. In der folgenden Fallstudie wird ein bestehendes Paket zerlegt, um den Aufbau von Paketen zu demonstrieren. Dabei werden Lektionen aus dem vorigen Kapitel zugrunde gelegt: Eine Gruppe benutzerdefinierter Blöcke zum Zuordnen von Geometrie aus einer Dynamo-Oberfläche zu einer anderen mithilfe von UV-Koordinaten wird bereitgestellt.
Sie arbeiten mit einem Beispielpaket, das die UV-Zuordnung von Punkten aus einer Oberfläche zu einer anderen zeigt. Sie haben die Grundfunktionen dieses Werkzeugs bereits im Abschnitt in diesem Leitfaden kennengelernt. In den folgenden Dateien wird gezeigt, wie Sie die UV-Zuordnung weiterentwickeln und eine Gruppe von Werkzeugen für eine Bibliothek erstellen können, die anschließend veröffentlicht werden kann.
In der unten gezeigten Abbildung wird ein Punkt aus einer Oberfläche mithilfe von UV-Koordinaten einer anderen zugeordnet. Dem Paket liegt dasselbe Prinzip zugrunde, es wird jedoch komplexere Geometrie verwendet.
Im vorigen Kapitel wurden in Dynamo verfügbare Methoden vorgestellt, mit denen eine Oberfläche mithilfe in der xy-Ebene definierter Kurven in Felder unterteilt werden kann. In dieser Fallstudie wird dies auf mehrdimensionale Geometrie erweitert. Dabei installieren Sie das fertige Paket und es wird gezeigt, wie dieses entwickelt wurde. Im nächsten Abschnitt wird gezeigt, wie dieses Paket veröffentlicht wurde.
Klicken Sie in Dynamo auf Pakete > Package Manager, und suchen Sie nach dem Paket MapToSurface (in einem Wort geschrieben). Klicken Sie auf Installieren, um den Download zu starten und das Paket zu Ihrer Bibliothek hinzuzufügen.
Nach der Installation sollten die benutzerdefinierten Blöcke im Abschnitt Add-Ons > Dynamo Primer verfügbar sein.
Nachdem Sie das Paket installiert haben, sehen Sie sich dessen Konfiguration an.
Für das Paket, das Sie hier erstellen, werden fünf benutzerdefinierte Blöcke verwendet. Diese Blöcke sind hier als Referenz bereits definiert. Im Folgenden analysieren Sie die Funktionen der einzelnen Blöcke. Einige der benutzerdefinierten Blöcke wurden ihrerseits unter Verwendung benutzerdefinierter Blöcke erstellt. Das Layout der Diagramme soll anderen Benutzern das Verständnis erleichtern.
Dieses Paket ist mit fünf benutzerdefinierten Blöcken recht einfach konstruiert. In den nachfolgenden Schritten wird der Aufbau der einzelnen Blöcke kurz erläutert.
Dieser recht einfache benutzerdefinierte Block bildet die Grundlage für alle anderen Zuordnungsblöcke. Dieser Block ordnet, einfach ausgedrückt, einen Punkt mit UV-Koordinaten auf einer Quelloberfläche der Position mit den entsprechenden UV-Koordinaten auf der Zieloberfläche zu. Punkte sind das einfachste Geometrieelement, aus dem komplexere Geometrie erstellt wird. Aus diesem Grund können Sie mithilfe dieser Logik 2D- und sogar 3D-Geometrie von einer Oberfläche einer anderen zuweisen.
Die Logik zum Erweitern der Punktzuordnung von 1D- auf 2D-Geometrie wird hier auf einfache Weise anhand von Polygonen gezeigt. Beachten Sie, dass der PointsToSurface-Block in diesem Block verschachtelt ist. Dadurch können Sie Punkte jedes Polygons der Oberfläche zuordnen und dann das Polygon aus den zugeordneten Punkten rekonstruieren. Durch Verwendung der geeigneten Datenstruktur (eine Liste aus Listen von Punkten) bleiben die Polygone nach ihrer Umwandlung in eine Punktsammlung als separate Polygone erhalten.
Hier kommt dieselbe Logik zum Einsatz wie beim PolygonsToSurface-Block. Dabei werden allerdings keine Punkte für Polygone, sondern Steuerpunkte für Nurbs-Kurven zugeordnet.
OffsetPointsToSurface
Dieser Block ist etwas komplexer, wobei jedoch ein einfaches Prinzip zugrunde liegt: Mit diesem Block werden genau wie beim PointsToSurface-Block Punkte aus einer Oberfläche einer anderen zugeordnet. Dabei werden jedoch auch Punkte berücksichtigt, die nicht auf der ursprünglichen Quelloberfläche liegen. Für diese Punkte wird ihr Abstand zum nächstgelegenen UV-Parameter abgerufen und dieser Abstand wird der Normalen an der entsprechenden UV-Koordinatenposition der Zieloberfläche zugeordnet. Bei der Bearbeitung der Beispieldateien wird dies leichter verständlich.
Mit diesem einfachen Block wird eine parametrische Oberfläche erstellt, die aus dem Quellraster einer gewellten Oberfläche in den Beispieldateien zugeordnet werden kann.
Die Beispieldateien befinden sich im Stammordner des Pakets. Klicken Sie auf Package Manager > Registerkarte Installierte Pakete.
Klicken Sie neben MapToSurface auf das Menü mit den drei Punkten > Stammverzeichnis anzeigen.
Navigieren Sie zum Ordner extra, in dem sich alle Dateien des Pakets befinden, die keine benutzerdefinierten Blöcke sind. Hier werden Beispieldateien (sofern vorhanden) für Dynamo-Pakete abgelegt. Mit den im Folgenden gezeigten Abbildungen werden die in den einzelnen Beispieldateien gezeigten Konzepte erläutert.
In dieser Übungsdatei wird eine Einrichtung zum Zuordnen von Kreisen (bzw. Polygonen, die Kreise repräsentieren) von einer Oberfläche zu einer anderen gezeigt. Hierfür wird der PolygonsToSurface-Block verwendet.
Diese Beispieldatei zeigt einen komplexeren Vorgang unter Verwendung des NurbsCrvToSurface-Blocks. Die Zieloberfläche wird um eine angegebene Strecke versetzt und die Nurbs-Kurve wird sowohl der ursprünglichen Zieloberfläche als auch der versetzten Oberfläche zugeordnet. Die beiden zugeordneten Kurven werden anschließend durch eine Erhebung verbunden, sodass eine Oberfläche entsteht, die anschließend verdickt wird. Der resultierende Körper weist eine gewellte Form auf, die den Normalen der Zieloberfläche folgt.
In dieser Beispieldatei wird die Zuordnung einer gefalteten PolySurface von einer Quell- zu einer Zieloberfläche gezeigt. Die Quell- und Zieloberfläche sind eine rechteckige, das ganze Raster umfassende Oberfläche und ein Rotationskörper.
Zuordnung des Quell-PolySurface von der Quell- zur Zieloberfläche.
Mithilfe der benutzerdefinierten Blöcke können Kurven unterschiedlicher Typen zugeordnet werden. In dieser letzten Datei wird daher eine aus Illustrator exportierte SVG-Datei referenziert und die importierten Kurven werden einer Zieloberfläche zugeordnet.
Durch Analyse der Syntax einer SVG-Datei werden die Kurven aus dem XML-Format in Dynamo-Polykurven konvertiert.
Die importierten Kurven werden einer Zieloberfläche zugeordnet. Dieser Vorgang ermöglicht es, eine Unterteilung explizit (durch Zeigen und Klicken) in Illustrator zu entwerfen, und sie anschließend in Dynamo zu importieren und auf eine Zieloberfläche anzuwenden.
Dynamo für Revit ergänzt die Gebäudemodellierung (Building Information Modelling) um die Daten- und Logikumgebung eines grafischen Algorithmeneditors. Die Flexibilität dieser Umgebung eröffnet zusammen mit einer robusten Revit-Datenbank neue Perspektiven für BIM.
Dieses Kapitel behandelt die Dynamo-Arbeitsabläufe für BIM. Die einzelnen Abschnitte enthalten im Wesentlichen Übungen, da sich ein grafischer Algorithmeneditor für BIM am besten anhand konkreter Projekte vorstellen lässt. Zunächst erhalten Sie hier jedoch eine Einführung in die Ursprünge dieses Programms.
Da sich sowohl Revit als auch Dynamo laufend weiterentwickeln, bemerken Sie möglicherweise, dass Ihre Revit-Version nicht mit der auf Ihrem Computer installierten Version von Dynamo für Revit kompatibel ist. Weiter unten wird erläutert, welche Versionen von Dynamo für Revit mit Revit kompatibel sind.
Ein spezialisiertes Entwicklerteam und eine engagierte Community haben dafür gesorgt, dass das Projekt seit seinen Anfängen kaum wiederzuerkennen ist.
Dynamo wurde ursprünglich zur Beschleunigung von AEC-Arbeitsabläufen in Revit entwickelt. In Revit wird für jedes Projekt eine robuste Datenbank erstellt. Für den durchschnittlichen Benutzer kann jedoch der Zugriff auf diese Informationen außerhalb der Benutzeroberfläche problematisch sein. In Revit steht eine umfassende API (Application Program Interface) zur Verfügung, über die externe Entwickler eigene Werkzeuge erstellen können. Programmierer nutzen diese API schon seit Jahren. Textbasierte Skripterstellung ist jedoch nicht für jeden Benutzer möglich. Dynamo soll die Arbeit mit Revit-Daten gewissermaßen demokratisieren, indem ein leichter verständlicher grafischer Algorithmeneditor bereitgestellt wird.
Die Core-Dynamo-Blöcke ermöglichen es dem Benutzer in Verbindung mit benutzerdefinierten Revit-Blöcken, parametrische Arbeitsabläufe für Interoperabilität, Dokumentation, Analyse und Erstellung erheblich zu erweitern. Mit Dynamo können Sie lästige Arbeitsabläufe automatisieren und erfolgreich mit Entwürfen experimentieren.
Navigieren Sie in einem Revit-Projekt oder im Familieneditor zu Zusatzmodule und klicken Sie auf Dynamo.*
*Dynamo wird nur in der Datei ausgeführt, in der die Anwendung geöffnet wurde.
Wenn Sie Dynamo in Revit öffnen, wird eine neue Kategorie namens Revit angezeigt. In dieser umfassenden Erweiterung der Benutzeroberfläche stehen spezielle Blöcke für Revit-Arbeitsabläufe zur Verfügung.*
*Da die für Revit spezifische Familie von Blöcken verwendet wird, funktioniert das Dynamo-Diagramm nur, wenn Sie es in Dynamo für Revit öffnen. Wenn Sie ein Diagramm aus Dynamo für Revit beispielsweise in Dynamo Sandbox öffnen, fehlen die Revit-Blöcke.
Revit ist eine Plattform mit robusten Funktionen zum Projektmanagement. Aus diesem Grund sind parametrische Operationen in Dynamo eventuell komplex und ihre Berechnung kann viel Zeit beanspruchen. Falls die Berechnung von Blöcken in Dynamo sehr lange dauert, können Sie die Blockfunktionen anhalten ("einfrieren") und damit die Ausführung von Revit-Vorgängen unterbrechen, während Sie Ihr Diagramm entwickeln.
Da Dynamo ursprünglich für AEC erstellt wurde, bietet seine große und weiter wachsende Community ausgezeichnete Ressourcen, die es ermöglichen, von Experten der Branche zu lernen und sich mit ihnen auszutauschen. Die Dynamo-Community setzt sich zusammen aus Architekten, Ingenieuren, Programmierern und Designern, denen die Leidenschaft für Austausch und Entwicklung gemeinsam ist.
Für Dynamo steht auch ein aktives Blog zur Verfügung. Lesen Sie die neuesten Posts, um sich über neue Entwicklungen auf dem Laufenden zu halten.
Unter Zero-Touch-Import versteht man ein einfaches Verfahren zum Importieren von C#-Bibliotheken durch Zeigen und Klicken. Dynamo liest die öffentlichen Methoden einer DLL-Datei und konvertiert sie in Dynamo-Blöcke. Sie können mithilfe von Zero-Touch Ihre eigenen benutzerdefinierten Blöcke und Pakete entwickeln sowie externe Bibliotheken in die Dynamo-Umgebung importieren.
DLL-Dateien
Dynamo-Blöcke
Mit Zero-Touch können Sie Bibliotheken importieren, die nicht unbedingt für Dynamo entwickelt wurden, und Suites mit neuen Blöcken erstellen. Die aktuelle Zero-Touch-Funktion zeigt das plattformübergreifende Konzept des Dynamo-Projekts.
Erstellen Sie in Dynamo eine neue Datei und wählen Sie Datei > Bibliothek importieren.
Suchen Sie als Nächstes die DLL-Datei.
Navigieren Sie im Popup-Fenster zum Release-Ordner in Ihrer AForge-Installation. Dies ist wahrscheinlich ein Ordner ähnlich dem folgenden: C:\Program Files (x86)\AForge.NET\Framework\Release.
AForge.Imaging.dll: Für diese Fallstudie benötigen Sie nur diese eine Datei aus der AForge-Bibliothek. Wählen Sie diese DLL-Datei aus und klicken Sie auf Öffnen.
In Dynamo sollte in der Bibliothek jetzt eine Gruppe von Blöcken namens AForge hinzugekommen sein. Damit haben Sie innerhalb des visuellen Programms Zugriff auf die AForge-Bildbearbeitungsbibliothek.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Nachdem Sie die Bibliothek importiert haben, beginnen Sie mit der ersten einfachen Übung (01-EdgeDetection.dyn). Sie führen einige einfache Bildverarbeitungsvorgänge an einem Beispielbild durch, um die Funktionsweise der Bildfilter in AForge zu demonstrieren. Dabei zeigen Sie die Ergebnisse in einem Watch Image-Block an und wenden in Dynamo Filter an, die denen von Photoshop ähnlich sind.
Im File Path-Block wird lediglich der Pfad zum ausgewählten Bild als Zeichenfolge angegeben. Als Nächstes müssen Sie den Pfad in eine verwendbare Bilddatei in Dynamo konvertieren.
Verwenden Sie einen File.FromPath-Block, um das Dateipfadelement in ein Bild in der Dynamo-Umgebung zu konvertieren.
Verbinden Sie den File Path-Block mit dem File.FromPath-Block.
Um diese Datei in ein Bild zu konvertieren, verwenden Sie den Image.ReadFromFile-Block.
Schließlich zeigen Sie das Ergebnis an. Fügen Sie einen Watch Image-Block in den Ansichtsbereich ein und verbinden Sie ihn mit dem Image.ReadFromFile-Block. Sie haben AForge noch nicht verwendet, aber das Bild erfolgreich in Dynamo importiert.
Unter AForge.Imaging.AForge.Imaging.Filters (im Navigationsmenü) stehen zahlreiche Filter zur Verfügung. Sie reduzieren mithilfe eines dieser Filter die Farbsättigung des Bildes anhand von Schwellenwerten.
Fügen Sie drei Schieberegler in den Ansichtsbereich ein und ändern Sie ihre Bereiche in 0 bis 1 und ihre Schrittwerte in 0,01.
Fügen Sie den Grayscale.Grayscale-Block in den Ansichtsbereich ein. Dies ist ein AForge-Filter, der einen Graustufenfilter auf das Bild anwendet. Verbinden Sie die drei Schieberegler aus Schritt 1 mit cr, cg und cb. Legen Sie im oberen und unteren Schieberegler jeweils den Wert 1 und im mittleren den Wert 0 fest.
Damit der Graustufenfilter angewendet wird, benötigen Sie eine Aktion für das Bild. Verwenden Sie hierfür einen BaseFilter.Apply-Block. Verbinden Sie das Bild mit der image-Eingabe und den Grayscale.Grayscale-Block mit der baseFilter-Eingabe.
Wenn Sie hier einen Watch Image-Block verbinden, erhalten Sie ein entsättigtes Bild.
Sie können mithilfe von Schwellenwerten für Rot, Grün und Blau steuern, wie das Bild entsättigt werden soll. Diese Werte werden über die Eingaben des Grayscale.Grayscale-Blocks definiert. Das Bild wirkt recht dunkel. Der Grund dafür ist, dass im Schieberegler für den Grün-Wert 0 eingestellt ist.
Legen Sie im oberen und unteren Schieberegler jeweils den Wert 0 und im mittleren den Wert 1 fest. Auf diese Weise erhalten Sie deutlicheres entsättigtes Bild.
Als Nächstes wenden Sie einen zusätzlichen Filter auf das entsättigte Bild an. Das entsättigte Bild weist einen gewissen Kontrast auf. Testen Sie daher jetzt die Kantenerkennung.
Fügen Sie im Ansichtsbereich einen SobelEdgeDetector.SobelEdgeDetector-Block hinzu.
Verbinden Sie diesen mit einem BaseUsingCopyPartialFilter.Apply-Block, und verbinden Sie das entsättigte Bild mit der image-Eingabe dieses Blocks.
Die Sobel-Kantenerkennung hebt in einem neuen Bild die Kanten hervor.
Die vergrößerte Darstellung zeigt, dass die Kantenerkennung die Umrisse der Blasen mit Pixeln markiert. In der AForge-Bibliothek stehen Werkzeuge zur Verfügung, mit denen Sie aus Ergebnissen wie diesem Dynamo-Geometrie erstellen können. Dies wird in der nächsten Übung genauer betrachtet.
Nach dieser Einführung in die einfache Bildverarbeitung wird hier gezeigt, wie Sie ein Bild dazu verwenden können, um Dynamo-Geometrie zu steuern. In dieser Übung führen Sie mithilfe von AForge und Dynamo einen einfachen Live Trace-Vorgang für ein Bild durch. Dieses Beispiel ist relativ einfach: Aus einem Referenzbild werden Rechtecke extrahiert. In AForge stehen jedoch auch Werkzeuge für komplexere Operationen zur Verfügung. Sie arbeiten mit der Datei 02-RectangleCreation.dyn aus den heruntergeladenen Übungsdateien.
Navigieren Sie im File Path-Block zu grid.jpg im Übungsordner.
Verbinden Sie die übrigen Blöcke der oben gezeigten Folge, um ein durch Verlaufsparameter definiertes Raster anzuzeigen.
Nachdem Sie einen BlobCounter-Block im Ansichtsbereich hinzugefügt haben, benötigen Sie eine Funktion zur Verarbeitung des Bildes (ähnlich dem BaseFilter.Apply-Werkzeug in der vorigen Übung).
Der Process Image-Block ist jedoch nicht direkt in der Dynamo-Bibliothek sichtbar. Der Grund hierfür ist, dass die Funktion eventuell nicht im AForge-Quellcode sichtbar ist. Dies müssen Sie mit einer Umgehungslösung beheben.
Fügen Sie im Ansichtsbereich einen Python-Block hinzu, und geben Sie im Python-Block den folgenden Code ein. Dieser Code importiert die AForge-Bibliothek und verarbeitet dann das importierte Bild.
Indem Sie die image-Ausgabe mit der Eingabe des Python-Blocks verbinden, erhalten Sie ein AForge.Imaging.BlobCounter-Ergebnis aus dem Python-Block.
Verbinden Sie die Ausgabe des Python-Skripts mit BlobCounterBase.GetObjectRectangles. Dieser Block liest Objekte in einem Bild anhand eines Schwellenwerts und extrahiert quantifizierte Rechtecke aus dem Pixelraum.
Fügen Sie einen weiteren Python-Block in den Ansichtsbereich ein, verbinden Sie ihn mit GetObjectRectangles und geben Sie den unten stehenden Code ein. Dadurch erhalten Sie eine strukturierte Liste von Dynamo-Objekten.
Vertauschen Sie die Listenebenen aus der Ausgabe des Python-Blocks aus dem vorigen Schritt mithilfe von Transpose. Dadurch erhalten Sie vier Listen, jeweils mit den x-, y-, Breiten- und Höhenwerten der einzelnen Rechtecke.
Mithilfe eines Codeblocks ordnen Sie die Daten in einer für den Rectangle.ByCornerPoints-Block geeigneten Struktur (mithilfe des folgenden Codes).
Wir sehen eine Reihe von Rechtecken, die die weißen Quadrate aus dem Bild darstellen. Durch diese Programmierung haben Sie einen Vorgang durchgeführt, der der Live Trace-Funktion von Illustrator recht nahe kommt.
Das Ergebnis muss jedoch noch bereinigt werden. Die vergrößerte Darstellung zeigt, dass einige unerwünschte kleine Rechtecke vorhanden sind.
Als Nächstes schreiben wir Code, um unerwünschte Rechtecke zu entfernen.
Fügen Sie einen Python-Block zwischen dem GetObjectRectangles-Block und einem anderen Python-Block ein. Der Code für diesen Block wird unten gezeigt. Er entfernt alle Rechtecke, die kleiner als die angegebene Größe sind.
Damit haben Sie die überflüssigen Rechtecke beseitigt. Erstellen Sie jetzt interessehalber eine Oberfläche aus diesen Rechtecken und extrudieren Sie diese um eine Entfernung in Abhängigkeit von ihrer Fläche.
Ändern Sie zum Schluss die both_sides-Eingabe in "false". Damit erhalten Sie eine Extrusion in nur eine Richtung. Tauchen Sie diese Form in Kunstharz, um den perfekten Tisch für Nerds zu erhalten!
Symbol | Name/Syntax | Eingaben | Ausgaben |
---|---|---|---|
Als Nächstes müssen wir entscheiden, welche Schlüssel wir verwenden, um diese Daten zu suchen. (Informationen zu Schlüsseln finden Sie im Abschnitt ).
Originalbild mit freundlicher Genehmigung von:
Wählen Sie neben DynamoUnfold das Optionsmenü aus.
Sie können auch auf der nach Dynamo-Paketen suchen. Hier finden Sie die Statistiken zu Paketen und zu den Ranglisten der Autoren. Sie können die Paketdateien auch über den Dynamo Package Manager herunterladen, der direkte Download in Dynamo ist jedoch ein nahtloserer Ablauf.
Sie beginnen mit einem Diagramm, das in einem benutzerdefinierten Block verschachtelt werden soll. In diesem Beispiel erstellen Sie ein Diagramm, mit dem Polygone aus einer Basisoberfläche mithilfe von UV-Koordinaten einer Zieloberfläche zugeordnet werden. Diese UV-Zuordnung wird häufig verwendet. Sie bietet sich daher für einen benutzerdefinierten Block an. Weitere Informationen zu Oberflächen und UV-Raum finden Sie auf der Seite . Das vollständige Diagramm ist UVmapping_Custom-Node.dyn aus der oben heruntergeladenen ZIP-Datei.
Zur Entwicklung benutzerdefinierter Blöcke in Dynamo steht eine große Vielfalt an Methoden zur Verfügung. In den Beispielen in diesem Kapitel erstellen Sie benutzerdefinierte Blöcke direkt in der Dynamo-Benutzeroberfläche. Wenn Sie Programmierer sind und Interesse an C# oder Zero-Touch-Formatierung haben, finden Sie auf im Dynamo-Wiki eine genauere Erklärung.
Ausgaben: Diese Blöcke funktionieren ähnlich wie Input-Blöcke, dienen jedoch zum Erstellen und Benennen der Ausgaben des benutzerdefinierten Blocks. Es ist sinnvoll, den Ein- und Ausgaben benutzerdefinierte Kommentare hinzuzufügen, um den Typ der Ein- bzw. Ausgabe zu verdeutlichen. Dies wird im Abschnitt genauer beschrieben.
In der unten folgenden Übung werden einige grundlegende Operationen für Netze unter Verwendung von Mesh Toolkit gezeigt. In der Übung schneiden Sie ein Netz mit einer Folge von Ebenen. Wenn Sie hierfür Volumenkörper verwenden, kann dies sehr viel Rechenaufwand erfordern. Bei Netzen ist die "Auflösung" im Gegensatz zu Volumenkörpern festgelegt. Darüber hinaus werden Netze nicht mathematisch, sondern topologisch definiert und die Auflösung kann für die Zwecke der jeweiligen Aufgabe definiert werden. Weitere Informationen zum Verhältnis von Netzen und Volumenkörpern finden Sie im Kapitel in diesem Leitfaden. Eine genauere Analyse von Mesh Toolkit finden Sie auf der Die folgende Übung zeigt die Verwendung dieses Pakets.
Dieses Beispiel zeigt die Unterteilung einer Oberfläche anhand eines Rasters aus Rechtecken mithilfe von PointsToSurface. Dieser Vorgang ist Ihnen wahrscheinlich vertraut, da ein ähnlicher Arbeitsablauf im gezeigt wurde.
Revit-Version | Erste stabile Version von Dynamo | Letzte unterstützte Version von Dynamo für Revit |
---|
Weitere Informationen zum Anhalten von Blöcken finden Sie im Abschnitt .
Dynamo ist ein Open Source-Projekt und entwickelt sich daher ständig weiter. Ein großer Teil dieser Entwicklungen steht in Verbindung mit Revit. Wenn Sie neu hinzugekommen sind, können Sie damit beginnen, im Diskussionsforum . Programmierer, die sich an der Entwicklung von Dynamo beteiligen möchten, finden alles Nötige im . Eine hervorragende Ressource für Bibliotheken externe Bibliotheken ist auch der . Viele dieser Pakete werden für die Verwendung mit AEC entwickelt. In diesem Kapitel werden solche extern entwickelten Pakete für die Unterteilung von Oberflächen in Felder vorgestellt.
In diesem Abschnitt wird gezeigt, wie Sie mithilfe von Zero-Touch externe Bibliotheken importieren können. Informationen zum Entwickeln eigener Zero-Touch-Bibliotheken finden Sie auf der .
Zero-Touch-Pakete sind eine gute Ergänzung für benutzerdefinierte Blöcke. In der folgenden Tabelle sind einige Pakete angegeben, in denen C#-Bibliotheken verwendet werden. Genauere Informationen über die Pakete finden Sie im im Anhang.
In dieser Fallstudie wird der Import der externen -DLL-Bibliothek gezeigt. AForge ist eine zuverlässige Bibliothek mit einem breiten Spektrum von Funktionen, angefangen mit der Bildbearbeitung und bis hin zu künstlicher Intelligenz. Hier referenzieren Sie die Bildverarbeitungsklasse von AForge für die im weiteren Verlauf dieses Abschnitts folgenden Übungen zur Bildverarbeitung.
Beginnen Sie, indem Sie AForge herunterladen. Wählen Sie auf der die Option [Download Installer]. Wenn der Download abgeschlossen ist, installieren Sie das Programm.
Um ein Bild zu importieren, fügen Sie einen File Path-Block im Ansichtsbereich hinzu, und wählen Sie die Datei "soapbubbles.jpg" aus dem Übungsordner (Foto: ) aus.
Im nächsten Schritt sollen die weißen Quadrate in diesem Bild referenziert und in Dynamo-Geometrie konvertiert werden. AForge bietet eine Vielfalt leistungsstarker Computer Vision-Werkzeuge. Hier verwenden Sie ein besonders wichtiges Werkzeug in der Bibliothek: .
Die Vorgänge in den nächsten Schritten setzen eine gewisse Kenntnis der voraus. Für die Arbeit mit Dynamo müssen Sie diese nicht komplett erlernen. Dies dient mehr zur Demonstration der Arbeit mit externen Bibliotheken innerhalb der Dynamo-Umgebung mit ihrer großen Flexibilität.
Die hier gezeigten Beispiele sind relativ einfach, die beschriebenen Konzepte jedoch lassen sich auf faszinierende reale Anwendungen übertragen. Computer Vision kann für eine Vielzahl von Prozessen verwendet werden. Hierzu gehören, um nur einige Beispiele zu nennen, Barcode-Scanner, Perspective Matching, und . Erweiterte Themen mit AForge für diese Übung finden Sie in .
Dynamo wurde ursprünglich im Hinblick auf Revit entwickelt, doch seine Vielseitigkeit als visuelles Programmierwerkzeug geht über Revit hinaus. Dynamo ist auch in Civil 3D integriert, sodass Benutzer leistungsstarke Automatisierungsroutinen für Infrastrukturprojekte erstellen können. Es ist ein äußerst nützliches Werkzeug für die Verarbeitung von gängigen Aufgaben bis hin zu komplexen Arbeitsabläufen und hilft Ihnen letztendlich, Zeit zu sparen, Ihre Entwürfe zu optimieren und bessere Konstruktionsentscheidungen zu treffen. In Dynamo stehen eine ganze Suite mit eigens für Civil 3D entwickelten Blöcken sowie Bibliotheken anderer Anbieter aus der sehr aktiven Community zur Verfügung.
In diesem Kapitel der Einführung beschäftigen wir uns mit Dynamo for Civil 3D, beginnend mit den Grundlagen. Später folgen dann Themen für fortgeschrittenere Benutzer.
Im Laufe der Zeit werden Sie möglicherweise Wissen über die Grundlagen von Dynamo hinaus benötigen und sich mit den fortgeschrittenen Funktionsweise von Dynamo vertraut machen müssen. Auf den Seiten in diesem Abschnitt erfahren Sie, wie Sie erweiterte Funktionen in Dynamo for Civil 3D nutzen und so Ihre Diagramme weiter optimieren können.
Object.IsNull
obj
bool
ARGB-Farbe (Color.ByARGB)
A, R, G, B
color
Alpha (Color.Alpha)
color
A
Rot (Color.Red)
color
R
Grün (Color.Green)
color
G
Blau (Color.Blue)
color
B
Komponenten (Color.Components)
color
A, R, G, B
Farbton (Color.Hue)
color
Hue
Sättigung (Color.Saturation)
color
Saturation
Helligkeit (Color.Brightness)
color
Brightness
2013 |
2014 |
2015 |
2016 |
2017 |
2018 |
2019 |
2020+ | 2.1.0 – Revit 2020+ enthält jetzt Dynamo. Dynamo wird entsprechend aktualisiert. | - |
Logo/Abbildung | Name |
Addieren (+)
var[]...[], var[]...[]
var[]...[]
Subtrahieren (-)
var[]...[], var[]...[]
var[]...[]
Multiplizieren (*)
var[]...[], var[]...[]
var[]...[]
Dividieren (/)
var[]...[], var[]...[]
var[]...[]
Wenn (If)
test, true, false
result
Formel (IF(x,y,z))
x, y, z
result
Codeblock ((x?y:z);)
x? y, z
result
Revit ist eine datenintensive Umgebung. Dadurch steht ein ganzes Spektrum von Auswahlfunktionen über das gewohnte "Zeigen und Klicken" hinaus zur Verfügung. Es ist möglich, während der Durchführung parametrischer Vorgänge die Revit-Datenbank abzufragen und Revit-Elemente dynamisch mit Dynamo-Geometrie zu verknüpfen.
Die in der Benutzeroberfläche enthaltene Revit-Bibliothek enthält die Kategorie "Selection" mit mehreren Möglichkeiten zur Auswahl von Geometrie.
Damit Sie Revit-Elemente Ihren Zwecken entsprechend auswählen können, müssen Sie die Elementhierarchie in Revit kennen. Sollen alle Wände in einem Projekt ausgewählt werden? Wählen Sie sie nach Kategorie aus. Möchten Sie alle Eames-Stühle in Ihrer Diele im Stil der Jahrhundertmitte auswählen? In diesem Fall wählen Sie sie nach Familie aus.
Lassen Sie uns kurz über die Revit-Hierarchie sprechen.
Dies lässt sich mit der Taxonomie in der Biologie vergleichen: Reich, Stamm, Klasse, Ordnung, Familie, Gattung, Art. Die Elemente in Revit sind auf ähnliche Weise geordnet. Die Revit-Hierarchie gliedert sich grundsätzlich in Kategorien, Familien, Typen* und Exemplare. Ein Exemplar ist ein einzelnes Modellelement (mit eindeutiger ID), während eine Kategorie eine allgemeine Gruppe definiert (z. B. Wände oder Geschossdecken). Diese Struktur der Revit-Datenbank ermöglicht es, ein Element und anhand der angegebenen Ebene in der Hierarchie auch alle ihm ähnlichen Elemente auszuwählen.
*Typen sind in Revit auf andere Weise definiert als in der Programmierung. In Revit ist mit einem Typ ein Zweig in der Hierarchie, nicht ein "Datentyp" gemeint.
Die drei Abbildungen unten zeigen die wichtigsten Kategorien für die Auswahl von Revit-Elementen in Dynamo im Detail. Sie lassen sich hervorragend miteinander kombinieren, was in den weiter unten folgenden Übungen genauer beschrieben wird.
Zeigen und Klicken: Dies ist das einfachste Verfahren zur direkten Auswahl von Revit-Elementen. Sie können dabei ein vollständiges Modellelement oder nur Teile seiner Topologie (z. B. eine Fläche oder Kante) auswählen. Diese bleiben dynamisch mit dem Revit-Objekt verknüpft, d. h., wenn in der Revit-Datei die Position oder Parameter geändert werden, wird das referenzierte Dynamo-Element im Diagramm aktualisiert.
Dropdown-Menüs: In diesen Menüs wird eine Liste aller Elemente im Revit-Projekt erstellt, auf die Sie zugreifen können. Über diese können Sie Revit-Elemente referenzieren, die eventuell in der jeweiligen Ansicht nicht sichtbar sind. Dieses Werkzeug eignet sich hervorragend zum Abfragen bestehender und zum Erstellen neuer Elemente in einem Revit-Projekt oder im Familieneditor.
![](../.gitbook/assets/selecting _database_navigation_with_dynamo_nodes_02.png)
Sie können darüber hinaus Revit-Elemente anhand ihrer Ebene in der Revit-Hierarchie auswählen. Diese Option erweist sich als hocheffizient, wenn große Datenmengen zur Vorbereitung der Dokumentation oder für die generative Instanziierung und Anpassung verarbeitet werden müssen.
Die drei oben stehenden Abbildungen bilden die Grundlage für die folgende Übung, in der Sie Elemente in einem einfachen Revit-Projekt auswählen. Dies dient als Vorbereitung für die parametrischen Anwendungen, die Sie in den übrigen Abschnitten dieses Kapitels erstellen.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Diese Revit-Beispieldatei enthält drei Elementtypen eines einfachen Gebäudes. Diese dient als Beispiel für die Auswahl von Revit-Elementen innerhalb der Revit-Hierarchie.
Gebäudekörper
Träger (Tragwerkselemente)
Fachwerk (adaptive Bauteile)
Welche Schlussfolgerungen erlauben die momentan in der Revit-Projektansicht angezeigten Elemente? Welche Ebene in der Hierarchie wird zur Auswahl der gewünschten Elemente benötigt? Bei der Arbeit in umfangreichen Projekten gestalten sich diese Fragen selbstverständlich komplexer. Es stehen zahlreiche Optionen zur Verfügung: Sie können Elemente nach Kategorien, Ebenen, Familien, Exemplaren usw. auswählen.
In diesem Fall liegt eine einfache Struktur vor. Wählen Sie daher den Gebäudekörper, indem Sie im Menüblock Categories die Option Mass wählen. Sie finden dies über Revit > Selection.
Die Ausgabe der Kategorie Mass ist die Kategorie selbst. Wir müssen jedoch Elemente auswählen. Verwenden Sie hierfür den Block All Elements of Category.
Bis jetzt wird noch keine Geometrie in Dynamo angezeigt. Sie haben ein Revit-Element ausgewählt, dieses jedoch noch nicht in Dynamo-Geometrie konvertiert. Diese Unterscheidung ist wichtig. Angenommen, Sie wählen eine große Zahl von Elementen aus. In diesem Fall wäre es nicht sinnvoll, alle diese Elemente in der Vorschau in Dynamo anzuzeigen, da dies die Leistung beeinträchtigen würde. Dynamo ist ein Werkzeug zur Verwaltung von Revit-Projekten, ohne dass notwendigerweise Geometrie verarbeitet wird. Dies wird im nächsten Abschnitt dieses Kapitels näher betrachtet.
In diesem Fall arbeiten Sie jedoch mit einfacher Geometrie, die in der Dynamo-Vorschau angezeigt werden kann. Neben dem Eintrag "BldgMass" im oben gezeigten Watch-Block steht eine grün unterlegte Nummer. Dies ist die ID des Elements. Sie weist außerdem darauf hin, dass wir es mit einem Revit-Element zu tun haben, und nicht mit Dynamo-Geometrie. Im nächsten Schritt konvertieren Sie dieses Revit-Element in Dynamo-Geometrie.
Mithilfe des Element.Faces-Blocks erhalten Sie eine Liste von Oberflächen, die die einzelnen Flächen des Revit-Körpers repräsentieren. Die Geometrie wird jetzt im Dynamo-Ansichtsfenster angezeigt und Sie können damit beginnen, Flächen für parametrische Operationen zu referenzieren.
Eine Alternative dazu wird im Folgenden beschrieben. In diesem Fall nehmen Sie die Auswahl nicht über die Revit-Hierarchie (All Elements of Category) vor, sondern wählen Geometrie explizit in Revit aus.
Klicken Sie im Select Model Element-Block auf die Schaltfläche *"select" *(oder "change"). Wählen Sie im Revit-Ansichtsfenster das gewünschte Element aus. In diesem Fall ist dies der Gebäudekörper.
Anstelle von Element.Faces können Sie mithilfe von Element.Geometry den gesamten Körper als Volumengeometrie auswählen. Dadurch wird die gesamte in diesem Körper enthaltene Geometrie ausgewählt.
Mit Geometry.Explode erhalten Sie ebenfalls die Liste der Oberflächen. Diese beiden Blöcke haben dieselbe Wirkung wie Element.Faces, aber sie bieten andere Optionen zum Ansteuern der Geometrie eines Revit-Elements.
Mithilfe einiger einfacher Listenoperationen können Sie eine bestimmte Fläche abrufen, die für Ihre Zwecke von Interesse ist.
Geben Sie zunächst die ausgewählten Elemente von zuvor an den Element.Faces-Block aus.
Der List.Count-Block zeigt dann, dass 23 Oberflächen im Körper enthalten sind.
Ändern Sie entsprechend dieser Zahl den Höchstwert im *Integer Slider *zu 22.
Geben Sie in List.GetItemAtIndex die Listen und die Werte aus dem *Integer Slider *für index ein. Wählen Sie durch Ziehen des Schiebereglers die Werte nacheinander aus und halten Sie bei index 9 an: Damit haben Sie die Hauptfassade ausgewählt, an der sich die Fachwerkelemente befinden.
Der letzte Schritt war etwas umständlich. Dasselbe Ergebnis erzielen Sie schneller mit dem Select Face-Block. Damit können Sie Flächen auswählen, die keine eigenständigen Elemente im Revit-Projekt sind. Dabei verwenden Sie dieselbe Interaktion wie bei Select Model Element, wobei Sie allerdings nicht das ganze Element, sondern nur die Oberfläche auswählen.
Angenommen, Sie möchten nur die Hauptfassaden des Gebäudes auswählen. Dies ist mithilfe des Select Faces-Blocks möglich. Klicken Sie auf die Schaltfläche Select, und wählen Sie dann die vier Hauptfassaden in Revit aus.
Achten Sie darauf, nach der Auswahl der vier Wände in Revit auf Fertig stellen zu klicken.
Damit werden die Flächen als Oberflächen in Dynamo importiert.
Als Nächstes arbeiten Sie mit den Trägern über dem Foyer.
Wählen Sie mithilfe des Select Model Element-Blocks einen der Träger aus.
Verbinden Sie das Trägerelement mit dem Element.Geometry-Block. Damit wird der Träger ins Dynamo-Ansichtsfenster übernommen.
In einem Watch3D-Block können Sie die Geometrie vergrößert anzeigen. (Falls der Träger dort nicht angezeigt wird, klicken Sie mit der rechten Maustaste und wählen Sie "Zoom anpassen".)
In Arbeitsabläufen mit Revit/Dynamo stellt sich häufig die Frage: Wie kann ich ein Element auswählen und alle weiteren ähnlichen Elemente abrufen? Da im ausgewählten Revit-Element sämtliche Informationen seiner Hierarchie enthalten sind, können Sie seinen Familientyp abrufen und dadurch alle Elemente dieses Typs auswählen.
Verbinden Sie das Trägerelement mit einem Element.ElementType-Block.
Im Watch-Block ist zu erkennen, dass anstelle eines Revit-Elements jetzt ein Familiensymbol ausgegeben wird.
Element.ElementType ist eine einfache Abfrage, d. h., Sie erzielen mithilfe eines Codeblocks mit der Eingabe
x.ElementType;
ebenso leicht dasselbe Ergebnis.
Verwenden Sie zum Auswählen der übrigen Träger den All Elements of Family Type-Block.
Im Watch-Block wird angezeigt, dass fünf Revit-Elemente ausgewählt sind.
Alle diese fünf Elemente können ebenfalls in Dynamo-Geometrie umgewandelt werden.
Was würde geschehen, wenn 500 Träger vorhanden wären? Alle diese Elemente in Dynamo-Geometrie zu konvertieren, würde sehr viel Zeit in Anspruch nehmen. Falls die Berechnung von Blöcken in Dynamo sehr lange dauert, können Sie die Blockfunktionen anhalten ("einfrieren") und damit die Ausführung von Revit-Vorgängen unterbrechen, während Sie Ihr Diagramm entwickeln. Weitere Informationen zum Anhalten von Blöcken finden Sie im entsprechenden Abschnitt im Kapitel Körper.
Angenommen, Sie möchten 500 Träger importieren: Benötigen Sie in diesem Fall sämtliche Oberflächen, um die beabsichtigte parametrische Operation durchzuführen? Oder können Sie grundlegende Informationen aus den Trägern extrahieren und generative Aufgaben mit Basisgeometrie durchführen? Diese Frage wird im weiteren Verlauf dieses Kapitels behandelt. Als Beispiel sehen wir uns nun das Fachwerksystem an.
Wählen Sie mithilfe desselben Diagramms aus Blöcken nicht das Träger-, sondern das Fachwerkelement aus. Löschen Sie jedoch zuvor den Element.Geometry-Block aus dem vorigen Schritt.
Als Nächstes extrahieren Sie grundlegende Informationen aus dem Fachwerkbinder-Familientyp.
Im Watch-Block wird eine Liste der in Revit ausgewählten adaptiven Bauteile angezeigt. Da grundlegende Informationen extrahiert werden sollen, beginnen Sie mit den adaptiven Punkten.
Verbinden Sie den All Elements of Family Type-Block mit dem AdaptiveComponent.Location-Block. Dadurch erhalten Sie eine Liste von Listen mit je drei Punkten für die Positionen der adaptiven Punkte.
Indem Sie einen Polygon.ByPoints-Block verbinden, erhalten Sie eine Polykurve. Dies ist im Dynamo-Ansichtsfenster zu erkennen. Mithilfe dieses Verfahrens haben Sie die Geometrie eines Elements visualisiert und die Geometrie der verbleibenden Reihen von Elementen abstrahiert (wobei mehr Elemente als in diesem Beispiel vorhanden sein könnten).
Tipp: Wenn Sie in Dynamo auf die grün unterlegte Nummer eines Revit-Elements klicken, wird im Revit-Ansichtsfenster auf dieses Element eingezoomt.
Dynamo ist eine flexible Umgebung und für die Verwendung mit vielen verschiedenen Programmen vorgesehen. Ursprünglich wurde Dynamo allerdings für Revit entwickelt. Ein visuelles Programm eröffnet ein breites Spektrum an Möglichkeiten für Gebäudemodelle (Building Information Models, BIM). In Dynamo stehen eine ganze Suite mit eigens für Revit entwickelten Blöcken sowie Bibliotheken anderer Anbieter aus der sehr erfolgreichen AEC-Community zur Verfügung. Dieses Kapitel behandelt die Grundlagen der Verwendung von Dynamo in Revit.
Zu den leistungsstarken Funktionen von Dynamo gehört die Möglichkeit zum Bearbeiten von Parametern auf parametrischer Ebene. Sie können beispielsweise die Parameter eines Arrays aus Elementen mithilfe eines generativen Algorithmus oder der Ergebnisse einer Simulation steuern. Auf diese Weise können Sie einer Gruppe von Exemplaren aus derselben Familie benutzerdefinierte Eigenschaften im Revit-Projekt zuweisen.
Exemplarparameter definieren die Öffnung der Elemente in der Dachoberfläche mit einem Öffnungsanteil zwischen 0.1 und 0.4.
Typenparameter werden auf sämtliche Elemente der Oberfläche angewendet, da diese zum selben Familientyp gehören. So kann beispielsweise das Material der einzelnen Elemente durch einen Typenparameter gesteuert werden.
Wenn Sie zuvor schon Revit-Familien eingerichtet haben, beachten Sie, dass Sie einen Parametertyp (Zeichenfolge, Zahl, Bemaßung usw.) zuweisen müssen. Achten Sie darauf, beim Zuweisen von Parametern in Dynamo den richtigen Datentyp zu verwenden.
Sie können Dynamo auch zusammen mit parametrischen Abhängigkeiten verwenden, die in den Eigenschaften einer Revit-Familie festgelegt wurden.
Rufen Sie sich zunächst ins Gedächtnis zurück, dass in Revit Typen- und Exemplarparameter verwendet werden. Beide können in Dynamo bearbeitet werden. In der folgenden Übung verwenden Sie jedoch Exemplarparameter.
Während Sie das breite Spektrum der Verwendungsmöglichkeiten für die Parameterbearbeitung kennenlernen, müssen Sie in manchen Fällen eventuell sehr zahlreiche Revit-Elemente mit Dynamo bearbeiten. Solche Vorgänge können sehr rechenintensiv sein und laufen deshalb eventuell nur langsam ab. Bei der Bearbeitung zahlreicher Elemente kann es daher sinnvoll sein, die Ausführung von Revit-Vorgängen mithilfe der Funktion Anhalten vorübergehend zu unterbrechen, während Sie das Diagramm entwickeln. Weitere Informationen zum Anhalten von Blöcken finden Sie im Abschnitt Anhalten im Kapitel Körper.
In Dynamo werden ab Version 0.8 grundsätzlich keine Einheiten verwendet. Dadurch bleibt Dynamo als abstrakte visuelle Programmierumgebung erhalten. Dynamo-Blöcke, die mit Revit-Bemaßungen interagieren, referenzieren die Einheiten aus dem Revit-Projekt. Wenn Sie beispielsweise in Revit einen Längenparameter aus Dynamo festlegen, entspricht dessen Zahlenwert in Dynamo den Vorgabeeinheiten im Revit-Projekt. Für die unten stehende Übung werden Meter verwendet.
Verwenden Sie zur schnellen Konvertierung von Einheiten den Block Convert Between Units. Dies ist ein sehr hilfreiches Werkzeug zum Konvertieren von Längen-, Flächen- und Volumeneinheiten nach Bedarf.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Die unten stehende Übung wird in Metern durchgeführt.
In dieser Übung bearbeiten Sie Revit-Elemente, ohne geometrische Operationen in Dynamo auszuführen. In diesem Fall importieren Sie keine Dynamo-Geometrie, sondern bearbeiten lediglich Parameter in einem Revit-Projekt. Dies ist eine Übung zu Grundlagen. Benutzer mit fortgeschrittenen Revit-Kenntnissen sollten beachten, dass hier zwar die Exemplarparameter eines Körpers behandelt werden, mithilfe derselben Logik jedoch auch Arrays von Elementen umfassend angepasst werden können. Für diesen Vorgang wird der Element.SetParameterByName-Block verwendet.
Beginnen Sie mit der Revit-Beispieldatei für diesen Abschnitt. Die Trägerelemente und adaptiven Fachwerkbinder aus dem vorigen Abschnitt wurden entfernt. Thema dieser Übung ist ein parametrisches Gerüst in Revit und seine Bearbeitung in Dynamo.
Wenn Sie das Gebäude in Revit unter Körper auswählen, wird in der Eigenschaftenpalette eine Reihe von Exemplarparametern angezeigt.
In Dynamo können Sie die Parameter abrufen, indem Sie das Zielelement auswählen.
Wählen Sie den Gebäudekörper mithilfe des Select Model Element-Blocks aus.
Sie können sämtliche Parameter dieses Körpers mithilfe des Element.Paramaters-Blocks abrufen. Dazu gehören Typen- und Exemplarparameter.
Referenzieren Sie den Element. Parameter-Block, um Zielparameter zu finden. Sie können stattdessen auch die Eigenschaftenpalette aus dem vorigen Schritt anzeigen, um die Namen der zu bearbeitenden Parameter zu wählen. In diesem Fall suchen Sie nach den Parametern, die sich auf die großräumigen geometrischen Veränderungen des Gebäudekörpers auswirken.
Wir nehmen mithilfe des Element.SetParameterByName-Blocks Änderungen am Revit-Element vor.
Verwenden Sie einen Code Block, um eine Liste von Parametern mit Anführungszeichen um jedes Element zu definieren, um eine Zeichenfolge zu kennzeichnen. Sie können auch den List.Create-Block mit einer Reihe von string-Blöcken verwenden, die mit mehreren Eingaben verbunden sind, aber der Codeblock ist schneller und einfacher. Stellen Sie sicher, dass die Zeichenfolge dem exakten Namen in Revit entspricht, in diesem Fall:
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};
Darüber hinaus müssen Sie Werte für die einzelnen Parameter festlegen. Fügen Sie sechs Integer Slider-Blöcke in den Ansichtsbereich ein und weisen Sie ihnen die Namen der entsprechenden Parameter in der Liste zu. Legen Sie außerdem in den einzelnen Schiebereglern die in der Abbildung oben gezeigten Werte fest. Dies sind die folgenden Werte (von oben nach unten: 62, 92, 25, 22, 8, 12.
Definieren Sie einen weiteren Code Block mit einer Liste von derselben Länge wie die Liste der Parameternamen. In diesem Fall geben Sie dabei Variablennamen (ohne Anführungszeichen) an und erhalten dadurch Eingaben für den Code Block. Verbinden Sie die Schieberegler mit den entsprechenden Eingaben:
{bw,bl,bh,ao,io,lu};
Verbinden Sie den Codeblock mit der Werteingabe Element.SetParameterByName*. Ist die Option Automatisch ausführen aktiviert, werden die Ergebnisse sofort angezeigt.
*Diese Demonstration kann nur mit Exemplarparametern, nicht jedoch mit Typenparametern durchgeführt werden.
Viele dieser Parameter sind genau wie in Revit voneinander abhängig. Dabei können manche Kombinationen selbstverständlich zu ungültiger Geometrie führen. Dieses Problem können Sie mithilfe definierter Formeln in den Parametereigenschaften beheben. Sie können stattdessen auch eine ähnliche Logik mit mathematischen Operationen in Dynamo einrichten. (Sie könnten dies als Zusatzübung ausprobieren.)
Mit der folgenden Kombination erhalten Sie ein recht originelles Design für den Gebäudekörper: 100, 92, 100, 25, 13, 51.
Als Nächstes sehen wir uns an, wie die Fassade mit einem ähnlichen Prozess bearbeitet werden kann.
Kopieren Sie für diese Aufgabe das Diagramm, um mit der Fassadenverglasung zu arbeiten, an der das Fachwerksystem angebracht werden soll. In diesem Fall isolieren Sie vier Parameter:
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
Erstellen Sie darüber hinaus Number Slider-Blöcke und ändern Sie ihre Namen in die der entsprechenden Parameter. Weisen Sie den ersten drei Schiebereglern (von oben nach unten) die Domäne [0,10], dem letzten Schieberegler Facade Bend Location hingegen die Domäne [0,1] zu. Diese Werte sollten von oben nach unten, mit den folgenden Angaben beginnen (wobei diese hier beliebig gewählt wurden): 2.68, 2.64, 2.29, 0.5.
Definieren Sie einen neuen Codeblock, und verbinden Sie die Schieberegler:
{so,mo,no,fbl};
Indem Sie die Werte der Schieberegler für diesen Teil des Diagramms ändern, können Sie die Fassadenverglasung erheblich verstärken: 9.98, 10.0, 9.71, 0.31.
Die Bearbeitung von Parametern für die Dokumentation schließt sich an die in den vorigen Abschnitten behandelten Aufgaben an. In diesem Abschnitt bearbeiten Sie Parameter, mit deren Hilfe Sie nicht die geometrischen Eigenschaften von Elementen steuern, sondern eine Revit-Datei für die Konstruktionsunterlagen erstellen können.
In der folgenden Übung verwenden Sie einen einfachen Block für die Abweichung von der Ebene, um einen Revit-Plan für die Dokumentation zu erstellen. Die einzelnen Elemente der parametrisch definierten Dachkonstruktion weisen unterschiedliche Abweichungswerte auf. Die Werte innerhalb dieses Bereichs sollen mithilfe von Farben gekennzeichnet und die adaptiven Punkte in einer Bauteilliste ausgegeben werden, sodass die Daten an einen Fassadenspezialisten, Bauingenieur oder Subunternehmer weitergegeben werden können.
Der Block für die Abweichung von der Ebene berechnet, in welchem Grad die Gruppe aus vier Punkten von der optimalen Ebene zwischen ihnen abweicht. Dies ist eine schnelle und einfache Möglichkeit zur Untersuchung der Realisierbarkeit.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Beginnen Sie mit der Revit-Datei für diesen Abschnitt (oder verwenden Sie weiterhin die Datei aus dem vorigen Abschnitt). Diese Datei zeigt eine Gruppe von EFTE-Elementen auf dem Dach. Diese Elemente werden in dieser Übung referenziert.
Fügen Sie einen Family Types-Block in den Ansichtsbereich ein und wählen Sie ROOF-PANEL-4PT.
Verbinden Sie diesen Block mit einem All Elements of Family Type-Block, um alle diese Elemente auszuwählen und aus Revit in Dynamo zu übernehmen.
Rufen Sie die Positionen der adaptiven Punkte für die einzelnen Elemente mithilfe eines AdaptiveComponent.Locations-Blocks ab.
Erstellen Sie mithilfe eines Polygon.ByPoints-Blocks Polygone jeweils aus den vier Eckpunkten. Dadurch erhalten Sie eine abstrakte Version des aus Einzelelementen bestehenden Systems in Dynamo, ohne dass die vollständige Geometrie des Revit-Elements importiert werden muss.
Berechnen Sie die planare Abweichung mithilfe des Polygon.PlaneDeviation-Blocks.
In der folgenden kurzen Zusatzübung legen Sie den Öffnungsgrad der einzelnen Elemente anhand ihrer planaren Abweichung fest.
Fügen Sie im Ansichtsbereich einen Element.SetParameterByName-Block hinzu und verbinden Sie die adaptiven Bauteile mit der element-Eingabe. Verbinden Sie einen Code Block mit der Angabe Aperture Ratio mit der parameterName-Eingabe.
Die Ergebnisse der Abweichungsberechnung können nicht direkt mit der value-Eingabe verbunden werden, da die Werte zunächst dem Parameterbereich neu zugeordnet werden müssen.
Ordnen Sie mithilfe von Math.RemapRange die Abweichungswerte einer Domäne zwischen 0.15 und 0_._45 zu, indem Sie
0.15; 0.45;
in den Code Block eingeben.Verbinden Sie diese Ergebnisse mit der value-Eingabe von Element.SetParameterByName.
In Revit ist die Veränderung der Öffnungen in der Oberfläche ungefähr zu erkennen.
Die vergrößerte Darstellung zeigt deutlicher, dass die weniger weit geöffneten Elemente sich näher an den Ecken befinden. Die weit geöffneten Elemente befinden sich hingegen ganz oben. Die Eckbereiche weisen stärkere Abweichungen, der Scheitel der Wölbung dagegen die geringste Krümmung auf. Das Ergebnis ist daher überzeugend.
Durch Festlegen des Öffnungsgrads wird die Abweichung der Elemente des Dachs nicht präzise dargestellt. Zudem kommt es zu Änderungen an der Geometrie des Elements selbst. Angenommen, Sie möchten lediglich die Abweichung unter dem Gesichtspunkt der Realisierbarkeit analysieren. In diesem Fall wäre es hilfreich, für die Dokumentation die Elemente in Abhängigkeit von Abweichungsbereichen farbig zu kennzeichnen. Dies ist mithilfe der folgenden Schritte möglich, wobei der Vorgang dem oben beschriebenen sehr ähnlich ist.
Entfernen Sie Element.SetParameterByName und die zugehörigen Eingabeblöcke, und fügen Sie Element.OverrideColorInView hinzu.
Fügen Sie im Ansichtsbereich einen Color Range-Block hinzu und verbinden Sie ihn mit der color-Eingabe von Element.OverrideColorInView. Um den Farbverlauf zu erstellen, müssen Sie noch die Abweichungswerte mit dem Farbbereich verbinden.
Wenn Sie den Mauszeiger auf die value-Eingabe setzen, wird angezeigt, dass Werte zwischen 0 und 1 für die Zuordnung von Farben zu Werten erforderlich sind. Sie müssen daher die Abweichungswerte für diesen Bereich neu zuordnen.
Ordnen Sie mithilfe von Math.RemapRange die Werte für die planare Abweichung dem Bereich zwischen* 0* und 1 zu. (Anmerkung: Sie können die Quelldomäne auch mithilfe eines MapTo-Blocks definieren.)
Verbinden Sie die Ergebnisse mit einem Color Range-Block.
Dadurch erhalten Sie als Ausgabe einen Bereich von Farben anstelle eines Bereichs von Zahlen.
Falls Manuell eingestellt ist, klicken Sie auf Ausführen. Für den Rest dieses Vorgangs können Sie die Einstellung Automatisch verwenden.
In Revit ist jetzt eine wesentlich übersichtlichere Darstellung mit einem Farbverlauf zu sehen, der die planare Abweichung unter Verwendung des Farbbereichs zeigt. Die Farben müssen jedoch möglicherweise angepasst werden. Momentan werden die Werte für die kleinste Abweichung in Rot angezeigt: Dies scheint das Gegenteil des erwarteten Resultats zu sein. Stattdessen soll der Höchstwert der Abweichung in Rot dargestellt werden, während für die kleinste Abweichung eine ruhigere Farbe verwendet wird. Kehren Sie zu Dynamo zurück, um dies zu korrigieren.
Geben Sie in einem Code Block zwei Zahlen in zwei getrennten Zeilen ein:
0;
und255;
.Erstellen Sie die Farben Rot und Blau, indem Sie die entsprechenden Werte mit zwei Color.ByARGB-Blöcken verbinden.
Erstellen Sie eine Liste aus diesen beiden Farben.
Verbinden Sie diese Liste mit der colors-Eingabe des Color Range-Blocks, und beobachten Sie die Aktualisierung dieses benutzerdefinierten Farbbereichs.
In Revit ist die Darstellung der Bereiche mit maximaler Abweichung in den Ecken jetzt besser verständlich. Mithilfe dieses Blocks werden Farben in einer Ansicht überschrieben. Aus diesem Grund kann es sehr hilfreich sein, wenn unter den Zeichnungen ein bestimmter Plan für einen bestimmten Analysetyp vorhanden ist.
Wenn Sie eines der ETFE-Elemente in Revit auswählen, werden vier Exemplarparameter angezeigt: XYZ1, XYZ2, XYZ3 und XYZ4. Diese sind nach der Erstellung leer. Diese Parameter sind textbasiert und benötigen Werte. Sie schreiben mithilfe von Dynamo die Positionen der adaptiven Punkte in die einzelnen Parameter. Dies verbessert die Interoperabilität, falls die Geometrie an einen Bauingenieur oder Fassadenspezialisten weitergegeben werden soll.
Der Beispielplan zeigt eine große, leere Bauteilliste. Die XYZ-Parameter sind gemeinsam genutzte Parameter in der Revit-Datei und können daher in die Bauteilliste aufgenommen werden.
Die vergrößerte Darstellung zeigt, dass die XYZ-Parameter noch ausgefüllt werden müssen. Die ersten beiden Parameter werden von Revit vorgegeben.
Um diese Werte zu schreiben, ist eine komplexe Listenoperation erforderlich. Das Diagramm selbst ist recht einfach, nutzt jedoch in großem Umfang die Listenzuordnung wie im Kapitel zu Listen beschrieben.
Wählen Sie mithilfe der oben gezeigten Blöcke alle adaptiven Bauteile aus.
Extrahieren Sie die Positionen der einzelnen Punkte mithilfe von AdaptiveComponent.Locations.
Konvertieren Sie diese Punkte in Zeichenfolgen. Beachten Sie, dass Sie hier textbasierte Parameter verwenden, und achten Sie darauf, den richtigen Datentyp einzugeben.
Erstellen Sie eine Liste mit den vier Zeichenfolgen, die die zu ändernden Parameter definieren: XYZ1, XYZ2, XYZ3 und XYZ4.
Verbinden Sie diese Liste mit der parameterName-Eingabe von Element.SetParameterByName.
Verbinden Sie Element.SetParameterByName mit der combinator-Eingabe von List.Combine. Verbinden Sie die adaptiven Bauteile mit list1. Verbinden Sie String from Object mit list2.
In diesem Vorgang werden Listen zugeordnet: Für jedes Element werden vier Werte geschrieben, wodurch eine komplexe Datenstruktur entsteht. Der List.Combine-Block definiert eine Operation, die eine Stufe tiefer in der Datenhierarchie abläuft. Aus diesem Grund wurden die Eingaben für Element und Wert von Element.SetParameterByName leer gelassen. List.Combine verbindet die Unterlisten aus seinen Eingaben mit den leeren Eingaben von Element.SetParameterByName in der Reihenfolge, in der sie verbunden wurden.
Wenn Sie jetzt ein Element in Revit auswählen, werden die Werte der einzelnen Parameter als Zeichenfolgen angezeigt. In der Praxis würden Sie ein einfacheres Format zum Schreiben von Punkten (x, y, z) erstellen. Sie könnten dies mithilfe von Zeichenfolgenoperationen in Dynamo erreichen. Da dies jedoch den Rahmen dieses Kapitels sprengen würde, wird dieses Verfahren hier nicht behandelt.
Ansicht der Bauteilliste mit ausgefüllten Parametern
Für jedes EFTE-Element sind jetzt die xyz-Koordinaten der adaptiven Punkte an seinen Ecken angegeben und können für die Fertigung der Elemente verwendet werden.
Sie können in Dynamo Arrays von Revit-Elementen mit uneingeschränkter parametrischer Steuerung erstellen. Die Revit-Blöcke in Dynamo ermöglichen das Importieren von Elementen aus allgemeiner Geometrie in spezifische Kategorietypen (z. B. Wände und Geschossdecken). In diesem Abschnitt importieren Sie Elemente mit flexiblen Parametern für adaptive Bauteile.
Ein adaptives Bauteil ist eine flexible Familienkategorie, die sich für generative Anwendungen eignet. Bei der Instanziierung können Sie ein komplexes geometrisches Element erstellen, das durch die Positionen adaptiver Punkte gesteuert wird.
Das Beispiel unten zeigt ein adaptives Bauteil mit drei Punkten im Familieneditor. Es dient zum Erstellen eines durch die Positionen der einzelnen adaptiven Punkte gesteuerten Fachwerkbinders. In der folgenden Übung erstellen Sie mithilfe dieses Bauteils eine Reihe von Fachwerkbindern an einer Fassade.
Adaptive Bauteile bieten ein gutes Beispiel für optimale Verfahren zur Interoperabilität. Sie können eine Reihe adaptiver Bauteile erstellen, indem Sie die zugrunde liegenden adaptiven Punkte definieren. Wenn Sie diese Daten in andere Programme übertragen, haben Sie die Möglichkeit, die Geometrie auf einfache Daten zu reduzieren. Dabei liegt eine ähnliche Logik zugrunde wie beim Importieren und Exportieren in Programmen wie Excel.
Angenommen, ein Berater für die Fassaden benötigt Angaben zur Position der Fachwerkelemente, möchte jedoch nicht die vollständig ausgearbeitete Geometrie analysieren. Zur Vorbereitung der Fertigung kann der Berater die Position der adaptiven Punkte ermitteln und daraus Geometrie für ein Programm wie Inventor neu generieren.
In der folgenden Übung richten Sie einen Arbeitsablauf ein, der Ihnen Zugriff auf alle diese Daten gibt und zugleich die Definition zum Erstellen von Revit-Elementen festlegt. In diesem Prozess führen Sie Konzeption, Dokumentation und Fertigung zu einem nahtlosen Arbeitsablauf zusammen. Damit erhalten Sie einen intelligenteren und effizienteren Prozess zur Interoperabilität.
In der ersten Übung unten wird gezeigt, wie Dynamo Daten für die Erstellung von Revit-Elementen referenziert. Um mehrere adaptive Bauteile zu generieren, definieren Sie eine Liste von Listen, wobei jede Liste drei Punkte enthält, die für die Punkte im adaptiven Bauteil stehen. Beachten Sie dies, während die Datenstrukturen in Dynamo verwaltet werden.
Mit DirectShape steht ein weiteres Verfahren zum Importieren parametrischer Dynamo-Geometrie in Revit zur Verfügung. Kurz zusammengefasst: Das DirectShape-Element und die dazugehörigen Klassen ermöglichen es, extern erstellte geometrische Formen in einem Revit-Dokument zu speichern. Zu dieser Geometrie können geschlossene Körper oder Netze gehören. DirectShape ist in erster Linie für den Import von Formen aus anderen Formaten wie z. B. IFC oder STEP vorgesehen, in denen nicht genügend Informationen zum Erstellen eines "echten" Revit-Elements zur Verfügung stehen. Die DirectShape-Funktionen eignen sich genau wie bei IFC- und STEP-Arbeitsabläufen auch zum Importieren mit Dynamo erstellter Geometrie als echte Elemente in Revit-Projekte.
Die zweite Übung zeigt den Ablauf für den Import von Dynamo-Geometrie als DirectShape in ein Revit-Projekt. Mithilfe dieses Verfahrens können Sie die Kategorie, das Material und den Namen der importierten Geometrie zuweisen, wobei die parametrische Verknüpfung mit dem Dynamo-Diagramm erhalten bleibt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Beginnen Sie mit der Beispieldatei für diesen Abschnitt (oder verwenden Sie weiterhin die Revit-Datei aus dem vorigen Abschnitt). Derselbe Revit-Körper wird angezeigt.
Dies ist der Zustand beim Öffnen der Datei.
Dies ist das Fachwerksystem, das Sie mit Dynamo erstellt haben, wobei eine intelligente Verknüpfung mit dem Revit-Körper genutzt wird.
Sie haben bereits mit den Blöcken Select Model Element und Select Face gearbeitet. Hier verwenden Sie Select Edge und arbeiten damit eine Ebene tiefer in der Geometriehierarchie. Stellen Sie für die Ausführung des Dynamo-Solver die Option Automatisch ein, damit das Diagramm laufend gemäß den Änderungen in der Revit-Datei aktualisiert wird. Die Kante, die Sie auswählen, ist dynamisch mit der Topologie des Revit-Elements verbunden. Solange die Topologie* unverändert bleibt, bleibt die Verknüpfung zwischen Revit und Dynamo erhalten.
Wählen Sie die oberste Kurve der verglasten Fassade aus. Diese erstreckt sich über die gesamte Länge des Gebäudes. Falls Sie bei der Auswahl der Kante Schwierigkeiten haben, können Sie in Revit den Mauszeiger auf die Kante setzen und die Tabulatortaste drücken, bis die gewünschte Kante hervorgehoben wird.
Wählen Sie über zwei Select Edge-Blöcke die beiden Kanten für den Vorsprung in der Mitte der Fassade aus.
Wiederholen Sie dies für die Kanten am unteren Ende der Fassade in Revit.
In den Watch-Blöcken wird angezeigt, dass in Dynamo jetzt Linien vorhanden sind. Diese werden automatisch in Dynamo-Geometrie konvertiert, da die Kanten selbst keine Revit-Elemente sind. Diese Kurven sind die Referenzen, die zum Instanziieren der adaptiven Fachwerkbinder entlang der Fassade verwendet werden.
*Um eine konsistente Topologie zu erhalten, wird hier ein Modell verwendet, dem keine zusätzlichen Flächen oder Kanten hinzugefügt wurden. Sie können zwar mithilfe von Parametern seine Form ändern, seine Struktur bleibt jedoch einheitlich.
Als Erstes müssen Sie die Kurven verbinden und zu einer Liste zusammenführen. Dadurch gruppieren Sie die Kurven, um geometrische Operationen durchführen zu können.
Erstellen Sie eine Liste für die beiden Kurven in der Mitte der Fassade.
Verbinden Sie die beiden Kurven zu einer Polykurve, indem Sie die List.Create-Komponente mit einem Polycurve.ByJoinedCurves-Block verbinden.
Erstellen Sie eine Liste für die beiden Kurven am unteren Rand der Fassade.
Verbinden Sie die beiden Kurven zu einer Polykurve, indem Sie die List.Create-Komponente mit einem Polycurve.ByJoinedCurves-Block verbinden.
Führen Sie schließlich die drei Hauptkurven (eine Linie und zwei Polykurven) zu einer Liste zusammen.
Danach verwenden Sie die oberste der Kurven, die eine über die gesamte Länge der Fassade verlaufende Linie ist. Sie erstellen entlang dieser Linie Ebenen, die die in der Liste zusammengefassten Kurven schneiden.
Definieren Sie in einem Code Block einen Bereich mit der Syntax:
0..1..#numberOfTrusses;
Verbinden Sie einen *Integer Slider *mit der Eingabe des Codeblocks. Dessen Werte geben naheliegenderweise die Anzahl der Fachwerkbinder an. Beachten Sie, dass der Schieberegler die Anzahl der Einträge in einem von *0 *bis 1 definierten Bereich steuert.
Verbinden Sie den Code Block mit der param-Eingabe eines Curve.PlaneAtParameter-Blocks und verbinden Sie die obere Kante mit der curve-Eingabe. Damit erhalten Sie zehn Ebenen, die gleichmäßig über die Länge der Fassade verteilt sind.
Eine Ebene ist ein abstraktes Geometrieelement, das für einen unendlichen zweidimensionalen Raum steht. Ebenen eignen sich ausgezeichnet zum Erstellen von Konturen und Schnitten wie in diesem Schritt gezeigt.
Verwenden Sie als Nächstes den Geometry.Intersect-Block (legen Sie die Vergitterungsoption auf Kreuzprodukt fest): Verbinden Sie den Curve.PlaneAtParameter-Block mit der entity-Eingabe des Geometry.Intersect-Blocks. Verbinden Sie den List.Create-Block mit der geometry-Eingabe. Im Dynamo-Ansichtsfenster werden daraufhin die Schnittpunkte der einzelnen Kurven mit den definierten Ebenen angezeigt.
Die Ausgabe ist eine Liste aus Listen von Listen. Sie enthält zu viele Listen für diesen Verwendungszweck. Sie müssen die Liste teilweise vereinfachen. Dazu müssen Sie die zweithöchste Ebene der Liste ansteuern und das Ergebnis vereinfachen. Verwenden Sie dazu die List.Map-Operation, die im Kapitel zu Listen in dieser Einführung beschrieben wird.
Verbinden Sie den Geometry.Intersect-Block mit der list-Eingabe von List.Map.
Verbinden Sie einen Flatten-Block mit der f(x)-Eingabe von List.Map. Als Ergebnis erhalten Sie drei Listen, jeweils mit so vielen Einträgen, wie Fachwerkbinder erstellt werden sollen.
Sie müssen diese Daten ändern. Für die Instanziierung des Fachwerkbinders benötigen Sie dieselbe Anzahl adaptiver Punkte wie in der Familie definiert. Dieses adaptive Bauteil weist drei Punkte auf. Sie benötigen also anstelle von drei Listen mit je zehn Einträgen (numberOfTrusses) zehn Listen mit je drei Einträgen. Auf diese Weise können Sie 10 adaptive Bauteile erstellen.
Verbinden Sie den List.Map-Block mit einem List.Transpose-Block. Damit werden die gewünschten Daten ausgegeben.
Um sich zu vergewissern, dass Sie die richtigen Daten erhalten haben, fügen Sie im Ansichtsbereich einen Polygon.ByPoints-Block hinzu und überprüfen Sie das Ergebnis in der Dynamo-Vorschau.
Ordnen Sie jetzt die adaptiven Bauteile in einem Array an, wobei Sie dasselbe Verfahren verwenden wie beim Erstellen der Polygone.
Fügen Sie im Ansichtsbereich einen AdaptiveComponent.ByPoints-Block hinzu und verbinden Sie den List.Transpose-Block mit der points-Eingabe.
Wählen Sie in einem Family Types-Block die AdaptiveTruss-Familie und verbinden Sie den Block mit der FamilyType-Eingabe des AdaptiveComponent.ByPoints-Blocks.
In Revit sind jetzt die zehn Fachwerkbinder gleichmäßig über die Länge der Fassade verteilt zu sehen.
Testen Sie das Diagramm: Erhöhen Sie den Wert für numberOfTrusses auf 30, indem Sie den Wert im Integer Slider ändern. Sie erhalten zahlreiche Fachwerkbinder: Dies mag nicht sonderlich realistisch wirken, es zeigt jedoch, dass die parametrische Verknüpfung funktionstüchtig ist. Legen Sie nach der Überprüfung numberOfTrusses auf 15 fest.
Führen Sie abschließend einen weiteren Test durch: Indem Sie in Revit den Körper auswählen und seine Exemplarparameter bearbeiten, können Sie die Form des Gebäudes ändern und beobachten, wie die Fachwerkbinder angepasst werden. Denken Sie daran, dass dieses Dynamo-Diagramm geöffnet sein muss, damit die Aktualisierung sichtbar ist. Sobald das Diagramm geschlossen wird, geht die Verknüpfung verloren.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Öffnen Sie als Erstes die Beispieldatei für diese Lektion: ARCH-DirectShape-BaseFile.rvt.
Die 3D-Ansicht zeigt den Gebäudekörper aus der letzten Lektion.
Entlang der Kante des Foyers verläuft eine Referenzkurve, die Sie in Dynamo referenzieren werden.
Entlang der gegenüberliegenden Kante des Foyers verläuft eine zweite Referenzkurve, die ebenfalls in Dynamo referenziert werden soll.
Zum Referenzieren der Geometrie in Dynamo verwenden Sie Select Model Element für die einzelnen Elemente in Revit. Wählen Sie den Körper in Revit aus und importieren Sie die Geometrie mithilfe von Element.Faces in Dynamo. Dadurch wird der Körper in der Dynamo-Vorschau angezeigt.
Importieren Sie eine der Referenzkurven mithilfe von Select Model Element und CurveElement.Curve in Dynamo.
Importieren Sie die andere Referenzkurve mithilfe von Select Model Element und CurveElement.Curve in Dynamo.
Wenn Sie das Beispieldiagramm verkleinern und nach rechts schwenken, sehen Sie eine große Gruppe von Blöcken. Diese stehen für die geometrischen Operationen, mit denen die in der Dynamo-Vorschau gezeigte Gitterkonstruktion für das Dach generiert wird. Diese Blöcke wurden mithilfe der Funktion Block zu Code erstellt, die im Abschnitt zu Codeblöcken dieser Einführung beschrieben wird.
Diese Konstruktion wird im Wesentlichen durch drei Parameter gesteuert: Diagonal Shift, Camber und Radius.
Vergrößern Sie die Darstellung der Parameter für dieses Diagramm. Indem Sie mit diesen experimentieren, erhalten Sie unterschiedliche Geometrie.
Fügen Sie im Ansichtsbereich einen DirectShape.ByGeometry-Block hinzu. Dieser Block weist die vier Eingaben geometry, category, material und name auf.
Die Geometrie ist der Körper, der mithilfe des Diagrammteils für die Geometrieerstellung erstellt wird.
Die category-Eingabe wird mithilfe der Dropdown-Liste im Categories-Block gewählt. Verwenden Sie hier "Tragwerk".
Die material-Eingabe wird über das Array von Blöcken darüber ausgewählt. In diesem Fall kann allerdings auch einfach die Vorgabe definiert werden.
Nachdem Sie Dynamo ausgeführt haben, befindet sich die importierte Geometrie im Revit-Projekt auf dem Dach. Dabei handelt es sich nicht um ein allgemeines Modell, sondern ein Tragwerkselement. Die parametrische Verknüpfung mit Dynamo bleibt erhalten.
Einer der vielen praktischen Anwendungsfälle von Dynamo ist das dynamische Platzieren einzelner Objekte entlang eines 3D-Profilkörpermodells. Häufig müssen Objekte an Positionen platziert werden, die unabhängig von den eingefügten Querschnitten entlang des 3D-Profilkörpers sind. Dies manuell zu erledigen ist sehr mühsam. Wenn sich die horizontale oder vertikale Geometrie des 3D-Profilkörpers ändert, ist ein erheblicher Überarbeitungsaufwand erforderlich.
Lesen von Daten aus einer externen Datei (in diesem Fall Excel)
Organisieren von Daten in Wörterbüchern
Steuern von Position/Skalierung/Drehung mithilfe von Koordinatensystemen
Platzieren von Blockreferenzen
Visualisieren von Geometrie in Dynamo
Dieses Diagramm wird in Civil 3D 2020 und höher ausgeführt.
Laden Sie zunächst die folgenden Beispieldateien herunter, und öffnen Sie dann die DWG-Datei und das Dynamo-Diagramm.
Die Excel-Datei sollte im selben Verzeichnis wie das Dynamo-Diagramm gespeichert werden.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Excel-Datei lesen und Daten in Dynamo importieren
Elementkanten aus der angegebenen 3D-Profilkörper-Basislinie abrufen
Koordinatensysteme entlang der 3D-Profilkörper-Elementkante an den gewünschten Stationen generieren
Koordinatensysteme zum Platzieren von Blockreferenzen im Modellbereich verwenden
Los gehts!
In diesem Beispieldiagramm verwenden wir eine Excel-Datei, um die Daten zu speichern, die Dynamo zum Platzieren der Lichtmast-Blockreferenzen verwendet. Die Tabelle sieht so aus.
Das Lesen von Daten aus externen Dateien (z. B. Excel-Dateien) mit Dynamo ist praktisch, insbesondere dann, wenn auch andere Teammitglieder die Daten nutzen müssen.
Die Excel-Daten werden wie folgt in Dynamo importiert.
Nachdem wir die Daten erstellt haben, müssen wir sie nach Spalten aufteilen (Corridor, Baseline, PointCode usw.), damit sie im restlichen Diagramm verwendet werden können. Eine gängige Methode hierfür ist die Verwendung des List.GetItemAtIndex-Blocks und die Angabe der Indexnummer für jede gewünschte Spalte. Beispiel: Die Spalte Corridor befindet sich bei Index 0, die Spalte Baseline bei Index 1 usw.
Klingt gut, oder? Doch bei diesem Ansatz gibt es ein potenzielles Problem. Was geschieht, wenn sich die Reihenfolge der Spalten in der Excel-Datei in Zukunft ändert? Oder wenn eine neue Spalte zwischen zwei Spalten hinzugefügt wird? Das Diagramm funktioniert dann nicht ordnungsgemäß und muss aktualisiert werden. Sie können das Diagramm für zukünftige Aktionen absichern, indem Sie die Daten in ein Wörterbuch einfügen, wobei die Excel-Spaltenüberschriften die Schlüssel und die übrigen Daten die Werte sind.
Wenn Wörterbücher neu für Sie sind, finden Sie im Abschnitt Wörterbücher in Dynamo weitere Informationen.
Dadurch wird das Diagramm stabiler, da es Flexibilität beim Ändern der Spaltenreihenfolge in Excel ermöglicht. Solange die Spaltenüberschriften gleich bleiben, können die Daten einfach mithilfe des Schlüssels (d. h. der Spaltenüberschrift) aus dem Wörterbuch abgerufen werden. Dies ist die Vorgehensweise beim nächsten Schritt.
Nachdem wir die Excel-Daten importiert haben und bereit für die Arbeit sind, können wir damit einige Informationen zu den 3D-Profilkörpermodellen aus Civil 3D abrufen.
Wählen Sie das 3D-Profilkörpermodell nach seinem Namen aus.
Rufen Sie eine bestimmte Basislinie innerhalb des 3D-Profilkörpers ab.
Rufen Sie eine Elementkante innerhalb der Basislinie anhand ihres Punktcodes ab.
Als Nächstes generieren wir Koordinatensysteme entlang der 3D-Profilkörper-Elementkanten an den Stationswerten, die wir in der Excel-Datei angegeben haben. Diese Koordinatensysteme werden verwendet, um die Position, Drehung und Skalierung der Lichtmast-Blockreferenzen zu definieren.
Wenn Koordinatensysteme neu für Sie sind, finden Sie im Abschnitt Vektor, Ebene und Koordinatensystem weitere Informationen.
Beachten Sie, dass zum Drehen der Koordinatensysteme hier ein Codeblock verwendet wird, je nachdem, auf welcher Seite der Basislinie sie sich befinden. Dies könnte mithilfe einer Sequenz von mehreren Blöcken erreicht werden, ist aber ein gutes Beispiel für eine Situation, in der es einfacher ist, einfach den Code zu schreiben.
Wenn Codeblöcke neu für Sie sind, finden Sie im Abschnitt Codeblöcke und DesignScript weitere Informationen.
Gleich haben wir es geschafft! Wir verfügen über alle Informationen, die wir benötigen, um die Blockreferenzen tatsächlich platzieren zu können. Als Erstes müssen wir die gewünschten Blockdefinitionen mithilfe der Spalte BlockName in der Excel-Datei abrufen.
Der letzte Schritt ist die Erstellung der Blockreferenzen.
Beim Ausführen des Diagramms sollten neue Blockreferenzen im Modellbereich entlang des 3D-Profilkörpers angezeigt werden. Wenn der Ausführungsmodus des Diagramms auf Automatisch eingestellt ist und Sie die Excel-Datei bearbeiten, werden die Blockreferenzen automatisch aktualisiert.
Weitere Informationen über die Diagrammausführungsmodi finden Sie im Abschnitt Benutzeroberfläche.
Hier sehen Sie ein Beispiel für die Ausführung des Diagramms mit Dynamo Player.
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt Dynamo Player weitere Informationen.
Es kann hilfreich sein, die 3D-Profilkörpergeometrie in Dynamo zu visualisieren, um Kontext bereitzustellen. In diesem speziellen Modell sind die 3D-Profilkörper-Volumenkörper bereits im Modellbereich extrahiert. Diese exportieren wir in Dynamo.
Aber wir müssen noch etwas bedenken. Volumenkörper sind ein relativ "schwerer" Geometrietyp, was bedeutet, dass dieser Vorgang das Diagramm verlangsamt. Es wäre praktisch, wenn es eine einfache Möglichkeit gäbe, auszuwählen, ob wir die Volumenkörper anzeigen möchten oder nicht. Die offensichtliche Antwort ist, einfach den Corridor.GetSolids-Block zu trennen. Dadurch werden jedoch Warnungen für alle nachgeordneten Blöcke angezeigt, was zu einer chaotischen Ansicht führt. Dies ist eine Situation, in der der ScopeIf-Block hilfreich ist.
Beachten Sie, dass der Object.Geometry-Block unten einen grauen Balken aufweist. Dies bedeutet, dass die Blockvorschau deaktiviert ist (Zugriff durch Klicken mit der rechten Maustaste auf den Block). Dadurch muss der Block GeometryColor.ByGeometryColor in der Hintergrundvorschau nicht mit anderer Geometrie um die Anzeigepriorität konkurrieren.
Mit dem ScopeIf-Block können Sie einen ganzen Zweig von Blöcken selektiv ausführen. Wenn die test-Eingabe false ist, werden alle mit dem ScopeIf-Block verbundenen Blöcke nicht ausgeführt.
Hier sehen Sie das Ergebnis in der Dynamo-Hintergrundvorschau.
Im Folgenden finden Sie einige Anregungen, wie Sie die Funktionen dieses Diagramms erweitern können.
Fügen Sie eine rotation-Spalte zur Excel-Datei hinzu, die Sie zum Steuern der Drehung des Koordinatensystems verwenden können.
Fügen Sie horizontale oder vertikale Versätze zur Excel-Datei hinzu, sodass die Lichtmasten bei Bedarf von der 3D-Profilkörper-Elementkante abweichen können.
Anstatt eine Excel-Datei mit Stationswerten zu verwenden, generieren Sie die Stationswerte direkt in Dynamo mit einer Anfangsstation und typischem Abstand.
Beim Hinzufügen von Haltungen und Schächten/Bauwerken zu einem Kanalnetz verwendet Civil 3D eine Vorlage, um automatisch Namen zuzuweisen. Dies ist während der ersten Platzierung in der Regel ausreichend, aber die Namen werden sich mit der Weiterentwicklung des Entwurfs unweigerlich ändern. Darüber hinaus sind möglicherweise viele verschiedene Benennungsmuster erforderlich, z. B. die sequenzielle Benennung von Schächten/Bauwerken in einem Kanalsystem ausgehend vom am weitesten stromabwärts gelegenen Schacht/Bauwerk oder die Verwendung eines Benennungsmusters, das dem Datenschema einer lokalen Behörde entspricht. In diesem Beispiel wird gezeigt, wie Dynamo zur Definition und konsistenten Anwendung jeder Art von Benennungsstrategie verwendet werden kann.
Arbeiten mit Begrenzungsrahmen
Filtern von Daten mithilfe des Blocks List.FilterByBoolMask
Sortieren von Daten mithilfe des Blocks List.SortByKey
Erstellen und Ändern von Textzeichenfolgen
Dieses Diagramm wird in Civil 3D 2020 und höher ausgeführt.
Laden Sie zunächst die folgenden Beispieldateien herunter, und öffnen Sie dann die DWG-Datei und das Dynamo-Diagramm.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Schächte/Bauwerke nach Layer auswählen
Positionen von Schächten/Bauwerken abrufen
Schächte/Bauwerke nach Versatz filtern und nach Station sortieren
Neue Namen generieren
Schächte/Bauwerke umbenennen
Los gehts!
Als Erstes müssen wir alle Schächte/Bauwerke auswählen, mit denen wir arbeiten möchten. Dazu wählen wir einfach alle Objekte auf einem bestimmten Layer aus. Das bedeutet, dass wir Schächte/Bauwerke aus verschiedenen Kanalnetzen auswählen können (vorausgesetzt, sie haben den gleichen Layer).
Dieser Block stellt sicher, dass wir nicht versehentlich unerwünschte Objekttypen abrufen, die möglicherweise den gleichen Layer wie die Schächte/Bauwerke verwenden.
Nachdem wir die Schächte/Bauwerke erstellt haben, müssen wir ihre Position im Raum herausfinden, damit wir sie nach ihrer Position sortieren können. Dazu nutzen wir den Begrenzungsrahmen der einzelnen Objekte. Der Begrenzungsrahmen eines Objekts ist ein Quader, dessen Mindestgröße die komplette Geometrie des Objekts umschließt. Durch die Berechnung des Mittelpunkts des Begrenzungsrahmens erhalten Sie eine ziemlich gute Annäherung an den Einfügepunkt des Schachts/Bauwerks.
Wir verwenden diese Punkte, um die Station und den Versatz der Schächte/Bauwerke relativ zu einer ausgewählten Achse abzurufen.
Jetzt wird es etwas schwieriger. Zu diesem Zeitpunkt haben wir eine große Liste aller Schächte/Bauwerke auf dem angegebenen Layer erstellt. Wir haben eine Achse ausgewählt, nach der wir sie sortieren möchten. Das Problem ist, dass die Liste möglicherweise Schächte/Bauwerke enthält, die nicht umbenannt werden sollen. Sie sind beispielsweise nicht Teil der Strecke, an der wir interessiert sind.
Die ausgewählte Achse
Die Schächte/Bauwerke, die wir umbenennen möchten
Die Schächte/Bauwerke, die ignoriert werden sollen
Wir müssen die Liste der Schächte/Bauwerke filtern, sodass diejenigen, die einen bestimmten Versatz von der Achse überschreiten, nicht berücksichtigt werden. Dies erreichen Sie am besten mit dem Block List.FilterByBoolMask. Nach dem Filtern der Schacht-/Bauwerksliste verwenden Sie den List.SortByKey-Block, um sie nach ihren Stationswerten zu sortieren.
Wenn Listen neu für Sie sind, finden Sie im Abschnitt Arbeiten mit Listen weitere Informationen.
Überprüfen, ob der Schacht-/Bauwerkversatz kleiner als der Schwellenwert ist.
Alle Nullwerte durch false ersetzen
Liste der Schächte/Bauwerke und Stationen filtern
Schächte/Bauwerke nach Stationen sortieren
Als Letztes müssen wir noch die neuen Namen für die Schächte/Bauwerke erstellen. Wir verwenden das Format <alignment name>-STRC-<number>
. Hier gibt es einige zusätzliche Blöcke, um die Nummern ggf. mit zusätzlichen Nullen zu füllen (z. B. "01" statt "1").
Und nicht zuletzt benennen wir die Schächte/Bauwerke um.
Hier sehen Sie ein Beispiel für die Ausführung des Diagramms mit Dynamo Player.
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt Dynamo Player weitere Informationen.
Es kann hilfreich sein, die 3D-Hintergrundvorschau von Dynamo zu nutzen, um die Zwischenausgaben des Diagramms anstatt nur das Endergebnis zu visualisieren. Eine einfache Möglichkeit besteht darin, die Begrenzungsrahmen für die Schächte/Bauwerke anzuzeigen. Darüber hinaus enthält dieses spezielle Dokument einen 3D-Profilkörper. Wir können die Geometrie der 3D-Profilkörper-Elementkante in Dynamo importieren, um den Kontext für die Position der Schächte/Bauwerke im Raum zu verdeutlichen. Wenn das Diagramm für einen Datensatz verwendet wird, der keine 3D-Profilkörper enthält, führen diese Blöcke einfach keine Aktionen aus.
Jetzt verstehen wir besser, wie der Prozess des Filterns der Schächte/Bauwerke nach Versatz funktioniert.
Im Folgenden finden Sie einige Anregungen, wie Sie die Funktionen dieses Diagramms erweitern können.
Benennen Sie die Schächte/Bauwerke basierend auf der nächstgelegenen Achse um, anstatt eine bestimmte Achse auszuwählen.
Benennen Sie die Haltungen um – zusätzlich zu den Schächten/Bauwerken.
Legen Sie die Layer der Schächte/Bauwerke fest – basierend auf ihrem Verlauf.
Dynamo for Civil 3D stellt Ingenieuren und Konstrukteuren, die an Tiefbau- und Infrastrukturprojekten arbeiten, ein visuelles Programmierkonzept zur Verfügung. Sie können sich Dynamo als eine Art digitales Multitool für Civil 3D-Benutzer vorstellen – was auch immer die Aufgabe sein mag, es bietet genau das richtige Werkzeug für die jeweilige Aufgabe. Die intuitive Benutzeroberfläche ermöglicht Ihnen die Erstellung leistungsstarker und anpassbarer Routinen, ohne dass Sie eine einzige Codezeile schreiben müssen. Sie müssen kein Programmierer sein, um Dynamo verwenden zu können, aber Sie müssen in der Lage sein, mit der Logik eines Programmierers zu denken. In Verbindung mit den anderen Kapiteln in dieser Einführung hilft Ihnen dieses Kapitel beim Vertiefen von Logikfähigkeiten. So können Sie ein Verständnis dafür entwickeln, wie Computer Fragestellungen lösen und Ihre Aufgaben (mit mehr oder weniger) Programmieraufwand entsprechend angehen.
Dynamo wurde erstmals in Civil 3D 2020 eingeführt und hat sich seitdem kontinuierlich weiterentwickelt. Die ursprünglich separat über ein Software-Update installierte Anwendung ist jetzt in allen Versionen von Civil 3D enthalten. Je nachdem, welche Version von Civil 3D Sie verwenden, werden Sie feststellen, dass die Benutzeroberfläche von Dynamo etwas anders aussieht als die in diesem Kapitel gezeigten Beispiele. Dies liegt daran, dass die Benutzeroberfläche in Civil 3D 2023 erheblich überarbeitet wurde.
Wir empfehlen Ihnen, den Dynamo-Blog zu lesen, um aktuelle Informationen zur Entwicklung von Dynamo zu erhalten. Die folgende Tabelle fasst die wichtigsten Meilensteine von Dynamo for Civil 3D zusammen.
Nachdem Sie sich einen Gesamtüberblick verschafft haben, können Sie jetzt direkt mit der Erstellung Ihres ersten Dynamo-Diagramms in Civil 3D beginnen.
Dies ist ein einfaches Beispiel zur Veranschaulichung der grundlegenden Dynamo-Funktionen. Es wird empfohlen, die Schritte in einem neuen, leeren Civil 3D-Dokument zu durchlaufen.
Als Erstes müssen Sie ein leeres Dokument in Civil 3D öffnen. Navigieren Sie in der Civil 3D-Multifunktionsleiste zur Registerkarte Verwalten, und suchen Sie die Gruppe Visuelle Programmierung.
Klicken Sie auf die Schaltfläche Dynamo. Dadurch wird Dynamo in einem separaten Fenster gestartet.
Was ist der Unterschied zwischen Dynamo und Dynamo Player?
Dynamo wird zum Erstellen und Ausführen von Diagrammen verwendet. Dynamo Player bietet eine einfache Möglichkeit zum Ausführen von Diagrammen, ohne sie in Dynamo öffnen zu müssen.
Gehen Sie zum Abschnitt Dynamo Player, wenn Sie ihn ausprobieren möchten.
Wenn Dynamo geöffnet ist, wird der Startbildschirm angezeigt. Klicken Sie auf Neu, um einen leeren Arbeitsbereich zu öffnen.
Wie sieht es mit Beispielen aus?
Dynamo for Civil 3D enthält einige vordefinierte Diagramme, die Ihnen Ideen zur Verwendung von Dynamo liefern können. Wir empfehlen, dass Sie sich diese sowie die hier in der Einführung erwähnten Beispielarbeitsabläufe ansehen.
Sie sollten jetzt einen leeren Arbeitsbereich sehen. Erleben Sie Dynamo in Aktion! Hier ist unser Ziel:
Ganz einfach, nicht wahr? Aber bevor wir beginnen, müssen wir einige Grundlagen klären.
Die wichtigsten Bausteine eines Dynamo-Diagramms werden Blöcke genannt. Ein Block ist wie ein kleiner Computer: Sie geben Daten ein, der Computer bearbeitet die Daten und gibt ein Ergebnis aus. Dynamo for Civil 3D verfügt über eine Bibliothek von Blöcken, die Sie mit Drähten verbinden können, um ein Diagramm zu erstellen, das größere und bessere Aufgaben bewältigen kann als ein einzelner Block.
Was ist, wenn ich noch nie mit Dynamo gearbeitet habe?
Einiges davon ist möglicherweise ziemlich neu für Sie. Aber keine Sorge. Diese Abschnitte helfen Ihnen.
Benutzeroberfläche Blöcke und Drähte Wichtige Blöcke und Konzepte
Erstellen wir nun unser Diagramm. Hier sehen Sie eine Liste aller benötigten Blöcke.
Sie können diese Blöcke finden, indem Sie ihre Namen in die Suchleiste in der Bibliothek eingeben, oder indem Sie mit der rechten Maustaste auf eine beliebige Stelle im Ansichtsbereich klicken und dort suchen.
Wie kann ich feststellen, welche Blöcke ich verwenden sollte und wo ich sie finde?
Blöcke in der Bibliothek werden in logische Kategorien eingeteilt, abhängig davon, welche Funktion sie haben. Eine ausführlichere Beschreibung finden Sie im Abschnitt Blockbibliothek.
Hier sehen Sie, wie das endgültige Diagramm aussehen sollte.
Fassen wir zusammen, was wir hier erreicht haben:
Wir haben das Dokument ausgewählt, in dem wir arbeiten möchten. In diesem (und in vielen anderen Fällen) möchten wir in Civil 3D im aktiven Dokument arbeiten.
Wir haben den Zielblock definiert, in dem das Textobjekt erstellt werden soll (in diesem Fall der Modellbereich).
Wir haben mithilfe eines String-Blocks angegeben, auf welchem Layer der Text platziert werden soll.
Wir haben einen Punkt mithilfe des Point.ByCoordinates-Blocks erstellt, um die Position zu definieren, an der der Text platziert werden soll.
Wir haben die X- und Y-Koordinaten des Texteinfügepunkts mithilfe von zwei Number Slider-Blöcken definiert.
Wir haben den Inhalt des Text-Objekts mithilfe eines anderen String-Blocks definiert.
Schließlich haben wir das Text-Objekt erstellt.
Sehen wir uns nun die Ergebnisse unseres brandneuen Diagramms an.
Vergewissern Sie sich in Civil 3D, dass die Registerkarte Modell ausgewählt ist. Das neue von Dynamo erstellte Text-Objekt sollte angezeigt werden.
Wenn Sie den Text nicht sehen können, müssen Sie möglicherweise den Befehl ZOOM -> GRENZEN ausführen, um zur richtigen Stelle zu zoomen.
Ausgezeichnet. Jetzt nehmen wir einige Änderungen am Text vor.
Ändern Sie im Dynamo-Diagramm einige der Eingabewerte, z. B. die Textzeichenfolge, die Koordinaten des Einfügepunkts usw. Der Text sollte automatisch in Civil 3D aktualisiert werden. Beachten Sie auch, dass beim Trennen eines der Eingabeanschlüsse der Text entfernt wird. Wenn Sie den Anschluss wieder verbinden, wird der Text erneut erstellt.
Warum fügt Dynamo nicht bei jeder Ausführung des Diagramms ein neues Textobjekt ein?
Vorgabemäßig "merkt sich" Dynamo die erstellten Objekte. Wenn Sie die Blockeingabewerte ändern, werden die Objekte in Civil 3D aktualisiert, anstatt neue Objekte zu erstellen. Weitere Informationen zu diesem Verhalten finden Sie im Abschnitt Objektbindung.
In diesem Beispiel wird nur oberflächlich erläutert, was Sie mit Dynamo for Civil 3D tun können. Lesen Sie weiter, um mehr zu erfahren!
Wie bereits erwähnt, sind Blöcke die wichtigsten Bausteine eines Dynamo-Diagramms. Sie werden in logische Gruppen in der Bibliothek organisiert. In Dynamo for Civil 3D gibt es zwei Kategorien (oder Bereiche) in der Bibliothek, die dedizierte Blöcke zum Arbeiten mit AutoCAD- und Civil 3D-Objekten enthalten, wie z. B. Achsen, Längsschnitte, 3D-Profilkörper, Blockreferenzen usw. Die restlichen Blöcke in der Bibliothek sind allgemeinere Blöcke, die in allen Dynamo-Versionen (z. B. Dynamo für Revit, Dynamo Sandbox usw.) gleich sind.
Weitere Informationen über die Struktur der Blöcke in der Dynamo-Hauptbibliothek finden Sie im Abschnitt Bibliothek.
Spezifische Blöcke für die Arbeit mit AutoCAD- und Civil 3D-Objekten
Allgemeine Blöcke
Blöcke aus Paketen von Drittanbietern, die Sie separat installieren können
Durch die Verwendung der Blöcke in den Bereichen AutoCAD und Civil 3D funktioniert Ihr Dynamo-Diagramm nur in Dynamo for Civil 3D. Wenn ein Diagramm aus Dynamo for Civil 3D an einer anderen Stelle geöffnet wird (z. B. in Dynamo für Revit), werden diese Blöcke mit einer Warnung markiert und nicht ausgeführt.
Warum gibt es zwei separate Bereiche für AutoCAD und Civil 3D?
In dieser Struktur werden die Blöcke für programmeigene AutoCAD-Objekte (Linien, Polylinien, Blockreferenzen usw.) von den Blöcken für Civil 3D-Objekte (Achsen, 3D-Profilkörper, DGMs usw.) unterschieden. Aus technischer Sicht sind AutoCAD und Civil 3D zwei separate Dinge: AutoCAD ist die Basisanwendung, und Civil 3D basiert darauf.
Um mit den AutoCAD- und Civil 3D-Blöcken arbeiten zu können, ist es wichtig, dass Sie die Objekthierarchie in jedem Bereich verstehen. Dies lässt sich mit der Taxonomie in der Biologie vergleichen: Reich, Stamm, Klasse, Ordnung, Familie, Gattung, Art. AutoCAD- und Civil 3D-Objekte werden auf ähnliche Weise kategorisiert. Sehen wir uns einige Beispiele zur Erläuterung an.
Als Beispiel verwenden wir eine Achse.
Angenommen, Sie möchten den Namen der Achse ändern. Der nächste Block, den Sie von hier aus hinzufügen, ist ein CivilObject.SetName-Block.
Zunächst scheint dies nicht sehr intuitiv. Was ist ein CivilObject, und warum enthält die Bibliothek keinen Alignment.SetName-Block? Die Antwort hängt mit der Wiederverwendbarkeit und Einfachheit zusammen. Denn: Der Prozess zum Ändern des Namens eines Civil 3D-Objekts ist gleich, unabhängig davon, ob es sich um eine Achse, einen 3D-Profilkörper, einen Längsschnitt oder etwas Anderes handelt. Anstatt sich wiederholende Blöcke zu verwenden, die im Wesentlichen alle denselben Zweck erfüllen (z. B. Alignment.SetName, Corridor.SetName, Profile.SetName usw.), ist es sinnvoll, diese Funktionen in einen einzigen Block zu vereinen. Genau das macht CivilObject.SetName!
Eine andere Betrachtungsweise dafür sind Beziehungen. Eine Achse und ein 3D-Profilkörper sind beide Arten von Civil-Objekten, genauso wie ein Apfel und eine Birne beide Obstsorten sind. Civil-Objekt-Blöcke können auf alle Typen von Civil-Objekten angewendet werden, so als ob Sie einen einzigen Schäler zum Schälen eines Apfels und einer Birne verwenden möchten. Ihre Küche wäre ziemlich vollgestopft, wenn Sie für jede Obstsorte einen eigenen Schäler verwenden würden! In diesem Sinne entspricht die Dynamo-Blockbibliothek Ihrer Küche.
Gehen wir nun einen Schritt weiter. Angenommen, Sie möchten den Layer der Achse ändern. Der Block, den Sie verwenden würden, ist der Object.SetLayer-Block.
Warum gibt es keinen Block mit dem Namen CivilObject.SetLayer? Hier gelten die gleichen Prinzipien der Wiederverwendbarkeit und Einfachheit, die wir bereits besprochen haben. Die Eigenschaft Layer ist für alle Objekte in AutoCAD identisch, die gezeichnet oder eingefügt werden können, wie Linien, Polylinien, Text, Blockreferenzen usw. Civil 3D-Objekte wie Achsen und 3D-Profilkörper fallen in dieselbe Kategorie. Jeder Block, der einem Objekt entspricht, kann daher auch mit einem beliebigen Civil-Objekt verwendet werden.
Die Entwicklung kinematischer Profile für die Lichtraumvalidierung ist ein wichtiger Bestandteil der Schienenkonstruktion. Dynamo kann verwendet werden, um Volumenkörper für die Profile zu erstellen, anstatt komplexe 3D-Profilkörper-Querschnittsbestandteile erstellen und verwalten zu müssen.
Arbeiten mit 3D-Profilkörper-Elementkanten
Transformieren von Geometrie zwischen Koordinatensystemen
Erstellen von Volumenkörpern durch Anhebung
Steuern des Blockverhaltens mit Vergitterungseinstellungen
Dieses Diagramm wird in Civil 3D 2020 und höher ausgeführt.
Laden Sie zunächst die folgenden Beispieldateien herunter, und öffnen Sie dann die DWG-Datei und das Dynamo-Diagramm.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Elementkanten aus der angegebenen 3D-Profilkörper-Basislinie abrufen
Koordinatensysteme entlang der 3D-Profilkörper-Elementkante mit dem gewünschten Abstand erstellen
Blockgeometrie des Längsschnitts in die Koordinatensysteme umwandeln
Volumenkörper zwischen den Längsschnitten anheben
Volumenkörper in Civil 3D erstellen
Los gehts!
Unser erster Schritt ist das Abrufen von 3D-Profilkörperdaten. Wir wählen das 3D-Profilkörpermodell nach Name aus, rufen eine bestimmte Basislinie innerhalb des 3D-Profilkörpers ab und erhalten dann eine Elementkante innerhalb der Basislinie anhand ihres Punktcodes.
Als Nächstes generieren wir Koordinatensysteme entlang der Elementkanten eines 3D-Profilkörpers zwischen einer bestimmten Anfangs- und Endstation. Diese Koordinatensysteme werden verwendet, um die Blockgeometrie des Fahrzeug-Längsschnitts am 3D-Profilkörper auszurichten.
Wenn Koordinatensysteme neu für Sie sind, finden Sie im Abschnitt Vektor, Ebene und Koordinatensystem weitere Informationen.
Beachten Sie das kleine XXX in der unteren rechten Ecke des Blocks. Dies bedeutet, dass die Vergitterungseinstellungen des Blocks auf Kreuzprodukt festgelegt sind. Dies ist erforderlich, um die Koordinatensysteme an den gleichen Stationswerten für beide Elementkanten zu generieren.
Wenn die Blockvergitterung neu für Sie ist, finden Sie im Abschnitt Was ist eine Liste? weitere Informationen.
Jetzt müssen wir eine Anordnung der Fahrzeug-Längsschnitte entlang der Elementkanten erstellen. Dafür transformieren wir die Geometrie mithilfe des Geometry.Transform-Blocks aus der Blockdefinition des Fahrzeug-Längsschnitts. Das Visualisieren dieses Konzepts ist schwierig. Bevor wir uns die Blöcke ansehen, sehen wir uns eine Grafik an, die zeigt, was passieren wird.
Im Prinzip wird also die Dynamo-Geometrie aus einer einzelnen Blockdefinition während der Erstellung einer Anordnung entlang der Elementkante verschoben/gedreht. Ziemlich cool! Hier sehen Sie die Blocksequenz.
Hiermit wird die Blockdefinition aus dem Dokument abgerufen.
Diese Blöcke übernehmen die Dynamo-Geometrie der Objekte innerhalb des Blocks.
Diese Blöcke definieren im Wesentlichen das Koordinatensystem, aus dem die Geometrie transformiert wird.
Und schließlich führt dieser Block die eigentliche Transformation der Geometrie durch.
Beachten Sie die längste Vergitterung in diesem Block.
Und so sieht dies in Dynamo aus.
Gute Neuigkeiten! Die harte Arbeit ist getan. Jetzt müssen wir nur noch Volumenkörper zwischen den Längsschnitten generieren. Dies lässt sich einfach mithilfe des Solid.ByLoft-Blocks bewerkstelligen.
Hier sehen Sie das Ergebnis. Beachten Sie, dass es sich um Dynamo-Volumenkörper handelt, die in Civil 3D noch erstellt werden müssen.
Der letzte Schritt besteht darin, die generierten Volumenkörper im Modellbereich auszugeben. Wir ordnen ihnen auch eine Farbe zu, damit sie sehr leicht zu erkennen sind.
Hier sehen Sie ein Beispiel für die Ausführung des Diagramms mit Dynamo Player.
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt Dynamo Player weitere Informationen.
Im Folgenden finden Sie einige Anregungen, wie Sie die Funktionen dieses Diagramms erweitern können.
Fügen Sie eine Funktion hinzu, mit der Sie verschiedene Stationsbereiche separat für jede Spur verwenden können.
Teilen Sie die Volumenkörper in kleinere Segmente, die einzeln auf Kollisionen analysiert werden können.
Überprüfen Sie, ob sich die Profilvolumenkörper ** mit Objekten überschneiden**, und färben Sie kollidierende Objekte ein.
Die Arbeit mit Koordinatenpunkten und Punktgruppen in Civil 3D ist ein Kernelement vieler Prozesse von der Feldvermessung bis zum grafischen Endergebnis. Dynamo eignet sich perfekt für die Datenverwaltung, und wir werden in diesem Beispiel einen potenziellen Anwendungsfall zeigen.
Arbeiten mit Listen
Gruppieren ähnlicher Objekte mit dem Block List.GroupByKey
Anzeigen von benutzerdefinierten Ausgaben in Dynamo Player
Dieses Diagramm wird in Civil 3D 2020 und höher ausgeführt.
Laden Sie zunächst die folgenden Beispieldateien herunter, und öffnen Sie dann die DWG-Datei und das Dynamo-Diagramm.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Alle Koordinatenpunkte im Dokument abrufen
Koordinatenpunkte nach Beschreibung gruppieren
Punktgruppen erstellen
Zusammenfassung in Dynamo Player ausgeben
Los gehts!
Der erste Schritt besteht darin, alle Punktgruppen im Dokument und dann alle Koordinatenpunkte in jeder Gruppe abzurufen. Dadurch erhalten wir eine verschachtelte Liste bzw. "Liste von Listen", die später einfacher zu bearbeiten ist, wenn wir alles mithilfe des List.Flatten-Blocks auf eine einzige Liste reduzieren.
Wenn Listen neu für Sie sind, finden Sie im Abschnitt Arbeiten mit Listen weitere Informationen.
Nachdem wir nun alle Koordinatenpunkte haben, müssen wir sie anhand ihrer Beschreibungen in Gruppen unterteilen. Dies entspricht genau der Funktion des Blocks List.GroupByKey. Im Prinzip werden alle Elemente, die denselben Schlüssel verwenden, in Gruppen zusammengefasst.
Die harte Arbeit ist getan! Der letzte Schritt besteht darin, neue Civil 3D-Punktgruppen aus den gruppierten Koordinatenpunkten zu erstellen.
Wenn Sie das Diagramm ausführen, ist in der Dynamo-Hintergrundvorschau nichts zu sehen, da wir nicht mit Geometrie arbeiten. Die einzige Möglichkeit, um zu sehen, ob das Diagramm korrekt ausgeführt wurde, besteht darin, den Projektbrowser zu überprüfen oder die Blockausgabe-Vorschau anzuzeigen. Wenn Sie das Diagramm jedoch mit Dynamo Player ausführen, wird mehr Feedback zu den Ergebnissen des Diagramms bereitgestellt, indem eine Zusammenfassung der erstellten Punktgruppen ausgegeben wird. Sie müssen nur mit der rechten Maustaste auf einen Block klicken und Ist Ausgabe auswählen. In diesem Fall verwenden wir einen umbenannten Watch-Block, um die Ergebnisse anzuzeigen.
Hier sehen Sie ein Beispiel für die Ausführung des Diagramms mit Dynamo Player.
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt Dynamo Player weitere Informationen.
Im Folgenden finden Sie einige Anregungen, wie Sie die Funktionen dieses Diagramms erweitern können.
Ändern Sie die Punktgruppierung, sodass die ausführliche Beschreibung anstelle der Kurzbeschreibung verwendet wird.
Gruppieren Sie die Punkte nach anderen vordefinierten Kategorien, die Sie auswählen (z. B. Geländeaufnahmen, Monumente usw.)
Erstellen Sie automatisch triangulierte DGMs für Punkte in bestimmten Gruppen.
Beim technischen Entwurf eines typischen Wohngebäudes werden verschiedene unterirdische Versorgungssysteme wie Abwasserkanäle, Regenwasserabläufe, Trinkwasser usw. geplant. In diesem Beispiel wird gezeigt, wie Sie mit Dynamo die Hausanschlüsse von einer Hauptverteilung zu einem bestimmten Grundstück (d. h. einer Parzelle) zeichnen können. Für jedes Grundstück ist ein Hausanschluss erforderlich, was die Positionierung der gesamten Anschlüsse sehr mühsam macht. Dynamo kann den Prozess beschleunigen, indem die erforderliche Geometrie automatisch präzise gezeichnet wird und flexible Eingaben bereitgestellt werden, die an lokale behördliche Standards angepasst werden können.
Verwenden des Blocks Select Objects für Benutzereingaben
Arbeiten mit Koordinatensystemen
Verwenden von geometrischen Operationen wie Geometry.DistanceTo und Geometry.ClosestPointTo
Erstellen von Blockreferenzen
Steuern der Einstellungen für Objektbindung
Dieses Diagramm wird in Civil 3D 2020 und höher ausgeführt.
Laden Sie zunächst die folgenden Beispieldateien herunter, und öffnen Sie dann die DWG-Datei und das Dynamo-Diagramm.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Ruft die Kurvengeometrie für die Hauptverteilung ab.
Ruft die Kurvengeometrie für eine vom Benutzer ausgewählte Parzellenlinie ab und kehrt sie bei Bedarf um
Generiert Einfügepunkte für die Hausanschlusszähler
Ruft die Punkte auf der Hauptverteilung ab, die den Zählerpositionen am nächsten sind
Erstellt Blockreferenzen und Linien im Modellbereich
Los gehts!
Der erste Schritt besteht darin, die Geometrie für die Hauptverteilung in Dynamo zu übernehmen. Anstatt einzelne Linien oder Polylinien auszuwählen, rufen wir stattdessen alle Objekte auf einem bestimmten Layer ab und führen sie als Dynamo-PolyCurve zusammen.
Wenn die Kurvengeometrie in Dynamo neu für Sie ist, finden Sie im Abschnitt Kurven weitere Informationen.
Als Nächstes müssen wir die Geometrie für eine ausgewählte Parzellenlinie in Dynamo importieren, damit wir mit ihr arbeiten können. Das richtige Werkzeug dafür ist der Block Select Object, mit dem der Benutzer des Diagramms ein bestimmtes Objekt in Civil 3D auswählen kann.
An dieser Stelle tritt möglicherweise ein Problem auf, um das wir uns kümmern müssen. Die Parzellenlinie hat einen Start- und einen Endpunkt, d. h., sie hat eine Richtung. Damit das Diagramm konsistente Ergebnisse erzeugt, müssen alle Parzellenlinien eine konsistente Richtung aufweisen. Wir können diese Bedingung direkt in der Diagrammlogik berücksichtigen, wodurch das Diagramm zuverlässiger wird.
Rufen Sie die Start- und Endpunkte der Parzellenlinie ab.
Messen Sie den Abstand von jedem Punkt zur Hauptverteilung, und ermitteln Sie dann, welcher Abstand größer ist.
Das gewünschte Ergebnis ist, dass der Startpunkt der Linie der Hauptverteilung am nächsten ist. Wenn dies nicht der Fall ist, kehren wir die Richtung der Parzellenlinie um. Andernfalls geben wir einfach die ursprüngliche Parzellenlinie zurück.
Jetzt überlegen wir, wo die Zähler platziert werden sollen. In der Regel wird die Platzierung durch die Anforderungen der lokalen Behörden bestimmt, daher geben wir einfach Eingabewerte an, die geändert werden können, um verschiedenen Bedingungen zu entsprechen. Wir verwenden ein Koordinatensystem entlang der Parzellenlinie als Referenz für die Erstellung der Punkte. Dadurch können Sie Versätze relativ zur Parzellenlinie ganz einfach definieren, unabhängig von der Ausrichtung.
Wenn Koordinatensysteme neu für Sie sind, finden Sie im Abschnitt Vektor, Ebene und Koordinatensystem weitere Informationen.
Jetzt müssen wir Punkte auf der Hauptverteilung abrufen, die den Zählerpositionen am nächsten sind. Dadurch können wir die Hausanschlüsse im Modellbereich so zeichnen, dass sie immer lotrecht zur Hauptverteilung sind. Dafür eignet sich der Block Geometry.ClosestPointTo.
Dies ist die Hauptverteilungs-PolyCurve.
Dies sind die Zählereinfügepunkte.
Der letzte Schritt besteht darin, Objekte im Modellbereich zu erstellen. Wir verwenden die zuvor generierten Einfügepunkte, um Blockreferenzen zu erstellen, und dann die Punkte auf der Hauptverteilung, um Linien zu den Hausanschlüssen zu zeichnen.
Wenn Sie das Diagramm ausführen, sollten neue Blockreferenzen und Hausanschlusslinien im Modellbereich angezeigt werden. Ändern Sie einige der Eingaben, und beobachten Sie, wie alles automatisch aktualisiert wird.
Sie werden feststellen, dass nach dem Platzieren der Objekte für eine Parzellenlinie die Objekte bei Auswahl einer anderen Parzellenlinie "verschoben" werden.
Dies ist das Vorgabeverhalten von Dynamo und in vielen Fällen sehr nützlich. Möglicherweise möchten Sie jedoch mehrere Hausanschlüsse nacheinander platzieren und Dynamo neue Objekte mit jeder Ausführung erstellen lassen, anstatt die ursprünglichen zu ändern. Sie können dieses Verhalten steuern, indem Sie die Einstellungen für die Objektbindung ändern.
Weitere Informationen finden Sie im Abschnitt Objektbindung
Durch Ändern dieser Einstellung wird Dynamo gezwungen, die Objekte, die mit jedem Durchlauf erstellt werden, zu "vergessen". Hier sehen Sie ein Beispiel für die Ausführung des Diagramms mit deaktivierter Objektbindung in Dynamo Player.
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt Dynamo Player weitere Informationen.
Im Folgenden finden Sie einige Anregungen, wie Sie die Funktionen dieses Diagramms erweitern können.
Platzieren Sie mehrere Hausanschlüsse gleichzeitig, anstatt jede Parzellenlinie auszuwählen.
Passen Sie die Eingaben an, um Kanalöffnungen anstelle von Wasserzählern zu platzieren.
Fügen Sie einen Schalter hinzu, um das Platzieren eines einzelnen Hausanschlusses auf einer bestimmten Seite der Parzellenlinie anstatt auf beiden Seiten zu ermöglichen.
Straßen, Schienen, Land, Versorgungseinrichtungen, Vermessung, GIS...
All das und noch viel mehr umfasst der Tief- und Infrastrukturbau! Dieser Abschnitt enthält mehrere praktische und relevante Beispieldiagramme, die Ihnen helfen, Dynamo noch besser zu nutzen und das volle Potenzial von Dynamo for Civil 3D auszuschöpfen. Jedes Diagramm wird mit detaillierten Beschreibungen der Logik ausgeliefert, die zur Erstellung des Diagramms verwendet wurde, sodass Sie es nicht nur verwenden, sondern auch verstehen können.
Darüber hinaus sind in diesen Beispielen bewährte Best Practices für die Erstellung aussagekräftiger Diagramme enthalten. Während Sie die Beispiele durcharbeiten, sollten Sie sich auch mit dem Abschnitt Optimale Verfahren vertraut machen, der weitere Ideen zum Erstellen leistungsstarker, flexibler und langlebiger Diagramme enthält.
Dynamo Player bietet eine vereinfachte Methode zum Ausführen von Dynamo-Diagrammen in Civil 3D. Nachdem ein Diagramm erstellt wurde, sind keine Dynamo-Kenntnisse erforderlich, um das Diagramm im Player auszuführen. Dies erleichtert die gemeinsame Nutzung von Diagrammen mit anderen Benutzern, die nicht an Details von Blöcken und Drähten interessiert sind.
Weitere Informationen zu Dynamo Player in Civil 3D finden Sie in der Dokumentation auf der Seite Civil 3D-Hilfe.
Dynamo for Civil 3D verfügt über einen leistungsstarken Mechanismus, mit dem sich das Programm die von jedem Block erstellten Objekte "merken" kann. Dieser Mechanismus wird als Objektbindung bezeichnet und ermöglicht es einem Dynamo-Diagramm, bei jeder Ausführung im selben Dokument konsistente Ergebnisse zu erzielen. Dies ist in vielen Fällen sehr wünschenswert, aber es gibt auch andere Situationen, in denen Sie mehr Kontrolle über das Verhalten von Dynamo haben möchten. In diesem Abschnitt erfahren Sie, wie die Objektbindung funktioniert und wie Sie sie nutzen können.
Betrachten Sie dieses Diagramm, das einen Kreis im Modellbereich auf dem aktuellen Layer erstellt.
Achten Sie darauf, was passiert, wenn der Radius geändert wird.
Dies ist Objektbindung in Aktion. Dynamo ändert vorgabemäßig den Radius des Kreises, anstatt bei jeder Änderung der Radiuseingabe einen neuen Kreis zu erstellen. Dies liegt daran, dass sich der Block Object.ByGeometry "merkt", dass er diesen spezifischen Kreis bei jeder Ausführung des Diagramms erstellt hat. Außerdem speichert Dynamo diese Informationen, sodass sie beim nächsten Öffnen des Civil 3D-Dokuments und Ausführen des Diagramms genau das gleiche Verhalten aufweisen.
Sehen wir uns ein Beispiel an, in dem Sie das vorgabemäßige Objektbindungsverhalten von Dynamo möglicherweise ändern möchten. Angenommen, Sie möchten ein Diagramm erstellen, das Text in der Mitte eines Kreises platziert. Sie möchten mit diesem Diagramm jedoch erreichen, dass es immer wieder ausgeführt und jedes Mal neuer Text in den ausgewählten Kreis eingefügt werden kann. So könnte dieses Diagramm aussehen.
Dies geschieht jedoch tatsächlich, wenn ein anderer Kreis ausgewählt wird.
Nachdem wir diese Änderung vorgenommen haben, erhalten wir das gewünschte Verhalten.
Dynamo for Civil 3D ermöglicht die Änderung des vorgegebenen Verhaltens für Objektbindungen über die Einstellungen für Bindungsdatenspeicherung im Menü Dynamo.
Beachten Sie, dass die Optionen für die Bindungsdatenspeicherung in Civil 3D 2022.1 und höher verfügbar sind.
Alle Optionen sind vorgabemäßig aktiviert. Hier finden Sie eine Zusammenfassung der Funktionen der einzelnen Optionen.
Wenn diese Option aktiviert ist, werden die Objekte, die beim letzten Ausführen des Diagramms erstellt wurden, von Dynamo "vergessen". Das Diagramm kann also in jeder beliebigen Zeichnung ausgeführt werden und erstellt jedes Mal neue Objekte.
Verwendung
Verwenden Sie diese Option, wenn Dynamo alle Aktionen aus früheren Durchläufen "vergessen" und jedes Mal neue Objekte erstellen soll.
Diese Option bedeutet, dass Metadaten der Objektbindung in das Diagramm (DYN-Datei) serialisiert werden, wenn es gespeichert wird. Wenn Sie das Diagramm schließen/erneut öffnen und es in derselben Zeichnung ausführen, sollte alles wie beim letzten Mal funktionieren. Wenn Sie das Diagramm in einer anderen Zeichnung ausführen, werden die Bindungsdaten aus dem Diagramm entfernt und neue Objekte erstellt. Dies bedeutet, dass beim Öffnen der ursprünglichen Zeichnung und erneuten Ausführen des Diagramms neue Objekte zusätzlich zu den alten erstellt werden.
Verwendung
Verwenden Sie diese Option, wenn sich Dynamo die Objekte "merken" soll, die beim letzten Ausführen in einer bestimmten Zeichnung erstellt wurden.
Diese Option eignet sich am besten für Situationen, in denen eine 1:1-Beziehung zwischen einer bestimmten Zeichnung und einem Dynamo-Diagramm beibehalten werden kann. Optionen 1 und 3 eignen sich besser für Diagramme, die für die Ausführung in mehreren Zeichnungen ausgelegt sind.
Dies ähnelt Option 2, mit der Ausnahme, dass die Objektbindungsdaten in der Zeichnung und nicht im Diagramm (DYN-Datei) serialisiert werden. Wenn Sie das Diagramm schließen/erneut öffnen und es in derselben Zeichnung ausführen, sollte alles wie beim letzten Mal funktionieren. Wenn Sie das Diagramm in einer anderen Zeichnung ausführen, bleiben die Bindungsdaten in der ursprünglichen Zeichnung erhalten, da sie in der Zeichnung und nicht im Diagramm gespeichert werden.
Verwendung
Verwenden Sie diese Option, wenn Sie dasselbe Diagramm in mehreren Zeichnungen verwenden möchten und Dynamo sich dabei "merken" soll, wie es in jeder Zeichnung dargestellt wurde.
Bei dieser Option ist zunächst zu beachten, dass sie keine Auswirkung darauf hat, wie das Diagramm mit der Zeichnung interagiert, wenn das Diagramm über die Dynamo-Hauptbenutzeroberfläche ausgeführt wird. Diese Option ist nur dann relevant, wenn das Diagramm mit Dynamo Player ausgeführt wird.
Wenn Sie das Diagramm über die Dynamo-Hauptbenutzeroberfläche ausführen, es schließen und anschließend mit Dynamo Player ausführen, werden zusätzlich zu den zuvor erstellten Objekten neue Objekte erstellt. Sobald das Diagramm jedoch einmal von Dynamo Player ausgeführt wurde, werden die Objektbindungsdaten in der Zeichnung serialisiert. Wenn Sie das Diagramm also mehrmals mit Dynamo Player ausführen, werden Objekte aktualisiert, statt neue zu erstellen. Wenn Sie das Diagramm mit Dynamo Player in einer anderen Zeichnung ausführen, bleiben die Bindungsdaten in der ursprünglichen Zeichnung erhalten, da sie in der Zeichnung und nicht im Diagramm gespeichert werden.
Verwendung
Verwenden Sie diese Option, wenn Sie ein Diagramm mit Dynamo Player über mehrere Zeichnungen hinweg ausführen und Dynamo Player sich dabei "merken" soll, wie es in jeder Zeichnung dargestellt wurde.
Codeblöcke sind eine spezielle Funktion in Dynamo, die eine dynamische Verbindung zwischen visueller und textbasierter Programmierumgebung darstellt. In einem Codeblock haben Sie Zugriff auf sämtliche Dynamo-Blöcke und können ein komplettes Diagramm in einem einzigen Block definieren. Lesen Sie die Informationen in diesem Kapitel sorgfältig, da Codeblöcke zu den wichtigsten Komponenten von Dynamo gehören.
Dynamo ist als zwar sehr leistungsstark, es ist jedoch auch möglich, nicht nur Blöcke und Drähte zu verwenden, sondern Code in Textform zu schreiben. Es gibt zwei Möglichkeiten, dies zu tun:
Schreiben von DesignScript mithilfe eines Codeblocks
Schreiben von Python mithilfe eines Python-Blocks
In diesem Abschnitt wird beschrieben, wie Sie Python in der Civil 3D-Umgebung einsetzen können, um die Vorteile der .NET-APIs von AutoCAD und Civil 3D zu nutzen.
Weitere allgemeine Informationen zur Verwendung von Python in Dynamo finden Sie im Abschnitt .
AutoCAD und Civil 3D verfügen über mehrere APIs, mit denen Entwickler wie Sie das Kernprodukt um benutzerdefinierte Funktionen erweitern können. Im Kontext von Dynamo sind die verwalteten .NET-APIs relevant. Die folgenden Links sind wichtig, um die Struktur der APIs und ihre Funktionsweise zu verstehen.
Wenn Sie diesen Abschnitt durcharbeiten, werden Ihnen möglicherweise einige Konzepte begegnen, mit denen Sie nicht vertraut sind, z. B. Datenbanken, Transaktionen, Methoden, Eigenschaften usw. Viele dieser Konzepte sind für die Arbeit mit .NET-APIs wichtig und nicht spezifisch für Dynamo oder Python. Da diese Konzepte in diesem Abschnitt der Einführung nicht behandelt werden, empfehlen wir für weitere Informationen die oben genannten Links.
Wenn Sie einen neuen Python-Block zum ersten Mal bearbeiten, wird er automatisch mit Vorlagencode gefüllt, um Ihnen den Einstieg zu erleichtern. Hier sehen Sie eine Aufschlüsselung der Vorlage mit Erläuterungen zu den einzelnen Blöcken.
Importiert die Module
sys
undclr
, die beide für die korrekte Funktionsweise des Python-Interpreters erforderlich sind. Insbesondere ermöglicht dasclr
-Modul, dass .NET-Namensbereiche im Wesentlichen wie Python-Pakete behandelt werden.Lädt die Standardbaugruppen (d. h. DLLs) für die Arbeit mit den verwalteten .NET-APIs für AutoCAD und Civil 3D.
Fügt Verweise zu den standardmäßigen AutoCAD- und Civil 3D-Namensbereichen hinzu. Diese entsprechen den Anweisungen
using
oderImports
in C# bzw. VB.NET.Auf die Eingabeanschlüsse des Blocks kann über eine vordefinierte Liste mit dem Namen
IN
zugegriffen werden. Sie können auf die Daten in einem bestimmten Anschluss über die Indexnummer zugreifen, z. B.dataInFirstPort = IN[0]
.Ruft das aktive Dokument und den aktiven Editor ab.
Sperrt das Dokument und initiiert eine Datenbanktransaktion.
Hier sollten Sie den Großteil der Skriptlogik platzieren.
Heben Sie die Auskommentierung dieser Zeile auf, um die Transaktion nach der Hauptarbeit zu bestätigen.
Wenn Sie Daten aus dem Block ausgeben möchten, weisen Sie diese der Variablen
OUT
am Ende des Skripts zu.
Sie möchten die Software anpassen?
Sie können die vorgabemäßige Python-Vorlage ändern, indem Sie die Datei PythonTemplate.py
in C:\ProgramData\Autodesk\C3D <Version>\Dynamo
bearbeiten.
Im Folgenden werden anhand eines Beispiels einige der grundlegenden Konzepte zum Schreiben von Python-Skripten in Dynamo for Civil 3D demonstriert.
Hier sehen Sie Beispieldateien, die für diese Übung als Referenz dienen können.
Hier sehen Sie einen Überblick über die Logik in diesem Diagramm.
Dokumentation zur Civil 3D-API ansehen
Alle Einzugsgebiete im Dokument nach Layernamen auswählen
Dynamo-Objekte "abwickeln", um auf die internen Civil 3D-API-Elemente zuzugreifen
Dynamo-Punkte aus AutoCAD-Punkten erstellen
PolyCurves aus den Punkten erstellen
Los gehts!
Jetzt können wir mit der Erstellung der Diagrammlogik beginnen. Als Erstes müssen Sie eine Liste aller Einzugsgebiete im Dokument abrufen. Hierfür sind Blöcke verfügbar, sodass Sie dies nicht in das Python-Skript aufnehmen müssen. Die Verwendung von Blöcken bietet eine bessere Sichtbarkeit für andere Benutzer, die das Diagramm möglicherweise lesen (im Gegensatz zu in einem Python-Skript "verstecktem" Code). Außerdem konzentriert sich das Python-Skript auf eine Sache: die Rückgabe der Umgrenzungspunkte der Einzugsgebiete.
Beachten Sie, dass die Ausgabe des Blocks All Objects on Layer eine Liste von CivilObjects ist. Dies liegt daran, dass Dynamo for Civil 3D derzeit keine Blöcke für die Arbeit mit Einzugsgebieten hat. Aus diesem Grund müssen wir über Python auf die API zugreifen.
Als Faustregel gilt: Es ist in der Regel sicherer, die Objekt-ID über die Eigenschaft InternalObjectId
abzurufen und dann in einer Transaktion auf das im Wrapper enthaltene Objekt zuzugreifen. Dies liegt daran, dass die Eigenschaft InternalDBObject
ein AutoCAD-DBObject zurückgibt, das sich nicht in einem schreibbaren Status befindet.
Hier sehen Sie das vollständige Python-Skript, das für den Zugriff auf die internen Einzugsgebietobjekte deren Umgrenzungspunkte abruft. Die hervorgehobenen Zeilen stehen für die Zeilen, die vom Vorgabevorlagencode geändert/hinzugefügt wurden.
Klicken Sie auf den unterstrichenen Text im Skript, um eine Erläuterung für jede Zeile anzuzeigen.
Als Faustregel sollten Sie den Großteil Ihrer Skriptlogik in eine Transaktion einschließen. Dadurch wird der sichere Zugriff auf die Objekte sichergestellt, die das Skript lesen und schreiben kann. In vielen Fällen kann das Auslassen einer Transaktion einen schwerwiegenden Fehler verursachen.
An dieser Stelle sollte das Python-Skript eine Liste von Dynamo-Punkten ausgeben, die Sie in der Hintergrundvorschau sehen können. Der letzte Schritt besteht darin, einfach PolyCurves aus den Punkten zu erstellen. Beachten Sie, dass dies auch direkt im Python-Skript erfolgen kann. Wir haben dies jedoch absichtlich außerhalb des Skripts in einem Block platziert, damit es besser sichtbar ist. Hier sehen Sie, wie das fertige Diagramm aussieht.
Hier sehen Sie die endgültige Dynamo-Geometrie.
Hier noch eine kurze Anmerkung. Je nachdem, welche Version von Civil 3D Sie verwenden, ist der Python-Block möglicherweise anders konfiguriert. In Civil 3D 2020 und 2021 hat Dynamo das Werkzeug IronPython verwendet, um Daten zwischen .NET-Objekten und Python-Skripten zu verschieben. In Civil 3D 2022 wurde in Dynamo jedoch der standardmäßige native Python-Interpreter (auch CPython genannt) anstelle von Python 3 verwendet. Zu den Vorteilen dieser Umstellung zählen der Zugriff auf beliebte moderne Bibliotheken und neue Plattformfunktionen, grundlegende Wartung und Sicherheits-Patches.
Diese Zeile ruft die spezifische Klasse ab, die wir aus der Dynamo-Geometriebibliothek benötigen. Beachten Sie, dass wir hier import Point as DynPoint
anstelle von import *
angeben, da Letzteres zu Namenskonflikten führen würde.
Hier geben wir an, welcher Eingabeanschluss die gewünschten Daten enthält, und nicht die Vorgabe IN
, die sich auf die gesamte Liste aller Eingaben bezieht.
Dynamo-Pakete sind Toolsets, die von Drittanbietern entwickelt wurden, um die Kernfunktionen von Dynamo zu erweitern. Sie stehen allen Anwendern zur Verfügung und können mit einem Klick auf die Schaltfläche heruntergeladen werden.
Weitere Informationen zum Einstieg in die Arbeit mit Paketen finden Sie im Abschnitt .
Hier finden Sie eine Liste der beliebtesten Pakete, mit denen Sie Ihre Dynamo for Civil 3D-Diagramme optimieren können.
Das Civil 3D-Toolkit ist ein Dynamo for Civil 3D-Paket, das durch eine große Anzahl zusätzlicher Blöcke wichtige Erweiterungen der Funktionen von Dynamo bietet.
Camber ist ein Open-Source-Paket für Dynamo for Civil 3D, das Hunderte von Blöcken für die Arbeit mit Beschriftungen, XRefs, Datenverknüpfungen, Stilen und vielem mehr enthält.
CivilConnection ist ein Open-Source-Paket für Dynamo für Revit, das den Austausch von Informationen zwischen Civil 3D, Dynamo und Revit ermöglicht.
Arkance Systems Nodes ist ein Dynamo for Civil 3D-Paket mit einer Vielzahl nützlicher Blöcke für die Arbeit mit Bemaßungen, Tabellen, Ansichten, Bohrungssteuerung und vielem mehr.
Codeblöcke geben Zugang zu DesignScript, der Programmiersprache, die Dynamo zugrunde liegt. DesignScript ist eine völlig neu entwickelte, leicht lesbare und knappe Programmiersprache speziell für experimentelle Arbeitsabläufe, die sowohl sofortiges Feedback für kleine Codeabschnitte als auch Skalierungsmöglichkeiten für umfangreiche und komplexe Interaktionen bietet. DesignScript ist zugleich das Kernstück der Engine, die die meisten Funktionen von Dynamo "hinter den Kulissen" steuert. Für fast jede Funktion in Dynamo-Blöcken und -Interaktionen ist eine entsprechende Funktion in der Skriptsprache vorhanden. Aus diesem Grund stehen einzigartige Möglichkeiten für einen nahtlosen Übergang zwischen Block-Interaktionen und Skripterstellung zur Verfügung.
Blöcke können automatisch in Textsyntax konvertiert werden, etwa um Anfängern den Einstieg in DesignScript zu erleichtern oder um ganz einfach größere Abschnitte eines Diagramms auf kleinerem Raum zusammenzufassen. Hierfür steht die Funktion Block zu Code zur Verfügung, die im Abschnitt genauer beschrieben wird. Benutzer mit umfassender Erfahrung können in Codeblöcken unter Verwendung vieler Standardparadigmen der Codeerstellung benutzerdefinierte Mashups bestehender Funktionen sowie eigene Beziehungen erstellen. Benutzer, die über einige Erfahrung verfügen, aber keine Experten sind, finden zahlreiche Shortcuts und Codeabschnitte, mit deren Hilfe sie schneller an ihren Entwürfen arbeiten können. Der Begriff "Codeblock" mag zwar für Benutzer ohne Programmierkenntnisse etwas zu fachspezifisch wirken, die Codeblöcke selbst sind jedoch benutzerfreundlich und robust. Für den Einstieg können Codeblöcke mit einem Minimum an Codeerstellung effizient eingesetzt werden, während Benutzer mit fortgeschrittenen Kenntnissen Skriptdefinitionen definieren und gegebenenfalls an anderer Stelle in einer Dynamo-Definition erneut aufrufen können.
Codeblöcke sind, kurz zusammengefasst, eine Oberfläche für Textskripts innerhalb einer Umgebung für visuelles Skripting. Sie können für Zahlen, Zeichenfolgen, Formeln und andere Datentypen verwendet werden. Die Codeblock-Funktion wurde für Dynamo entwickelt. Sie können daher beliebige Variable im Codeblock definieren, die anschließend automatisch den Eingaben des Blocks hinzugefügt werden:
Bei Codeblöcken kann der Benutzer flexibel entscheiden, wie die Eingaben festgelegt werden sollen. Die folgenden Abbildungen zeigen verschiedene Möglichkeiten zum Erstellen eines einfachen Punkts mit den Koordinaten (10, 5, 0):
Während Sie weitere Funktionen aus der Bibliothek kennenlernen, erweist sich eventuell die Eingabe von "Point.ByCoordinates" als leichter und schneller als die Suche nach dem passenden Block in der Bibliothek. Wenn Sie beispielsweise Point. eingeben, zeigt Dynamo eine Liste möglicher Funktionen an, die für Punkte angewendet werden können. Dadurch gestaltet sich die Skripterstellung intuitiver und die Anwendung von Funktionen in Dynamo ist leichter zu erlernen.
Der Codeblock befindet sich unter Core > Input > Actions > Code Block. Sie können den Codeblock jedoch auch wesentlich schneller durch einfaches Doppelklicken im Ansichtsbereich aufrufen. Dieser Block wird so häufig verwendet, dass ihm uneingeschränkte Doppelklickfunktionen zugewiesen wurden.
Codeblöcke können auch flexibel für unterschiedliche Datentypen eingesetzt werden. Die Benutzer können rasch Zahlen, Zeichenfolgen und Formeln definieren und der Codeblock liefert die gewünschte Ausgabe.
Die folgende Abbildung zeigt, dass der "herkömmliche" Ablauf für diese Angaben etwas umständlich ist: Der Benutzer sucht in der Benutzeroberfläche nach dem gewünschten Block, fügt diesen im Ansichtsbereich hinzu und gibt die Daten ein. Einen Codeblock hingegen kann der Benutzer durch Doppelklicken im Ansichtsbereich aufrufen, um anschließend den benötigten Datentyp in der entsprechenden Syntax einzugeben.
Die Blöcke number, string und formula sind drei Beispiele für Dynamo-Blöcke, die im Vergleich zu Code Block als veraltet betrachtet werden könnten.
Traditionell
Codeblöcke
Dynamo ist eine hervorragende Möglichkeit, um mit der Programmierung für den AEC-Bereich zu beginnen. Sie sind vielleicht an einigen dieser Abschnitte interessiert, um selbst mit dem Coding zu beginnen:
Die Namen von Blöcken in Dynamo weisen ein gemeinsames Merkmal auf: Sie enthalten einen Punkt "." ohne Leerzeichen. Der Grund dafür ist, dass als Text oben in jedem Block dessen Syntax in der Skriptsprache angegeben wird. Der Punkt (".") in der sogenannten Punktnotation trennt dabei das Element von den möglichen Methoden, die für dieses aufgerufen werden können. Dies vermittelt auf einfache Weise zwischen visueller und textbasierter Skripterstellung.
Zur allgemeinen Veranschaulichung der Punktnotation dient hier die parametrische Behandlung eines Apfels in Dynamo. Im Folgenden werden einige "Methoden" betrachtet, die Sie für den Apfel ausführen können (bevor Sie ihn essen). (Anmerkung: Diese Methoden sind keine echten Dynamo-Methoden.)
Für Menschen lesbar | Punktnotation | Ausgabe |
---|
Die Ausgabedaten in der Tabelle lassen darauf schließen, dass dieser Apfel schmackhaft ist. Ich glaube, ich Apfel.Essen().
Behalten Sie dieses anschauliche Beispiel im Gedächtnis, wenn jetzt anhand von Point.ByCoordinates gezeigt wird, wie Sie mithilfe von Codeblöcken einen Punkt erstellen können.
Die Code Block-Syntax Point.ByCoordinates(0,10);
gibt dasselbe Ergebnis aus wie der Point.ByCoordinates-Block in Dynamo, allerdings genügt ein Block, um den Punkt zu erstellen. Dieses Verfahren ist effizienter als die Verbindung separater Blöcke mit x und y.
Indem Sie Point.ByCoordinates im Codeblock verwenden, legen Sie die Eingabewerte in derselben Reihenfolge fest wie im vorgegebenen Block (x, y).
Sie können beliebige Blöcke aus der Bibliothek mithilfe eines Codeblocks aufrufen. Ausgenommen hiervon sind spezielle Blöcke für die Benutzeroberfläche, d. h. Blöcke mit einer speziellen Funktion in der Benutzeroberfläche. So können Sie beispielsweise Circle.ByCenterPointRadius aufrufen; einen Watch 3D-Block aufzurufen, wäre jedoch wenig sinnvoll.
Es gibt generell drei Typen normaler Blöcke (dies umfasst die meisten Blöcke in der Bibliothek). Die Bibliothek ist anhand dieser Kategorien geordnet. Methoden bzw. Blöcke dieser drei Typen werden beim Aufruf in einem Codeblock unterschiedlich behandelt.
Erstellen: Erstellt bzw. konstruiert ein Objekt.
Aktion: Führt einen Vorgang für ein Objekt aus.
Abfrage: Ruft eine Eigenschaft eines bestehenden Objekts ab.
Mit Blöcken aus der Kategorie Erstellen wird völlig neue Geometrie konstruiert. Die Werte werden von links nach rechts in den Codeblock eingegeben. Dabei wird dieselbe Reihenfolge für die Eingaben eingehalten wie im eigentlichen Block von oben nach unten.
Der Vergleich des Line.ByStartPointEndPoint-Blocks und der entsprechenden Syntax im Codeblock zeigt, dass Sie dieselben Ergebnisse erhalten.
Eine Aktion ist ein Vorgang, den Sie für ein Objekt des gegebenen Typs ausführen. In Dynamo wird die vielen Programmiersprachen gemeinsame Punktnotation zum Anwenden von Aktionen auf Objekte verwendet. Dabei geben Sie zuerst das Objekt, dann einen Punkt und schließlich den Namen der Aktion ein. Die Eingabewerte für Aktionsmethoden werden genau wie bei Erstellungsmethoden in Klammern gesetzt, wobei Sie jedoch die erste Eingabe aus dem entsprechenden Block nicht angeben müssen. Stattdessen geben Sie das Element an, für Sie die Aktion durchführen:
Der Point.Add-Block ist ein Aktionsblock, d. h., die Syntax funktioniert anders als zuvor.
Die Eingaben sind: 1. der point und 2. der hinzuzufügende vector. Im Code Block hat der Punkt (das Objekt) die Bezeichnung "pt". Um einen Vektor *"vec" * zu "pt" hinzuzufügen, müssen Sie pt.Add(vec) schreiben, oder: Objekt, Punkt, Aktion. Die Aktion Add benötigt nur eine Eingabe, d. h. alle Eingaben aus dem Point.Add-Block ausgenommen die erste. Die erste Eingabe für den Point.Add-Block ist der Punkt selbst.
Abfragemethoden rufen eine Eigenschaft eines Objekts ab. Da das Objekt selbst die Eingabe ist, müssen Sie keine weiteren Eingaben angeben. Es sind keine Klammern erforderlich.
Die Funktionsweise der Vergitterung in Blöcken unterscheidet sich von derjenigen in Codeblöcken. In Blöcken klickt der Benutzer mit der rechten Maustaste auf den jeweiligen Block und wählt die benötigte Vergitterungsoption. Codeblöcke bieten wesentlich mehr Kontrolle über die Strukturierung der Daten. In der Codeblock-Kurzschreibweise wird die Zuordnung mehrerer eindimensionaler Listen mithilfe von Replikationsanleitungen festgelegt,. Die Hierarchie innerhalb der resultierenden verschachtelten Liste wird durch Zahlen in spitzen Klammern "< >" definiert: <1>,<2>,<3> usw.
In diesem Beispiel werden mithilfe der Kurzschreibweise zwei Bereiche definiert. (Genauere Informationen zu Kurzschreibweisen erhalten Sie im folgenden Abschnitt dieses Kapitels.) Kurz gesagt,
0..1;
entspricht{0,1}
und-3..-7
entspricht{-3,-4,-5,-6,-7}
. Als Ergebnis erhalten Sie Listen mit zwei x- und 5 y-Werten. Ohne Replikationsanleitungen wird aus diesen nicht übereinstimmenden Listen eine Liste mit zwei Punkten erstellt, was der Länge der kürzesten Liste entspricht. Mithilfe der Replikationsanleitungen werden sämtliche möglichen Kombinationen aus zwei und fünf Koordinaten (d. h. ihr Kreuzprodukt) ermittelt.Mit der Syntax Point.ByCoordinates
(x_vals<1>,y_vals<2>);
erhalten Sie zwei Listen mit je fünf Einträgen.Mit der Syntax Point.ByCoordinates
(x_vals<2>,y_vals<1>);
erhalten Sie fünf Listen mit je zwei Einträgen.
Diese Notation ermöglicht es außerdem, welche der Listen der anderen übergeordnet sein soll, d. h., ob zwei Listen mit fünf Einträgen oder fünf Listen mit zwei Einträgen ausgegeben werden sollen. In diesem Beispiel bewirkt die Änderung der Reihenfolge der Replikationsanleitungen, dass als Ergebnis eine Liste entweder mit Zeilen von Punkten oder mit Spalten von Punkten ausgegeben wird.
Für die oben beschriebenen Codeblock-Methoden ist eventuell eine gewisse Einarbeitung nötig. In Dynamo steht die Funktion Block zu Code zur Verfügung, die dies erleichtert. Um diese Funktion zu verwenden, wählen Sie eine Gruppe von Blöcken in Ihrem Dynamo-Diagramm aus, klicken mit der rechten Maustaste in den Ansichtsbereich und wählen Block zu Code. Dynamo fasst daraufhin diese Blöcke einschließlich aller Ein- und Ausgaben in einem Codeblock zusammen. Dies ist nicht nur ideal zum Erlernen von Codeblock, sondern ermöglicht darüber hinaus die Arbeit mit effizienteren und stärker parametrischen Dynamo-Diagrammen. Die unten folgende Übungslektion wird mit einem Abschnitt zu Block zu Code abgeschlossen. Sie sollten sie daher vollständig bearbeiten.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Zur Demonstration der Effizienz von Codeblock wird hier eine bestehende Definition eines Attraktorfelds in Codeblockform übertragen. Die Verwendung einer bestehenden Definition zeigt die Beziehung zwischen Codeblock und visuellem Skript und erleichtert das Erlernen der Design Script-Syntax.
Erstellen Sie zuerst die in der Abbildung oben gezeigte Definition (oder öffnen Sie die Beispieldatei).
Als Vergitterung für Point.ByCoordinates wurde Kreuzprodukt eingestellt.
Die einzelnen Punkte eines Rasters werden in Abhängigkeit von ihrer Entfernung zum Referenzpunkt in z-Richtung nach oben verschoben.
Eine Oberfläche wird erstellt und verdickt, sodass die Geometrie relativ zur Entfernung vom Referenzpunkt ausgebeult wird.
Wir beginnen mit der Definition des Referenzpunkts: Point.ByCoordinates
(x,y,0);
Wir verwenden dieselbe Point.ByCoordinates-Syntax wie oben im Referenzpunkt-Block angegeben.Die Variablen x und y werden in den Codeblock eingefügt, sodass sie mithilfe von Schiebereglern dynamisch aktualisiert werden können.
Fügen Sie Schieberegler für die Eingaben im Codeblock hinzu, mit denen Bereiche von -50 bis 50 definiert werden. Dies erstreckt sich über das gesamte Vorgaberaster von Dynamo.
Definieren Sie in der zweiten Zeile des Codeblocks eine Kurzschreibweise, um den Nummernsequenz-Block zu ersetzen:
coordsXY = (-50..50..#11);
Dies wird im nächsten Abschnitt genauer beschrieben. Halten Sie zunächst fest, dass diese Kurzschreibweise dem Number Sequence-Block im visuellen Skript entspricht.
Als Nächstes erstellen Sie ein Raster aus Punkten aus der coordsXY-Folge. Hierfür soll die Syntax Point.ByCoordinates verwendet werden, Sie müssen jedoch außerdem genau wie im visuellen Skript das Kreuzprodukt aus der Liste erstellen. Dazu geben Sie die folgende Zeile ein:
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);
Die spitzen Klammern geben die Referenz auf das Kreuzprodukt an.Im Watch3D-wird jetzt ein Raster von Punkten über das gesamte Dynamo-Raster angezeigt.
Jetzt folgt der schwierige Teil: Die Punkte des Rasters sollen in Abhängigkeit von ihrer Entfernung zum Referenzpunkt nach oben verschoben werden. Diese neue Punktgruppe soll den Namen transPts erhalten. Eine Verschiebung ist eine Aktion, die für ein bestehendes Element durchgeführt wird. Daher verwenden wir nicht
Geometry.Translate...
sonderngridPts.Translate
.Im Block, der im Ansichtsbereich gezeigt wird, sind drei Eingaben zu sehen. Die zu verschiebende Geometrie ist bereits deklariert, da die Aktion für dieses Element durchgeführt wird (mithilfe von gridPts.Translate). Die beiden verbleibenden Eingaben werden in die Klammern der Funktion eingegeben: direction und distance.
Die Richtung ist leicht anzugeben: Sie geben
Vector.ZAxis()
für die vertikale Verschiebung an.Die Abstände zwischen dem Referenzpunkt und den einzelnen Rasterpunkten müssen jedoch noch berechnet werden. Dies erreichen Sie auf dieselbe Weise wie zuvor durch eine Aktion für den Referenzpunkt:
refPt.DistanceTo(gridPts)
Die letzte Codezeile enthält die verschobenen Punkte:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
Damit haben Sie ein Raster aus Punkten mit einer geeigneten Datenstruktur zum Erstellen einer Nurbs-Oberfläche erstellt. Wir erstellen die Oberfläche mithilfe von
srf = NurbsSurface.ByControlPoints(transPts);
.
Schließlich fügen Sie der Oberfläche Tiefe hinzu: Dazu konstruieren Sie mithilfe von
solid = srf.Thicken(5);
einen Volumenkörper. In diesem Fall wurde die Oberfläche im Code um 5 Einheiten verdickt, dies kann jedoch jederzeit auch als Variable (etwa mit dem Namen thickness) deklariert werden, deren Wert durch einen Schieberegler gesteuert wird.
Die Funktion Block zu Code führt die gesamte eben behandelte Übung durch einen einfachen Mausklick aus. Sie ermöglicht damit nicht nur die Erstellung benutzerdefinierter Definitionen und wiederverwendbarer Codeblöcke, sondern ist auch ein äußerst nützliches Hilfsmittel beim Erlernen der Skripterstellung in Dynamo:
Beginnen Sie mit dem bestehenden visuellen Skript aus Schritt 1 dieser Übungslektion. Wählen Sie sämtliche Blöcke aus, klicken Sie mit der rechten Maustaste in den Ansichtsbereich und wählen Sie Block zu Code. Dieser einfache Schritt genügt.
Dynamo hat automatisch eine Textversion des visuellen Diagramms einschließlich Vergitterung und aller anderen Angaben erstellt. Probieren Sie dies mit Ihren visuellen Skripts aus und schöpfen Sie die Möglichkeiten von Codeblöcken voll aus!
/
/
/
Platzieren Sie Lichtmast-Blockreferenzen entlang eines 3D-Profilkörpers an Stationswerten, die in einer Excel-Datei angegeben sind.
Mission erfüllt!
Benennen Sie Kanalnetz-Schächte/Bauwerke basierend auf der Station einer Achse um.
Mission erfüllt!
Civil 3D-Version | Dynamo-Version | Anmerkungen |
---|---|---|
Erstellen Sie ein Dynamo-Diagramm, das Text in den Modellbereich einfügt.
Mission erfüllt!
Verwenden Sie einen Block für einen Fahrzeug-Längsschnitt, um 3D-Volumenkörper mit Lichtraumprofil entlang eines 3D-Profilkörpers zu erstellen.
Mission erfüllt!
Erstellen Sie eine Punktgruppe für jede eindeutige Koordinatenpunktbeschreibung.
Mission erfüllt!
Platzieren Sie Wasseranschlusszähler-Blockreferenzen in angegebenen Abständen von einer Parzellenlinie, und zeichnen Sie eine Linie für jeden Hausanschluss lotrecht zur Hauptverteilung.
Mission erfüllt!
Offenbar wird der Text gelöscht und mit jedem Durchlauf des Diagramms neu erstellt. In Wirklichkeit wird die Position des Texts geändert, abhängig davon, welcher Kreis ausgewählt ist. Es ist also derselbe Text, nur an einer anderen Stelle! Um jedes Mal neuen Text zu erstellen, müssen Sie die Einstellungen für die Objektbindung in Dynamo ändern, sodass keine Bindungsdaten beibehalten werden (siehe unten).
Wenn Dynamo Player neu für Sie ist, finden Sie im Abschnitt weitere Informationen.
Ruft die Umgrenzungsgeometrie aller Einzugsgebiete in einer Zeichnung ab.
Bevor wir beginnen, unser Diagramm zu erstellen und Code zu schreiben, sollten wir uns die Dokumentation zur Civil 3D-API ansehen und einen Eindruck davon gewinnen, was die API uns zur Verfügung stellt. In diesem Fall gibt es eine , die die Umgrenzungspunkte des Einzugsgebiets zurückgibt. Beachten Sie, dass diese Eigenschaft ein Point3dCollection
-Objekt zurückgibt. Dynamo kann diese Objektart nicht verarbeiten. Mit anderen Worten: Wir können keine PolyCurve aus einer Point3dCollection
erstellen, daher müssen wir irgendwann alles in Dynamo-Punkte umwandeln. Doch mehr dazu später.
Bevor wir fortfahren, müssen wir noch kurz auf ein wichtiges Konzept eingehen. Im Abschnitt wurde erläutert, wie Objekte und CivilObjects miteinander verbunden sind. Eine weitere relevante Information ist, dass ein Dynamo-Objekt als Wrapper um ein AutoCAD-Objekt herum fungiert. In ähnlicher Weise ist ein Dynamo-CivilObject ein Wrapper um ein Civil 3D-Objekt herum. Sie können ein Objekt abwickeln, indem Sie auf seine InternalDBObject
- oder InternalObjectId
-Eigenschaften zugreifen.
Dynamo-Typ | Enthält im Wrapper |
---|
Mission erfüllt!
Weitere Informationen zu dieser Umstellung und zum Aktualisieren älterer Skripte finden Sie im . Wenn Sie IronPython weiterhin verwenden möchten, müssen Sie lediglich das DynamoIronPython2.7-Paket mithilfe des Dynamo Package Manager installieren.
2024.1
2.18
2024
2.17
Aktualisierung der Dynamo Player-Benutzeroberfläche
2023.2
2.15
2023
2.13
Aktualisierung der Dynamo-Benutzeroberfläche
2022.1
2.12
Datenspeichereinstellungen für Objektbindung hinzugefügt
Neue Blöcke zum Steuern der Objektbindung
2022
2.10
Zur Civil 3D-Hauptinstallation hinzugefügt
Wechsel von IronPython zu Python.NET
2021
2.5
2020.2
2.4
2020 Update 2
2.4
Neue Blöcke hinzugefügt
2020.1
2.2
2020
2.1
Ursprüngliche Version
Objekt Autodesk.AutoCAD.DynamoNodes.Object | Objekt Autodesk.AutoCAD.DatabaseServices.Entity |
CivilObject Autodesk.Civil.DynamoNodes.CivilObject | Objekt Autodesk.Civil.DatabaseServices.Entity |
In diesem Abschnitt finden Sie eine Reihe von Lektionen zur Geometrieerstellung mit DesignScript. Machen Sie mit, indem Sie die DesignScript-Beispiele in Dynamo-Codeblöcke kopieren.
Welche Farbe hat der Apfel? | Apfel.Farbe | Rot |
Ist der Apfel reif? | Apfel.istReif | Wahr |
Wie viel wiegt der Apfel? | Apfel.Gewicht | 170 g |
Woher kommt der Apfel? | Apfel.Übergeordnet | Baum |
Was kann aus dem Apfel entstehen? | Apfel.Untergeordnet | Kerne |
Wurde der Apfel hier in der Gegend angebaut? | Apfel.EntfernungVonObstgarten | 100 km |
Funktionen können in einem Codeblock erstellt und an anderer Stelle in einer Dynamo-Definition erneut aufgerufen werden. Dadurch erhalten Sie eine weitere Steuerungsmöglichkeit in parametrischen Dateien. Sie stellt eine Textversion eines benutzerdefinierten Blocks dar. In diesem Fall ist der übergeordnete Block problemlos verfügbar und kann sich an beliebiger Stelle im Diagramm befinden. Hierfür sind keine Verbindungen erforderlich.
Die erste Zeile besteht aus dem Schlüsselwort "def" und dem Namen der Funktion mit den Namen der Eingaben in Klammern. Der Hauptteil der Funktion wird in geschweiften Klammern angegeben. Verwenden Sie zum Ausgeben eines Werts "return =". In Codeblöcken, die eine Funktion definieren, sind keine Eingabe- oder Ausgabeverbindungen vorhanden, da sie über andere Codeblöcke aufgerufen werden.
Sie können die Funktion in einem anderen Codeblock in derselben Datei aufrufen, indem Sie ihren Namen und dieselbe Anzahl von Argumenten angeben. Dies funktioniert auf dieselbe Weise wie die vordefinierten Blöcke aus der Bibliothek.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung erstellen Sie eine allgemeine Definition zum Erstellen von Kugeln aus einer eingegebenen Liste von Punkten. Der Radius dieser Kugeln wird durch die z-Eigenschaft des jeweiligen Punkts gesteuert.
Sie beginnen mit einem Zahlenbereich, der zehn Werte von 0 bis 100 umfasst. Verbinden Sie diesen mit einem Point.ByCoordinates-Block, um eine diagonale Linie zu erhalten.
Erstellen Sie einen Code Block und stellen Sie die Definition vor.
Verwenden Sie die folgenden Codezeilen:
Dabei ist inputPt der Name, den Sie für die Punkte zuweisen, über die die Funktion gesteuert werden soll. Bis hierher hat die Funktion keine Wirkung. Dies entwickeln Sie jedoch in den folgenden Schritten.
Fügen Sie der Code Block-Funktion einen Kommentar und die Variable sphereRadius hinzu, die die Z-Position der einzelnen Punkte abfragt. Beachten Sie, dass die Methode inputPt.Z keine Klammern benötigt. Da es sich um eine Abfrage von Eigenschaften eines bestehenden Elements handelt, sind keine Eingaben erforderlich.
Als Nächstes rufen Sie die eben erstellte Funktion in einem anderen Code Block auf. Wenn Sie im Ansichtsbereich doppelklicken, um einen neuen Code Block zu erstellen, und sphereB eingeben, schlägt Dynamo die eben definierte sphereByZ-Funktion vor: Die Funktion wurde der IntelliSense-Bibliothek hinzugefügt. Dieser Mechanismus ist sehr hilfreich.
Als Nächstes erstellen Sie eine Variable mit dem Namen Pt, um die Verbindung zu den Punkten herzustellen, die Sie in den vorherigen Schritten erstellt haben:
Die Ausgabe zeigt lediglich Nullwerte. Dies geschieht aus dem folgenden Grund: Beim Definieren der Funktion wurde festgelegt, dass die Variable sphereRadius berechnet werden soll, Sie haben jedoch noch nicht definiert, was die Funktion als Ausgabe zurückgeben soll. Dies beheben Sie im nächsten Schritt.
In diesem wichtigen Schritt müssen Sie die Ausgabe der Funktion definieren. Fügen Sie die Zeile
return = sphereRadius;
in die sphereByZ-Funktion ein.Jetzt zeigt die Ausgabe im Codeblock die z-Koordinaten der einzelnen Punkte an.
Als Nächstes erstellen Sie die Kugeln, indem Sie die übergeordnete Funktion bearbeiten.
Definieren Sie zunächst eine Kugel mit der folgenden Codezeile:
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
Als Nächstes ändern Sie den Rückgabewert in sphere anstelle von sphereRadius:
return = sphere;
Dadurch erhalten Sie in der Dynamo-Vorschau einige riesengroße Kugeln.
1. Um die Größe dieser Kugeln zu verringern, aktualisieren wir den Wert sphereRadius, indem wir ein Trennzeichen hinzufügen:
sphereRadius = inputPt.Z/20;
Jetzt sind die einzelnen Kugeln getrennt sichtbar und die Beziehung zwischen dem Radius und dem z-Wert wird erkennbar.
Indem Sie im Point.ByCoordinates-Block die Vergitterung von Kürzeste in Kreuzprodukt ändern, erstellen Sie ein Raster aus Punkten. Die sphereByZ-Funktion ist weiterhin uneingeschränkt wirksam, d. h., für alle Punkte werden Kugeln mit von ihren z-Werten abhängigen Radien erstellt.
Verbinden Sie jetzt als weiteren Test die ursprüngliche Zahlenliste mit der x-Eingabe von Point.ByCoordinates. Dadurch entsteht ein Würfel aus Kugeln.
Anmerkung: Wenn diese Berechnung auf Ihrem Computer viel Zeit in Anspruch nimmt, ändern Sie den Wert #10 in einen kleineren Wert, z. B. #5.
Beachten Sie, dass die von Ihnen erstellte Funktion sphereByZ eine allgemeine Funktion ist. Sie können daher die Helix aus einer der vorigen Lektionen erneut öffnen und die Funktion darauf anwenden.
In einem letzten Schritt steuern Sie das Radienverhältnis über einen benutzerdefinierten Parameter. Zu diesem Zweck müssen Sie eine neue Eingabe für die Funktion erstellen und den Teiler 20 durch einen Parameter ersetzen.
Aktualisieren Sie die Definition von sphereByZ wie folgt:
Aktualisieren Sie den untergeordneten Codeblock, indem Sie der Eingabe eine Verhältnisvariable hinzufügen:
sphereByZ(Pt,ratio);
. Verbinden Sie einen Schieberegler mit der neu erstellten Code Block-Eingabe und ändern Sie die Größe der Radien anhand des Radienverhältnisses.
Für Codeblöcke stehen einige einfache Kurzschreibweisen zur Verfügung, die, einfach ausgedrückt, die Arbeit mit den Daten erheblich erleichtern. Im Folgenden werden die Grundlagen genauer erläutert und beschrieben, wie die jeweilige Kurzschreibweise zum Erstellen und Abfragen von Daten verwendet werden kann.
Die Methoden zum Definieren von Bereichen und Sequenzen können in einfachen Kurzschreibweisen ausgedrückt werden. Die folgende Abbildung bietet eine Anleitung zum Definieren einer Liste mit numerischen Daten mithilfe der Syntax ".." in Codeblöcken. Nachdem Sie sich mit dieser Notation vertraut gemacht haben, können Sie numerische Daten äußerst effizient erstellen:
In diesem Beispiel wird ein Zahlenbereich durch einfache Codeblock-Syntax mit Angaben für
beginning..end..step-size;
ersetzt. In numerischer Darstellung erhalten wir die Werte:0..10..1;
Beachten Sie, dass die Syntax
0..10..1;
der Syntax0..10;
entspricht. Die Schrittgröße 1 ist der Vorgabewert für die Kurzschreibweise. Mit0..10;
erhalten wir daher eine Folge von 0 bis 10 mit der Schrittgröße 1.Das Beispiel für die Folge ist ähnlich, allerdings wird hier mithilfe eines #-Zeichens angegeben, dass die Liste nicht beim Wert 15 enden, sondern 15 Werte enthalten soll. In diesem Fall wird Folgendes definiert:
beginning..#ofSteps..step-size:
. Die tatsächliche Syntax für die Sequenz lautet:0..#15..2
Platzieren Sie das #-Zeichen aus dem vorigen Schritt jetzt im Bereich für die Schrittgröße der Syntax. Damit haben Sie einen Zahlenbereich vom Anfang zum Ende erstellt. Die Notation für die Schrittgröße verteilt die angegebene Anzahl Werte gleichmäßig zwischen diesen beiden Angaben:
beginning..end..#ofSteps
Indem Sie erweiterte Bereiche erstellen, können Sie auf einfache Weise mit Listen von Listen arbeiten. In den Beispielen unten wird eine Variable aus der Darstellung der primären Liste isoliert und ein weiterer Bereich aus dieser Liste erstellt.
1. Vergleichen Sie die Notation mit und ohne #-Zeichen bei der Erstellung verschachtelter Bereiche. Dabei gilt dieselbe Logik wie bei einfachen Bereichen, die Angaben sind jedoch etwas komplexer.
2. Sie können an beliebiger Stelle des primären Bereichs einen Unterbereich erstellen. Es ist auch möglich, zwei Unterbereiche zu verwenden.
3. Mithilfe des Werts für end in einem Bereich erstellen Sie weitere Bereiche unterschiedlicher Länge.
Vergleichen Sie als Übung zu dieser Logik die beiden oben gezeigten Kurzschreibweisen und testen Sie, wie Unterbereiche und das #-Zeichen sich auf das Ergebnis auswirken.
Sie können Listen nicht nur mithilfe von Kurzschreibweisen, sondern auch ad hoc erstellen. Solche Listen können eine Vielfalt von Elementtypen enthalten und können abgefragt werden (da Listen ihrerseits Objekte sind). Kurz zusammengefasst: Mit einem Codeblock erstellen Sie Listen, und zum Abfragen der Listen verwenden Sie eckige Klammern:
1. Sie können Listen schnell aus Zeichenfolgen erstellen und über die Indizes der Einträge abfragen.
2. Sie können Listen mit Variablen erstellen und sie über die Kurzschreibweisen für Bereiche abfragen.
Verschachtelte Listen werden auf ähnliche Weise verwaltet. Beachten Sie dabei die Reihenfolge der Listen und verwenden Sie mehrere Paare eckiger Klammern:
1. Definieren Sie eine Liste von Listen.
2. Fragen Sie eine Liste mit einer Angabe in eckigen Klammern ab.
3. Fragen Sie einen Eintrag mit zwei Angaben in eckigen Klammern ab.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung wenden Sie Ihre Kenntnisse der Kurzschreibweise an und erstellen eine originelle gewölbte Oberfläche, die Sie mithilfe von Bereichen und Formeln definieren. Beachten Sie in dieser Übung, wie Codeblöcke und bestehende Dynamo-Blöcke zusammenwirken: Für umfangreiche Datenverarbeitungen kommen Codeblöcke zum Einsatz, durch die visuelle Darstellung der Dynamo-Blöcke ist die Definition leichter zu lesen.
Erstellen Sie zunächst eine Oberfläche, indem Sie die oben gezeigten Blöcke verbinden. Verwenden Sie zum Definieren der Breite und Länge keinen Number-Block, sondern doppelklicken Sie in den Ansichtsbereich und geben Sie den Wert 100;
in einen Codeblock ein.
Definieren Sie einen Bereich zwischen 0 und 1 mit 50 Unterteilungen, indem Sie
0..1..#50
in einen Codeblock eingeben.Verbinden Sie den Bereich mit Surface.PointAtParameter. Dieser Block benötigt u- und v-Werte zwischen 0 und 1 für die gesamte Oberfläche. Sie müssen die Vergitterung in Kreuzprodukt ändern. Klicken Sie dazu mit der rechten Maustaste auf den Surface.PointAtParameter-Block.
In diesem Schritt verschieben Sie das Raster aus Punkten mithilfe der ersten Funktion in z-Richtung nach oben. Dieses Raster steuert die zu erstellende Oberfläche anhand der zugrunde liegenden Funktion. Fügen Sie neue Blöcke hinzu, wie in der folgenden Abbildung gezeigt.
Verwenden Sie anstelle eines Formelblocks einen Codeblock mit der folgenden Zeile:
(0..Math.Sin(x*360)..#50)*5;
. Dadurch definieren Sie, kurz zusammengefasst, einen Bereich, der eine Formel enthält. Diese Formel ist die Sinusfunktion. Da für die Sinusfunktion in Dynamo Werte in Grad eingegeben werden müssen, multiplizieren Sie die x-Werte (d. h. den eingegebenen Bereich zwischen 0 und 1) mit 360, um eine vollständige Sinuskurve zu erhalten. Als Nächstes wird dieselbe Anzahl Unterteilungen als Rastersteuerpunkte für die einzelnen Reihen benötigt. Definieren Sie daher 50 Unterteilungen mit #50. Der Multiplikator 5 schließlich verstärkt die Verschiebung, sodass deren Wirkung in der Dynamo-Vorschau deutlich zu sehen ist.
Der zuvor verwendete Codeblock erfüllte seine Funktion, war jedoch nicht vollständig parametrisch. Die Parameter sollen dynamisch gesteuert werden. Ersetzen Sie daher die Zeile aus dem vorherigen Schritt durch
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;
. Dadurch erhalten Sie die Möglichkeit, diese Werte anhand Ihrer Eingaben zu definieren.
Indem Sie die Werte der Schieberegler (zwischen 0 und 10) ändern, erhalten Sie interessante Ergebnisse.
Indem Sie Transpose auf den Zahlenbereich anwenden, kehren Sie die Richtung der Wellen um:
transposeList = List.Transpose(sineList);
Durch Addieren von sineList und tranposeList erhalten Sie eine verzerrte Hülle:
eggShellList = sineList+transposeList;
Ändern Sie die unten angegebenen Schiebereglerwerte, um den Algorithmus etwas ausgeglichener zu gestalten.
In dieser letzten Übung fragen wir isolierte Teile der Daten mithilfe eines Codeblocks ab. Fügen Sie den oben gezeigten Codeblock zwischen dem Geometry.Translate- und dem NurbsSurface.ByPoints-Block ein, um die Oberfläche aus einem bestimmten Bereich von Punkten neu zu erstellen. Der Codeblock enthält die folgende Textzeile: sineStrips[0..15..1];
. Dadurch werden die ersten 16 (von 50) Punktreihen ausgewählt. Wenn die Oberfläche neu erstellt wird, ist zu erkennen, dass ein isolierter Teil des Punktrasters generiert wurde.
Im letzten Schritt erweitern Sie den Codeblock um parametrische Funktionen, indem Sie einen Schieberegler mit dem Bereich von 0 bis 1 zur Steuerung der Abfrage verwenden. Dies geschieht mit der folgenden Codezeile:
sineStrips[0..((List.Count(sineStrips)-1)*u)];
. Dies mag etwas verwirrend wirken. Diese Codezeile ermöglicht jedoch eine schnelle Skalierung der Länge der Liste über einen Multiplikator zwischen 0 und 1.
Mithilfe des Werts 0.53
im Schieberegler erstellen Sie eine Oberfläche, die sich knapp über die Mitte des Rasters hinaus erstreckt.
Mit dem Wert 1
im Schieberegler wird erwartungsgemäß eine Oberfläche aus dem gesamten Punktraster erstellt.
Im visuellen Diagramm können Sie die einzelnen Codeblöcke markieren und ihre Funktionen sehen.
1. Der erste Codeblock ersetzt den Number-Block.
2. Der zweite Codeblock ersetzt den Number Range-Block.
3. Der dritte Codeblock ersetzt den Formula-Block (sowie List.Transpose, List.Count und Number Range).
4. Der vierte Codeblock ruft eine Liste von Listen ab und ersetzt den List.GetItemAtIndex-Block.
Zwar ist Dynamo in der Lage, eine Reihe komplexer geometrischer Formen zu erstellen, jedoch bilden einfache geometrische Grundkörper die Grundlage jedes computergestützten Entwurfs: entweder als direkter Ausdruck in der endgültigen Entwurfsform oder als Gerüst für die Erstellung einer komplexeren Geometrie.
Ein Koordinatensystem ist streng genommen kein Geometrieobjekt, dient jedoch als wichtiges Hilfsmittel zum Erstellen von Geometrie. Ein CoordinateSystem-Objekt verfolgt Positions- und Geometrietransformationen wie Drehen, Scheren und Skalieren.
Zum Erstellen eines an einem Punkt mit x = 0, y = 0, z = 0 zentrierten Koordinatensystems ohne Rotations-, Skalierungs- oder Schertransformationen kann einfach der Konstruktor Identity aufgerufen werden:
Koordinatensysteme mit geometrischen Transformationen gehen über den Umfang dieses Kapitels hinaus, auch wenn Sie mit einem anderen Konstruktor, namentlich CoordinateSystem.ByOriginVectors, ein Koordinatensystem an einem bestimmten Punkt erstellen können:
Der einfachste geometrische Grundkörper ist ein Punkt, der eine nulldimensionale Position im dreidimensionalen Raum darstellt. Wie bereits erwähnt gibt es verschiedene Möglichkeiten zum Erstellen eines Punkts in einem bestimmten Koordinatensystem: Point.ByCoordinates erstellt einen Punkt mithilfe der angegebenen Koordinaten x, y und z, Point.ByCartesianCoordinates erstellt einen Punkt mithilfe der angegebenen Koordinaten x, y und z in einem bestimmten Koordinatensystem, Point.ByCylindricalCoordinates erstellt einen Punkt, der auf einem Zylinder mit angegebenen Werten für Radius, Drehwinkel und Höhe liegt, und Point.BySphericalCoordinates erstellt einen Punkt auf einer Kugel mit einem angegebenen Radius und zwei Drehwinkeln.
Dieses Beispiel zeigt Punkte, die in unterschiedlichen Koordinatensystemen erstellt wurden:
Der nächsthöherdimensionale Dynamo-Grundkörper ist ein Liniensegment, das eine unendliche Anzahl von Punkten zwischen zwei Endpunkten darstellt. Linien können erstellt werden, indem Sie die beiden Grenzpunkte mit dem Konstruktor Line.ByStartPointEndPoint explizit angeben, oder durch Angabe eines Startpunkts, einer Richtung und Länge in dieser Richtung mittels Line.ByStartPointDirectionLength.
Dynamo verfügt über Objekte, die grundlegende Typen geometrischer Grundkörper in drei Dimensionen darstellen: Quader, erstellt mit Cuboid.ByLengths; Kegel, erstellt mit Cone.ByPointsRadius und Cone.ByPointsRadii; Zylinder, erstellt mit Cylinder.ByRadiusHeight sowie Kugeln, erstellt mit Sphere.ByCenterPointRadius.
Das einfachste geometrische Objekt in der Dynamo-Bibliothek für Standardgeometrie ist ein Punkt. Jegliche Geometrie wird mit speziellen Funktionen namens Konstruktoren erstellt, die jeweils ein neues Exemplar dieses bestimmten Geometrietyps zurückgeben. In Dynamo beginnen Konstruktoren mit dem Namen des Objekttyps, in diesem Fall Point, gefolgt von der Konstruktionsmethode. Zum Erstellen eines dreidimensionalen Punkts, der durch die kartesischen Koordinaten x, y und z angegeben wird, verwenden Sie den Konstruktor ByCoordinates:
Konstruktoren in Dynamo sind normalerweise mit dem Präfix By gekennzeichnet, und wenn Sie diese Funktionen aufrufen, geben sie ein neu erstelltes Objekt des betreffenden Typs zurück. Dieses neu erstellte Objekt wird in der Variablen mit dem Namen gespeichert, der links vom Gleichheitszeichen steht.
Die meisten Objekte verfügen über viele verschiedene Konstruktoren, und mit dem Konstruktor BySphericalCoordinates können wir einen Punkt erstellen, der auf einer Kugel liegt und durch den Radius der Kugel, einen ersten Drehwinkel sowie einen zweiten Drehwinkel (in Grad) angegeben wird:
Punkte können verwendet werden, um höherdimensionale Geometrien wie z. B. Linien zu erstellen. Mit dem Konstruktor ByStartPointEndPoint können wir ein Linienobjekt zwischen zwei Punkten erstellen:
In ähnlicher Weise können mit Linien wiederum höherdimensionale Oberflächengeometrien erstellt werden, beispielsweise mit dem Konstruktor Loft, der aus einer Reihe von Linien oder Kurven eine Oberfläche zwischen diesen interpoliert.
Auch Oberflächen können zum Erstellen höherdimensionaler Volumenkörper-Geometrien genutzt werden, zum Beispiel durch Verdicken der Oberfläche um einen gegebenen Abstand. Vielen Objekten sind Funktionen zugewiesen, die Methoden genannt werden, und mit denen Programmierer Befehle für das jeweilige Objekt ausführen können. Methoden, die allen Geometrien gemein sind, sind z. B. Translate und Rotate, die die Geometrie um einen bestimmten Wert verschieben oder drehen. Oberflächen haben eine Methode namens Thicken, die einen einzelnen Eingabewert (Nummer) akzeptiert, der die neue Dicke der Oberfläche angibt.
Mit den Intersection-Befehlen können niedrigerdimensionale Geometrien aus höherdimensionalen Objekten extrahiert werden. Diese extrahierte niedrigerdimensionale Geometrie kann als Grundlage für eine höherdimensionale Geometrie in einem zyklischen Prozess des geometrischen Erstellens, Extrahierens und erneuten Erstellens dienen. In diesem Beispiel verwenden wir den generierten Volumenkörper, um eine Oberfläche zu erstellen, und nutzen anschließend die Oberfläche, um eine Kurve zu erstellen.
Bestimmte geometrische Objekte können erstellt werden, indem Sie die x-, y- und z-Koordinaten im dreidimensionalen Raum explizit angeben. Häufiger wird die Geometrie jedoch mithilfe von geometrischen Transformationen auf das Objekt selbst oder auf das zugrunde liegende Koordinatensystem in ihre endgültige Position verschoben.
Die einfachste geometrische Transformation ist eine Verschiebung, bei der ein Objekt um eine bestimmte Anzahl von Einheiten in x-, y- und z-Richtung verschoben wird.
Zwar können alle Objekte in Dynamo durch Anhängen der Methode .Translate ans Ende des Objektnamens verschoben werden, jedoch erfordern komplexere Transformationen, dass das Objekt von einem zugrunde liegenden Koordinatensystem in ein neues Koordinatensystem überführt wird. Um beispielsweise ein Objekt um 45 Grad um die X-Achse zu drehen, können wir das Objekt aus seinem bisherigen Koordinatensystem ohne Drehung in ein Koordinatensystem überführen, das mit der Methode .Transform um 45 Grad um die X-Achse gedreht wurde:
Zusätzlich zu den Möglichkeiten, Koordinatensysteme zu verschieben und zu drehen, können sie auch skaliert oder geschert erstellt werden. Ein Koordinatensystem kann mit der Methode .Scale skaliert werden:
Gescherte Koordinatensysteme werden erstellt, indem nicht-orthogonale Vektoren in den Konstruktor CoordinateSystem eingegeben werden.
Skalieren und Scheren sind erheblich komplexere geometrische Transformationen als Drehen und Verschieben, daher können sie nicht auf alle Dynamo-Objekte angewendet werden. Die folgende Tabelle gibt Aufschluss darüber, welche Dynamo-Objekte ungleichmäßig skalierte sowie gescherte Koordinatensysteme aufweisen können.
Objekte in computergestützten Entwürfen werden selten explizit in ihrer endgültigen Position und Form erstellt, meist werden sie verschoben, gedreht und anderweitig anhand von bestehender Geometrie positioniert. Die Vektormathematik dient als eine Art geometrisches Gerüst, um der Geometrie Richtung und Ausrichtung zu verleihen sowie Bewegungen durch den dreidimensionalen Raum ohne visuelle Darstellung zu konzeptuieren.
In seiner einfachsten Form stellt ein Vektor eine Position im dreidimensionalen Raum dar. Man stellt sich ihn oft als Endpunkt eines Pfeils zwischen der Position (0, 0, 0) und der gegebenen Position vor. Vektoren können unter Verwendung des Konstruktors ByCoordinates erstellt werden, wobei die x-, y- und z-Position des neu erstellten Vektorobjekts angegeben wird. Beachten Sie, dass Vektoren keine geometrischen Objekte sind und nicht im Dynamo-Fenster angezeigt werden. Informationen zu einem neu erstellten oder geänderten Vektor können jedoch im Konsolenfenster gedruckt werden:
Für Vektoren ist ein Satz von mathematischen Operationen definiert, sodass Sie Objekte im dreidimensionalen Raum genauso addieren, subtrahieren, multiplizieren und anderweitig verschieben können wie reelle Zahlen im eindimensionalen Raum auf einer Zahlengeraden.
Vektoraddition ist definiert als die Summe der Komponenten von zwei Vektoren. Man kann sie sich so vorstellen, dass der resultierende Vektor aus zwei mit der Spitze des einen am Ende des anderen platzierten Vektoren entsteht. Vektoraddition wird mit der Methode Add durchgeführt und wird im Diagramm auf der linken Seite abgebildet.
Gleichermaßen können zwei Vektorobjekte mit der Methode Subtract voneinander subtrahiert werden. Vektorsubtraktion kann man sich als die Richtung vom ersten zum zweiten Vektor vorstellen.
Vektormultiplikation kann man sich so vorstellen, dass der Endpunkt eines Vektors in seiner eigenen Richtung um einen angegebenen Skalierungsfaktor verschoben wird.
Häufig ist beim Skalieren eines Vektors erwünscht, dass die Länge des resultierenden Vektors genau gleich dem skalierten Betrag ist. Dies wird einfach erreicht, indem zuerst ein Vektor normalisiert wird, also die Länge des Vektors auf genau eins festgelegt wird.
c weist weiterhin in dieselbe Richtung wie (1, 2, 3), hat jetzt jedoch eine Länge genau gleich 5.
In der Vektormathematik gibt es zwei weitere Methoden, die keine eindeutigen Parallelen zur eindimensionalen Mathematik aufweisen, das Kreuzprodukt und das Skalarprodukt. Das Kreuzprodukt ist eine Methode zum Erstellen eines Vektors, der sich im rechten Winkel (90 Grad) zu zwei vorhandenen Vektoren befindet. Beispielsweise ist das Kreuzprodukt der x- und y-Achsen die Z-Achse, auch wenn die beiden Eingabevektoren nicht orthogonal zueinander sein müssen. Ein Kreuzproduktvektor wird mit der Methode Cross berechnet.
Eine weitere, wenn auch fortgeschrittenere Funktion der Vektormathematik ist das Skalarprodukt. Das Skalarprodukt zwischen zwei Vektoren ist eine reelle Zahl (kein Vektorobjekt), die mit dem Winkel zwischen zwei Vektoren zusammenhängt, jedoch nicht exakt diesem Winkel entspricht. Ein hilfreiche Eigenschaft des Skalarprodukts besteht darin, dass das Skalarprodukt zweier Vektoren nur genau dann 0 ist, wenn sie lotrecht zueinander stehen. Das Skalarprodukt wird mit der Methode Dot berechnet.
Es gibt zwei grundlegende Methoden zum Erstellen von Freiform-Kurven in Dynamo: Die Angabe einer Sammlung von Punkten, zwischen denen Dynamo eine glatte Kurve interpoliert, oder eine einfachere Methode, bei der die zugrunde liegenden Steuerpunkte einer Kurve mit einem bestimmten Grad angegeben werden. Interpolierte Kurven sind nützlich, wenn ein Konstrukteur genau weiß, welche Form eine Linie annehmen soll, oder wenn der Entwurf bestimmte Beschränkungen aufweist, wo die Kurve verlaufen kann und wo nicht. Mit Steuerpunkten angegebene Kurven sind im Wesentlichen eine Reihe gerader Liniensegmente, die über einen Algorithmus in die endgültige Kurvenform geglättet werden. Das Festlegen einer Kurve mit Steuerpunkten eignet sich zum Experimentieren mit unterschiedlichen Kurvenformen mit verschiedenen Glättungsgraden, oder wenn glatte Übergänge zwischen Kurvensegmenten erforderlich sind.
Zum Erstellen einer interpolierten Kurve übergeben Sie einfach eine Sammlung von Punkten an die Methode NurbsCurve.ByPoints.
Die generierte Kurve schneidet jeden der eingegebenen Punkte und beginnt dabei am ersten und endet am letzten Punkt der Sammlung. Mit einem optionalen periodischen Parameter kann eine periodische Kurve erstellt werden, die geschlossen ist. Dynamo füllt das fehlende Segment automatisch aus, sodass kein duplizierter (mit dem Startpunkt identischer) Endpunkt erforderlich ist.
NurbsCurves werden in ähnlicher Weise erstellt, wobei die Eingabepunkte die Endpunkte eines geraden Liniensegments darstellen und ein zweiter Parameter den Betrag und die Art der Glättung der Kurve angibt, was als Grad bezeichnet wird.* Eine Kurve mit dem Grad 1 ist nicht geglättet, sondern eine Polylinie.
Eine Kurve mit dem Grad 2 wird so geglättet, dass die Kurve den Mittelpunkt der Polyliniensegmente schneidet und tangential zu diesem ist:
Dynamo unterstützt NURBS-Kurven (Non-Uniform Rational B-Spline) bis zu 20 Grad. Das folgende Skript veranschaulicht die Auswirkungen steigender Glättungsstufen auf die Form einer Kurve:
Beachten Sie, dass Sie mindestens einen Steuerpunkt mehr angeben müssen als der Grad, den die Kurve aufweist.
Ein weiterer Vorteil der Kurvenerstellung mittels Steuerscheitelpunkten ist die Möglichkeit, Tangentialität zwischen einzelnen Kurvensegmenten beizubehalten. Dies erfolgt durch Extrahieren der Richtung zwischen den letzten beiden Steuerpunkten, und Fortsetzen dieser Richtung mit den ersten beiden Steuerpunkten der folgenden Kurve. Im folgenden Beispiel werden zwei getrennte NURBS-Kurven erstellt, die so glatt wie eine einzige Kurve sind:
*Dies ist eine sehr einfache Beschreibung der NURBS-Kurvengeometrie. Eine präzisere und detailliertere Erläuterung finden Sie bei Pottmann et al. 2007 (siehe Referenzen).
Intersect, Trim und SelectTrim werden hauptsächlich für niedrigerdimensionale Geometrien wie Punkte, Kurven und Oberflächen genutzt. Volumenkörper-Geometrie verfügt über einen zusätzlichen Satz von Methoden zum Ändern der Form nach ihrer Erstellung, sowohl durch Subtraktion von Material, ähnlich wie Trim, als auch durch Kombination von Elementen zu einem größeren Ganzen.
Die Methode Union nimmt zwei Volumenkörper-Objekte und erstellt ein einzelnes Volumenkörper-Objekt aus dem Raum, der von beiden Objekten abgedeckt wird. Der Überlappungsbereich zwischen den einzelnen Objekten wird zur endgültigen Form kombiniert. In diesem Beispiel werden eine Kugel und ein Quader in einer einzigen Volumenkörper-Kugel-Quader-Form kombiniert:
Die Methode Difference subtrahiert ähnlich wie Trim die Inhalte des eingegebenen Werkzeug-Volumenkörpers vom Basis-Volumenkörper. In diesem Beispiel kerben wir eine Kugel leicht ein:
Die Methode Intersect gibt den überlappenden Volumenkörper zwischen zwei Eingabe-Volumenkörpern zurück. Im folgenden Beispiel wurde Difference in Intersect geändert, und der resultierende Volumenkörper entspricht dem ursprünglich eingekerbten Leerraum:
Bei computergestützten Entwürfen werden Kurven und Oberflächen häufig als zugrunde liegendes Gerüst verwendet, auf dem die spätere Geometrie konstruiert wird. Damit diese erste Geometrie als Grundlage für spätere Geometrien genutzt werden kann, muss das Skript fähig sein, Merkmale wie Position und Ausrichtung über das gesamte Objekt hinweg extrahieren zu können. Sowohl Kurven als auch Oberflächen unterstützen diese Extraktion, die als Parametrisierung bezeichnet wird.
Alle Punkte auf einer Kurve kann man sich so vorstellen, dass sie einen eindeutigen Parameter zwischen 0 und 1 aufweisen. Wenn wir eine NurbsCurve basierend auf mehreren Steuerpunkten oder interpolierten Punkten erstellen möchten, hat der erste Punkt den Parameter 0 und der letzte Punkt den Parameter 1. Es ist nicht möglich, im Voraus wissen, welchen genauen Parameter ein Zwischenpunkt aufweist. Dies kann wie eine schwerwiegende Einschränkung klingen, wird jedoch durch eine Reihe von nützlichen Funktionen aufgewogen. Oberflächen weisen eine ähnliche Parametrisierung wie Kurven auf, allerdings mit zwei Parametern statt nur einem, die als u und v bezeichnet werden. Wenn wir eine Oberfläche aus den folgenden Punkten erstellen möchten, gilt:
p1 hat die Parameter u = 0 v = 0, während p9 die Parameter u = 1 v = 1 aufweist.
Parametrisierung ist nicht sehr hilfreich, wenn Sie Punkte zum Erstellen von Kurven ermitteln möchten. Der Hauptzweck liegt darin, die Positionen der Zwischenpunkte zu bestimmen, die von den Konstruktoren NurbsCurve und NurbsSurface generiert werden.
Kurven haben die Methode PointAtParameter, die ein einzelnes double-Argument zwischen 0 und 1 annimmt und das Punktobjekt an diesem Parameter zurückgibt. Dieses Skript ermittelt beispielsweise die Punkte an den Parametern 0, .1, .2, .3, .4, .5, .6, .7, .8, .9 und 1:
Analog dazu haben Oberflächen eine Methode PointAtParameter, die zwei Argumente annimmt, nämlich die u- und v-Parameter des generierten Punkts.
Das Extrahieren einzelner Punkte auf einer Kurve und Oberfläche kann nützlich sein, Skripte erfordern jedoch häufig die genauen geometrischen Merkmale an einem Parameter, z. B., in welche Richtung die Kurve bzw. Oberfläche gewandt ist. Die Methode CoordinateSystemAtParameter findet nicht nur die Position, sondern ein ausgerichtetes Koordinatensystem am Parameter einer Kurve oder Oberfläche. Beispielsweise extrahiert das folgende Skript ausgerichtete Koordinatensysteme entlang einer Rotationsfläche und verwendet die Ausrichtung der Koordinatensysteme, um Linien zu generieren, die senkrecht zur Oberfläche stehen:
Wie bereits erwähnt, erfolgt die Parametrisierung nicht immer gleichmäßig über die Länge einer Kurve oder Oberfläche hinweg, was bedeutet, dass der Parameter 0.5 nicht immer dem Mittelpunkt und 0.25 nicht immer einem Viertel der Länge entlang einer Kurve oder Oberfläche entspricht. Um diese Einschränkung zu umgehen, verfügen Kurven über einen zusätzlichen Satz von Parametrisierungsbefehlen, mit denen Sie einen Punkt mit einer bestimmten Länge entlang einer Kurve finden können.
Die folgenden Python-Skripte erstellen Punktgruppen für verschiedene Beispiele. Fügen Sie sie wie folgt in einen Python-Skript-Block ein:
python_points_1
python_points_2
python_points_3
python_points_4
python_points_5
Python ist eine häufig verwendete Programmiersprache, die sich aufgrund ihrer Syntax großer Beliebtheit erfreut. Sie ist leicht zu lesen und damit leichter zu erlernen als viele andere Sprachen. Python unterstützt Module und Pakete und kann in bestehende Anwendungen eingebettet werden. Eine geeignete Ressource für den Einstieg in Python finden Sie auf der Seite Getting Started auf Python.org.
Dieser Teil des Leitfadens ist quasi ein laufendes Protokoll für optimale Verfahren. Wir stellen hier eine Reihe von Vorgehensweisen vor, die sich unserer Erfahrung nach und bei Recherchen als besonders nützlich für hochwertige parametrische Arbeitsabläufe erwiesen haben. Als Designer und Programmierer legen wir einen Qualitätsmaßstab mit den Hauptkriterien einfache Wartung, Zuverlässigkeit, Benutzerfreundlichkeit und Effizienz unserer Werkzeuge zugrunde. In diesen optimalen Verfahren werden zwar spezielle Beispiele für visuelle oder textbasierte Skripterstellung gegeben, ihre Prinzipien gelten jedoch für alle Programmierumgebungen und können als Anregung für viele berechnungsbasierte Arbeitsabläufe dienen.
In Dynamo 2.0 haben Sie die Möglichkeit eine Standardvorlage (.py extension)
festzulegen, die verwendet wird, wenn Sie das Python-Fenster zum ersten Mal öffnen. Entwickler haben sich diese Funktion schon lange gewünscht, da sie die Verwendung von Python innerhalb von Dynamo beschleunigt. Durch die Verwendung einer Vorlage stehen uns vorgabemäßige Imports jederzeit einsatzbereit zur Verfügung, wenn wir ein benutzerdefiniertes Python-Skript entwickeln möchten.
Die Vorlage befindet sich im Ordner APPDATA
Ihrer Dynamo-Installation.
Dies ist in der Regel wie folgt ( %appdata%\Dynamo\Dynamo Core\{version}\ )
.
Um diese Funktion nutzen zu können, müssen wir unserer Datei DynamoSettings.xml
die folgende Zeile hinzufügen. (in Editor bearbeiten)
Ersetzen Sie alle Vorkommen von <PythonTemplateFilePath />
durch das Folgende:
Anmerkung: Ersetzen Sie CURRENTUSER durch Ihren Benutzernamen
Als Nächstes müssen wir eine Vorlage mit den Funktionen erstellen, die wir integrieren möchten. In diesem Fall können wir die Revit-bezogenen Importe und einige andere typische Elemente einbetten, die wir bei der Arbeit mit Revit verwenden.
Sie können mit einem leeren Editor-Dokument beginnen und den folgenden Code einfügen:
Anschließend speichern Sie diese Datei als PythonTemplate.py
am Speicherort APPDATA
.
Nach dem Erstellen der Python-Vorlage sucht Dynamo jedes Mal danach, wenn Sie einen Python-Block einfügen. Wenn sie nicht gefunden wird, wird das vorgabemäßige Python-Fenster angezeigt.
Wenn die Python-Vorlage gefunden wird (beispielsweise für Revit), werden alle vorgegebenen Elemente angezeigt, die Sie integriert haben.
Weitere Informationen zu dieser großartigen Ergänzung (von Radu Gidei) finden Sie hier. https://github.com/DynamoDS/Dynamo/pull/8122
Nachdem im vorigen Abschnitt die Verwendung von Python-Skripts in Dynamo gezeigt wurde, erhalten Sie hier eine Einführung zur Einbindung von Revit-Bibliotheken in die Skriptumgebung. Rufen Sie sich kurz ins Gedächtnis zurück, dass wir Python Standard und unsere Dynamo-Core-Blöcke mithilfe der ersten vier Zeilen im folgenden Codeabschnitt importiert haben. Um die Blöcke, Elemente und die Dokumentenverwaltung von Revit zu importieren, sind lediglich einige weitere Zeilen erforderlich:
Dadurch erhalten Sie Zugriff auf die Revit-API und können benutzerdefinierte Skripte für beliebige Revit-Aufgaben erstellen. Die Kombination der visuellen Programmierung mit der Skripterstellung in der Revit-API bringt erhebliche Verbesserungen für die Zusammenarbeit und die Entwicklung von Werkzeugen mit sich. So könnten beispielsweise ein BIM-Manager und ein Schemaplanentwickler gemeinsam am selben Diagramm arbeiten. Bei dieser Zusammenarbeit können sie sowohl den Entwurf als auch die Realisierung des Modells verbessern.
Erstellen Sie ein neues Revit-Projekt.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In diesen Übungen lernen Sie die grundlegenden Python-Skripts in Dynamo für Revit kennen. Dabei liegt das Hauptaugenmerk auf der Verarbeitung von Revit-Dateien und -Elementen sowie der Kommunikation zwischen Revit und Dynamo.
Dies ist eine einfache Methode zum Abrufen von doc, uiapp und app für die mit der Dynamo-Sitzung verknüpfte Revit-Datei. Programmierern, die zuvor bereits in der Revit-API gearbeitet haben, fallen eventuell die Einträge in der Liste des Watch-Blocks auf. Falls diese Einträge ungewohnt wirken, besteht kein Grund zur Beunruhigung. In den weiteren Übungen werden andere Beispiele verwendet.
Der folgende Code zeigt, wie Sie die Revit-Dienste importieren und die Dokumentdaten in Dynamo abrufen können.
Werfen Sie einen Blick auf den Python-Block in Dynamo. Sie finden den Code auch unten:
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung erstellen Sie mithilfe des Python-Blocks von Dynamo eine einfache Modellkurve in Revit.
Beginnen Sie, indem Sie in Revit eine neue Entwurfskörperfamilie erstellen.
Öffnen Sie den Ordner Conceptual Mass, und verwenden Sie die Vorlagendatei Metric Mass.rft.
Verwenden Sie in Revit den Tastaturbefehl un
, um die Einstellungen für Projekteinheiten aufzurufen, und ändern Sie die Längeneinheit in Meter.
Starten Sie Dynamo und erstellen Sie die Gruppe von Blöcken in der Abbildung unten. Sie erstellen zunächst mithilfe von Dynamo-Blöcken zwei Referenzpunkte in Revit.
Erstellen Sie einen Codeblock mit dem Wert
"0;"
.Verbinden Sie diesen Wert mit den x-, y- und z-Eingaben eines ReferencePoint.ByCoordinates-Blocks.
Erstellen Sie drei Schieberegler mit dem Bereich zwischen -100 und 100 und der Schrittgröße 1.
Verbinden Sie die Schieberegler jeweils mit einem ReferencePoint.ByCoordinates-Block.
Fügen Sie einen Python-Block im Arbeitsbereich hinzu, klicken Sie auf die Schaltfläche +, um eine weitere Eingabe hinzuzufügen, und verbinden Sie die beiden Referenzpunkte mit den Eingaben. Öffnen Sie den Python-Block.
Werfen Sie einen Blick auf den Python-Block in Dynamo. Den vollständigen Code finden Sie unten.
System.Array: Für Revit wird eine Systemreihe (anstelle einer Python-Liste) benötigt. Hierfür genügt eine weitere Codezeile. Indem Sie sorgfältig auf die Argumenttypen achten, erleichtern Sie jedoch die Python-Programmierung in Revit.
Sie haben in Dynamo zwei Referenzpunkte erstellt und diese mithilfe von Python mit einer Linie verbunden. In der nächsten Übung führen Sie dies weiter.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Diese Übung ist relativ einfach, macht jedoch die Verbindung von Daten und Geometrie zwischen Revit und Dynamo – in beiden Richtungen – deutlich. Öffnen Sie zuerst Revit-StructuralFraming.rvt. Starten Sie anschließend Dynamo und öffnen Sie die Datei Revit-StructuralFraming.dyn.
Diese Datei ist denkbar einfach. Sie umfasst zwei auf Ebene 1 und Ebene 2 gezeichnete Referenzkurven. Diese Kurven sollen in Dynamo übernommen werden, wobei eine Direktverknüpfung bestehen bleibt.
Diese Datei enthält eine Gruppe von Blöcken, die mit den fünf Eingaben eines Python-Blocks verbunden sind.
Select Model Element-Blöcke: Klicken Sie jeweils auf die Schaltfläche Auswählen und wählen Sie die zugehörige Kurve in Revit aus.
Code Block: Geben Sie die Syntax
0..1..#x;
, ein und verbinden Sie einen Integer Slider mit Werten zwischen 0 und 20 mit der x-Eingabe. Dadurch wird die Anzahl der Träger gesteuert, die zwischen den beiden Kurven gezeichnet werden sollen.Structural Framing Types: Wählen Sie hier den vorgegebenen W12x26-Träger aus der Dropdown-Liste.
Levels: Wählen Sie "Level 1".
Dieser Code in Python ist etwas komplexer, aus den darin enthaltenen Kommentaren geht jedoch hervor, wie der Prozess abläuft.
In Revit wird eine Reihe von Trägern zwischen den beiden Kurven als Tragwerkselemente angezeigt. Anmerkung: Dies ist kein realistisches Beispiel. Die Tragwerkselemente sind nur als Beispiele für aus Dynamo erstellte native Revit-Exemplare.
In Dynamo werden die Ergebnisse ebenfalls angezeigt. Die Träger im Watch3D-Block verweisen auf die aus den Revit-Elementen abgefragte Geometrie.
Dabei werden Daten aus der Revit-Umgebung für die Dynamo-Umgebung konvertiert. Zusammenfassung: Der Prozess läuft wie folgt ab:
Wählen Sie das Revit-Element aus.
Konvertieren Sie das Revit-Element in eine Dynamo-Kurve.
Unterteilen Sie die Dynamo-Kurve in eine Folge von Dynamo-Punkten.
Erstellen Sie Dynamo-Linien mithilfe der Dynamo-Punkte zwischen den beiden Kurven.
Erstellen Sie Revit-Träger durch Referenzieren der Dynamo-Linien.
Geben Sie Dynamo-Oberflächen durch Abfragen der Geometrie der Revit-Träger aus.
Dies mag etwas umständlich erscheinen. Das Skript erleichtert den Vorgang jedoch erheblich: Sie müssen jetzt lediglich die Kurve in Revit bearbeiten und den Solver erneut ausführen. (Es ist möglich, dass Sie dabei die bisherigen Träger löschen müssen.) Dies liegt daran, dass wir die Träger in Python platzieren und dadurch die Zuordnung der OOTB-Blöcke auflösen.
Werden die Referenzkurven in Revit aktualisiert, erhalten Sie eine neue Reihe von Trägern.
In den vorangegangenen Kapiteln dieses Handbuchs wurde bereits behandelt, wie Sie die leistungsstarken Funktionen zur visuellen Programmierung in Dynamo einsetzen können. Ein gutes Verständnis dieser Funktionen ist eine solide Grundlage und der erste Schritt bei der Erstellung zuverlässiger visueller Programme. Bei der Verwendung visueller Programme in der Praxis, der Weitergabe an Kollegen, der Behebung von Fehlern oder beim Testen von Grenzen müssen zusätzliche Aspekte berücksichtigt werden. Wenn andere Benutzer mit Ihrem Programm arbeiten sollen oder Sie damit rechnen, es z. B. sechs Monate später erneut zu öffnen, müssen seine Grafik und seine Logik unmittelbar verständlich sein. Dynamo stellt zahlreiche Werkzeuge zur Verfügung, die Ihnen helfen, die Komplexität Ihres Programms zu bewältigen. In diesem Kapitel finden Sie Richtlinien zu ihren Verwendungszwecken.
Während Sie Ihr Dynamo-Diagramm entwickeln und Ihre Ideen testen, kann es rasch an beachtlicher Größe und Komplexität zunehmen. Natürlich ist es wichtig, ein funktionsfähiges Programm zu erstellen, es sollte jedoch auch möglichst einfach gehalten werden. Das Diagramm lässt sich so nicht nur schneller und besser vorhersehbar ausführen, sondern seine Logik ist dadurch für Sie und andere Benutzer problemlos verständlich. Im Folgenden werden einige Methoden beschrieben, mit denen Sie die Logik Ihres Diagramms verdeutlichen können.
Gruppen ermöglichen es, bei der Entwicklung eines Programms separate Teile mit unterschiedlichen Funktionen zu erstellen.
Mithilfe von Gruppen können Sie darüber hinaus große Teile des Programms verschieben, wobei die Modularität und Ausrichtung erhalten bleiben.
Sie können die Farbe einer Gruppe zur Differenzierung ihres Verwendungszwecks (Eingaben oder Funktionen) ändern.
Gruppen können als Ausgangspunkt beim Organisieren des Diagramms zur Vereinfachung der Erstellung benutzerdefinierter Blöcke verwendet werden.
Die Farben in diesem Programm kennzeichnen den Verwendungszweck der einzelnen Gruppen. Mithilfe dieses Verfahrens können Sie eine Hierarchie in den von Ihnen entwickelten Grafikstandards oder -vorlagen erstellen.
Funktionsgruppe (blau)
Eingabengruppe (orange)
Skriptgruppe (grün)
In manchen Fällen können Sie in einem Codeblock eine Methode für eine Zahl oder einen Block schneller eingeben, als Sie nach ihr suchen könnten (Point.ByCoordinates, Number, String, Formula).
Codeblöcke sind nützlich zum Definieren benutzerdefinierter Funktionen in DesignScript, damit weniger Blöcke im Diagramm benötigt werden.
1 und 2 führen dieselbe Funktion aus. Dabei nahm das Schreiben einiger Codezeilen wesentlich weniger Zeit in Anspruch als das Suchen und Hinzufügen jedes einzelnen Blocks. Die Angaben im Codeblock sind darüber hinaus wesentlich prägnanter.
In Codeblock geschriebenes DesignScript
Entsprechendes Programm in Blöcken
Sie können mithilfe von Block zu Code die Komplexität eines Diagramms reduzieren, wobei eine Gruppe einfacher Blöcke zusammengefasst und das entsprechende DesignScript in einen einzigen Codeblock geschrieben wird.
Block zu Code kann** Code komprimieren, ohne die Verständlichkeit des Programms zu beeinträchtigen.**
Die Verwendung von Block zu Code bietet die folgenden Vorteile:
Einfache Komprimierung von Code in eine einzige Komponente, die nach wie vor bearbeitet werden kann
Vereinfachung eines großen Teils eines Diagramms
Nützlich, wenn das „Mini-Programm“ nicht oft bearbeitet werden muss
Nützlich für die Integration anderer Codeblock-Funktionalität, z. B. Funktionen
Die Verwendung von Block zu Code bringt die folgenden Nachteile mit sich:
Schlechtere Lesbarkeit wegen allgemeiner Benennung
Für andere Benutzer schwieriger zu verstehen
Keine einfache Möglichkeit, zur Version aus der visuellen Programmierung zurückzuwechseln
Vorhandenes Programm
Mithilfe von Block zu Code erstellter Codeblock
List@Level kann es Ihnen erleichtern, Ihr Diagramm durch Ersetzen der Blöcke List.Map und List.Combine zu vereinfachen, die viel Platz im Ansichtsbereich beanspruchen können.
List@Level bietet ein schnelleres Verfahren zum Konstruieren von Blocklogik als List.Map/List.Combine, indem es den Zugriff auf Daten auf einer beliebigen Ebene einer Liste direkt über den Eingabeanschluss eines Blocks ermöglicht.
Sie können überprüfen, wie viele True-Werte BoundingBox.Contains zurückgibt und in welchen Listen diese enthalten sind, indem Sie List@Level für den list-Eingang von CountTrue aktivieren. List@Level ermöglicht es, die Ebene festzulegen, auf der die Eingabe Daten übernimmt. List@Level ist flexibel und effizient und wird gegenüber anderen Verfahren, die List.Map und List.Combine nutzen, dringend empfohlen.
Zählen der True-Werte auf Listenebene 2
Zählen der True-Werte auf Listenebene 3
Gestalten Sie Ihr Diagramm nicht nur so einfach und effizient wie möglich, sondern streben Sie auch eine übersichtliche grafische Darstellung an. Beziehungen sind trotz Ihrer Bemühungen, das Diagramm intuitiv mit logischen Gruppen zu gestalten, eventuell nicht ohne Weiteres zu erkennen. Ein einfacher Block innerhalb einer Gruppe oder das Umbenennen eines Schiebereglers kann Ihnen oder anderen Benutzern unnötige Verwirrung oder das Suchen im gesamten Diagramm ersparen. Im Folgenden werden mehrere Verfahren beschrieben, mit deren Hilfe Sie eine einheitliche Grafik innerhalb eines Diagramms und diagrammübergreifend erzielen können.
Um den Arbeitsaufwand nach dem Erstellen des Diagramms zu reduzieren, achten Sie auf eine gute Leserlichkeit des Blocklayouts, indem Sie die Blöcke während der Arbeit häufig ausrichten.
Wenn andere Benutzer mit Ihrem Diagramm arbeiten sollen, sorgen Sie vor der Bereitstellung für ein Layout mit einem leicht verständlichen Ablauf aus Blöcken und Drähten.
Um die Ausrichtung zu erleichtern, verwenden Sie die Funktion Blocklayout bereinigen zur automatischen Ausrichtung des Diagramms. Durch manuelles Ausrichten erzielen Sie allerdings präzisere Ergebnisse.
Ungeordnetes Diagramm
Ausgerichtetes Diagramm
Durch Umbenennen von Eingaben machen Sie Ihr Diagramm für andere Benutzer leicht verständlich, insbesondere, wenn Objekte, die sich außerhalb des Bildschirms befinden, verbunden werden sollen.
Benennen Sie nach Möglichkeit nicht Blöcke, sondern Eingaben um. Als Alternative dazu können Sie einen benutzerdefinierten Block aus einer Gruppe von Blöcken erstellen und ihn umbenennen. Dabei ist ersichtlich, dass andere Elemente darin enthalten sind.
Eingaben für die Bearbeitung der Oberfläche
Eingaben für Architekturparameter
Eingaben für das Skript zur Simulation der Entwässerung
Um einen Block umzubenennen, klicken Sie mit der rechten Maustaste auf seinen Namen, und wählen Sie Block umbenennen.
Fügen Sie eine Anmerkung hinzu, wenn ein Bestandteil des Diagramms eine Erläuterung in Klartext benötigt, die nicht in den Blöcken selbst gegeben werden kann.
Fügen Sie eine Anmerkung hinzu, wenn eine Sammlung von Blöcken oder eine Gruppe zu groß oder zu komplex ist und nicht direkt verstanden werden kann.
Anmerkung zur Beschreibung des Teils des Programms, der Rohwerte der Verschiebungsstrecken zurückgibt
Anmerkung zur Beschreibung des Codes, der diese Werte einer Sinuswelle zuordnet
Verwenden Sie während der Entwicklung des Programms Beobachtungs- oder Vorschaublöcke,** um zu überprüfen, ob wichtige Ausgaben das erwartete Ergebnis zurückgeben.**
Mithilfe der Beobachtungsblöcke werden verglichen:
Die Rohwerte der Verschiebungsstrecken
Die durch die Sinusgleichung geleiteten Werte
Ihr Programm wird sehr wahrscheinlich irgendwann auch von anderen Benutzern geöffnet werden, selbst wenn Sie unabhängig voneinander arbeiten. Diese Benutzer sollten in der Lage sein, anhand der Ein- und Ausgaben rasch zu bestimmen, was das Programm benötigt und was es produziert. Dies ist besonders bei der Entwicklung benutzerdefinierter Blöcke wichtig, die an die Dynamo-Community weitergegeben und in Programmen anderer Benutzer verwendet werden sollen. Mit diesen Vorgehensweisen erhalten Sie zuverlässige, wiederverwendbare Programme und Blöcke.
Für eine optimale Lesbarkeit und Skalierbarkeit sollten Sie die Ein- und Ausgaben auf ein Minimum beschränken.
Versuchen Sie, eine Strategie zur Entwicklung der Logik zu erarbeiten, indem Sie zunächst einen groben Plan ihrer Funktionsweise erstellen, bevor Sie den ersten Block im Ansichtsbereich einfügen. Behalten Sie während der Arbeit an diesem Plan im Auge, welche Ein- und Ausgaben in den Skripts verwendet werden sollen.
Falls bestimmte Optionen oder Bedingungen vorhanden sind, die Sie in das Diagramm einbetten möchten, empfiehlt es sich, Voreinstellungen für den schnellen Zugriff zu verwenden.
Mithilfe von Voreinstellungen können Sie darüber hinaus durch Caching spezifischer Schiebereglerwerte die Komplexität in Diagrammen mit langen Laufzeiten reduzieren.
Verwenden Sie einen benutzerdefinierten Block, wenn das Programm in einem einzelnen Container zusammengefasst werden kann.
Verwenden Sie einen benutzerdefinierten Block, wenn ein Teil des Diagramms oft in anderen Programmen wiederverwendet werden soll.
Verwenden Sie einen benutzerdefinierten Block, wenn Sie eine Funktion für die Dynamo-Community bereitstellen möchten.
Indem Sie das Programm zur Verschiebung von Punkten in einem benutzerdefinierten Block zusammenfassen, wird dieses zuverlässige, spezielle Programm portierbar und wesentlich leichter verständlich. Aussagekräftige Namen für die Eingabeanschlüsse erleichtern es anderen Benutzern, die Verwendungsweise des Blocks zu verstehen. Achten Sie darauf, für jede Eingabe eine Beschreibung und den erforderlichen Datentyp anzugeben.
Bestehendes Programm für Attraktor
Benutzerdefinierter Block, in dem dieses Programm, PointGrid, enthalten ist
Mithilfe von Vorlagen können Sie Grafikstandards für alle Ihre visuellen Diagramme einrichten, um sie Ihren Kollegen in einheitlicher, verständlicher Weise bereitzustellen.
Beim Erstellen einer Vorlage können Sie Gruppenfarben und Schriftgrößen standardisieren, um Typen von Arbeitsabläufen oder Datenaktionen zu kategorisieren.
Sie können beim Erstellen einer Vorlage sogar Beschriftung, Farbe oder Stil für die Unterscheidung zwischen Frontend- und Backend-Arbeitsabläufen in Ihrem Diagramm standardisieren.
Die Benutzeroberfläche (das Frontend) des Programms umfasst den Projektnamen, die Eingabe-Schieberegler und die Importgeometrie.
Backend des Programms.
Kategorien für Gruppenfarben (allgemeines Design, Eingaben, Python-Skripts, importierte Geometrie)
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
Sie haben eine Reihe optimaler Verfahren festgelegt und wenden diese jetzt auf ein rasch zusammengestelltes Programm an. Das Programm erstellt zwar wie vorgesehen das Dach, das Diagramm stellt jedoch eher eine „Mind-Map“ des Autors dar. Ihm fehlt die Struktur, und es gibt keine Beschreibung des Verwendungszwecks. Sie ordnen, beschreiben und analysieren das Programm unter Verwendung der optimalen Verfahren so, dass andere Benutzer seine Verwendungsweise verstehen.
Das Programm funktioniert, aber dem Diagramm fehlt Struktur.
Bestimmen Sie als Erstes die Daten und die Geometrie, die das Programm zurückgibt.
Um logische Unterteilungen, d. h. Modularität zu erzielen, müssen Sie die Stellen kennen, an denen wesentliche Änderungen an den Daten erfolgen. Analysieren Sie den Rest des Programms mithilfe von Beobachtungsblöcken, um festzustellen, ob Gruppen erkennbar sind, bevor Sie mit dem nächsten Schritt fortfahren.
Dieser Codeblock mit einer mathematischen Gleichung scheint ein wichtiger Bestandteil des Programms zu sein. Ein Watch-Block wird angezeigt, der Listen von Verschiebungsstrecken zurückgibt.
Der Zweck dieses Bereichs ist nicht ohne Weiteres ersichtlich. Die Anordnung der True-Werte auf der Listenebene L2 aus BoundingBox.Contains und das Vorhandensein von List.FilterByBoolMask lassen darauf schließen, dass ein Teil des Punktrasters als Beispiel entnommen wird.
Nachdem Sie die zugrunde liegenden Bestandteile des Programms verstanden haben, fassen Sie sie in Gruppen zusammen.
Gruppen ermöglichen dem Benutzer die visuelle Unterscheidung der Programmbestandteile.
3D-Grundstücksmodell importieren
Punktraster entsprechend der Sinusgleichung verschieben
Bestandteil des Punktrasters als Beispiel
Dachoberfläche der Architektur erstellen
Glasfassade erstellen
Nachdem Sie die Gruppen eingerichtet haben, richten Sie die Blöcke innerhalb des Diagramms auf einheitliche Weise aus.
Eine einheitliche Darstellung macht den Programmablauf und die impliziten Beziehungen zwischen den Blöcken für den Benutzer leichter erkennbar.
Machen Sie das Programm noch leichter verständlich, indem Sie eine weitere Ebene grafischer Verbesserungen hinzufügen. Fügen Sie Anmerkungen hinzu, mit denen Sie die Funktionsweise eines bestimmten Programmteils beschreiben, geben Sie den Eingaben benutzerdefinierte Namen, und weisen Sie verschiedenen Typen von Gruppen Farben zu.
Diese grafischen Verbesserungen geben dem Benutzer genaueren Aufschluss über den Verwendungszweck des Programms. Die unterschiedlichen Farben der Gruppen helfen bei der Unterscheidung von Eingaben und Funktionen.
Anmerkungen
Eingaben mit aussagekräftigen Namen
Bevor Sie damit beginnen, das Programm zusammenzufassen, suchen Sie nach einem geeigneten Platz für den Python-Skript-Entwässerungssimulator. Verbinden Sie die Ausgabe der ersten skalierten Dachoberfläche mit der dazugehörigen Skripteingabe.
Durch die Entscheidung, das Skript an dieser Stelle des Programms zu integrieren, wird erreicht, dass die Entwässerungssimulation für die einfache Originaloberfläche des Dachs durchgeführt wird. Diese spezielle Oberfläche wird nicht in der Vorschau angezeigt, aber durch diesen Schritt entfällt die separate Auswahl der oberen Fläche in der gefasten PolySurface.
Quellgeometrie für Skripteingabe
Python-Block
Eingabe-Schieberegler
„Schalter“ Ein-Aus
Damit befinden sich alle Elemente an ihrem Platz, und als Nächstes vereinfachen Sie das Diagramm.
Durch Zusammenfassen des Programms mit Block zu Code und benutzerdefinierten Blöcken haben Sie das Diagramm erheblich verkleinert. Die Gruppen für die Erstellung der Dachoberfläche und der Wände wurden in Code konvertiert, da sie für dieses Programm hochspezifisch sind. Die Gruppe zur Verschiebung von Punkten ist in einem benutzerdefinierten Block eingeschlossen, da sie auch in anderen Programmen verwendet werden könnte. Erstellen Sie in der Beispieldatei Ihren eigenen benutzerdefinierten Block aus der Gruppe zur Verschiebung von Punkten.
Benutzerdefinierter Block als Container für die Gruppe zur Verschiebung von Punkten
Block zu Code für die Zusammenfassung der Gruppen zum Erstellen der Oberfläche für das Dach in der Architektur und der Wände
Im letzten Schritt erstellen Sie Voreinstellungen für als Beispiele zu verwendende Dachformen.
Diese Eingaben sind die wesentlichen Angaben zum Steuern der Dachform und geben den Benutzern Hinweise auf die Möglichkeiten des Programms.
Das Programm mit Ansichten zweier Voreinstellungen.
Die Muster der Dachentwässerung bieten dem Benutzer eine analytische Ansicht der jeweiligen Voreinstellungen.
Wozu dient die Textprogrammierung in der visuellen Programmierumgebung von Dynamo? bietet viele Vorteile. Sie ermöglicht es, in einer intuitiven visuellen Oberfläche Programme zu entwickeln, ohne eine spezielle Syntax zu erlernen. Visuelle Programme können jedoch recht unübersichtlich werden und enthalten zuweilen nicht genügend Funktionalität. So stehen in Python beispielsweise wesentlich praktischere Methoden zum Schreiben von Bedingungsanweisungen (if/then) und für Schleifen zur Verfügung. Python ist ein leistungsstarkes Werkzeug, das das Funktionsspektrum von Dynamo erweitern und Ihnen die Möglichkeit geben kann, eine große Gruppe von Blöcken durch einige wenige präzise Codezeilen zu ersetzen.
Visuelles Programm:
Textprogramm:
Python-Blöcke sind genau wie Codeblöcke eine Scripting-Oberfläche innerhalb einer Umgebung für die visuelle Programmierung. Der Python-Block befindet sich in der Bibliothek unter Skript > Editor > Python Script.
Durch Doppelklicken auf den Block wird der Python-Skript-Editor geöffnet. (Sie können auch mit der rechten Maustaste auf den Block klicken und Bearbeiten … auswählen.) Oben auf dem Bildschirm befindet sich vorgegebener Text, der es Ihnen erleichtern soll, die benötigten Bibliotheken zu referenzieren. Eingaben werden in der IN-Reihe gespeichert. Werte werden durch Zuweisung zur OUT-Variablen an Dynamo zurückgegeben.
Zu den Methoden gehören Konstruktoren, wie ByCoordinates, Aktionen wie Add und Abfragen wie X-, Y- und Z-Koordinaten.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In diesem Beispiel schreiben Sie ein Python-Skript zum Erstellen von Mustern aus einem Körpermodul und wandeln das Skript in einen benutzerdefinierten Block um. Zuerst erstellen Sie das Körpermodul mithilfe von Dynamo-Blöcken.
Rectangle.ByWidthLength: Erstellen Sie ein Rechteck, das als Basis für den Körper verwendet wird.
Surface.ByPatch: Verbinden Sie das Rechteck mit der closedCurve-Eingabe, um die untere Oberfläche zu erstellen.
Geometry.Translate: Verbinden Sie das Rechteck mit der geometry-Eingabe, um es nach oben zu verschieben, wobei Sie mithilfe eines Codeblocks die allgemeine Dicke des Körpers festlegen.
Polygon.Points: Fragen Sie die Eckpunkte des verschobenen Rechtecks ab.
Geometry.Translate: Erstellen Sie mithilfe eines Codeblocks eine Liste mit vier Werten für die vier Punkte, wobei Sie eine Ecke des Körpers nach oben verschieben.
Polygon.ByPoints: Erstellen Sie das obere Polygon aus den verschobenen Punkten erneut.
Surface.ByPatch: Schließen Sie das Polygon, um die obere Oberfläche zu erstellen.
Damit haben Sie die obere und untere Oberfläche erstellt. Erstellen Sie jetzt durch eine Erhebung zwischen den beiden Profilen die Seiten des Körpers.
List.Create: Verbinden Sie das Rechteck unten und das Polygon oben mit den index-Eingaben.
Surface.ByLoft: Erstellen Sie über eine Erhebung die Seiten des Körpers.
List.Create: Verbinden Sie die obere und untere sowie die seitlichen Oberflächen mit den index-Eingaben, um eine Liste der Oberflächen zu erhalten.
Solid.ByJoinedSurfaces: Verbinden Sie die Flächen, um das Körpermodul zu erstellen.
Damit haben Sie den Körper erstellt. Fügen Sie jetzt einen Block für das Python-Skript in den Arbeitsbereich ein.
Um dem Block weitere Eingaben hinzuzufügen, klicken Sie auf das +-Symbol im Block. Die Eingaben erhalten die Namen IN[0], IN[1] usw., um anzuzeigen, dass sie für die Einträge einer Liste stehen.
Sie beginnen, indem Sie die Ein- und Ausgaben definieren. Doppelklicken Sie auf den Block, um den Python-Editor zu öffnen. Halten Sie sich an den unten stehenden Code, um den Code im Editor zu ändern.
Dieser Code wird im weiteren Verlauf der Übung leichter verständlich. Als Nächstes müssen Sie überlegen, welche Informationen Sie zum Erstellen einer Reihe aus dem Körpermodul benötigen. Als Erstes müssen Sie die Maße des Körpers kennen, um die Entfernung für die Verschiebung zu ermitteln. Wegen eines Fehlers bei Begrenzungsrahmen müssen Sie diesen anhand der Kurvengeometrie der Kanten erstellen.
Werfen Sie einen Blick auf den Python-Block in Dynamo. Dieselbe Syntax wie in den Titeln der Blöcke in Dynamo wird auch hier verwendet. Sehen Sie sich den kommentierten Code unten an.
Da die Körpermodule sowohl verschoben als auch gedreht werden sollen, verwenden Sie hier die Geometry.Transform-Operation. Wenn Sie den Geometry.Transform-Block genauer betrachten, sehen Sie, dass für die Transformation des Körpers ein Quell- und ein Zielkoordinatensystem benötigt werden. Die Quelle ist das Koordinatensystem, das den Kontext für den Ausgangskörper bildet, während als Ziel ein eigenes Koordinatensystem für jedes Modul in der Reihe verwendet wird. Das bedeutet, dass Sie die x- und y-Werte in einer Schleife verarbeiten müssen, um das Koordinatensystem jedes Mal auf andere Weise zu transformieren.
Klicken Sie auf Ausführen, und speichern Sie dann den Code. Verbinden Sie den Python-Block wie folgt mit dem vorhandenen Skript.
Verbinden Sie die Ausgabe aus Solid.ByJoinedSurfaces als erste Eingabe für den Python-Block, und definieren Sie die anderen Eingaben mithilfe eines Codeblocks.
Erstellen Sie einen Topology.Edges-Block, und verwenden Sie die Ausgabe aus dem Python-Block als Eingabe.
Erstellen Sie abschließend einen Edge.CurveGeometry-Block, und verwenden Sie die Ausgabe von Topology.Edges als Eingabe.
Ändern Sie den Wert für die Ausgangszahl, um verschiedene Muster zu erstellen. Indem Sie die Parameter des Körpermoduls selbst ändern, erzielen Sie ebenfalls unterschiedliche Wirkungen.
Damit haben Sie ein nützliches Python-Skript erstellt. Speichern Sie dieses jetzt als benutzerdefinierten Block. Wählen Sie den Python Script-Block aus, klicken Sie mit der rechten Maustaste auf den Arbeitsbereich, und wählen Sie Benutzerdefinierten Block erstellen aus.
Weisen Sie einen Namen, eine Beschreibung und eine Kategorie zu.
Dadurch wird ein neuer Arbeitsbereich geöffnet, in dem Sie den benutzerdefinierten Block bearbeiten können.
Eingabe-Blöcke: Geben Sie den Eingaben aussagekräftigere Namen und fügen Sie Datentypen und Vorgabewerte hinzu.
Ausgabe-Blöcke: Ändert den Namen der Ausgabe.
Speichern Sie den Block als DYF-Datei. Nun sollten Sie sehen, dass der benutzerdefinierte Block die gerade vorgenommenen Änderungen widerspiegelt.
Die zweidimensionale Entsprechung zur NurbsCurve ist die NurbsSurface, und wie die Freiform-NurbsCurve können NurbsSurfaces mit zwei grundlegenden Methoden konstruiert werden: durch Eingabe eines Satzes von Basispunkten, zwischen denen Dynamo interpoliert, oder durch explizites Angeben der Steuerpunkte der Oberfläche. Ebenso wie Freiformkurven sind interpolierte Oberflächen nützlich, wenn ein Konstrukteur die präzise Form kennt, die eine Oberfläche aufweisen soll, oder ein Entwurf erfordert, dass die Oberfläche durch Abhängigkeitspunkte führt. Mit Steuerpunkten erstellte Oberflächen wiederum können dann nützlich sein, wenn es um experimentelle Entwürfe mit unterschiedlichen Glättungsgraden geht.
Zum Erstellen einer interpolierten Oberfläche generieren Sie einfach eine zweidimensionale Punktsammlung als Annäherung an die Form einer Oberfläche. Die Sammlung muss rechteckig sein, also nicht gezackt. Die Methode NurbsSurface.ByPoints erstellt eine Oberfläche aus diesen Punkten.
Freiform-NurbsSurfaces können auch erstellt werden, indem die zugrunde liegenden Steuerpunkte einer Oberfläche angegeben werden. Wie bei NurbsCurves kann man sich die Steuerpunkte als Darstellung eines vierseitigen Netzes mit geraden Segmenten vorstellen, das je nach dem Grad der Oberfläche zur endgültigen Oberflächenform geglättet wird. Um eine NurbsSurface aus Steuerpunkten zu erstellen, schließen Sie zwei zusätzliche Parameter in NurbsSurface.ByPoints ein, die den Grad der zugrunde liegenden Kurven in beide Richtungen der Oberfläche angeben.
Wir können den Grad der NurbsSurface erhöhen, um die resultierende Oberflächengeometrie zu ändern:
Genauso wie Oberflächen durch Interpolation zwischen einer Reihe eingegebener Punkte erstellt werden können, können sie auch durch Interpolation zwischen einem Satz von Basiskurven erstellt werden. Dieser Ansatz wird als Erhebung bezeichnet. Eine Erhebungskurve wird mit dem Konstruktor Surface.ByLoft und einer Sammlung von Eingabekurven als einzigem Parameter erstellt.
Rotationsflächen sind ein weiterer Typ von Oberflächen, die durch Sweeping einer Basiskurve um eine Mittelachse erstellt werden. Wenn interpolierte Oberflächen zweidimensional analog zu interpolierten Kurven sind, dann sind Rotationsflächen zweidimensional analog zu Kreisen und Bogen.
Rotationsflächen werden definiert durch eine Basiskurve, die die Kante der Oberfläche darstellt, einen Achsenursprung, der den Basispunkt der Oberfläche bildet, eine Achsenrichtung, die die Kernrichtung vorgibt, einen Sweeping-Startwinkel sowie einen Sweeping-Endwinkel. Diese Parameter werden als Eingabe für den Konstruktor Surface.Revolve verwendet.
Viele der bisherigen Beispiele bezogen sich auf die Konstruktion einer höherdimensionalen Geometrie aus niedrigerdimensionalen Objekten. Mit Intersection-Methoden können diese höherdimensionalen Geometrien Objekte mit niedrigerer Dimension generieren, während die Befehle Trim und SelectTrim es ermöglichen, geometrische Formen mit Skripts stark zu ändern, nachdem sie erstellt wurden.
Die Methode Intersect ist für alle Geometrieobjekte in Dynamo definiert. Das bedeutet, dass theoretisch jedes Geometrieobjekt mit einem beliebigen anderen geschnitten werden kann. Natürlich sind einige Überschneidungen nicht von Bedeutung, wie z. B. Schnittpunkte von Punkten, da das resultierende Objekt immer der Eingabepunkt selbst ist. Andere mögliche Kombinationen von Überschneidungen zwischen Objekten sind in der folgenden Tabelle beschrieben. Die folgende Tabelle zeigt die Ergebnisse verschiedener Überschneidungsoperationen:
Das folgende sehr einfache Beispiel zeigt die Überschneidung einer Ebene mit einer NurbsSurface. Die Überschneidung erzeugt ein NurbsCurve-Array, das wie jede andere NurbsCurve verwendet werden kann.
Die Methode Trim ähnelt der Methode Intersect insofern, dass sie ebenfalls für nahezu jedes Geometrieobjekt definiert ist. Es bestehen jedoch für Trim weitaus mehr Einschränkungen als für Intersect.
Erwähnenswert bei den Trim-Methoden ist die Anforderung eines Select-Punkts, der bestimmt, welche Geometrie verworfen und welche Teile beibehalten werden sollen. Dynamo sucht und verwirft die gestutzte Geometrie, die dem ausgewählten Punkt am nächsten liegt.
Die textbasierte Skripterstellung innerhalb der Umgebung für visuelle Skripterstellung ermöglicht leistungsstarke und visuelle Beziehungen mithilfe von DesignScript, Python und ZeroTouch (C#). Die Benutzer können in ein und demselben Arbeitsbereich Elemente wie Eingabe-Schieberegler bereitstellen, umfangreiche Abläufe in DesignScript zusammenfassen sowie in Python oder C# auf leistungsstarke Werkzeuge und Bibliotheken zugreifen. Diese Vorgehensweisen können bei effizientem Einsatz die Möglichkeiten zur benutzerdefinierten Anpassung, die Verständlichkeit und die Effizienz des gesamten Programms erheblich steigern. Die im Folgenden beschriebenen Richtlinien helfen Ihnen dabei, Ihre visuellen Skripts um Textskripte zu ergänzen.
Mit Textskripts können Sie komplexere Beziehungen erstellen als durch visuelle Programmierung, jedoch sind beiden Verfahren auch zahlreiche Funktionen gemeinsam. Dies ist sinnvoll, da Blöcke letzten Endes vorgefertigter Code sind. Es ist wahrscheinlich möglich, ein ganzes Dynamo-Programm in DesignScript oder Python zu schreiben. Die visuellen Skripte kommen jedoch zum Einsatz, weil die Benutzeroberfläche mit Blöcken und Drähten eine intuitive Darstellung des Ablaufs in grafischer Form bietet. Indem Sie sich klarmachen, inwiefern die Möglichkeiten von Textskripts über diejenigen visueller Skripts hinausgehen, erhalten Sie eine wichtige Grundlage für die Entscheidung, wann Textskripts verwendet werden sollten, ohne dabei die intuitive Arbeitsweise mit Blöcken und Drähten aufgeben zu müssen. Die folgenden Richtlinien beschreiben, wann und in welcher Sprache Skripts erstellt werden sollten.
Verwenden Sie Textskripts für:
Schleifen
Rekursionen
Zugriff auf externe Bibliotheken
Wählen Sie eine Sprache:
Bei der Skripterstellung in Dynamo, einer zwangsläufig parametrischen Umgebung, ist es sinnvoll, Ihren Code bezogen auf die Blöcke und Drähte zu strukturieren, in denen er zum Einsatz kommt. Betrachten Sie den Block mit Ihrem Textskript als einen normalen Block wie andere Blöcke im Programm mit spezifischen Eingaben, einer Funktion und einer erwarteten Ausgabe. Dadurch stellen Sie dem Code im Block direkt eine kleine Gruppe von Variablen zur Verarbeitung zur Verfügung, was für ein ordnungsgemäßes parametrisches System entscheidend ist. Im Folgenden finden Sie einige Richtlinien für eine bessere Integration von Code in ein visuelles Programm.
Identifizieren der externen Variablen:
Versuchen Sie, die gegebenen Parameter in der Designaufgabe so festzulegen, dass Sie ein Modell direkt auf Basis dieser Daten konstruieren können.
Identifizieren Sie die Variablen, bevor Sie mit dem Erstellen von Code beginnen:
Eine auf das absolut Notwendige beschränkte Gruppe von Eingaben
Die beabsichtigte Ausgabe
Konstanten
Vor dem Schreiben des Codes wurden mehrere Variablen festgelegt.
Die in der Simulation dem Regen ausgesetzte Oberfläche.
Die gewünschte Anzahl Regentropfen (Agents).
Die von den Regentropfen zurückgelegte Strecke.
Umschalten zwischen steilstmöglichem Pfad und Überqueren der Oberfläche.
Python-Block mit der entsprechenden Anzahl Eingaben.
Ein Codeblock, mit dem die zurückgegebenen Kurven blau gefärbt werden.
Entwerfen der internen Beziehungen:
Das parametrische Prinzip ermöglicht die Bearbeitung bestimmter Parameter oder Variablen, um das Endergebnis einer Gleichung zu ändern oder zu beeinflussen.
Versuchen Sie stets, Objekte in Ihrem Skript, die logisch miteinander verbunden sind, als Funktionen voneinander zu definieren. Auf diese Weise wird bei einer Änderung eines der Objekte auch das andere proportional dazu aktualisiert.
Beschränken Sie die Anzahl der Eingaben, indem Sie nur die wichtigsten Parameter bereitstellen:
Wenn eine Gruppe von Parametern aus Parametern auf einer höheren Hierarchieebene abgeleitet werden kann, stellen Sie nur die übergeordneten Parameter als Skripteingaben bereit. Auf diese Weise vereinfachen Sie die Benutzeroberfläche des Skripts und machen dieses dadurch benutzerfreundlicher.
Eingaben.
Interne Variablen für das Skript.
Eine Schleife, die diese Eingaben und Variablen für ihre Funktion nutzt.
Tipp: Wenden Sie für den Prozess dieselbe Sorgfalt an wie für die Lösung.
Falls es mehrere Möglichkeiten für denselben Vorgang in Ihrem Skript gibt, werden die doppelt vorhandenen Darstellungen schließlich asynchron, was die Wartung extrem schwierig macht, die Faktorisierung verschlechtert und interne Widersprüche verursacht.
Das DRY-Prinzip besagt, dass jede für jede Information genau eine eindeutige und maßgebliche Darstellung im System vorhanden sein muss.
Wird dieses Prinzip erfolgreich angewendet, erfolgen Änderungen an allen verbundenen Elementen in Ihrem Skript in vorhersehbarer und einheitlicher Weise und Elemente, die nicht miteinander verbunden sind, haben keine logischen Auswirkungen aufeinander.
Tipp: Bevor Sie Objekte in Ihrem Skript duplizieren (wie die Konstante im obigen Beispiel), überlegen Sie, ob Sie stattdessen eine Verknüpfung zur Quelle erstellen können.
Mit zunehmender Länge und Komplexität des Codes ist das Grundkonzept bzw. der Gesamtalgorithmus immer schwieriger zu entziffern. Es wird zudem schwieriger, zu verfolgen, welche spezifischen Vorgänge ablaufen (und wo dies geschieht), bei Fehlfunktionen den Fehler zu finden, anderen Code zu integrieren und Entwicklungsaufgaben zuzuweisen. Um diese Probleme zu vermeiden, ist es sinnvoll, Code in Modulen zu erstellen: Bei diesem Organisationsverfahren wird Code anhand der jeweils ausgeführten Aufgaben aufgegliedert. Im Folgenden finden Sie einige Tipps, die es Ihnen erleichtern sollen, durch Modularisierung leichter zu verwaltende Skripts zu erstellen.
Schreiben von Code in Modulen:
Ein Modul ist eine Sammlung von Code, der eine bestimmte Aufgabe ausführt, ähnlich wie ein Dynamo-Block im Arbeitsbereich.
Dabei kann es sich um beliebigen Code handeln, der visuell von angrenzendem Code abgetrennt sollte (eine Funktion, eine Klasse, eine Gruppe von Eingaben oder die von Ihnen importierten Bibliotheken).
Durch die Entwicklung von Code in Form von Modulen können Sie sowohl die visuellen, intuitiven Eigenschaften von Blöcken als auch die komplexen Beziehungen nutzen, die nur mit Textskripts zu erreichen sind.
Diese Schleifen rufen eine Klasse namens „agent“ auf, die in dieser Übung entwickelt wird.
Ein Code-Modul, das den Startpunkt jedes Agents definiert.
Ein Code-Modul, das den Agent aktualisiert.
Ein Code-Modul, das den Pfad zeichnet, dem der Agent folgt.
Erkennen der Wiederverwendung von Code:
Wenn Sie feststellen, dass Ihr Code dieselbe (oder eine sehr ähnliche) Aufgabe an mehr als einer Stelle ausführt, suchen Sie nach Möglichkeiten, ihn zu einer Funktion zusammenzufassen, die aufgerufen werden kann.
„Manager“-Funktionen steuern den Programmablauf und enthalten in erster Linie Aufrufe an „Worker“-Funktionen, die Details auf unteren Ebenen, etwa das Verschieben von Daten zwischen Strukturen, verarbeiten.
In diesem Beispiel werden Kugeln erstellt, deren Radien und Farben vom Z-Wert ihrer Mittelpunkte abhängig sind.
Zwei übergeordnete „Worker“-Funktionen zum Erstellen von Kugeln mit Radien und mit Anzeigefarben anhand des Z-Werts des Mittelpunkts.
Eine übergeordnete „Manager“-Funktion, die die beiden „Worker“-Funktionen kombiniert. Durch Aufrufen dieser Funktion werden beide darin enthaltenen Funktionen aufgerufen.
Beschränken der Anzeige auf das Nötige:
Die Schnittstelle eines Moduls gibt die vom Modul bereitgestellten und benötigten Elemente an.
Nachdem Sie die Schnittstellen zwischen den Einheiten definiert haben, kann die detaillierte Entwicklung jeder Einheit separat erfolgen.
Möglichkeit zum Trennen bzw. Ersetzen:
Module erkennen oder berücksichtigen einander nicht.
Allgemeine Formen der Modularisierung :
Codegruppierung:
Funktionen:
Klassen:
Es ist sinnvoll, während der Entwicklung von Textskripts in Dynamo laufend zu überprüfen, ob die tatsächlich erstellten Funktionen Ihren Erwartungen entsprechen. Dadurch stellen Sie sicher, dass unvorhergesehene Ereignisse wie Syntaxfehler, logische Diskrepanzen, falsche Werte, regelwidrige Ausgaben usw. nicht erst zum Schluss alle zusammen, sondern direkt bei ihrem Auftreten schnell erkannt und korrigiert werden. Da die Textskripts sich innerhalb der Blöcke im Ansichtsbereich befinden, sind sie bereits in den Datenfluss des visuellen Programms integriert. Die laufende Überwachung des Skripts gestaltet sich dadurch so einfach wie das Zuweisen von Daten für die Ausgabe, die Ausführung des Programms und die Auswertung des Skriptergebnisses über einen Beobachtungsblock. Im Folgenden finden Sie einige Tipps für die laufende Überwachung Ihrer Skripts, während Sie sie konstruieren.
Testen Sie während der Entwicklung:
Wenn Sie eine Gruppe von Funktionen erstellt haben:
Überprüfen Sie Ihren Code aus distanzierter Sicht.
Seien Sie dabei kritisch. Ist die Funktionsweise für einen Teamkollegen verständlich? Brauche ich das wirklich? Kann diese Funktion effizienter durchgeführt werden? Werden unnötige Duplikate oder Abhängigkeiten erstellt?
Führen Sie rasch Tests durch, um sich zu überzeugen, dass plausible Daten zurückgegebenen werden.
Weisen Sie die aktuellsten Daten, mit denen Sie arbeiten, in Ihrem Skript als Ausgabedaten zu, damit der Block bei einer Aktualisierung des Skripts immer relevante Daten ausgibt:
Überprüfen Sie, ob alle Kanten des Volumenkörpers als Kurven zurückgegeben werden, damit ein Begrenzungsrahmen darum erstellt wird.
Überprüfen Sie, ob die Count-Eingaben in Ranges konvertiert werden.
Überprüfen Sie, ob Koordinatensysteme in dieser Schleife ordnungsgemäß verschoben und gedreht wurden.
Vorwegnehmen von Grenzfällen:
Geben Sie während der Skripterstellung die Mindest- und Höchstwerte der Eingabeparameter innerhalb ihrer zugewiesenen Domäne an, um zu testen, ob das Programm auch unter extremen Bedingungen funktioniert.
Überprüfen Sie auch dann, wenn das Programm mit seinen Extremwerten funktioniert, ob es unbeabsichtigte Nullwerte oder leere Werte zurückgibt.
Bugs und Fehler, die auf grundlegende Probleme mit dem Skript hinweisen, werden zuweilen nur in solchen Grenzfällen erkennbar.
Ermitteln Sie die Fehlerursache, und entscheiden Sie, ob sie intern behoben werden muss oder ob zur Vermeidung des Problems eine Parameterdomäne neu definiert werden muss.
Tipp: Gehen Sie stets davon aus, dass die Benutzer jede mögliche Kombination sämtlicher für sie bereitgestellten Eingabewerte verwenden werden. Auf diese Weise vermeiden Sie unangenehme Überraschungen.
Debugging ist der Prozess der Beseitigung von Fehlern („Bugs“) in Ihrem Skript. Bugs können Fehler, Ineffizienzen, Ungenauigkeiten oder beliebige nicht beabsichtigte Ergebnisse sein. Um einen Bug zu beheben, kann ein einfacher Schritt wie die Korrektur eines falsch geschriebenen Variablennamens genügen, es können jedoch auch tiefergehende, die Struktur des Skripts betreffende Probleme vorhanden sein. Im Idealfall erkennen Sie solche potenziellen Probleme frühzeitig, indem Sie das Skript während des Erstellens testen, eine Garantie für Fehlerfreiheit ist dadurch jedoch nicht gegeben. Im Folgenden werden einige der oben genannten optimalen Verfahren genauer beschrieben, um Ihnen die systematische Beseitigung von Bugs zu erleichtern.
Verwenden Sie den Beobachtungsblock:
Überprüfen Sie die an verschiedenen Stellen des Codes zurückgegebenen Daten, indem Sie ihn ähnlich wie beim Testen des Programms der OUT-Variablen zuweisen:
Schreiben Sie aussagekräftige Kommentare:
Das Debugging eines Codemoduls ist erheblich einfacher, wenn das beabsichtigte Ergebnis klar beschrieben ist.
Normalerweise wäre dies ein Übermaß an Kommentaren und leeren Zeilen, beim Debugging kann es jedoch hilfreich sein, den Code in überschaubare Abschnitte aufzuteilen.
Nutzen Sie die Modularität des Codes:
Die Ursache eines Problems kann gezielt auf bestimmte Module zurückgeführt werden.
Nachdem Sie das fehlerhafte Modul identifiziert haben, lässt sich das Problem wesentlich leichter beheben.
Wenn ein Programm geändert werden muss, ist Code, der in Form von Modulen entwickelt wurde, erheblich leichter zu ändern.
Sie können neue oder korrigierte Module in ein bestehendes Programm einfügen und sich dabei darauf verlassen, dass der Rest des Programms unverändert bleibt.
Die Eingabegeometrie gibt einen Begrenzungsrahmen zurück, der größer ist als sie selbst, wie durch Zuweisen von xDist und yDist zu OUT zu erkennen ist.
Die Kantenkurven der Eingabegeometrie geben einen passenden Begrenzungsrahmen mit den richtigen Entfernungen für xDist und yDist zurück.
Das zur Behebung des Problems mit den xDist- und yDist-Werten eingefügte Codemodul.
Laden Sie die Beispieldatei herunter, indem Sie auf den folgenden Link klicken.
Eine vollständige Liste der Beispieldateien finden Sie im Anhang.
In dieser Übung schreiben Sie unter Beachtung der optimalen Verfahren für Textskripts ein Skript zur Simulation von Regen. Im Kapitel „Strategien für Diagramme“ war es möglich, optimale Verfahren auf ein unstrukturiertes visuelles Programm anzuwenden. Bei Textskripts ist dies jedoch wesentlich schwieriger. Logische Beziehungen, die in Textskripts erstellt werden, sind weniger sichtbar und können in unzureichend strukturiertem Code kaum unterschieden werden. Die Leistungsfähigkeit der Textskripts bringt einen größeren Organisationsbedarf mit sich. Hier werden die einzelnen Schritte gezeigt und während des ganzen Vorgangs die optimalen Verfahren angewendet.
Das auf eine durch einen Attraktor verformte Oberfläche angewendete Skript.
Als Erstes müssen Sie die benötigten Dynamo-Bibliotheken importieren. Indem Sie dies zu Anfang durchführen, erhalten Sie globalen Zugriff auf Dynamo-Funktionen in Python.
Sie müssen hier sämtliche Bibliotheken importieren, die Sie verwenden möchten.
Anschließend müssen Sie die Eingaben und die Ausgabe definieren, die als Eingabeanschlüsse am Block angezeigt werden. Diese externen Eingaben sind die Grundlage für das Skript und der Schlüssel zum Erstellen einer parametrischen Umgebung.
Sie müssen Eingaben definieren, die Variablen im Python-Skript entsprechen, und die gewünschte Ausgabe bestimmen:
Die Oberfläche, über die die Bewegung nach unten erfolgen soll.
Die Anzahl der Agents, die sich bewegen sollen.
Die maximale Anzahl an Schritten, die die Agents ausführen dürfen.
Eine Option, mit der entweder der kürzeste Weg abwärts auf der Oberfläche oder eine seitliche Bewegung gewählt werden kann.
Der Python-Block mit Eingabe-IDs, die den Eingaben im Skript (IN[0], IN[1]) entsprechen.
Ausgabekurven, die in einer anderen Farbe angezeigt werden können.
Erstellen Sie jetzt unter Beachtung des Modularitätsprinzips den Hauptteil des Skripts. Die Simulation des kürzesten Wegs abwärts auf einer Oberfläche ausgehend von unterschiedlichen Startpunkten ist eine größere Aufgabe, die mehrere Funktionen erfordert. Anstatt die verschiedenen Funktionen im Verlauf des ganzen Skripts aufzurufen, können Sie den Code modularisieren, indem Sie sie in einer einzigen Klasse, dem Agent, sammeln. Die verschiedenen Funktionen dieser Klasse – des „Moduls“ – können über unterschiedliche Variablen aufgerufen oder sogar in einem anderen Skripts wiederverwendet werden.
Sie müssen eine Klasse bzw. eine Vorlage für einen Agent definieren, der eine Abwärtsbewegung über eine Oberfläche darstellt, wobei bei jedem Schritt der Bewegung jeweils die Richtung mit der maximalen Neigung gewählt wird:
Name.
Globale, allen Agents gemeinsame Attribute.
Exemplarattribute, die für jeden Agent spezifisch sind.
Eine Funktion zum Ausführen eines Schritts.
Eine Funktion zum Katalogisieren der Position jedes Schritts in einer Liste für den Pfad.
Initialisieren Sie die Agents, indem Sie ihre Startpositionen definieren. Dies ist eine gute Gelegenheit, das Skript zu testen und sicherzustellen, dass die Agent-Klasse funktioniert.
Sie müssen alle Agents, deren Abwärtsbewegung über die Oberfläche Sie beobachten möchten, instanziieren und ihre Anfangsattribute definieren.
Eine neue, leere Pfadliste.
Ausgangspunkt der Bewegung über die Oberfläche.
Die Liste der Agents wird als Ausgabe zugewiesen, um zu überprüfen, was das Skript hier zurückgibt. Die richtige Anzahl der Agents wird zurückgegeben, das Skript muss jedoch später erneut getestet werden, um die zurückgegebene Geometrie zu prüfen.
Aktualisieren Sie die einzelnen Agents bei jedem Schritt. Anschließend müssen Sie eine verschachtelte Schleife starten, wobei die Position für jeden Agent und jeden Schritt aktualisiert und in der jeweiligen Pfadliste aufgezeichnet wird. Bei jedem Schritt wird außerdem geprüft, ob der Agent einen Punkt auf der Oberfläche erreicht hat, von dem aus keine weiteren Abwärtsschritte mehr möglich sind. Ist diese Bedingung erfüllt, wird die Bewegung des Agent beendet.
Nachdem die Agents vollständig aktualisiert sind, können Sie Geometrie ausgeben, durch die sie dargestellt werden. Nachdem alle Agents entweder den Endpunkt ihrer Abwärtsbewegung erreicht oder die maximale Anzahl Schritte ausgeführt haben, erstellen Sie eine Polykurve durch die Punkte in ihrem Pfad und geben die Polykurvenpfade aus.
Das Skript zur Ermittlung der steilstmöglichen Pfade.
Voreinstellung zur Simulation von Regen auf der zugrunde liegenden Oberfläche.
Die Agents können umgeschaltet werden, sodass sie nicht die steilstmöglichen Pfade suchen, sondern die Oberfläche überqueren.
Das vollständige Python-Textskript.
Klasse | Ungleichmäßig skaliertes Koordinatensystem | Geschertes Koordinatensystem |
---|---|---|
Mit dem Dynamo-Projekt ist beabsichtigt, die Möglichkeiten der Plattformimplementierung zu erweitern. Da Dynamo nach und nach weitere Programme in seine Palette aufnimmt, erhalten Benutzer Zugriff auf plattformspezifische APIs aus der Python-Skriptumgebung. In diesem Abschnitt wird ein Fallbeispiel für Revit behandelt. Zukünftig sollen jedoch weitere Kapitel mit umfassenden Lernprogrammen zur Skripterstellung für andere Plattformen bereitgestellt werden. Darüber hinaus stehen jetzt zahlreiche -Bibliotheken zur Verfügung, die Sie in Dynamo importieren können.
Die folgenden Beispiele zeigen Möglichkeiten zur Implementierung Revit-spezifischer Vorgänge aus Dynamo mit Python. Eine genauere Beschreibung der Beziehung zwischen Python einerseits und Dynamo und Revit andererseits finden Sie auf der . Eine andere nützliche Ressource für Python und Revit ist das -Projekt.
Informationen zur Verwendung von Gruppen finden Sie unter .
Informationen zur Verwendung von Codeblöcken finden Sie unter
Informationen zur Verwendung von Block zu Code finden Sie unter .
Informationen zur Verwendung von List@Level finden Sie unter .
Informationen zur Verwendung der Blockausrichtung finden Sie unter .
Informationen zum Hinzufügen einer Anmerkung finden Sie unter .
Es ist wichtig, während der Entwicklung des visuellen Skripts zu überprüfen, ob die zurückgegebenen Ergebnisse Ihren Erwartungen entsprechen. Nicht alle Fehler oder Probleme lassen das Programm sofort fehlschlagen, dies gilt insbesondere für Nullwerte, die sich erst viel später im weiteren Verlauf auswirken können. Diese Vorgehensweise wird auch im Zusammenhang mit Textskripts unter beschrieben. Das folgende Verfahren hilft Ihnen, sicherzustellen, dass Sie das gewünschte Ergebnis erzielen:
Informationen zur Verwendung der Beobachtungsfunktion finden Sie unter .
Informationen zur Verwendung von Voreinstellungen finden Sie unter .
Weitere Informationen zur Verwendung benutzerdefinierter Blöcke finden Sie unter .
In der Autodesk.DesignScript.Geometry-Bibliothek können Sie Punktnotation ähnlich wie in Codeblöcken verwenden. Weitere Informationen zur Dynamo-Syntax finden Sie unter sowie im . (Um dieses PDF-Dokument herunterzuladen, klicken Sie mit der rechten Maustaste auf den Link und wählen Link speichern unter... aus). Wenn Sie einen Geometrietyp, z. B. 'Point.' eingeben, wird eine Liste mit den Methoden zum Erstellen und Abfragen von Punkten angezeigt.
Unter ist aufgelistet, worauf Sie mit welcher Dynamo-Bibliothek zugreifen können.
Die Codemodule aus dem Beispiel unter .
Debuggen der Beispieldatei aus dem .
Bogen
Nein
No
NurbsCurve
Ja
Ja
NurbsSurface
Nein
No
Kreis
Nein
No
Linie
Ja
Ja
Ebene
Nein
No
Punkt
Ja
Ja
Polygon
Nein
No
Volumenkörper
Nein
No
Oberfläche
Nein
No
Text
Nein
No
Verwendung: Punkt | Kurve | Ebene | Oberfläche | Volumenkörper |
Auf: Kurve | Ja | Nein | Nein | Nein | No |
Polygon | - | Nein | Ja | Nein | No |
Oberfläche | - | Ja | Ja | Ja | Ja |
Volumenkörper | - | - | Ja | Ja | Ja |
Schleifen | Rekursionen | Zusammenfassen von Blöcken | Ext. Bibliotheken | Kurzschreibweisen |
DesignScript | Ja | Ja | Ja | Nein | Ja |
Python | Ja | Ja | Teilweise | Ja | Nein |
ZeroTouch (C#) | Nein | Nein | Nein | Ja | Nein |
Datentyp
Dynamo-Standarddarstellung
Codeblock-Entsprechung
Zahlen
Zeichenfolgen
Sequenzen
Bereiche
Eintrag an Indexposition abrufen
Liste erstellen
Zeichenfolgen verketten
Bedingungsanweisungen
Block/Blöcke
Codeblock-Entsprechung
Anmerkung
Beliebiger Operator (+, &&, >=, Not, usw.)
+, &&, >=, !, usw.
Beachten Sie, dass "Not" (Nicht) durch "!" ersetzt wird, der Block jedoch zur Unterscheidung von "Fakultät" nach wie vor "Not" heißt.
Boolescher Wert True
true;
Anmerkung: Kleinbuchstaben
Boolescher Wert False
false;
Anmerkung: Kleinbuchstaben
Mit: | Oberfläche | Kurve | Ebene | Volumenkörper |
Oberfläche | Kurve | Punkt | Punkt, Kurve | Oberfläche |
Kurve | Punkt | Punkt | Punkt | Kurve |
Ebene | Kurve | Punkt | Kurve | Kurve |
Volumenkörper | Oberfläche | Kurve | Kurve | Volumenkörper |
Der visuelle Programmierungsprozesses ist eine äußerst leistungsstarke, kreative Aktivität, wobei der Programmablauf und die wichtigsten Benutzereingaben jedoch schnell durch ihre Komplexität und/oder das Layout des Arbeitsbereichs unübersichtlich werden können. Machen Sie sich im Folgenden mit einigen bewährten Verfahren für die Verwaltung von Programmen vertraut.
Nachdem Sie bereits zahlreiche Blöcke zum Arbeitsbereich hinzugefügt haben, möchten Sie sie möglicherweise neu anordnen, um das Layout übersichtlicher zu gestalten. Indem Sie mehrere Blöcke auswählen und mit der rechten Maustaste in den Arbeitsbereich klicken, wird ein Popup-Fenster mit dem Menü Auswahl ausrichten angezeigt, das Optionen zum Ausrichten und Verteilen in X- und Y-Richtung enthält.
Wählen Sie mehrere Blöcke aus.
Klicken Sie mit der rechten Maustaste in den Arbeitsbereich.
Verwenden Sie die Optionen von Auswahl ausrichten.
Mit etwas Erfahrung werden Sie auch in der Lage sein, visuelle Programme zu "lesen", indem Sie die Blocknamen überprüfen und den Programmablauf verfolgen. Für Benutzer unterschiedlicher Erfahrungsniveaus hat es sich ebenfalls bewährt, aussagekräftige Beschriftungen und Beschreibungen einzufügen. In Dynamo ist hierfür ein Notes-Block mit einem bearbeitbaren Textfeld verfügbar. Für das Hinzufügen von Anmerkungen zum Arbeitsbereich bestehen zwei Möglichkeiten:
Navigieren Sie zum Menü Datei > Anmerkung erstellen.
Die Tastenkombination Strg+W verwenden
Nachdem Sie eine Anmerkung zum Arbeitsbereich hinzugefügt haben, wird ein Popup-Textfeld angezeigt, in dem Sie den Text für die Anmerkung bearbeiten können. Nach der Erstellung einer Anmerkung können Sie sie bearbeiten, indem Sie darauf doppelklicken oder mit der rechten Maustaste auf den Note-Block klicken.
Je umfangreicher ein visuelles Programm wird, desto hilfreicher kann es sein, größere Schritte zu identifizieren, die ausgeführt werden. Sie können größere Sammlungen von Blöcken durch ein Rechteck mit farbigem Hintergrund und einen Titel zu einer Gruppe zusammenfassen. Für das Erstellen einer Gruppe mit mehreren ausgewählten Blöcken sind drei Möglichkeiten verfügbar:
Navigieren Sie zum Menü Datei > Gruppe erstellen.
Die Tastenkombination Strg+G verwenden
Klicken Sie mit der rechten Maustaste in den Arbeitsbereich und wählen Sie "Gruppe erstellen".
Nachdem Sie eine Gruppe erstellt haben, können Sie deren Einstellungen wie den Titel und die Farbe bearbeiten.
Tipp: Verwenden Sie Anmerkungen und Gruppen, um Ihre Datei effektiv zu beschriften und die Lesbarkeit zu erhöhen.
Hier sehen Sie ein Beispiel für ein Programm mit hinzugefügten Anmerkungen und Gruppen:
Anmerkung: "Rasterparameter"
Anmerkung: "Rasterpunkte"
Gruppe: "Raster aus Punkten erstellen"
Gruppe: "Attraktorpunkt erstellen"
Anmerkung: "Entfernungswerte kalibrieren"
Anmerkung: "Variables Raster von Kreisen"
Diese Referenzseite bietet ausführlichere Informationen zu Codebibliotheken, Beschriftungen und Stil aus den optimalen Verfahren, die unter „Vorgehensweisen zur Skripterstellung“ beschrieben wurden. Zur Verdeutlichung der im Folgenden beschriebenen Konzepte wird hier Python verwendet, es gelten jedoch dieselben Prinzipien sowohl in Python als auch in C# (Zerotouch), allerdings mit unterschiedlicher Syntax.
Standardbibliotheken sind außerhalb von Dynamo verfügbar und liegen in den Programmiersprachen Python und C# (Zerotouch) vor. Dynamo verfügt darüber hinaus über eigene Bibliotheken, die direkt seiner Blockhierarchie entsprechen und es dem Benutzer ermöglichen, alle Abläufe, die aus Blöcken und Drähten konstruiert werden können, auch in Form von Code zu erstellen. Der folgende Leitfaden zeigt, worauf Sie in den einzelnen Dynamo-Bibliotheken Zugriff erhalten und wann Sie eine Standardbibliothek verwenden sollten.
Standardbibliotheken und Dynamo-Bibliotheken
Standardbibliotheken in Python und C# können zum Erstellen erweiterter Daten- und Ablaufstrukturen in der Dynamo-Umgebung genutzt werden.
Dynamo-Bibliotheken entsprechen direkt der Blockhierarchie zum Erstellen von Geometrie und anderer Dynamo-Objekte.
Dynamo-Bibliotheken
ProtoGeometry*
Funktionen: Bogen, Begrenzungsrahmen, Kreis, Kegel, Koordinatensystem, Quader, Kurve, Zylinder, Kante, Ellipse, elliptischer Bogen, Fläche, Geometrie, Spirale, Indexgruppe, Linie, Netz, NURBS-Kurve, NURBS-Oberfläche, Ebene, Punkt, Polygon, Rechteck, Volumenkörper, Kugel, Oberfläche, Topologie, TSpline, UV, Vektor, Scheitelpunkt.
Importverfahren: import Autodesk.DesignScript.Geometry
``
DSCoreNodes
Funktionen: Farbe, Farbbereich 2D, Datum und Uhrzeit, Zeitraum, IO, Formel, Logik, Liste, mathematische Funktionen, Quadtree, Zeichenfolge, Thread.
Importverfahren: import DSCore
Tessellieren
Funktionen: konvexe Hülle, Delaunay, Voronoi.
Importverfahren: import Tessellation
DSOffice
Funktion: Excel.
Importverfahren: import DSOffice
*Anmerkung: Beachten Sie bei der Verwendung von ProtoGeometry in Python oder C#, dass Sie hierbei nicht verwaltete Objekte erstellen, deren Speicher manuell verwaltet werden muss, wie weiter unten im Abschnitt Nicht verwaltete Objekte genauer beschrieben.
Beim Erstellen von Skripts werden Elemente wie Variablen, Typen, Funktionen und andere Objekte laufend mit IDs gekennzeichnet. Durch dieses System der symbolischen Schreibweise können Sie beim Entwickeln von Algorithmen ganz einfach über Beschriftungen, die in der Regel aus einer Folge von Zeichen bestehen, auf Informationen verweisen. Die aussagekräftige Benennung von Elementen spielt eine wichtige Rolle beim Erstellen von Code, den sowohl andere Benutzer als auch Sie selbst zu einem späteren Zeitpunkt problemlos lesen und verstehen können. Beachten Sie beim Benennen von Elementen in Ihrem Skript die folgenden Tipps:
Sie können Abkürzungen verwenden, müssen diese jedoch in einem Kommentar erläutern:
Vermeiden Sie überzählige Beschriftungen:
Verwenden Sie für Variablennamen positive anstatt negativer Logik:
Geben Sie der Rückwärtsschreibweise den Vorzug:
Dies ist unter dem Aspekt der Struktur sinnvoller.
Verwenden Sie Aliasse zur Verkürzung überlanger und häufig wiederholter Ketten:
Aliasse führen rasch zu verwirrenden und nicht standardmäßigen Programmen.
Verwenden Sie nur die erforderlichen Wörter:
Man muss die Dinge so einfach wie möglich machen. Aber nicht einfacher. - Albert Einstein
Im Allgemeinen gibt es beim Programmieren von Anwendungen jeder Art mehrere Möglichkeiten. Ihr „persönlicher Stil“ beim Schreiben von Skripts ist daher das Ergebnis zahlloser Detailentscheidungen für oder gegen einzelne Schritte während der Arbeit. Wie leserlich und leicht zu warten Ihr Code ist, ist dennoch gleichermaßen das direkte Ergebnis seiner internen Kohärenz und der Einhaltung allgemeiner Stilkonventionen. Als Faustregel gilt, dass Code, der an zwei unterschiedlichen Stellen gleich aussieht, auch dieselbe Funktion ausführen muss. Die folgenden Tipps sollen beim Schreiben von verständlichem und einheitlichem Code helfen.
Namenskonventionen: (Wählen Sie eine der folgenden Konventionen für jede Art von Element in Ihrem Code und behalten Sie sie konsequent bei.)
Variablen, Funktionen, Methoden, Pakete, Module:
lower_case_with_underscores
Objektklassen und Ausnahmen:
CapWords
Geschützte Methoden und interne Funktionen:
_single_leading_underscore(self, ...)
Private Methoden:
__double_leading_underscore(self, ...)
Konstanten:
ALL_CAPS_WITH_UNDERSCORES
Tipp: Vermeiden Sie Variablen, die aus nur einem Buchstaben bestehen (insbesondere L, O, I), ausgenommen in sehr kurzen Blöcken, wenn die Bedeutung unmissverständlich aus dem unmittelbaren Kontext hervorgeht.
Verwendung leerer Zeilen:
Fügen Sie vor und nach Definitionen von Funktionen auf oberster Ebene und von Klassen je zwei Leerzeilen ein.
Schließen Sie Methodendefinitionen innerhalb einer Klasse in einfache leere Zeilen ein.
Zusätzliche Leerzeilen können (in Maßen) dazu verwendet werden, um Gruppen zusammengehöriger Funktionen voneinander zu trennen.
Vermeiden Sie überflüssigen Leerraum an den folgenden Stellen:
direkt in runden, geschweiften oder eckigen Klammern:
unmittelbar vor einem Komma, Semikolon oder Doppelpunkt:
unmittelbar vor der öffnenden Klammer am Anfang der Liste der Argumente für einen Funktionsaufruf:
unmittelbar vor der öffnenden Klammer am Anfang von Indizierungen und Teilbereichen:
Fügen Sie vor und nach diesen Binäroperatoren immer jeweils ein Leerzeichen ein:
Beachten Sie die Länge:
Sie sollte 79 Zeichen möglichst nicht überschreiten.
Indem Sie die Breite der benötigten Editor-Fenster beschränken, können Sie mehrere Dateien nebeneinander anzeigen. Dies ist besonders bei der Verwendung von Codeprüfungs-Tools hilfreich, die die beiden Versionen in benachbarten Spalten zeigen.
Lange Zeilen können umbrochen und auf mehrere Zeilen verteilt werden, indem Sie Ausdrücke in Klammern setzen:
Vermeiden Sie allzu offensichtliche und überflüssige Kommentare:
Durch weniger Kommentare erhalten Sie zuweilen leichter lesbaren Code. Dies gilt insbesondere, wenn Sie infolgedessen auf aussagekräftige Symbolnamen achten müssen.
Durch sinnvolle Arbeitsgewohnheiten beim Schreiben von Code benötigen Sie weniger Kommentare:
Tipp: Kommentare beantworten die Frage nach dem Warum, Code nach dem Wie.
Orientieren Sie sich an Open-Source-Code:
Open-Source-Projekte werden durch die Zusammenarbeit vieler Entwickler vorangetrieben. In diesen Projekten ist die leichte Verständlichkeit des Codes unverzichtbar, damit das Team so effizient wie möglich zusammenarbeiten kann. Aus diesem Grund empfiehlt es sich, den Quellcode dieser Projekte durchzusehen und aus der Arbeitsweise dieser Entwickler Anregungen zu schöpfen.
Verbessern Sie Ihre Konventionen:
Überprüfen Sie für jede einzelne Konvention. ob sie für den aktuellen Verwendungszweck geeignet ist.
Kommt es zu Beeinträchtigungen der Funktionsfähigkeit/Effizienz?
Auf den folgenden Wiki-Seiten finden Sie Anweisungen zum Schreiben von C# für Zerotouch und wie Sie zu Dynamo beitragen können:
Im folgenden Wiki werden allgemeine Kodierungsstandards zum Dokumentieren und Testen Ihres Codes beschrieben: https://github.com/DynamoDS/Dynamo/wiki/Coding-Standards
Im folgenden Wiki wird speziell auf Namenskonventionen für Bibliotheken, Kategorien, Blocknamen, Anschlussnamen und Abkürzungen eingegangen: https://github.com/DynamoDS/Dynamo/wiki/Naming-Standards
Nicht verwaltete Objekte:
Wenn Sie die Geometriebibliothek von Dynamo (ProtoGeometry) in Python oder C# verwenden, werden von Ihnen erstellte Geometrieobjekte nicht durch die virtuelle Maschine verwaltet, und der Speicher für viele dieser Objekte muss manuell bereinigt werden. Zum Bereinigen nativer oder nicht verwalteter Objekte können Sie die Dispose-Methode oder das using-Schlüsselwort verwenden. Einen Überblick hierzu finden Sie in diesem Wiki-Eintrag: https://github.com/DynamoDS/Dynamo/wiki/Zero-Touch-Plugin-Development#dispose--using-statement.
Sie müssen nur diejenigen nicht verwalteten Ressourcen beseitigen, die Sie nicht in das Diagramm ausgeben und auf die keine Verweise gespeichert werden. Für den Rest dieses Abschnitts werden diese Objekte als temporäre Geometrie bezeichnet. Das Codebeispiel unten zeigt ein Beispiel für diese Klasse von Objekten. Diese Zerotouch C#-Funktion namens singleCube gibt einen einzelnen Würfel zurück, erstellt jedoch während ihrer Ausführung 10000 zusätzliche Würfel. Nehmen wir an, dass diese zusätzliche Geometrie als temporäre Geometrie zur Konstruktion verwendet wurde.
Diese Zerotouch-Funktion bringt Dynamo mit großer Wahrscheinlichkeit zum Absturz. Es wurden 10000 Volumenkörper erstellt, jedoch nur einer davon gespeichert, und nur dieser wurde zurückgegeben. Stattdessen sollten alle temporären Würfel, ausgenommen derjenige, der zurückgegeben werden soll, beseitigt werden. Der zurückzugebende Würfel darf nicht beseitigt werden, da er an das Diagramm weitergeleitet und von anderen Blöcken verwendet werden soll.
Der feste Code sieht ungefähr so aus:
Im Allgemeinen müssen Sie nur Geometrie wie Surfaces
, Curves
und Solids
entfernen. Um jedoch sicher zu sein, können Sie alle Geometrietypen (Vectors
, Points
, CoordinateSystems
) entfernen.
Dynamo 2.0 stellt nicht nur die oben erwähnten Blöcke für Wörterbücher zur Verfügung, sondern gibt Codeblöcken auch neue Funktionen.
Sie können die im Folgenden beschriebene Syntax für Blöcke verwenden, oder sie auf DesignScript-Basis darstellen.
Da ein Wörterbuch in Dynamo ein Objekttyp ist, können wir die folgenden Aktionen damit ausführen.
Diese Art der Interaktion ist besonders nützlich, um Revit-Daten mit Zeichenfolgen in Bezug zu setzen. Als Nächstes sehen wir uns einige Anwendungsfälle in Revit an.