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.

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.

Interpolierte Kurve

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.

Steuerpunktekurve

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:

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.

Interpolierte Oberfläche

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.

Steuerpunktoberfläche

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:

Erhabene Fläche

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.

Drehen von Flächen

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.

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

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.

Vektorsubtraktion

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

Vektormultiplikation kann man sich so vorstellen, dass der Endpunkt eines Vektors in seiner eigenen Richtung um einen angegebenen Skalierungsfaktor verschoben wird.

Vektorlänge normalisieren

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.

Kreuzprodukt

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.

Punktprodukt

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.

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.

Union

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:

s1 = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

s2 = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(4, 0,
    0), 6);

combined = s1.Union(s2);

Difference

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:

s = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

tool = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(10, 0,
    0), 6);

result = s.Difference(tool);

Intersect

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:

s = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin, 6);

tool = Sphere.ByCenterPointRadius(
    CoordinateSystem.Identity().Origin.Translate(10, 0,
    0), 6);

result = s.Intersect(tool);

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:

pts = [ [p1, p2, p3],
        [p4, p5, p6],
        [p7, p8, p9] ];

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:

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(6, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(3, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);

crv = NurbsCurve.ByPoints(pts);

pts_at_param = crv.PointAtParameter(0..1..#11);

// draw Lines to help visualize the points
lines = Line.ByStartPointEndPoint(pts_at_param,
    Point.ByCoordinates(4, 6, 0));

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:

pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);

crv = NurbsCurve.ByPoints(pts);

axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);

surf = Surface.ByRevolve(crv, axis_origin, axis, 90,
    140);

cs_array = surf.CoordinateSystemAtParameter(
    (0..1..#7)<1>, (0..1..#7)<2>);

def make_line(cs : CoordinateSystem) {
	lines_start = cs.Origin;
    lines_end = cs.Origin.Translate(cs.ZAxis, -0.75);

    return = Line.ByStartPointEndPoint(lines_start,
        lines_end);
}

lines = make_line(Flatten(cs_array));

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.

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:

Intersect

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.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

WCS = CoordinateSystem.Identity();

pl = Plane.ByOriginNormal(WCS.Origin.Translate(0, 0,
    0.5), WCS.ZAxis);

// intersect surface, generating three closed curves
crvs = surf.Intersect(pl);

crvs_moved = crvs.Translate(0, 0, 10);

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.

Trim

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.

// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10

surf = NurbsSurface.ByPoints(python_points_5, 3, 3);

tool_pts = Point.ByCoordinates((-10..20..10)<1>,
    (-10..20..10)<2>, 1);

tool = NurbsSurface.ByPoints(tool_pts);

pick_point = Point.ByCoordinates(8, 1, 3);

result = surf.Trim(tool, pick_point);

Punkt

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:

// create a point with the following x, y, and z
// coordinates:
x = 10;
y = 2.5;
z = -6;

p = Point.ByCoordinates(x, y, z);

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:

// create a point on a sphere with the following radius,
// theta, and phi rotation angles (specified in degrees)
radius = 5;
theta = 75.5;
phi = 120.3;
cs = CoordinateSystem.Identity();

p = Point.BySphericalCoordinates(cs, radius, theta,
    phi);

Von Punkt zu Linie

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:

// create two points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

// construct a line between p1 and p2
l = Line.ByStartPointEndPoint(p1, p2);

Von Linie zu Oberfläche

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.

// create points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

p5 = Point.ByCoordinates(9, -10, -2);
p6 = Point.ByCoordinates(-11, -12, -4);

// create lines:
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
l3 = Line.ByStartPointEndPoint(p5, p6);

// loft between cross section lines:
surf = Surface.ByLoft([l1, l2, l3]);

Von Oberfläche zu Volumenkörper

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.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

// true indicates to thicken both sides of the Surface:
solid = surf.Thicken(4.75, true);

Schneiden

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.

p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft([l1, l2]);

solid = surf.Thicken(4.75, true);

p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),
    Vector.ByCoordinates(1, 1, 1));

int_surf = solid.Intersect(p);

int_line = int_surf.Intersect(Plane.ByOriginNormal(
    Point.ByCoordinates(0, 0, 0),
    Vector.ByCoordinates(1, 0, 0)));

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.

Translation

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.

// create a point at x = 1, y = 2, z = 3
p = Point.ByCoordinates(1, 2, 3);

// translate the point 10 units in the x direction,
// -20 in y, and 50 in z
// p2’s new position is x = 11, y = -18, z = 53
p2 = p.Translate(10, -20, 50);

Drehung

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:

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Rotate(Point.ByCoordinates(0, 0),
    Vector.ByCoordinates(1,0,0.5), 25);

// get the existing coordinate system of the cube
old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

Skalieren

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:

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    10, 10, 10);

new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Scale(20);

old_cs = CoordinateSystem.Identity();

cube2 = cube.Transform(old_cs, new_cs2);

Gescherte Koordinatensysteme werden erstellt, indem nicht-orthogonale Vektoren in den Konstruktor CoordinateSystem eingegeben werden.

new_cs = CoordinateSystem.ByOriginVectors(
    Point.ByCoordinates(0, 0, 0),
	Vector.ByCoordinates(-1, -1, 1),
	Vector.ByCoordinates(-0.4, 0, 0));

old_cs = CoordinateSystem.Identity();

cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
    5, 5, 5);

new_curves = cube.Transform(old_cs, new_cs);

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.

Koordinatensystem

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:

// create a CoordinateSystem at x = 0, y = 0, z = 0,
// no rotations, scaling, or sheering transformations

cs = CoordinateSystem.Identity();

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:

// create a CoordinateSystem at a specific location,
// no rotations, scaling, or sheering transformations
x_pos = 3.6;
y_pos = 9.4;
z_pos = 13.0;

origin = Point.ByCoordinates(x_pos, y_pos, z_pos);
identity = CoordinateSystem.Identity();

cs = CoordinateSystem.ByOriginVectors(origin,
    identity.XAxis, identity.YAxis, identity.ZAxis);

Punkt

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:

// create a point with x, y, and z coordinates
x_pos = 1;
y_pos = 2;
z_pos = 3;

pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);

// create a point in a specific coordinate system
cs = CoordinateSystem.Identity();
pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,
    y_pos, z_pos);

// create a point on a cylinder with the following
// radius and height
radius = 5;
height = 15;
theta = 75.5;

pCyl = Point.ByCylindricalCoordinates(cs, radius, theta,
    height);

// create a point on a sphere with radius and two angles

phi = 120.3;

pSphere = Point.BySphericalCoordinates(cs, radius,
    theta, phi);

Linie

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.

p1 = Point.ByCoordinates(-2, -5, -10);
p2 = Point.ByCoordinates(6, 8, 10);

// a line segment between two points
l2pts = Line.ByStartPointEndPoint(p1, p2);

// a line segment at p1 in direction 1, 1, 1 with
// length 10
lDir = Line.ByStartPointDirectionLength(p1,
    Vector.ByCoordinates(1, 1, 1), 10);

3D-Grundkörper - Quader, Kegel, Zylinder, Kugel usw.

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.

// create a cuboid with specified lengths
cs = CoordinateSystem.Identity();

cub = Cuboid.ByLengths(cs, 5, 15, 2);

// create several cones
p1 = Point.ByCoordinates(0, 0, 10);
p2 = Point.ByCoordinates(0, 0, 20);
p3 = Point.ByCoordinates(0, 0, 30);

cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);
cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);

// make a cylinder
cylCS = cs.Translate(10, 0, 0);

cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);

// make a sphere
centerP = Point.ByCoordinates(-10, -10, 0);

sph = Sphere.ByCenterPointRadius(centerP, 5);

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