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.

// copy this code into a Code Block
// to start writing DesignScript

x = "Let's create some geometry!";

Python i Revit

Zaprezentowaliśmy, jak używać skryptów w języku Python w dodatku Dynamo. Przyjrzyjmy się teraz połączeniu bibliotek programu Revit w środowisku skryptowym. Za pomocą czterech pierwszych wierszy bloku kodu poniżej zaimportowaliśmy węzły podstawowe dodatku Dynamo i standardowe elementy języka Python. Aby zaimportować węzły programu Revit, elementy programu Revit oraz menedżera dokumentów programu Revit, wystarczy tylko dodać kilka innych wierszy:

import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit

# Import Revit elements
from Revit.Elements import *

# Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager

import System

Zapewnia to dostęp do interfejsu API programu Revit i obsługę skryptów niestandardowych dla dowolnego zadania programu Revit. Połączenie programowania wizualnego z obsługą skryptów z użyciem interfejsu API programu Revit znacznie usprawnia współpracę i opracowywanie narzędzi. Na przykład menedżer BIM i projektant schematów mogą współpracować na tym samym wykresem. W ramach tej współpracy mogą poprawić projekt i realizację modelu.

Interfejsy API dla konkretnych platform

Zadaniem projektu Dynamo jest poszerzenie zakresu wdrożeń na platformach. W miarę dodawania do wykazu dodatku Dynamo kolejnych programów użytkownicy uzyskują dostęp do interfejsów API dla konkretnych platform ze środowiska obsługi skryptów w języku Python. Mimo że w tej sekcji analizujemy program Revit, przewidujemy przygotowanie w przyszłości kolejnych rozdziałów, które będą zawierać kompleksowe samouczki dotyczące tworzenia skryptów na innych platformach. Ponadto dostępnych jest teraz wiele bibliotek IronPython, które można importować do dodatku Dynamo.

Poniższe przykłady ilustrują sposoby implementowania operacji specyficznych dla programu Revit z dodatku Dynamo za pomocą języka Python. Aby zapoznać się z bardziej szczegółowym omówieniem powiązania języka Python z dodatkiem Dynamo i programem Revit, zobacz stronę wiki dodatku Dynamo. Innym przydatnym zasobem dla języka Python i programu Revit jest projekt Revit Python Shell.

Ćwiczenie 1

Utwórz nowy projekt programu Revit.

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

W tych ćwiczeniach omówimy podstawowe skrypty w języku Python w dodatku Dynamo dla programu Revit. W tym ćwiczeniu zostanie omówione postępowanie z plikami i elementami programu Revit oraz komunikacja między programem Revit i dodatkiem Dynamo.

Jest to oczywista metoda pobierania pozycji doc, uiapp i app pliku programu Revit połączonego z sesją dodatku Dynamo. Programiści, którzy już wcześniej pracowali w interfejsie API programu Revit, mogą zauważyć te elementy na liście obserwowanych. Jeśli te elementy nie wyglądają znajomo, nie ma problemu. W ćwiczeniach poniżej będziemy korzystać z innych przykładów.

W ten sposób importujemy usługi programu Revit i pobieramy dane dokumentów w dodatku Dynamo.

Przyjrzyj się węzłowi Python w dodatku Dynamo. Można również skorzystać z kodu z poniższego materiału:

# Load the Python Standard and DesignScript Libraries
import sys
import clr

#Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager

#Place your code below this line
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application

#Assign your output to the OUT variable
OUT = [doc,uiapp,app]

Ćwiczenie 2

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

W tym ćwiczeniu utworzymy prostą krzywą modelu w programie Revit za pomocą węzła Dynamo w języku Python.

Rozpocznij od utworzenia nowej rodziny brył koncepcyjnych w programie Revit.

Otwórz folder Conceptual Mass i użyj pliku szablonu Metric Mass.rft.

W programie Revit użyj skrótu klawiaturowego un, aby wywołać ustawienia jednostki projektu, a następnie zmień jednostkę długości na metry.

Uruchom dodatek Dynamo i utwórz zestaw węzłów na ilustracji poniżej. Najpierw utworzymy dwa punkty odniesienia w programie Revit z węzłów Dynamo.

1. Utwórz węzeł Code Block i nadaj mu wartość "0;"

2. Podłącz tę wartość do węzła ReferencePoint.ByCoordinates dla wejść X, Y i Z.

3. Utwórz trzy suwaki o zakresach od -100 do 100 i kroku o wartości 1.

4. Połącz każdy suwak z węzłem ReferencePoint.ByCoordinates.

5. Dodaj węzeł Python do obszaru roboczego, kliknij przycisk „+” na węźle, aby dodać kolejne wejście, i podłącz dwa punkty odniesienia do każdego wejścia. Otwórz węzeł Python.

Przyjrzyj się węzłowi Python w dodatku Dynamo. Pełny kod podano poniżej.

1. System.Array: program Revit wymaga jako wejścia szyku systemowego (a nie listy języka Python). To jeden więcej wiersz kodu, ale zwracanie uwagi na typy argumentów ułatwia programowanie w języku Python w programie Revit.

import sys
import clr

# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
#Import Revit elements
from Revit.Elements import *
import System

#define inputs
startRefPt = IN[0]
endRefPt = IN[1]

#define system array to match with required inputs
refPtArray = System.Array[ReferencePoint]([startRefPt, endRefPt])

#create curve by reference points in Revit
OUT = CurveByPoints.ByReferencePoints(refPtArray)

W dodatku Dynamo utworzyliśmy za pomocą języka Python dwa punkty odniesienia z łączącą je linią. W następnym ćwiczeniu rozwiniemy to.

Ćwiczenie 3

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

To ćwiczenie jest proste, ale pozwala wyjaśnić tematy łączenia danych i geometrii z programu Revit do dodatku Dynamo i odwrotnie. Zacznijmy od otwarcia pliku Revit-StructuralFraming.rvt. Po jego otwarciu uruchom dodatek Dynamo i otwórz plik Revit-StructuralFraming.dyn.

Ten plik programu Revit jest tak prosty, jak to tylko możliwe. Dwie krzywe odniesienia: jedna narysowana na poziomie 1, a druga na poziomie 2. Chcemy umieścić te krzywe w dodatku Dynamo i utrzymać aktywne połączenie.

W tym pliku znajduje się zestaw węzłów podłączonych do pięciu wejść węzła w języku Python.

1. Wybierz węzły elementów modelu: naciśnij przycisk wyboru dla każdego z nich i wybierz odpowiednią krzywą w programie Revit.

2. Code Block: za pomocą składni 0..1..#x;, połącz suwak liczby całkowitej o zakresie od 0 do 20 z wejściem x. Ta opcja określa liczbę belek do narysowania między dwiema krzywymi.

3. Typy ram konstrukcyjnych: z menu rozwijanego wybierzemy domyślną belkę W12x26.

4. Poziomy: wybierz „Poziom 1”.

Ten kod Python jest nieco gęściejszy, ale komentarze znajdujące się w kodzie oddają to, co się dzieje w tym procesie

import clr
#import Dynamo Geometry
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
# Import Revit elements
from Revit.Elements import *
import System

#Query Revit elements and convert them to Dynamo Curves
crvA=IN[0].Curves[0]
crvB=IN[1].Curves[0]

#Define input Parameters
framingType=IN[3]
designLevel=IN[4]

#Define "out" as a list
OUT=[]

for val in IN[2]:
	#Define Dynamo Points on each curve
	ptA=Curve.PointAtParameter(crvA,val)
	ptB=Curve.PointAtParameter(crvB,val)
	#Create Dynamo line
	beamCrv=Line.ByStartPointEndPoint(ptA,ptB)
	#create Revit Element from Dynamo Curves
	beam = StructuralFraming.BeamByCurve(beamCrv,designLevel,framingType)
	#convert Revit Element into list of Dynamo Surfaces
	OUT.append(beam.Faces)

W programie Revit mamy szyk belek obejmujący dwie krzywe jako elementy konstrukcyjne. Uwaga: nie jest to realistyczny przykład — elementy konstrukcyjne są używane jako przykład dla natywnych wystąpień programu Revit utworzonych z dodatku Dynamo.

Również w dodatku Dynamo można wyświetlić wyniki. Belki w węźle Watch3D odnoszą się do geometrii przywołanej z elementów programu Revit.

Warto zauważyć, że mamy ciągły proces przekształcania danych ze środowiska programu Revit do środowiska dodatku Dynamo. Podsumowując: oto przebieg tego procesu:

1. Wybierz element programu Revit

2. Przekształć element programu Revit w krzywą Dynamo

3. Podziel krzywą Dynamo na serię punktów Dynamo

4. Użyj punktów Dynamo między dwiema krzywymi, aby utworzyć linie Dynamo

5. Utwórz belki programu Revit przez odniesienie do linii Dynamo

6. Wygeneruj wyjściowe powierzchnie Dynamo przez zastosowanie zapytania do geometrii belek programu Revit

Może to wydawać się nieco skomplikowane, ale skrypt sprawia, że wystarczy edytować krzywą w programie Revit i ponownie uruchomić solwer (chociaż może być konieczne usunięcie poprzednich belek). Jest to spowodowane faktem, że umieszczamy belki za pomocą języka Python, przez co przerywamy powiązanie węzłów OOTB.

Po zaktualizowaniu krzywych odniesienia w programie Revit uzyskuje się nowy szyk belek.

Bloki kodu zapewniają głęboki wgląd w język DesignScript, czyli język programowania stanowiący rdzeń dodatku Dynamo. Język DesignScript, stworzony od podstaw do obsługi badawczych przepływów roboczych procesów projektowych, jest czytelny i zwięzły oraz zapewnia natychmiastową informację zwrotną dla małych fragmentów kodu, ale umożliwia też skalowanie do dużych i złożonych interakcji. Język DesignScript stanowi też fundament mechanizmu sterującego większością zaplecza dodatku Dynamo. Fakt, że prawie wszystkie funkcje dostępne w węzłach i interakcjach dodatku Dynamo mają relację „jeden do jednego” z językiem skryptów, zapewnia niepowtarzalne możliwości płynnego przechodzenia między interakcjami opartymi na węzłach a stosowaniem skryptów.

W przypadku użytkowników początkujących węzły mogą być automatycznie przekształcane w składnię tekstową, co pomaga w nauce języka DesignScript, a także po prostu zmniejsza rozmiar większych części wykresów. Do tego celu służy proces o nazwie „Konwersja węzłów na kod”, który jest szczegółowo opisany w sekcji Składnia języka DesignScript. Bardziej doświadczeni użytkownicy mogą używać bloków kodu do tworzenia własnych połączeń istniejących funkcji oraz samodzielnie utworzonych relacji za pomocą wielu standardowych paradygmatów kodowania. Zarówno początkujący, jak i zaawansowani użytkownicy znajdą wiele przydatnych skrótów i fragmentów kodu, które przyspieszają pracę nad projektami. Chociaż termin „blok kodu” może wywoływać nieco niepokoju u użytkowników, którzy nie są programistami, jest to łatwe w obsłudze i niezawodne narzędzie. Początkujący użytkownik może efektywnie używać bloku kodu przy minimalnym kodowaniu, a zaawansowany użytkownik może tworzyć definicje skryptowe, które będą przywoływane w innych miejscach definicji dodatku Dynamo.

Węzeł Code Block: krótkie omówienie

W skrócie: bloki kodu są interfejsem skryptów tekstowych w środowisku skryptów wizualnych. Mogą one być używane jako liczby, ciągi, formuły i inne typy danych. Funkcję bloku kodu zaprojektowano dla dodatku Dynamo, więc można definiować w bloku kodu dowolne zmienne, które będą automatycznie dodawane do wejść węzła:

Bloki kodu pozwalają użytkownikowi elastycznie decydować, w jaki sposób będą określane dane wejściowe. Oto kilka różnych sposobów na ustawienie podstawowego punktu o współrzędnych (10, 5, 0):

Po poznaniu większej liczby dostępnych funkcji w bibliotece użytkownik może nawet stwierdzić, że wpisanie „Point.ByCoordinates” jest szybsze niż wyszukanie odpowiedniego węzła w bibliotece. Na przykład po wpisaniu „Point.” w dodatku Dynamo zostanie wyświetlona lista funkcji, które można zastosować do punktu. Dzięki temu tworzenie skryptów jest bardziej intuicyjne. Pomaga to też w nauce stosowania funkcji w dodatku Dynamo.

Tworzenie węzłów bloku kodu — Code Block

Blok kodu (Code Block) można znaleźć w sekcji Podstawowe > Dane wejściowe > Operacje > Code Block. Jeszcze szybciej: wystarczy kliknąć dwukrotnie obszar rysunku, a zostanie wyświetlony blok kodu. Ten węzeł jest używany tak często, że przypisano do niego funkcję dwukrotnego kliknięcia.

Liczby, ciągi i formuły

Bloki kodu są również elastyczne pod względem typów danych. Użytkownik może szybko definiować liczby, ciągi i formuły, a blok kodu zapewni żądane wyniki.

Na poniższej ilustracji pokazano „stary” i nieco pracochłonny sposób realizacji zadania: użytkownik wyszukuje węzeł w interfejsie, dodaje go do obszaru rysunku, a następnie wprowadza dane. Za pomocą bloku kodu użytkownik może kliknąć dwukrotnie obszar rysunku, aby pojawił się węzeł, i wpisać właściwy typ danych za pomocą podstawowej składni.

Number, String i Formula to trzy przykłady węzłów Dynamo, które są najprawdopodobniej przestarzałe w porównaniu z węzłem Code Block.

1. Rozwiązanie tradycyjne

2. Węzły Code Block

W bloku kodu można tworzyć funkcje, a następnie można je ponownie wywoływać w innym miejscu w definicji dodatku Dynamo. Powoduje to utworzenie innej warstwy sterującej w pliku parametrycznym. Można to postrzegać jako wersję tekstową węzła niestandardowego. W tym przypadku „nadrzędny” blok kodu jest łatwo dostępny i może być umieszczony w dowolnym miejscu na wykresie. Nie są potrzebne żadne przewody.

Parent

Pierwszy wiersz zawiera słowo kluczowe „def”, następnie nazwę funkcji, a następnie nazwy danych wejściowych w nawiasach. Klamry definiują treść funkcji. Wartość jest zwracana za pomocą instrukcji „return =”. Bloki kodu, które definiują funkcję, nie mają portów wejściowych ani wyjściowych, ponieważ są wywoływane z innych bloków kodu.

/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Podrzędne

Wywołaj funkcję w innym bloku kodu w tym samym pliku przez podanie nazwy i takiej samej liczby argumentów. Działa to tak jak w przypadku gotowych węzłów w bibliotece.

FunctionName(in1,in2);

Ćwiczenie: kula według osi Z

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

W tym ćwiczeniu zostanie utworzona ogólna definicja, która utworzy sfery z wejściowej listy punktów. Promień tych sfer zależy od właściwości Z każdego punktu.

Zacznijmy od przedziału liczbowego dziesięciu wartości z zakresu od 0 do 100. Podłącz je do węzłów Point.ByCoordinates, aby utworzyć linię przekątną.

Utwórz węzeł Code Block i wprowadź naszą definicję.

1. Użyj następujących wierszy kodu:

   Copy

   def sphereByZ(inputPt)
   {
   
   };

inputPt to nazwa, którą nadaliśmy reprezentacji punktów sterujących funkcją. Na razie funkcja niczego nie robi, ale w kolejnych krokach ją skonstruujemy.

1. Dodając elementy do funkcji Code Block, umieścimy komentarz i zmienną sphereRadius, która wysyła zapytanie o położenie Z każdego punktu. Pamiętaj, że inputPt.Z nie wymaga nawiasów jak metoda. Jest to zapytanie o właściwości istniejącego elementu, dlatego żadne dane wejściowe nie są konieczne:

Copy

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};

1. Teraz przypomnijmy sobie funkcję, którą utworzyliśmy w innym węźle Code Block. Jeśli dwukrotnie klikniemy obszar roboczy, aby utworzyć nowy węzeł Code Block, i wpiszemy sphereB, dodatek Dynamo zasugeruje zdefiniowaną przez nas wcześniej funkcję sphereByZ. Funkcja została dodana do biblioteki intellisense. To przydatne.

1. Teraz wywołamy tę funkcję i utworzymy zmienną o nazwie Pt, aby podłączyć punkty utworzone w poprzednich krokach:

   Copy

   sphereByZ(Pt)

2. Wszystkie wyjścia mają wartości null. Dlaczego tak jest? W definicji funkcji obliczamy zmienną sphereRadius, ale nie zdefiniowaliśmy, co funkcja powinna zwracać na wyjściu. Możemy to naprawić w następnym kroku.

1. Ważnym krokiem jest zdefiniowanie wyjścia funkcji przez dodanie wiersza return = sphereRadius; do funkcji sphereByZ.

2. Teraz na wyjściu węzła Code Block pojawiają się współrzędne Z każdego punktu.

Teraz utworzymy właściwe sfery, edytując funkcję nadrzędną.

1. Najpierw zdefiniujemy sferę za pomocą wiersza kodu: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);

2. Następnie zmienimy zwracaną wartość na sphere zamiast sphereRadius: return = sphere; To pozwoli nam uzyskać kilka gigantycznych sfer w podglądzie Dynamo.

1. Aby zwiększyć rozmiar tych sfer, zaktualizuj wartość sphereRadius dodając dzielnik: sphereRadius = inputPt.Z/20; Teraz możemy dostrzec osobne sfery i zrozumieć związek między wartością promienia a wartością Z.

1. W węźle Point.ByCoordinates tworzymy siatkę punktów, zmieniając skratowanie z Shortest List na Cross Product. Funkcja sphereByZ nadal w pełni działa, dlatego wszystkie punkty tworzą sfery z promieniami na podstawie wartości Z.

1. Aby przetestować rozwiązanie, podłączymy oryginalną listę liczb do wejść X węzła Point.ByCoordinates. Mamy teraz sześcian sfer.

2. Uwaga: jeśli obliczenia na komputerze trwają długo, spróbuj zmienić #10 na wartość typu #5.

Pamiętaj, że utworzona przez nas funkcja sphereByZ to funkcja ogólna, więc możemy przywołać helisę z wcześniejszej lekcji i zastosować do niej tę funkcję.

Ostatni krok: sterowanie współczynnikiem promienia za pomocą parametru zdefiniowanego przez użytkownika. Aby to zrobić, należy utworzyć nowe wejście dla tej funkcji, a także zastąpić dzielnik 20 parametrem.

1. Zaktualizuj definicję funkcji sphereByZ do postaci:

   Copy

   def sphereByZ(inputPt,radiusRatio)
   {
   //get Z Value, use it to drive radius of sphere
   sphereRadius=inputPt.Z/radiusRatio;
   //Define Sphere Geometry
   sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
   //Define output for function
   return sphere;
   };

2. Zaktualizuj podrzędne węzły Code Block, dodając do wejścia zmienną ratio: sphereByZ(Pt,ratio);. Podłącz suwak do nowo utworzonego wejścia węzła Code Block i zmieniaj rozmiar promieni na podstawie współczynnika promienia.

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”):

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

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

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

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

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:

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

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ę.

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

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.

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

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.

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

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

W nazwach węzłów w dodatku Dynamo można zauważyć wspólną cechę: w każdym węźle używana jest składnia „.” bez spacji. Jest tak dlatego, że tekst znajdujący się na górze każdego węzła odzwierciedla rzeczywistą składnię skryptów, a znak „.” (lub notacja kropkowa) oddziela element od metod, które możemy wywołać. W ten sposób można łatwo przekształcać skrypty wizualne w skrypty tekstowe.

Omawiając notację kropkową przez analogię, zobaczmy, co możemy zrobić z parametrycznym jabłkiem w dodatku Dynamo. Poniżej przedstawiono kilka metod, które zastosujemy do jabłka, zanim zdecydujemy się je zjeść. (Uwaga: to nie są rzeczywiste metody dodatku Dynamo):

Można się nie zgodzić, ale wyniki w powyższej tabeli wskazują, że to bardzo smaczne jabłko. Możemy zastosować do niego funkcję Apple.eat() (Jabłko.zjeść).

Notacja kropkowa w bloku kodu

Pamiętając o porównaniu z jabłkiem, przyjrzyjmy się węzłowi Point.ByCoordinates i zobaczmy, jak można utworzyć punkt za pomocą węzła Code Block.

Składnia Point.ByCoordinates(0,10); w węźle Code Block daje taki sam wynik jak węzeł Point.ByCoordinates w dodatku Dynamo, z tą różnicą, że umożliwia utworzenie punktu za pomocą jednego węzła. Jest to bardziej wydajne niż łączenie oddzielnego węzła ze współrzędnymi „X” i „Y”.

1. Używając polecenia Point.ByCoordinates w węźle Code Block, określamy dane wejściowe w takiej samej kolejności jak w gotowym węźle: (X,Y).

Wywoływanie węzłów — tworzenie, operacje, zapytanie

Można wywołać dowolny zwykły węzeł w bibliotece za pomocą węzła Code Block, o ile nie jest to specjalny węzeł interfejsu użytkownika, pełniący szczególną funkcję w interfejsie użytkownika. Można na przykład wywołać węzeł Circle.ByCenterPointRadius, ale wywołanie węzła Watch 3D nie miałoby sensu.

Zwykłe węzły (stanowiące większość biblioteki) należą do trzech ogólnych typów. Warto zauważyć, że biblioteka jest uporządkowana zgodnie z tymi kategoriami. Metody, czyli węzły, tych trzech typów są traktowane inaczej po wywołaniu w bloku kodu.

1. Create — umożliwiają utworzenie (lub konstruowanie) elementu.

2. Action — umożliwiają wykonywanie operacji na elementach.

3. Query — umożliwiają pobranie właściwości istniejącego elementu.

Tworzenie

Kategoria „Create” umożliwia tworzenie geometrii od podstaw. Wprowadzamy wartości w bloku kodu od lewej do prawej. Te dane wejściowe mają taką samą kolejność, jak elementy wejściowe węzła uporządkowane od góry do dołu.

Porównując węzeł Line.ByStartPointEndPoint i odpowiadającą mu składnię w węźle Code Block, otrzymujemy te same wyniki.

Działanie

Określa operację wykonywaną na obiekcie danego typu. W dodatku Dynamo do wykonywania operacji na obiekcie używana jest notacja kropkowa, wspólna dla wielu języków kodowania. Po wpisaniu obiektu wpisz kropkę, a następnie nazwę operacji. Dane wejściowe metod typu Action są umieszczane w nawiasach, podobnie jak w przypadku metod typu Create, z tym że nie trzeba określać pierwszego elementu wejściowego widocznego w odpowiednim węźle. Zamiast tego należy określić element, na którym wykonywana jest operacja:

1. Węzeł Point.Add stanowi węzeł typu Action, dlatego składnia nieco się różni.

2. Dane wejściowe to (1) point (punkt) i (2) vektor (wektor), który ma być do niego dodany. W węźle Code Block nazwaliśmy ten punkt (obiekt) „pt”. Aby dodać wektor o nazwie „vec” do punktu „pt”, należy napisać pt.Add(vec), czyli: obiekt, kropka, operacja. Operacja Add ma tylko jeden element wejściowy, czyli wszystkie elementy wejściowe węzła Point.Add z wyjątkiem pierwszego. Pierwszym elementem wejściowym węzła Point.Add jest sam punkt.

Zapytanie

Metody typu Query pobierają właściwość obiektu. Ponieważ sam obiekt jest elementem wejściowym, nie trzeba określać żadnych danych wejściowych. Nie są wymagane nawiasy.

A co ze skratowaniem?

Skratowanie w przypadku węzłów i bloków kodu nieco się różni. W przypadku węzłów użytkownik klika prawym przyciskiem myszy węzeł i wybiera opcję skratowania, którą chce zastosować. W bloku kodu użytkownik ma znacznie większą kontrolę nad strukturą danych. W krótkiej składni metody w węźle Code Block wykorzystuje się prowadnice replikacji do określenia, w jaki sposób połączyć w pary kilka jednowymiarowych list. Numery w nawiasach ostrych „<>” definiują hierarchię wynikowej listy zagnieżdżonej: <1>,<2>,<3> i tak dalej.

1. W tym przykładzie użyjemy krótkiej składni do zdefiniowania dwóch zakresów (więcej informacji na temat krótkiej składni przedstawiono w następnej sekcji tego rozdziału). Krótko mówiąc: 0..1; odpowiada {0,1}, a -3..-7 odpowiada {-3,-4,-5,-6,-7}. W wyniku tej operacji zostaną zwrócone listy 2 wartości x i 5 wartości y. Jeśli nie użyjemy prowadnic replikacji z tymi niedopasowanymi listami, otrzymamy listę dwóch punktów, ponieważ tyle wynosi długość najkrótszej listy. Za pomocą prowadnic replikacji można znaleźć wszystkie możliwe kombinacje 2 i 5 współrzędnych (czyli iloczyn wektorowy).

2. Użycie składni Point.ByCoordinates(x_vals<1>,y_vals<2>); umożliwia uzyskanie dwóch list, z których każda zawiera pięć elementów.

3. Użycie składni Point.ByCoordinates(x_vals<2>,y_vals<1>); umożliwia uzyskanie pięciu list, z których każda zawiera dwa elementy.

Przy tym zapisie możemy także określić, która lista będzie dominująca: 2 listy po 5 elementów czy 5 list po 2 elementy. W tym przykładzie zmiana kolejności prowadnic replikacji powoduje, że wynikiem jest lista wierszy punktów lub lista kolumn punktów w siatce.

Konwersja węzłów na kod

Chociaż przyzwyczajenie się do metod bloków kodu może wymagać trochę wysiłku, w dodatku Dynamo dostępna jest funkcja konwersji węzłów na kod, która to ułatwia. Aby użyć tej funkcji, wybierz szyk węzłów na wykresie dodatku Dynamo, kliknij prawym przyciskiem myszy obszar rysunku i wybierz opcję „Węzeł do kodowania”. Dodatek Dynamo połączy te węzły w blok kodu zawierający wszystkie dane wejściowe i wyjściowe. To nie tylko doskonałe narzędzie do poznawania bloków kodu, ale też sposób na uzyskanie bardziej wydajnych i parametrycznych wykresów dodatku Dynamo. Poniższe ćwiczenie wymaga użycia konwersji węzłów na kod, więc nie przegap tego.

Ćwiczenie: przyciąganie powierzchni

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

Aby pokazać możliwości bloków kodu, przekształcimy istniejącą definicję pola atraktorowego w formę bloków kodu. Praca z istniejącą definicją pokazuje powiązania między blokiem kodu a skryptami wizualnymi i ułatwia naukę składni języka DesignScript.

Rozpocznij od odtworzenia definicji z powyższego rysunku (lub otwarcia pliku przykładowego).

1. Zwróć uwagę, że skratowanie węzła Point.ByCoordinates zostało ustawione na iloczyn wektorowy.

2. Każdy punkt na siatce jest przesunięty w górę w kierunku Z na podstawie odległości od punktu odniesienia.

3. Po odtworzeniu i pogrubieniu powierzchni w geometrii powstaje wypukłość zależna od odległości od punktu odniesienia.

1. Najpierw zdefiniujmy punkt odniesienia: Point.ByCoordinates (x,y,0); Użyjemy tej samej składni Point.ByCoordinates jak ta widoczna w górnej części węzła tworzącego punkt odniesienia.

2. Zmienne x i y są wstawione do węzła Code Block, dzięki czemu można je dynamicznie aktualizować za pomocą suwaków.

3. Dodaj suwaki do wejść węzła Code Block mające zakres od –50 do 50. W ten sposób można objąć cały obszar domyślnej siatki dodatku Dynamo.

1. W drugim wierszu węzła Code Block zdefiniujemy skrót, który zastąpi węzeł sekwencji liczb: coordsXY = (-50..50..#11);Więcej informacji na ten temat podamy w następnej sekcji. Na razie wystarczy zauważyć, że ten skrót odpowiada węzłowi Number Sequence w skrypcie wizualnym.

1. Teraz chcemy utworzyć siatkę punktów na podstawie sekwencji coordsXY. W tym celu chcemy użyć składni Point.ByCoordinates, ale musimy też utworzyć iloczyn wektorowy listy w taki sam sposób, jak w skrypcie wizualnym. W tym celu należy wpisać wiersz: gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0); Nawiasy ostre oznaczają odniesienie do iloczynu wektorowego.

2. W węźle Watch 3D widać, że na siatce dodatku Dynamo znajduje się siatka punktów.

1. Teraz trudniejsza część: chcemy przesunąć siatkę punktów w górę na podstawie ich odległości od punktu odniesienia. Najpierw nazwiemy nowy zestaw punktów transPts. Ponieważ przekształcenie jest operacją na istniejącym elemencie, zamiast Geometry.Translate... użyjemy gridPts.Translate.

2. Odczytując węzeł na obszarze rysunku, widzimy, że zawiera on trzy elementy wejściowe. Geometria do przekształcenia jest już zadeklarowana, ponieważ wykonujemy operację na tym elemencie (za pomocą składni gridPts.Translate). Pozostałe dwie wartości wejściowe, direction i distance, wstawimy w nawiasach funkcji.

3. Kierunek jest łatwy do ustawienia — użyjemy składni Vector.ZAxis() do przesunięcia w pionie.

4. Należy też obliczyć odległość między punktem odniesienia a każdym punktem siatki, dlatego wykonamy operację dotyczącą punktu odniesienia w ten sam sposób: refPt.DistanceTo(gridPts)

5. Ostatni wiersz kodu pozwala uzyskać przekształcone punkty: transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));

1. Otrzymaliśmy siatkę punktów ze strukturą danych odpowiednią do utworzenia powierzchni NURBS. Konstruujemy powierzchnię, używając składni srf = NurbsSurface.ByControlPoints(transPts);

1. Na koniec dodamy do powierzchni głębię, tworząc bryłę przy użyciu składni solid = srf.Thicken(5); W tym przypadku pogrubiliśmy powierzchnię o 5 jednostek w kodzie, ale zawsze możemy zadeklarować tę wartość jako zmienną (na przykład o nazwie thickness) i określać ją suwakiem.

Upraszczanie wykresu dzięki konwersji węzłów na kod

Funkcja konwersji węzłów na kod umożliwia zautomatyzowanie całego ćwiczenia, które właśnie wykonaliśmy, jednym kliknięciem przycisku. Jest to nie tylko wydajny sposób tworzenia niestandardowych definicji i bloków kodu wielokrotnego użytku, ale również naprawdę przydatne narzędzie do nauki tworzenia skryptów w dodatku Dynamo:

1. Rozpocznij od istniejącego skryptu wizualnego z kroku 1. ćwiczenia. Wybierz wszystkie węzły, kliknij prawym przyciskiem myszy obszar rysunku i wybierz polecenie „Węzeł do kodowania”. To wystarczy.

W dodatku Dynamo została automatycznie utworzona tekstowa wersja wykresu graficznego, wraz ze skratowaniem i innymi elementami. Przetestuj tę funkcję na własnych skryptach wizualnych i wykorzystaj możliwości bloków kodu.

Blok kodu jest wyjątkową funkcją w dodatku Dynamo, która dynamicznie łączy środowisko programowania wizualnego ze środowiskiem tekstowym. Blok kodu zapewnia dostęp do wszystkich węzłów Dynamo i umożliwia zdefiniowanie całego wykresu w jednym węźle. Ten rozdział należy przeczytać uważnie, ponieważ blok kodu jest podstawowym składnikiem dodatku Dynamo.

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

Krótka składnia

W węźle Code Block dostępnych jest kilka podstawowych metod o krótkiej składni, które znacznie ułatwiają zarządzanie danymi. Podstawy zostały szczegółowo omówione poniżej. Wyjaśniamy też, jak za pomocą tej krótkiej składni można tworzyć dane i stosować do nich zapytania.

Dodatkowa składnia

Zakresy i sekwencje

Metoda definiowania zakresów i sekwencji może zostać zredukowana do krótkiej składni. Poniższa ilustracja przedstawia składnię „..”, która umożliwia definiowanie listy danych liczbowych za pomocą bloku kodu. Po zaznajomieniu się z tą notacją tworzenie danych liczbowych jest bardzo wydajnym procesem:

1. W tym przykładzie zakres liczb zostaje zastąpiony podstawową składnią węzła Code Block definiującą beginning..end..step-size;. Liczbowo będzie to: 0..10..1;

2. Warto zauważyć, że składnia 0..10..1; odpowiada 0..10; Wielkość kroku równa 1 jest domyślną wartością w krótkiej składni. Dlatego 0..10; daje sekwencję od 0 do 10 o kroku 1.

3. Przykład Sequence jest podobny, ale do ustawienia 15 wartości na liście używamy znaku „#” zamiast listy do 15. W tym przypadku definiujemy: beginning..#ofSteps..step-size: Rzeczywista składnia dla tej sekwencji to 0..#15..2

4. Używając znaku „#” z poprzedniego kroku, umieścimy go teraz w części „rozmiar-kroku” składni. Teraz mamy zakres liczb (Number Range) od początku „beginning” do końca „end” z ustalonym rozmiarem kroku „step-size”, co powoduje równomierne rozmieszczenie wartości między dwoma punktami: beginning..end..#ofSteps

Zakresy zaawansowane

Tworzenie zakresów zaawansowanych pozwala na łatwe korzystanie z listy list. W poniższych przykładach wyodrębniamy zmienną z notacji zakresu głównego i tworzymy inny zakres tej listy.

1. Tworząc zakresy zagnieżdżone, porównaj notację z „#” z notacją bez tego znaku. Zastosowanie ma ta sama logika co w zakresach podstawowych, choć rozwiązanie jest nieco bardziej złożone.

2. Możemy zdefiniować zakres podrzędny w dowolnym miejscu w zakresie głównym i możemy też używać dwóch zakresów podrzędnych.

3. Sterując wartością „końca” w zakresie, tworzymy więcej zakresów o różnych długościach.

W ramach ćwiczenia logicznego porównaj dwie wersje krótkiej składni i spróbuj przeanalizować, w jaki sposób zakresy podrzędne i notacja # wpływają na wynik na wyjściu.

Tworzenie list i pobieranie elementów z listy

Poza tworzeniem list za pomocą krótkiej składni możemy również tworzyć listy na bieżąco. Te listy mogą zawierać szeroki zakres typów elementów i można stosować do nich zapytania (należy pamiętać, że listy to także obiekty). Podsumowując: blok kodu pozwala tworzyć listy i stosować zapytania o elementy z listy za pomocą nawiasów kwadratowych:

1. Szybko twórz listy za pomocą ciągów i stosuj do nich zapytania, korzystając z indeksu elementu.

2. Twórz listy ze zmiennymi i stosuj do nich zapytania za pomocą notacji krótkiej składni zakresu.

Zarządzanie z listami zagnieżdżonymi jest podobnym procesem. Pamiętaj o kolejności listy i o korzystaniu z wielu zestawów nawiasów kwadratowych:

1. Zdefiniuj listę list.

2. Zastosuj zapytanie do listy za pomocą notacji z jedną parą nawiasów kwadratowych.

3. Zastosuj zapytanie do elementu za pomocą notacji z dwiema parami nawiasów kwadratowych.

Ćwiczenie: powierzchnia sinusoidalna

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

W tym ćwiczeniu przećwiczymy nowe umiejętności dotyczące krótkiej składni, aby utworzyć „jajowatą” powierzchnię zdefiniowaną przez zakresy i formuły. W trakcie ćwiczenia zwróć uwagę na to, w jaki sposób używane są blok kodu i istniejące węzły Dynamo: blok kodu jest używany do złożonej obsługi danych, natomiast węzły Dynamo są rozmieszczone wizualnie w celu zapewnienia czytelności definicji.

Rozpocznij od utworzenia powierzchni przez połączenie powyższych węzłów. Zamiast używać węzła number do zdefiniowania szerokości i długości, kliknij dwukrotnie obszar rysunku i wpisz 100; w bloku kodu.

1. Zdefiniuj zakres od 0 do 1 z 50 podziałami, wpisując 0..1..#50 w węźle Code Block.

2. Połącz ten zakres z węzłem Surface.PointAtParameter, który pobiera wartości u i v z zakresu od 0 do 1 na powierzchni. Pamiętaj, aby zmienić skratowanie na Iloczyn wektorowy, klikając prawym przyciskiem myszy węzeł Surface.PointAtParameter.

W tym kroku użyjemy pierwszej funkcji do przesunięcia siatki punktów w górę na osi Z. Ta siatka będzie sterować generowaną powierzchnią na podstawie funkcji źródłowej. Dodaj nowe węzły, jak pokazano na ilustracji poniżej

1. Zamiast używać węzła formuły, użyjemy węzła Code Block z wierszem: (0..Math.Sin(x*360)..#50)*5;. Krótkie objaśnienie: definiujemy zakres z formułą w jego wnętrzu. Ta formuła jest funkcją sinus. Funkcja sinus przyjmuje w dodatku Dynamo dane wejściowe w stopniach, więc aby uzyskać pełny kształt funkcji sinus, należy przemnożyć wartości x (jest to wejście zakresu od 0 do 1) przez 360. Następnie chcemy uzyskać taką samą liczbę podziałów, ile jest punktów siatki sterującej dla każdego wiersza, dlatego zdefiniujemy pięćdziesiąt podziałów podrzędnych za pomocą instrukcji #50. Na koniec: mnożnik 5 po prostu zwiększa amplitudę przekształcenia, dzięki czemu możemy zobaczyć efekt w podglądzie Dynamo.

1. Mimo że poprzedni węzeł Code Block działał dobrze, nie był całkowicie parametryczny. Chcemy dynamicznie sterować jego parametrami, dlatego zastąpimy wiersz z poprzedniego kroku wierszem (0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;. Daje to możliwość zdefiniowania tych wartości na podstawie wejść.

Zmieniając suwaki (w zakresie od 0 do 10), otrzymujemy interesujące wyniki.

1. Transponując zakres liczb, odwrócimy kierunek fali kurtynowej: transposeList = List.Transpose(sineList);

1. Po dodaniu wartości sineList i transposeList uzyskujemy zniekształconą „jajowatą” powierzchnię: eggShellList = sineList+transposeList;

Zmienimy wartości suwaków określone poniżej, aby zmniejszyć zniekształcenia tworzone przez ten algorytm.

Na koniec zastosujmy zapytania do wyodrębnionych części danych za pomocą węzła Code Block. Aby ponownie wygenerować powierzchnię za pomocą określonego zakresu punktów, dodaj węzeł Code Block powyżej między węzłami Geometry.Translate i NurbsSurface.ByPoints. Będzie on zawierać wiersz tekstu: sineStrips[0..15..1];. Spowoduje to wybranie pierwszych 16 wierszy punktów (spośród 50). Po ponownym utworzeniu powierzchni widać, że wygenerowaliśmy wyodrębnioną część siatki punktów.

1. W ostatnim kroku, aby uczynić ten węzeł Code Block bardziej parametrycznym, będziemy sterować zapytaniem za pomocą suwaka o zakresie od 0 do 1. W tym celu dodamy ten wiersz kodu: sineStrips[0..((List.Count(sineStrips)-1)*u)];. Może to wydawać się skomplikowane, ale ten wiersz kodu pozwala szybko przeskalować długość listy do mnożnika z zakresu od 0 do 1.

Wartość 0.53 na suwaku powoduje utworzenie powierzchni tuż za punktem środkowym siatki.

Zgodnie z oczekiwaniami wartość 1 na suwaku tworzy powierzchnię z pełnej siatki punktów.

Przyglądając się wykresowi wizualnemu, możemy wyróżnić bloki kodu i przejrzeć ich poszczególne funkcje.

1. Pierwszy węzeł Code Block zastępuje węzeł Numer.

2. Drugi węzeł Code Block zastępuje węzeł Number Range.

3. Trzeci węzeł Code Block zastępuje węzeł Formula (jak również węzły List.Transpose, List.Count i Number Range).

4. Czwarty węzeł Code Block stosuje zapytania do listy list, zastępując węzeł List.GetItemAtIndex.

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.

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

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:

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

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

combined = s1.Union(s2);

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:

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

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

result = s.Difference(tool);

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:

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

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

result = s.Intersect(tool);

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.

Dodatek Dynamo doskonale nadaje się do rozpoczęcia przygody z kodowaniem w świecie architektury, inżynierii i budownictwa. Niektóre z tych sekcji mogą Cię zainteresować — rozpocznij przygodę z kodowaniem:

• Bloki kodu i język DesignScript

• Geometria przy użyciu języka DesignScript

• Python

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

out_points = []

for i in range(11):
	sub_points = []
	for j in range(11):
		z = 0
		if (i == 5 and j == 5):
			z = 1
		elif (i == 8 and j == 2):
			z = 1
		sub_points.append(Point.ByCoordinates(i, j, z))
	out_points.append(sub_points)

OUT = out_points

python_points_2

out_points = []

for i in range(11):
	z = 0
	if (i == 2):
		z = 1
	out_points.append(Point.ByCoordinates(i, 0, z))

OUT = out_points

python_points_3

out_points = []

for i in range(11):
	z = 0
	if (i == 7):
		z = -1
	out_points.append(Point.ByCoordinates(i, 5, z))

OUT = out_points

python_points_4

out_points = []

for i in range(11):
	z = 0
	if (i == 5):
		z = 1
	out_points.append(Point.ByCoordinates(i, 10, z))

OUT = out_points

python_points_5

out_points = []

for i in range(11):
	sub_points = []
	for j in range(11):
		z = 0
		if (i == 1 and j == 1):
			z = 2
		elif (i == 8 and j == 1):
			z = 2
		elif (i == 2 and j == 6):
			z = 2
		sub_points.append(Point.ByCoordinates(i, j, z))
	out_points.append(sub_points)

OUT = out_points

Dlaczego w środowisku programowania wizualnego Dynamo warto używać programowania tekstowego? ma wiele zalet. Umożliwia tworzenie programów bez konieczności poznawania specjalnej składni w intuicyjnym interfejsie wizualnym. Jednak program wizualny może z czasem zawierać zbyt wiele elementów i nie działać zgodnie z założeniami. Na przykład język Python oferuje znacznie więcej dostępnych metod pisania instrukcji warunkowych (jeśli/to) i zapętlania. Język Python jest zaawansowanym narzędziem, które umożliwia rozszerzenie możliwości dodatku Dynamo i zastąpienie wielu węzłów kilkoma zwięzłymi liniami kodu.

Program wizualny:

Program tekstowy:

Węzeł w języku Python

Podobnie jak bloki kodu węzły języka Python są interfejsem skryptowym w środowisku programowania wizualnego. Węzeł Python można znaleźć w bibliotece w obszarze Skrypt>Edytor>Skrypt w języku Python.

Dwukrotne kliknięcie węzła powoduje otwarcie edytora skryptów języka Python (można również kliknąć prawym przyciskiem myszy węzeł i wybrać polecenie Edytuj). Na górze jest wyświetlany tekst wstępny, który ma ułatwić odnoszenie się do potrzebnych bibliotek. Dane wejściowe są przechowywane w szyku IN. Wartości są zwracane do dodatku Dynamo przez przypisanie ich do zmiennej OUT

Metody obejmują konstruktory, takie jak ByCoordinates, akcje, takie jak Add, oraz zapytania, takie jak współrzędne X, Y i Z.

Ćwiczenie: węzeł niestandardowy ze skryptem w języku Python do tworzenia wzorów z modułu bryłowego

Część I. Konfigurowanie skryptu w języku Python

Pobierz plik przykładowy, klikając poniższe łącze.

Pełna lista plików przykładowych znajduje się w załączniku.

W tym przykładzie napiszemy skrypt w języku Python, który tworzy wzorce z modułu bryłowego, i zmienimy go w węzeł niestandardowy. Najpierw utworzymy moduł bryłowy za pomocą węzłów Dynamo.

1. Rectangle.ByWidthLength: utwórz prostokąt, który będzie podstawą bryły.

2. Surface.ByPatch: połącz prostokąt z wejściem „closedCurve”, aby utworzyć dolną powierzchnię.

1. Geometry.Translate: połącz prostokąt z wejściem „geometry”, aby przesunąć go w górę, używając węzła Code Block do określenia grubości bazowej bryły.

2. Polygon.Points: zastosuj zapytanie do przekształconego prostokąta w celu wyodrębnienia punktów narożnych.

3. Geometry.Translate: użyj węzła Code Block, aby utworzyć listę czterech wartości odpowiadających czterem punktom, przekształcając jeden narożnik bryły w górę.

4. Polygon.ByPoints: użyj przekształconych punktów, aby odtworzyć górny wielobok.

5. Surface.ByPatch: połącz wielobok, aby utworzyć górną powierzchnię.

Teraz gdy mamy górną i dolną powierzchnię, wyciągnijmy między dwoma profilami, aby utworzyć boki bryły.

1. List.Create: połącz dolny prostokąt i górny wielobok z wejściami indeksu.

2. Surface.ByLoft: wyciągnij dwa profile w celu utworzenia boków bryły.

3. List.Create: połącz górną, boczną i dolną powierzchnię z wejściami indeksu, aby utworzyć listę powierzchni.

4. Solid.ByJoinedSurfaces: połącz powierzchnie, aby utworzyć moduł bryły.

Po uzyskaniu bryły upuść węzeł skryptu w języku Python w obszarze roboczym.

1. Aby dodać kolejne wejścia do węzła, kliknij ikonę „+” na węźle. Nazwy wejść to IN[0], IN[1] itd., aby wskazać, że reprezentują one elementy na liście.

Zacznijmy od zdefiniowania wejść i wyjść. Kliknij dwukrotnie węzeł, aby otworzyć edytor języka Python. Zmodyfikuj kod w edytorze na podstawie poniższego kodu.

Ten kod będzie bardziej przejrzysty w trakcie dalszej analizy tego ćwiczenia. Następnie należy zastanowić się, jakie informacje są wymagane, aby ułożyć moduł bryłowy w szyku. Najpierw musimy znać wymiary bryły, aby określić odległość przekształcenia. Z powodu błędu ramki ograniczającej należy użyć geometrii krzywej krawędzi, aby utworzyć ramkę ograniczającą.

Przyjrzyj się węzłowi Python w dodatku Dynamo. Zauważ, że używamy tej samej składni, która jest używana w węzłach w dodatku Dynamo. Zapoznaj się z poniższym skomentowanym kodem.

Ponieważ będziemy zarówno przekształcać, jak i obracać moduły brył, użyjmy operacji Geometry.Transform. Z węzła Geometry.Transform wynika, że będziemy potrzebować źródłowego układu współrzędnych i docelowego układu współrzędnych do przekształcenia bryły. Źródłem jest kontekstowy układ współrzędnych bryły, natomiast elementem docelowym będzie inny układ współrzędnych dla każdego modułu ustawionego w szyku. Oznacza to, że należy utworzyć pętlę przez wartości x i y, aby przekształcić układ współrzędnych za każdym razem w inny sposób.

Kliknij przycisk Uruchom, a następnie Zapisz kod. Połącz węzeł w języku Python z istniejącym skryptem w następujący sposób.

1. Połącz dane wyjściowe z węzła Solid.ByJoinedSurfaces z pierwszym wejściem węzła Python i użyj węzła Code Block, aby zdefiniować pozostałe wejścia.

2. Utwórz węzeł Topology.Edges i użyj danych wyjściowych z węzła Python jako jego danych wejściowych.

3. Na koniec utwórz węzeł Edge.CurveGeometry i użyj danych wyjściowych z węzła Topology.Edges jako jego danych wejściowych.

Spróbuj zmienić wartość źródłową, aby utworzyć różne wzorce. Można również zmienić parametry samego modułu bryły w celu uzyskania różnych efektów.

Część II. Przekształcanie węzła skryptu w języku Python w węzeł niestandardowy

Teraz po utworzeniu przydatnego skryptu w języku Python zapiszemy go jako węzeł niestandardowy. Wybierz węzeł skryptu w języku Python, kliknij prawym przyciskiem myszy obszar roboczy i wybierz opcję „Utwórz węzeł niestandardowy”.

Przypisz nazwę, opis i kategorię.

Spowoduje to otwarcie nowego obszaru roboczego, w którym będzie edytowany węzeł niestandardowy.

1. Wejścia Input: zmień nazwy wejść na bardziej opisowe i dodaj typy danych oraz wartości domyślne.

2. Wyjście Output: zmień nazwę węzła danych wyjściowych

Zapisz węzeł jako plik .dyf. Węzeł niestandardowy powinien odzwierciedlać wprowadzone zmiany.

​Język Python to powszechnie używany język programowania, którego popularność ma wiele wspólnego z jego stylem składni. Jest wysoce czytelny, co sprawia, że łatwiej jest się go nauczyć niż wielu innych języków. Język Python obsługuje moduły i pakiety. Można go osadzać w istniejących aplikacjach. Aby uzyskać informacje na temat rozpoczynania korzystania z języka Python, skorzystaj z zasobu (Pierwsze kroki) na stronie .

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.

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.

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

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.

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.

W dodatku Dynamo 2.0 można określić domyślny szablon (.py extension), który ma być używany podczas otwierania okna języka Python po raz pierwszy. Od dawna proszono o dodanie tej funkcji, ponieważ przyspiesza ona korzystanie z języka Python w dodatku Dynamo. Dzięki możliwości użycia szablonu można przygotować domyślny import gotowy do użycia, gdy chcemy utworzyć skrypt niestandardowy w języku Python.

Położenie tego szablonu to APPDATA dla instalacji dodatku Dynamo.

Zwykle jest to ścieżka ( %appdata%\Dynamo\Dynamo Core\{version}\ ).

Konfigurowanie szablonu

Aby korzystać z tej funkcji, należy dodać następujący wiersz w pliku DynamoSettings.xml. (Edytuj w Notatniku)

Część <PythonTemplateFilePath /> można po prostu zastąpić następującą treścią:

Następnie musimy utworzyć szablon z funkcjami, które mają być wbudowane. W tym przypadku osadźmy powiązane z programem Revit importy i niektóre inne typowe elementy podczas pracy z programem Revit.

Można rozpocząć od pustego dokumentu Notatnika i wkleić do niego następujący kod:

Po zakończeniu zapisz ten plik jako PythonTemplate.py w lokalizacji APPDATA.

Późniejsze zachowanie skryptu w języku Python

_P_o zdefiniowaniu szablonu w języku Python dodatek Dynamo będzie go szukać po każdym umieszczeniu węzła w języku Python. Jeśli go nie znajdzie, okno będzie wyglądać jak domyślne okno języka Python.

Jeśli szablon w języku Python zostanie znaleziony (np. nasz szablon dotyczący programu Revit), zostaną wyświetlone wszystkie domyślne wbudowane elementy.

Dodatkowe informacje dotyczące tego wspaniałego dodatku (którego autorem jest Radu Gidei) można znaleźć tutaj. https://github.com/DynamoDS/Dynamo/pull/8122