projektowanie parametryczne, parametric design
Home > GC > Tworzenie komponentów w GC

Tworzenie komponentów w GC

Po dłuższej ciszy w eterze powracamy do GC z tematem dość już konkretnym, czyli z komponentami. W Generative Components, jak sama nazwa wskazuje, możemy używac komponentów, czyli powtarzalnych elementów stworzonych przez nas z powierzchni, linii, wielokątów itp. Użycie komponentów może służyć na przykład do zbudowania spójnego i powtarzalnego, lecz adaptywnego (w sensie elastycznej geometrii) systemu konstrukcyjnego.

Bardzo często komponenty stosowane są przy projektowaniu parametrycznych fasad z powtarzalnymi elementami, wykonywanymi w zautomatyzowany sposób (za pomocą maszyn tnących CNC lub podobnych), gdzie ich zaprogramowanie ma kluczowe znaczenie w procesie produkcji takiej architektury. Dlatego też odpowiedni projekt parametryczny jest nieodzowny.

Dobrym przykładem jest jedna z fasad w nowej części regenerowanego terenu portowego w Hamburgu. Powstał tam budynek o podwójnym przeszkleniu zbudowanym z przezroczystych komponentów, gdzie każdy ma zupełnie unikatową geometrię dostosowaną do kształtu całości obiektu.

IMGP9940

IMGP9944

Spróbujmy zatem zbudować prosty komponent w środowisku Generative Components. W tym celu stwórzmy najpierw czysty plik, i zbudujmy powierzchnię BSpline na której zostaną one ułożone.

Zacznijmy od rozłożenia na płaszczyźnie XY dziewięciu arbitralnie położonych punktów. Użyjemy w tym celu narzędzia ‘Place Point’ pokazanego poniżej czerwoną strzałką :

komponent_1_

Następnie klikamy ikonkę ‘New Features’ (jeśli nie możemy jej znaleźć, jest ona w menu Tools>Create Features>New Feature), i tworzymy element BSplineCurve, aby zbudować pierwszy ‘Loft’. Do stworzenia powierzchni potrzebujemy trzy takie krzywe.

W liście metod dostępnych pod polem ‘BSplineCurve’ wybieramy ‘ByPoles’ i w pierwszym polu (‘Poles’) wprowadzamy pierwsze trzy punkty. Najlepiej umieścić poprostu w nim kursor, i kliknąć po kolei trzy punkty z przyciśniętym przyciskiem Control. W przypadku pokazanym poniżej w polu pojawił się wpis {point01, point02, point03}

komponent_02

Po naciśnięciu przycisku ‘OK’ poniżej, możemy poprostu powielić krzywą używająć guzika ‘Create copy’ zaznaczonego na ilustracji powyżej. To przyspieszy nam trochę pracę. Oczywiście w polu ‘Poles’ wpisujemy już inne punkty – tym razem trzy środkowe, oraz ponownie klikamy ‘OK’. Operację powtarzamy dla ostatniej trójki punktów.

Należy oczywiście pamiętać, aby krzywe miały ten sam kierunek. Po ich stworzeniu powinniśmy otrzymać model jak poniżej :

komponent_03

Dobrze byłoby teraz dla dodania naszemu projektowi dynamiki wygiąć krzywe tak, aby stały się łukami. Najlepiej zrobić to używając narzędzia ‘Move Feature’ i łapiąc za uchwyty środkowych punktów kontrolnych przeciągnąć je w górę.

komponent_04

Jesteśmy już o krok od stworzenia naszej ‘bazowej’ powierzchni, stwórzmy więc nowy element (narzędziem ‘New Feature’) typu BSplineSurface, metodą ‘Loft Curves’. Metoda przyjmuje tylko jeden podstawowy parametr, którym są właśnie krzywe, więc umieszczamy kursor w polu ‘Curves’ i z przyciśniętym Controlem klikamy po kolei na trzech Loftach. Powinno tam się pojawić coś w stylu : {bsplineCurve01, bsplineCurve02, bsplineCurve03} . Wpiszmy jeszcze na koniec ’3′ w polu ‘Order’. Nie jest to konieczne, ale jeśli to zrobimy, będziemy pewni co do stopnia krzywizny powierzchni (w przypadku użycia liczby ’2′, nasz dach będzie składał się z powierzchni pojedynczo zakrzywionych).

Po kliknięciu ‘OK’ powinniśmy zobaczyć powierzchnię jak poniżej.

komponent_06

To by było na tyle, jeśli chodzi o tworzenie prostej powierzchni krzywoliniowej. Oczywiście powierzchnia jest tylko naszym ‘płótnem’, na którym tworzyć będziemy kolejne warstwy elementów, i może ona przyjąć zupełnie inne formy i konfiguracje przestrzenne. Gdybyśmy np chcieli zaprojektować wieżowiec, stworzylibyśmy powierzchnię ‘zapętloną’ w jednym kierunku przypominającą bardziej komin.

Teraz spróbujmy stworzyć elementy na których będzie bazował nasz komponent. Każdy komponent musi na czymś się ‘opierać’, czyli mieć jakiś parametr ‘wejściowy’, który jest obiektem geometrycznym. Tak samo jak np. żeby stworzyć krzywą BSpline musimy podać na wejściu zbiór punktów kontrolnych, tak  i w przypadku komponentu, musimy podać jakieś obiekty.

Aby wyjaśnić to w miarę przystępny sposób, użyjemy elementu ‘Polygon’ jako bazy do naszego komponentu (czyli wielokąta). Dlaczego ? Otóż jest on najlepszy przy budowaniu komponentów przykrywających jakąś powierzchnię. Poza tym jest też w miarę łatwy do powielenia na powierzchni (chodzi tutaj o metodę ‘ByPointGrid‘), oraz umożliwia łatwy dostęp do danych o swoich wierzchołkach (o tym za chwilę).

Zanim stworzymy siatkę czworokątów ‘opinających’ naszą powierzchnię, musimy stworzyć siatkę punktów (tak jak w poprzednim tutorialu). Użyjemy w tym celu nowego Punktu stworzonego za pomocą metody ByUVParametersOnSurface. W polu ‘Surface’ podajemy nazwę naszej powierzchni, zaś w polach U oraz V musimy podać łańcuch współrzędnych. Jak wiadomo, współrzędne U i V mogą przyjmować wartości od 0 do 1, więc chcąc mieć np. 8 punktów w każdym z tych kierunków musimy użyć funkcji SeriesByCount. Wpiszmy :

SeriesByCount(0, 1, 8 )

Co wyprodukuje coś w stylu {0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0}

Po kliknięciu ok niestety nie zobaczymy jeszcze siatki, lecz dziwny ‘zbiór’ ośmiu punktów przecinających naszą powierzchnię po przekątnej.

komponent_07

Aby zrobiła się z tego siatka, musimy zmienić metodę Replikacji punktów. Tak jak w poprzednim tutorialu, musimy użyć narzędzia ‘Toggle Replication‘ pokazanego powyżej strzałką nr 1. Po jego wybraniu klikamy poprostu na którymś z punktów (strzałka 3). Aby uniknąć zamieszania na ekranie, schowajmy powierzchnię (nie będzie już nam potrzebna) za pomocą narzędzia ‘Toggle Visibility‘ (strzałka 2).

Otrzymujemy coś na wzór poniższego obrazka :

komponent_08

Należy pamiętać, aby po każdej kluczowej operacji, jak dodanie jakiegoś elementu, kliknąć ikonkę zaznaczoną w czerwonym kółku (Record Recent Graph Changes). Spowoduje to zapisanie naszych ostatnich działań jako osobną transakcję, co czyni wszystko czytelniejszym i łatwiejszym w późniejszej ewentualnej edycji. Pamiętajmy też o regularnym zapisywaniu pliku (Ctrl+S)

Stwórzmy więc wspomniane wielokąty. Klikamy w tym celu ikonę ‘New Feature’, wybieramy ‘Polygon‘ i metodę ‘ByPointGrid‘. W pole ‘Points’ wpisujemy poprostu nazwę punktu (bez indeksów w kwadratowych nawiasach) i klikamy OK. Zapisujemy ten ruch jako kolejną transakcję.

komponent_09

Ok, czas zatem zabrać się za tworzenie ‘właściwego’ komponentu.

Mamy już naszą ‘bazę’, czyli zbiór wielokątów, na których pojawią się komponenty. Teraz musimy stworzyć jeden osobny, ‘specjalny’ wielokąt, który posłuży nam za ‘szkielet’ do budowy. Chodzi o to, żeby zbudować najpierw coś jak ‘prototyp’, następnie zapisać go w ‘bazie’ elementów GC, i dopiero wtedy można go użyć do pokrycia wielu wielokątów.

Tak naprawdę istnieje kilka strategii tworzenia komponentów, można na przykład stworzyć go w zupełnie innym pliku, zapisać, a potem otworzyć nowy plik i użyć go w nim. Komponent jest zapisywany na dysku jako plik .dll , więc może być nawet skopiowany i rozpowszechniony przez internet itp.

My spróbujemy stworzyć go w tym samym pliku, aby nie komplikować sprawy.

Stwórzmy więc ‘szkielet’, czyli prototypowy wielokąt, na którym stworzymy strukturę komponentu. Najpierw narzędziem ‘Place point’ stawiamy cztery punkty, a potem budujemy na nich ‘Polygon’ metodą ‘ByVertices’. W polu ‘Vertex Points’ wpisujemy punkty, otrzymując coś jak {point11, point12, point13, point14}. Ważna jest oczywiście kolejność, albo zgodnie albo przeciwnie kierunkowi wskazówek zegara.

komponent_10

Następnie wybieramy narzędzie ‘Toggle Visibility’ (czerwona strzałka) i chowamy wszystkie cztery punkty, zostawiając tylko wielokąt. Robimy to klikając albo na punktach, albo na ich reprezentacjach w modelu symbolicznym (czerwony prostokąt).

(nie jest to konieczne, ale zróbmy to, aby wszystkie cechy komponentu zależały tylko od wielokąta, a nie od innych elementów – więcej o tej strategii za chwilę)

Aby zacząć budować kolejne elementy, dobrze jest wstawić w środek komponentu tzw. centroid, czyli punkt będący uśrednieniem pozycji wszystkich wierzchołków. Stwórzmy więc nowy punkt metodą ‘Centroid of Set’, w polu ‘SetToFindCentroidFrom’ wpisując… no właśnie, tutaj musimy wpisać listę wierzchołków. Nie chcemy podawać tu pierwotnych czterech punktów stworzonych chwilę temu, po pierwsze dlatego, że ich nie widać, po drugie dlatego, że .. chcielibyśmy, żeby wszystko było zbudowane wyłącznie na wielokącie.

Wpisujemy więc nazwę naszego prototypowego wielokąta i zaraz po niej naciskamy kropkę, po to, żeby mieć dostęp do wewnętrznych składników tegoż elementu. Konkretnie chodzi nam o wierzchołki, więc wybieramy z listy ‘Vertices’ i naciskamy enter. Po naciśnięciu OK dostajemy punkt leżący dokładnie pośrodku obiektu !

komponent_11

komponent_12_

Możemy też zauważyć, że na widoku symbolicznym, na prawo od elementu ‘Polygon’ pojawia się nasz punkt, a potem dodawane będą kolejne elementy. Naszym celem jest to, aby strzałki do wszystkich obiektów tworzących komponent szły od tego wielokąta (gdyż jest on naszym parametrem wejściowym i wszystko powinno zależeć tylko od niego).

——————–

W kolejnym etapie budowy przykładowego komponentu, spróbujemy zbudować otwór w kształcie koła. Wykorzystamy w tym celu metodę rysującą koło na podstawie trzech punktów. Jak wiadomo podstawowymi dwoma punktami do narysowania koła w dwóch wymiarach są  : środek (origin) oraz punkt pokazujący promień (radius). Dla trzech wymiarów potrzebujemy jeszcze jeden punkt definiujący płaszczyznę.

Punktem definiującym promień powinien być jakiś punkt leżący wewnątrz komponentu. Stwórzmy więc nowy Punkt, i spróbujmy użyć metody ‘ByDirectionAndDistanceFromOrigin’. Jako origin (początek) wpiszmy przed chwilą stworzony punkt środka wielokąta (możemy go oczywiście poprostu kliknąć, gdy kursor znajduje się w polu ‘Origin’, a nazwa pojawi się sama).  W polu ‘Direction’ możemy wpisać jeden z wierzchołków wielokąta, aby określić, w jakim kierunku chcemy umieścić docelowy promień. Aby to zrobić, podobnie jak poprzednio użyjemy ‘wewnętrznych’ składników wielokąta, czyli wpisując jego nazwę dodajemy kropkę,  i z listy wybieramy ‘Vertices’ a potem kwadratowym nawiasem precyzujemy o który wierzchołek nam chodzi (jest ich 4). Wybierając pierwszy z nich, wpis w polu ‘Direction’ mógłby wyglądać tak :

polygon02.Vertices[0]

Ostatnim polem będzie długość promienia koła, które chcemy stworzyć. Można tam wpisać poprostu jakąś liczbę, np. 1. Spróbujmy jednak zrobić coś odrobinę sprytniejszego. Jako, że nasze wielokąty mogą mieć różne rozmiary, najlepiej jest użyć długości proporcjonalnej do odległości wierzchołka od środka koła. Użyjmy więc funkcji Distance, podając jako oba parametry (punkt początkowy i końcowy) właśnie środek koła i dany wierzchołek. Może to wyglądać tak:

Distance(point15, polygon02.Vertices[0]) / 4

Co oznacza, że koło będzie miało promień równy 1/4 odległości wierzchołka nr 0 od punktu środkowego.

komponent_13

Można oczywiście tą odległość pomnożyć przez jakiś parametr/zmienną, i manipulować wielkością koła w zależności od różnych kryteriów, ale o tym może kiedy indziej :-)

Stwórzmy więc koło (Circle) metodą ByCenterStartPlanePoint, wpisując jako CenterPoint punkt środkowy, StartPoint punkt definiujący promień, a PlanePoint któryś z wierzchołków (np. polygon02.Vertices[1]).

komponent_14_

Otrzymaliśmy koło. Póki co, widzimy koło i wielokąt. Na widoku symbolicznym zauważamy też, że zaczyna się nam budować pewna struktura, całkowicie zależna od wielokąta (póki co są to koło i dwa punkty). Co zrobić, żeby otrzymać kwadratowy element z otworem w środku ?

Najlepiej w tym wypadku użyć (znowu) powierzchni BSpline zdefniowanej za pomocą metody ‘LoftCurves’. Dlaczego ? Bo to najłatwiejsze :-) Na wejściu podajemy tylko dwie krzywe,  i dostajemy powierzchnię ‘przeciągniętą’ pomiędzy nimi. Niezbyt skomplikowane, prawda ?

Zatem : New Feature >> BSplineSurface >> LoftCurves i z wciśniętym Controlem do pola ‘Curves’ wprowadzamy wielokąt (np. polygon02)  i koło ( circle01). Zaraz po naciśnięciu OK, należy w widoku symbolicznym wyłączyć widoczność (Toggle Visibility) koła i wielokąta, gdyż będą się nakładać z wynikową powierzchnią. Powinniśmy zobaczyć coś na ten kształt :

komponent_15_

Nasz komponent (wszystko co widzimy po prawej stronie na widoku symbolicznym, czyli cztery elementy) jest prawie gotowy !

——————————–

Ostatecznym etapem jego tworzenia jest użycie narzędzia ‘Generate Feature Type’ gft. Po jego wywołaniu zobaczymy nowe okno :

komponent_16

Teraz : żeby wybrać parametr wejściowy (czyli obiekt z którego będzie stworzony komponent) klikamy przycisk ‘Select from model’ i na modelu symbolicznym wybieramy nasz ‘prototypowy’ wielokąt (polygon02). Po kliknięciu na niego podświetlą się także wszystkie elementy zależne od niego (a więc koło, dwa punkty i powierzchnia BSpline, które stworzyliśmy). Zostaną one także automatycznie umieszczone w ‘Output properties’.

Następnie przyglądamy się zawartości okna. U góry w polu ‘Type name‘ wpisujemy nazwę komponentu (np ‘komponent1‘). W ramce ‘Input properties’ zaznaczamy tickbox ‘Replicatable’, gdyż umożliwi nam to powielanie komponentu. Następnie w ramce ‘Output Properties’ zaznaczmy elementy, które nie muszą być widoczne (czyli wszystkie, oprócz samej powierzchni z otworem) klikając przy nich opcję ‘construction’.

Klikamy ‘OK’ i voila ! Komponent utworzony !

—————————————

Jak ‘zaaplikować’ komponent na naszą strukturę ? Otóż podobnie jak wiele razy wcześniej, klikamy ‘New Feature’, i wybieramy z listy.. komponent01 ! Tak, nasz komponent jest teraz elementem takim samym jak linie, punkty i powierzchnie!

W ukazanych dostępnych metodach (nie jest ich wiele) wybieramy ‘ByDefault’ i w polu ‘Polygon’ wpisujemy nazwę wielokąta, z którego zbudowany jest dach (w tym przypadku polygon01). Po kliknięciu ‘OK’, komponent ten powinien pojawić się na całym dachu, w różnych konfiguracjach geometrycznych, automatycznie dostosowując się do każdego wielokąta.

Aby dokończyć dzieła, ukryjmy jeszcze wejściowe wielokąty za pomocą ‘Toggle Visibility’ (najlepiej klikając w ‘polygon01′ na modelu symbolicznym, inaczej trudno w niego ‘trafić’ :-)

Wynik powinien wyglądać mniej więcej tak :

komponent_17

———————-

Przeanalizujmy więc, co się stało na modelu symbolicznym :

komponent_18

Zwyczajnie to co figuruje na końcu czerwonej strzałki, czyli nasz komponent, jest ‘upakowaną’ wersją ‘prototypu’ który stworzyliśmy, czyli koła, dwóch punktów i powierzchni BSpline. Jest to poprostu ‘pojemnik’ na te elementy.

Na koniec wspomnę jeszcze  o ważnej rzeczy : komponenty raz stworzone, ładowane są do pamięci GC jako pliki DLL, i nie można ich ‘wykasować’ lub zmienić. Niestety, jeśli chcemy się takiego komponentu pozbyć, musimy zrestartować GC (lub alternatywnie tworzymy poprostu komponent o nowej nazwie).

Dostęp do załadowanych komponentów mamy przez menu Utilities >> Manage Feature Types >> Loaded Assemblies, i tam możemy zdefiniować, które komponenty będą automatycznie ładowane przy starcie GC, oraz możemy załadować gotowe komponenty z pliku. Standardowo znajdują się one w katalogu :

(…) GC\WorkSpace\Projects\Examples\GC_Default\Assemblies\

Na koniec jeszcze kilka przykładowych renderów :-)

( z dodanym elementem typu ‘Solid’ dla pogrubienia struktury)

viz2

viz3

viz1

To oczywiście bardzo prosty komponent, i nie wyczerpuje on dostępnych opcji, których jest mnóstwo, i ograniczeniem tego co możliwe jest tylko wyobraźnia projektanta :-)

Więcej w kolejnych odcinkach.

  1. December 17th, 2014 at 08:12 | #1

    Treść pokrewna każdemu, polecam lekturę

  1. No trackbacks yet.