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.
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.
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.
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.
Foto von .
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: Zeta) 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.
