Punkt

Najprostszym obiektem geometrycznym w standardowej bibliotece geometrii dodatku Dynamo jest punkt. Cała geometria jest tworzona za pomocą specjalnych funkcji zwanych konstruktorami, które zwracają nowe wystąpienia danego typu geometrii. W dodatku Dynamo konstruktory zaczynają się od nazwy typu obiektu, w tym przypadku Point (punkt), a następnie podawana jest metoda konstrukcji. Aby utworzyć trójwymiarowy punkt określony przez współrzędne kartezjańskie x, y i z, użyj konstruktora ByCoordinates („na podstawie współrzędnych”):

Konstruktory w dodatku Dynamo są zazwyczaj oznaczone prefiksem „By”. Wywołanie takiej funkcji zwraca nowo utworzony obiekt danego typu. Nowo utworzony obiekt jest przechowywany w zmiennej o nazwie podanej po lewej stronie znaku równości.

Większość obiektów ma wiele różnych konstruktorów. Można na przykład użyć konstruktora BySphericalCoordinates, aby utworzyć punkt leżący na sferze, określony przez promień sfery, kąt pierwszego obrotu i kąt drugiego obrotu (określone w stopniach):

Od punktu do linii

Punkty mogą być używane do tworzenia geometrii wyższych wymiarów, np. linii. Za pomocą konstruktora ByStartPointEndPoint można utworzyć obiekt linii między dwoma punktami:

Od linii do powierzchni

Podobnie linie mogą być używane do tworzenia geometrii powierzchni wyższych wymiarów, na przykład za pomocą konstruktora Loft, który wykorzystuje szereg linii lub krzywych i interpoluje między nimi powierzchnię.

Od powierzchni do bryły

Także powierzchnie mogą być używane do tworzenia geometrii brył wyższych wymiarów, na przykład przez pogrubienie powierzchni o określoną odległość. Do wielu obiektów są dołączone funkcje zwane metodami, które umożliwiają programistom wykonywanie poleceń na tych konkretnych obiektach. Wspólne dla wszystkich elementów geometrii są metody Translate i Rotate, które odpowiednio przekształcają (przesuwają) i obracają geometrię o określoną wartość. Powierzchnie mają metodę Thicken, która pobiera pojedyncze dane wejściowe: liczbę określającą nową grubość powierzchni.

Przecięcie

Polecenia Intersection mogą wyodrębniać geometrię niższych wymiarów z obiektów wyższych wymiarów. Ta wyodrębniona geometria niższych wymiarów może stanowić podstawę dla geometrii wyższych wymiarów w cyklicznym procesie tworzenia, wyodrębniania i ponownego tworzenia geometrii. W tym przykładzie używamy wygenerowanej bryły do utworzenia powierzchni, a następnie używamy tej powierzchni do utworzenia krzywej.

W tej części przedstawiono serię lekcji poświęconych tworzeniu geometrii za pomocą języka DesignScript. Aby je przerobić, kopiuj kolejno przykładowy kod DesignScript do bloków kodu Dynamo.

W dodatku Dynamo istnieją dwa podstawowe sposoby tworzenia krzywych o dowolnych kształtach: określanie kolekcji punktów i interpolowanie gładkiej krzywej między nimi za pomocą dodatku Dynamo oraz metoda niższego poziomu polegająca na określeniu bazowych punktów kontrolnych krzywej o określonym stopniu. Krzywe interpolowane są przydatne, gdy projektant dokładnie wie, jaką postać powinna przyjąć linia, lub gdy projekt ma specyficzne ograniczenia dotyczące tego, przez co krzywa może i nie może przechodzić. Krzywe określone za pomocą punktów kontrolnych są w istocie serią segmentów linii prostej, które algorytm wygładza do końcowej postaci krzywej. Określenie krzywej za pomocą punktów sterujących może być przydatne w przypadku badania postaci krzywych o różnych stopniach wygładzenia lub gdy wymagana jest gładka ciągłość między segmentami krzywej.

Krzywa interpolowana

Aby utworzyć krzywą interpolowaną, wystarczy przekazać kolekcję punktów do metody NurbsCurve.ByPoints.

num_pts = 6;

s = Math.Sin(0..360..#num_pts) * 4;

pts = Point.ByCoordinates(1..30..#num_pts, s, 0);

int_curve = NurbsCurve.ByPoints(pts);

Wygenerowana krzywa przecina każdy z punktów wejściowych, zaczynając i kończąc odpowiednio na pierwszym i ostatnim punkcie w kolekcji. Opcjonalny parametr okresowy pozwala utworzyć krzywą okresową, która jest zamknięta. Dodatek Dynamo automatycznie wypełni brakujący segment, dlatego powielony punkt końcowy (identyczny z punktem początkowym) nie jest potrzebny.

pts = Point.ByCoordinates(Math.Cos(0..350..#10),
    Math.Sin(0..350..#10), 0);

// create an closed curve
crv = NurbsCurve.ByPoints(pts, true);

// the same curve, if left open:
crv2 = NurbsCurve.ByPoints(pts.Translate(5, 0, 0),
    false);

Krzywa punktów kontrolnych

Krzywe NurbsCurve są generowane w ten sam sposób, przy czym punkty wejściowe reprezentują punkty końcowe segmentu linii prostej, a drugi parametr, nazywany stopniem, określa wielkość i typ wygładzania krzywej.* Krzywa stopnia 1. nie ma wygładzenia; to polilinia.

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 1 is a polyline
ctrl_curve = NurbsCurve.ByControlPoints(pts, 1);

Krzywa stopnia 2. zostaje wygładzona w taki sposób, że przecina i jest styczna do punktu środkowego segmentów polilinii:

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

// a B-Spline curve with degree 2 is smooth
ctrl_curve = NurbsCurve.ByControlPoints(pts, 2);

Dodatek Dynamo obsługuje krzywe NURBS (niejednorodne wymierne B-splajn) do 20. stopnia, a poniższy skrypt ilustruje wpływ zwiększającego się poziomu wygładzania na kształt krzywej:

num_pts = 6;

pts = Point.ByCoordinates(1..30..#num_pts,
    Math.Sin(0..360..#num_pts) * 4, 0);

def create_curve(pts : Point[], degree : int)
{
	return = NurbsCurve.ByControlPoints(pts,
        degree);
}

ctrl_crvs = create_curve(pts, 1..11);

Należy zwrócić uwagę, że musi istnieć co najmniej jeden punkt kontrolny więcej, niż wynosi stopień krzywej.

Inną zaletą tworzenia krzywych przez wierzchołki kontrolne jest możliwość utrzymania styczności między poszczególnymi segmentami krzywej. Odbywa się to przez wyodrębnienie kierunku między dwoma ostatnimi punktami kontrolnymi i kontynuowanie tego kierunku z dwoma pierwszymi punktami kontrolnymi kolejnej krzywej. W poniższym przykładzie tworzone są dwie oddzielne krzywe NURBS, które mimo to są gładkie jak jedna krzywa:

pts_1 = {};

pts_1[0] = Point.ByCoordinates(0, 0, 0);
pts_1[1] = Point.ByCoordinates(1, 1, 0);
pts_1[2] = Point.ByCoordinates(5, 0.2, 0);
pts_1[3] = Point.ByCoordinates(9, -3, 0);
pts_1[4] = Point.ByCoordinates(11, 2, 0);

crv_1 = NurbsCurve.ByControlPoints(pts_1, 3);

pts_2 = {};

pts_2[0] = pts_1[4];
end_dir = pts_1[4].Subtract(pts_1[3].AsVector());

pts_2[1] = Point.ByCoordinates(pts_2[0].X + end_dir.X,
    pts_2[0].Y + end_dir.Y, pts_2[0].Z + end_dir.Z);

pts_2[2] = Point.ByCoordinates(15, 1, 0);
pts_2[3] = Point.ByCoordinates(18, -2, 0);
pts_2[4] = Point.ByCoordinates(21, 0.5, 0);

crv_2 = NurbsCurve.ByControlPoints(pts_2, 3);

CoordinateSystem

Dodatek Dynamo umożliwia tworzenie różnych złożonych form geometrycznych, ale geometryczne obiekty elementarne tworzą podstawę każdego projektu obliczeniowego: są wyrażone bezpośrednio w ostatecznej postaci projektowej lub służą jako rusztowanie, z których generowana jest bardziej złożona geometria.

Obiekt CoordinateSystem, choć nie jest właściwym fragmentem geometrii, jest ważnym narzędziem do tworzenia geometrii. Obiekt CoordinateSystem śledzi zarówno przekształcenia położenia i geometryczne, takie jak obrót, pion i skalowanie.

Utworzenie obiektu CoordinateSystem wyśrodkowanego w punkcie x = 0, y = 0 i z = 0 bez rotacji, skalowania ani przekształceń pionowych wymaga po prostu wywołania konstruktora tożsamości:

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

cs = CoordinateSystem.Identity();

Obiekty CoordinateSystem z transformacjami geometrycznymi wykraczają poza zakres tego rozdziału, choć warto wspomnieć, że inny konstruktor umożliwia utworzenie układu współrzędnych w określonym punkcie: CoordinateSystem.ByOriginVectors:

// 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

Najprostszym geometrycznym obiektem elementarnym jest punkt (Point), reprezentujący położenie zero-wymiarowe w przestrzeni trójwymiarowej. Jak wspomniano wcześniej, istnieje kilka sposobów utworzenia punktu w konkretnym układzie współrzędnych: Point.ByCoordinates tworzy punkt o określonych współrzędnych x, y i z; Point.ByCartesianCoordinates tworzy punkt z określonymi współrzędnymi x, y i z w określonym układzie współrzędnych; Point.ByCylindricalCoordinates tworzy punkt leżący na walcu o danych promieniu, kącie obrotu i wysokości; a Point.BySphericalCoordinates tworzy punkt leżący na sferze o danych promieniu i dwóch kątach obrotu.

W tym przykładzie przedstawiono punkty utworzone w różnych układach współrzędnych:

// 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);

Linia

Kolejnym obiektem elementarnym wyższego wymiaru w dodatku Dynamo jest segment linii reprezentujący nieskończoną liczbę punktów między dwoma punktami końcowymi. Linie można tworzyć przez jawne określenie dwóch punktów obwiedni za pomocą konstruktora Line.ByStartPointEndPoint lub przez określenie punktu początkowego, kierunku i długości w tym kierunku: 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);

Obiekty elementarne 3D — prostopadłościan, stożek, walec, kula itp.

Dodatek Dynamo zawiera obiekty reprezentujące najbardziej podstawowe typy geometrycznych obiektów elementarnych w trzech wymiarach: prostopadłościany, tworzone za pomocą Cuboid.ByLengths; stożki tworzone za pomocą Cone.ByPointsRadius i Cone.ByPointsRadii; walce tworzone za pomocą Cylinder.ByRadiusHeight; oraz sfery tworzone za pomocą 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);

Niektóre obiekty geometrii mogą być tworzone przez jawne podanie współrzędnych x, y i z w przestrzeni trójwymiarowej. Jednak częściej geometria jest przesuwana do jej położenia końcowego za pomocą transformacji geometrycznych samego obiektu lub jego źródłowego obiektu CoordinateSystem.

Tłumaczenie

Najprostszą transformacją geometryczną jest przekształcenie, które przesuwa obiekt o określoną liczbę jednostek w kierunkach x, y i z.

// 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);

Obrót

Mimo że wszystkie obiekty w dodatku Dynamo mogą być przekształcane przez dołączenie metody .Translate do końca nazwy obiektu, bardziej złożone transformacje wymagają przekształcenia obiektu z jednego źródłowego obiektu CoordinateSystem do nowego. Aby na przykład obrócić obiekt o 45 stopni wokół osi x, przekształcilibyśmy obiekt z jego istniejącego obiektu CoordinateSystem bez obrotu do obiektu CoordinateSystem, który został obrócony o 45 stopni wokół osi x za pomocą metody .Transform:

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);

Skala

Poza przekształcaniem i obróceniem obiekty CoordinateSystem można również tworzyć skalowane i ścięte. Obiekt CoordinateSystem może być skalowany za pomocą metody .Scale:

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);

Ścięte obiekty CoordinateSystem tworzy się przez przekazanie wektorów nieortogonalnych do konstruktora CoordinateSystem.

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);

Skalowanie i ścinanie to względnie bardziej skomplikowane transformacje geometryczne niż obrót i przekształcenie, więc nie każdy obiekt Dynamo może je przejść. W poniższej tabeli przedstawiono ogólnie, które obiekty Dynamo mogą mieć niejednorodnie skalowane obiekty CoordinateSystem i ścięte obiekty CoordinateSystem.

Dwuwymiarowym odpowiednikiem krzywej NurbsCurve jest powierzchnia NurbsSurface. Tak jak krzywą NurbsCurve o dowolnym kształcie powierzchnię NurbsSurface można skonstruować za pomocą dwóch podstawowych metod: wstawienie zestawu punktów bazowych i interpolacja przestrzeni między nimi w dodatku Dynamo oraz jawne określenie punktów kontrolnych powierzchni. Podobnie jak krzywe swobodne powierzchnie interpolowane są przydatne, gdy projektant dokładnie wie, jaki kształt musi przyjąć powierzchnia, lub jeśli projekt wymaga, aby powierzchnia przechodziła przez określone punkty. Z drugiej strony powierzchnie utworzone przez punkty kontrolne mogą być bardziej użyteczne w projektach z analizą różnych poziomów wygładzania.

Powierzchnia interpolowana

Aby utworzyć powierzchnię interpolowaną, wystarczy wygenerować dwuwymiarową kolekcję punktów przybliżających kształt powierzchni. Kolekcja musi być prostokątna, czyli nieposzarpana. Metoda NurbsSurface.ByPoints tworzy powierzchnię z tych punktów.

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

surf = NurbsSurface.ByPoints(python_points_1);

Powierzchnia punktów kontrolnych

Swobodne powierzchnie NurbsSurface można również tworzyć przez określenie źródłowych punktów kontrolnych powierzchni. Podobnie jak w przypadku krzywych NurbsCurve punkty kontrolne reprezentują czworokątną siatkę z prostymi segmentami, które w zależności od stopnia powierzchni są wygładzane do końcowej postaci powierzchni. Aby utworzyć powierzchnię NurbsSurface za pomocą punktów kontrolnych, należy przekazać dwa dodatkowe parametry dla metody NurbsSurface.ByPoints, wskazując stopnie krzywych źródłowych w obu kierunkach powierzchni.

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

// create a surface of degree 2 with smooth segments
surf = NurbsSurface.ByPoints(python_points_1, 2, 2);

Można zwiększyć stopień powierzchni NurbsSurface, aby zmienić wynikową geometrię powierzchni:

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

// create a surface of degree 6
surf = NurbsSurface.ByPoints(python_points_1, 6, 6);

Powierzchnia wyciągnięcia

Powierzchnie mogą być tworzone nie tylko przez interpolację między punktami z zestawu wejściowego — mogą one być też tworzone przez interpolację między zestawem krzywych bazowych. Jest to nazywane wyciągnięciem złożonym. Krzywa wyciągnięta jest tworzona za pomocą konstruktora Surface.ByLoft z kolekcją krzywych wejściowych jako jedynym parametrem.

// python_points_2, 3, and 4 are generated with
// Python scripts found in Chapter 12, Section 10

c1 = NurbsCurve.ByPoints(python_points_2);
c2 = NurbsCurve.ByPoints(python_points_3);
c3 = NurbsCurve.ByPoints(python_points_4);

loft = Surface.ByLoft([c1, c2, c3]);

Obrót powierzchni

Powierzchnie obrotu są dodatkowym typem powierzchni tworzonym przez przeciągnięcie krzywej bazowej wokół osi środkowej. Jeśli powierzchnie interpolowane są dwuwymiarowym odpowiednikiem krzywych interpolowanych, powierzchnie obrotu są dwuwymiarowym odpowiednikiem okręgów i łuków.

Powierzchnie obrotu są określone przez krzywą bazową reprezentującą „krawędź” powierzchni; początek osi, punkt bazowy powierzchni; kierunek osi, „główny” kierunek środkowy; kąt początkowy przeciągnięcia; kąt końcowy przeciągnięcia. Są one używane jako dane wejściowe konstruktora Surface.Revolve.

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, 0,
    360);

Wiele z dotychczasowych przykładów koncentrowało się na konstruowaniu geometrii wyższych wymiarów z obiektów niższych wymiarów. Metody przecięcia umożliwiają generowanie obiektów niższych wymiarów za pomocą geometrii wyższych wymiarów, natomiast polecenia ucinania i ucinania selektywnego umożliwiają skryptowi znaczne modyfikowanie form geometrycznych po ich utworzeniu.

Metoda Intersect jest zdefiniowana dla wszystkich elementów geometrii w dodatku Dynamo, co oznacza, że teoretycznie każdy element geometrii może zostać przecięty za pomocą dowolnego innego elementu geometrii. Naturalnie niektóre przecięcia są bez znaczenia, na przykład przecięcia z punktami, ponieważ obiekt wynikowy będzie zawsze punktem wejściowym. Pozostałe możliwe kombinacje przecięć między obiektami zostały przedstawione w poniższym zestawieniu. W poniższej tabeli przedstawiono wyniki różnych operacji przecięcia:

Intersect

Poniższy bardzo prosty przykład przedstawia przecięcie płaszczyzny z powierzchnią NurbsSurface. To przecięcie generuje szyk NurbsCurve, który może być używany jak każdy inny obiekt NurbsCurve.

// 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);

Metoda Trim jest bardzo podobna do metody Intersect pod tym względem, że jest zdefiniowana dla niemal każdego elementu geometrii. Jednak dla metody Trim istnieje znacznie więcej ograniczeń niż dla metody Intersect.

Trim

W przypadku metod Trim warto pamiętać o wymaganiu punktu „wyboru”, określającego, która geometria zostanie odrzucona, a które elementy zostaną zachowane. Dodatek Dynamo znajduje i odrzuca uciętą geometrię najbliżej wybranego punktu.

// 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);

Obiekty w projektach obliczeniowych rzadko są tworzone jawnie w końcowym położeniu i formie. Najczęściej są przekształcane, obracane i umieszczane w oparciu o istniejącą geometrię. Matematyka wektorowa służy jako rodzaj geometrycznego rusztowania pozwalającego nadać geometrii kierunek i orientację, jak również do konceptualizowania ruchów w przestrzeni 3D bez reprezentacji wizualnej.

Podstawowy wektor reprezentuje położenie w przestrzeni 3D i zwykle jest uważany za punkt końcowy strzałki od położenia (0, 0, 0) do położenia grotu. Wektory mogą być tworzone za pomocą konstruktora ByCoordinates po podaniu położenia x, y i z nowo utworzonego obiektu wektora. Należy zauważyć, że obiekty wektorów nie są obiektami geometrycznymi i nie pojawiają się w oknie dodatku Dynamo. Jednak w oknie konsoli można wyświetlić informacje o nowo utworzonym lub zmodyfikowanym wektorze:

// construct a Vector object
v = Vector.ByCoordinates(1, 2, 3);

s = v.X + " " + v.Y + " " + v.Z;

Dla obiektów wektorów zdefiniowany jest zestaw operacji matematycznych umożliwiający dodawanie, odejmowanie, mnożenie i w inny sposób przenoszenie obiektów w przestrzeni 3D, podobnie jak w przypadku przesuwania rzeczywistych liczb w przestrzeni jednowymiarowej na oznaczonej liczbami linii.

Dodawanie wektorów

Dodawanie wektorów jest zdefiniowane jako suma składników dwóch wektorów i może być traktowane jako wektor wynikowy, jeśli dwie składowe strzałki wektorów stykają się „grotem do końcówki”. Dodawanie wektorów odbywa się za pomocą metody Add i jest przedstawione za pomocą wykresu po lewej stronie.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 9, y = 6, z = 0
c = a.Add(b);

Odejmowanie wektorów

Podobnie dwa obiekty wektorów można od siebie odjąć za pomocą metody Substract. Odejmowanie wektorów może być traktowane jako kierunek od pierwszego wektora do drugiego wektora.

a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 1, y = 4, z = 0
c = a.Subtract(b);

Mnożenie wektorów

Mnożenie wektorów może być traktowane jako przesuwanie punktu końcowego wektora w jego własnym kierunku z danym współczynnikiem skalowania.

a = Vector.ByCoordinates(4, 4, 0);

// c has value x = 20, y = 20, z = 0
c = a.Scale(5);

Normalizowanie długości wektora

Często podczas skalowania wektora wymagane jest uzyskanie długości wynikowego wektora dokładnie równej wielkości skalowanej. Można to łatwo osiągnąć przez najpierw znormalizowanie wektora, czyli ustawienie długości wektora równej dokładnie jeden.

a = Vector.ByCoordinates(1, 2, 3);
a_len = a.Length;

// set the a's length equal to 1.0
b = a.Normalized();
c = b.Scale(5);

// len is equal to 5
len = c.Length;

c nadal wskazuje w tym samym kierunku co a (1, 2, 3), ale teraz ma długość dokładnie równą 5.

Iloczyn wektorowy

Istnieją dwie dodatkowe metody w matematyce wektorowej, które nie mają wyraźnych odpowiedników w matematyce jednowymiarowej: iloczyn wektorowy i iloczyn skalarny. Iloczyn wektorowy to metoda generowania wektora, który jest prostopadły (jest pod kątem 90 stopni) do dwóch istniejących wektorów. Na przykład wynikiem iloczynu wektorowego osi x i y jest oś z, chociaż dwa wektory wejściowe nie muszą być do siebie prostopadłe. Wektor będący wynikiem iloczynu wektorowego jest obliczany za pomocą metody Cross.

a = Vector.ByCoordinates(1, 0, 1);
b = Vector.ByCoordinates(0, 1, 1);

// c has value x = -1, y = -1, z = 1
c = a.Cross(b);

Iloczyn skalarny

Dodatkowa, choć nieco bardziej zaawansowana funkcja matematyki wektorowej, to iloczyn skalarny. Iloczyn skalarny dwóch wektorów jest liczbą rzeczywistą (nie obiektem wektora), która odnosi się do, ale nie jest dokładnie kątem między dwoma wektorami. Jedną z przydatnych właściwości iloczynu skalarnego jest to, że ma on wartość 0 wtedy i tylko wtedy, gdy mnożone wektory są prostopadłe. Iloczyn skalarny jest obliczany za pomocą metody Dot.

a = Vector.ByCoordinates(1, 2, 1);
b = Vector.ByCoordinates(5, -8, 4);

// d has value -7
d = a.Dot(b);

W projektach obliczeniowych krzywe i powierzchnie są często używane jako rusztowanie źródłowe do konstruowania kolejnej geometrii. Aby ta wczesna geometria mogła być używana jako fundament późniejszej geometrii, skrypt musi być w stanie wyodrębnić cechy, takie jak położenie i orientacja, z całej powierzchni obiektu. Zarówno krzywe, jak i powierzchnie obsługują to wyodrębnianie. Nazywa się to parametryzacją.

Wszystkie punkty na krzywej można uznać za mające niepowtarzalny parametr z zakresu od 0 do 1. Jeśli chcemy utworzyć krzywą NurbsCurve w oparciu o kilka punktów kontrolnych lub punktów interpolowanych, pierwszy punkt miałby parametr 0, a ostatni punkt — parametr 1. Nie można wcześniej ustalić, jaką dokładnie wartość ma parametr dowolnego z punktów pośrednich, co może wydawać się ograniczeniem, ale jest to nieco równoważone przez szereg funkcji narzędziowych. Powierzchnie mają podobną parametryzację jak krzywe, ale mają dwa parametry zamiast jednego: u i v. Jeśli zechcemy utworzyć powierzchnię z następującymi punktami:

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

p1 ma parametry u = 0 v = 0, natomiast p9 ma parametry u = 1 v = 1.

Parametryzacja nie jest szczególnie przydatna podczas określania punktów używanych do generowania krzywych. Jej głównym zastosowaniem jest określenie położeń punktów pośrednich generowanych przez konstruktory krzywych NurbsCurve i powierzchni NurbsSurface.

Krzywe mają metodę PointAtParameter, która przyjmuje pojedynczy argument podwójny z zakresu od 0 do 1 i zwraca obiekt punktu o tym parametrze. Na przykład ten skrypt wyszukuje punkty o parametrach 0, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9 i 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));

Podobnie w przypadku powierzchni istnieje metoda PointAtParameter, która pobiera dwa argumenty — parametry u i v generowanego punktu.

Wyodrębnianie poszczególnych punktów na krzywej i powierzchni może być przydatne, ale skrypty często wymagają znajomości konkretnych cech geometrycznych przy danym parametrze, na przykład określających, w jakim kierunku skierowana jest krzywa lub powierzchnia. Metoda CoordinateSystemAtParameter umożliwia nie tylko znalezienie położenia, ale również zorientowanego obiektu CoordinateSystem przy danym parametrze krzywej lub powierzchni. Na przykład poniższy skrypt wyodrębnia zorientowane obiekty CoordinateSystem wzdłuż obróconej powierzchni i używa orientacji obiektów CoordinateSystem do generowania linii, które są przylegające prostopadle do powierzchni:

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));

Jak wspomniano wcześniej, parametryzacja nie zawsze jest jednorodna na całej długości krzywej lub powierzchni, co oznacza, że parametr 0,5 nie zawsze odpowiada punktowi środkowemu, a 0,25 nie zawsze odpowiada punktowi w jednej czwartej odległości wzdłuż krzywej lub powierzchni. Aby można było obejść to ograniczenie, krzywe mają dodatkowy zestaw poleceń parametryzacji, które umożliwiają znalezienie punktu na określonych długościach wzdłuż krzywej.

Metody Intersect, Trim i SelectTrim są używane przede wszystkim na geometriach niższych wymiarów, takich jak punkty, krzywe i powierzchnie. Natomiast geometria brył ma dodatkowy zestaw metod do modyfikowania postaci po jej utworzeniu, zarówno przez odjęcie materiału w sposób podobny do zastosowania metody Trim, jak i przez połączenie elementów w celu utworzenia większej części.

Union

Metoda Union pobiera dwa obiekty brył i tworzy pojedynczy obiekt bryły z przestrzeni objętej tymi dwoma obiektami. Przestrzeń wspólna między obiektami jest łączona w postać końcową. W tym przykładzie kula i prostopadłościan łączą się w pojedynczy kształt bryły złożonej z kuli i sześcianu:

Difference

Metoda Difference, podobnie jak metoda Trim, odejmuje zawartość bryły wejściowej od bryły bazowej. W tym przykładzie tworzymy małe wcięcie w sferze:

Intersect

Metoda Intersect zwraca bryłę wspólną między dwiema bryłami wejściowymi. W poniższym przykładzie metodę Difference zmieniono na metodę Intersect, a wynikowa bryła to brakująca wcześniej wycięta pustka:

Poniższe skrypty w języku Python generują szyki punktów dla kilku przykładów. Powinny zostać wklejone do węzła skryptu w języku Python w następujący sposób:

python_points_1

python_points_2

python_points_3

python_points_4

python_points_5