Kontynuując poprzedni wątek tworzenia parametrycznych modeli, przejdźmy do zasad budowania kolejnych elementów w Generative Components. W tym rozdziale zapoznamy się  z budowaniem powierzchni krzywoliniowych, replikacji oraz panelizacji, a także z przygotowywaniem elementów do maszynowego wycinania.

Zanim jednak zbudujemy dach, zapoznajmy się z kilkoma podstawami za pomocą ćwiczeń

W poprzednim odcinku skończyliśmy tworząc prostą krzywą BSpline, opartą na czterech punktach kontrolnych. Aby zrozumieć lepiej jak tworzyć więcej krzywych, na których np. możemy zbudować dach, musimy poznać replikację i zasady tworzenia kolekcji.

Otwórzmy więc GC i stwórzmy element (feature) za pomocą ikonki ‘Create Feature’ w górnym menu narzędzi. Po rozwinięciu pozycji ‘Point’ ukaże się nam mnóstwo metod, spośród których wybierzmy najprostszą – ByCartesianCoordinates. Rozwijając ją przyciskiem ‘+’ po lewej stronie, zobaczymy pola do wypełnienia :

CoordinateSystem : baseCS (to nasz podstawowy układ współrzędnych – ale możemy tutaj też wpisać inny, który wcześniej stworzymy).

XTranslation, YTranslation, ZTranslation : przesunięcie w osi X, Y i Z

Origin : opcjonalny parametr (punkt), przesuwający kartezjański środek układu współrzędnych w inne miejsce. Standardowo pole powinno pokazywać wartość null.

Normalnie, w pola te wpisujemy współrzędne, czyli np. X=1,Y= 5 , Z=8 itp. Możemy jednak zamiast współrzędnej podać funkcję , taką jak Series lub SeriesByCount(o tym za chwilę), lub grupę współrzędnych. Spowodują one zreplikowanie punktu i nie będzie on już tylko pojedynczym elementem, ale tzw. kolekcją. Istota pracy w GC opiera się na replikacji i kolekcjach, dzięki czemu możemy przeprowadzać operacje na wielu elementach w taki sam sposób, jak na jednym elemencie.

Jeśli w którymkolwiek momencie zamiast podawać jeden parametr, chcemy podać kilka, zamykamy je w klamrowych nawiasach { } , i stają się one kolekcją.

Przykład : stwórzmy nowy punkt metodą ByCartesianCoordinates

układ współrzędnych : baseCS

XTranslation : 1

YTranslation : 2

ZTranslation : {3,5,8}

Origin : null

po naciśnięciu OK otrzymamy.. trzy punkty ! To ilustruje ideę prostej replikacji. Co więcej, jeśli za YTranslation podamy {9,10,11} , współrzędne Y będą korespondować z wcześniej podaną kolekcją współrzędnych Z , czyli dostaniemy trzy punkty : {1,9,3}, {1,10,5} oraz {1,11,8}.

Warto wspomnieć, że można też te grupy współrzędnych skorelować w inny sposób. Poniższy ekran pokazuje jak odsłonić ‘ukryte’ właściwości elementu.

Po włączeniu opcji ’show settings properties’ pojawi się nam mnóstwo dodatkowych właściwości naszego punktu, których zazwyczaj nie będziemy używać, oprócz jednej, bardzo ważnej : Replication. To pole przyjmować może dwie wartości ReplicationOption.CorrespondingIndexing albo ReplicationOption.AllCombinations.

Jak łatwo się domyślić, pierwsza opcja stworzy trzy punkty, z każdego zestawu trzech współrzędnych. Jeśli mamy trzy współrzędne w polu X, i trzy współrzędne w polu Y, dostaniemy 3 punkty. Jeśli wpiszemy po trzy różne współrzędne w polach X, Y i Z – też dostaniemy 3 punkty. Jeśli wpiszemy 3 współrzędne w polu X i Y, a cztery w Z – dostaniemy… też trzy punkty! (ponieważ dodatkowa, czwarta współrzędna w polu Z nie koresponduje z żadną inną w pozostałych polach).

Druga opcja działa zupełnie inaczej – jako wynik produkuje wszystkie kombinacje danych współrzędnych. Czyli wpisując trzy różne współrzędne do pola X (na przykład {9,10,11} ) i trzy współrzędne do pola Y {3,5,8} , dostaniemy 9 punktów. Jeśli do pola Z wpiszemy też 3 współrzędne, np. {1,2,3} , dostaniemy 27 punktów.

Obie opcje można też włączyć edytując transakcję ‘ręcznie’ (prawy klik, ‘edit transaction’) i dopisując linię Replication = ReplicationOption.AllCombinations; albo ReplicationOption.CorrespondingIndexing;)

Bardzo ważną rzeczą w tworzeniu kolekcji, szczególnie za pomocą drugiej omówionej powyżej opcji jest indeksowanie. Jeśli wybierzemy z menu ikonę ‘edit feature’ (dłoń wskazująca na kwadrat) i najedziemy nad stworzony obiekt (tutaj punkt), wyświetli nam się nazwa obiektu oraz jego pozycja w kolekcji.

(tutaj wskaźnik pokazuje punkt [2][1] z kolekcji punktów point01). Tak jak wspominałem powyżej, całą kolekcję można traktować jako jeden punkt. Zilustrujmy to tworząc linię od układu współrzędnych baseCS do kolekcji point01 :

(>> Create Feature >> Line >> ByPoints,  jako StartPoint wybieramy baseCS – najlepiej umieszczając kursor w tym polu a potem najeżdżając na baseCS z naciśniętym CTRL. Jako EndPoint wybieramy point01 – kasując indeksy w kwadratowych nawiasach, tak żeby pole zawierało tylko point01)

(na tym etapie wyłączmy wspomnianą wcześniej opcję ’show settings properties’, żeby uniknąć niepotrzebnego zamieszania)

Jako parametry wejściowe wpisaliśmy baseCS (pierwszy punkt), i point01 (drugi punkt), a w rezultacie dostaliśmy.. grupę linii ! Tak właśnie działa replikacja.

——————————–

Ok, czas przejść do czegoś, co przyspieszy nam trochę pracę nad kolekcjami.. przyjrzyjmy się funkcji Series i SeriesByCount.

Series (start, limit, increment) – tworzy kolekcję wartości liczbowych będących łańcuchem. Łańcuch zaczyna się od wartości start, i wypełnia się kolejnymi wartościami stopniowo zwiększanymi o increment, aż osiągnie limit). Przykład  : Series(1, 3, 0.4) to to samo co {1, 1.4, 1.8, 2.2, 2.6, 3.0}

SeriesByCount(start, final, count) – tworzy kolekcję wartości liczbowych zaczynających się od start, kończących na final, wypełnioną pośrednimi wartościami, w count krokach). Przykład: SeriesByCount(1, 15, 2) to to samo co {1,3,5,7,9,11,13,15}

Powyższe funkcje można wykorzystywać jako argumenty wejściowe do innych funkcji, np sinusoidy (Sin). SeriesByCount(0, 720, 50) stworzy łańcuch wartości wędrujący od zera do 720 w 50-ciu krokach.

Aby narysować w przestrzeni ciekawą krzywą bazującą na replikacji punktów, stwórzmy nowy skrypt, i nowy punkt ByCartesianCoordinates.

CoordinateSystem : baseCS

XTranslation : Sin(SeriesByCount(0,720,50))

(w GC argumenty wejściowe do funkcji Sin podajemy w stopniach, nie radianach)

YTranslation : Cos(SeriesByCount(0,720,50))

ZTranslation : SeriesByCount(0, 5, 50)

a potem dodajmy krzywą BSpline, stworzoną metodą ByPoints

Points : point01

MakePeriodic : false

Rezultat : Krzywa spiralna (może np posłużyć jako baza do schodów!)

Dla dociekliwych : Możemy zreplikować stworzoną właśnie krzywą poprzez skopiowanie jej do kolekcji układów współrzędnych. Najpierw tworzymy jakąś grupę układów współrzędnych, np metodą BySphericalCoordinates (CoordinateSystem : baseCS,  Radius : 5 ,  Theta  : SeriesByCount(0,360,20),   Phi : -30 ), a potem tworzymy nową krzywą BSpline metodą CopyTransformGeometricContents ( CopyFrom : baseCS,    CopyTo : coordinateSystem01,  FeatureToCopy  : bsplineCurve01), kopiując spiralę do dziesięciu nowych orientacji. Rezultat poniżej :

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

Po tej krótkiej demonstracji przejdźmy do czegoś bardziej zaawansowanego geometrycznie, czyli do powierzchni BSplineSurface. Powierzchnie BSpline są skonstruowane podobnie do krzywych BSpline (np. w tym sensie, że posiadają punkty kontrolne), przy czym oczywiście w sensie parametrycznym są dwuwymiarowe. Żeby nanieść na krzywą bspline punkt, wystarczy podać jeden parametr, w zakresie od 0 do 1. Żeby nanieść taki sam punkt (lub punkty) na powierzchnię BSplineSurface , należy podać dwa parametry – U i V. Oba przyjmują wartości od 0 do 1.

Stwórzmy nowy plik ( File >> New Transaction File ) i wybierając narzędzie ‘Create Point’ (żółta ikonka) stwórzmy cztery punkty.

Następnie stwórzmy element BSplineCurve metodą ByPoles (nie ByPoints!), wpisując w pole ‘Poles’ kolejno nazwy poszczególnych punktów. Najłatwiej jest to zrobić umieszczając w nim kursor i klikając w kolejne punkty z przyciśniętym klawiszem CTRL. W polu powinno się pojawić coś jak poniżej

{point01,point02,point03,point04,}

Resztę pól zostawmy ze standardowymi wartościami. Klikając ‘OK’ stworzymy krzywą jak poniżej :

Krzywa została stworzona na płaszczyźnie XY (to znaczy że jest płaska), więc możemy teraz poprzemieszczać punkty w przestrzeni, tak, aby nadać krzywej pożądaną formę. Sposoby manipulowania uchwytami punktów pokazuje poniższa ilustracja :

Mając pierwszą krzywą w odpowiedniej konfiguracji przestrzennej dodajmy kolejne dwie krzywe, postępując w ten sam sposób (cztery punkty w przestrzeni, nowa krzywa BSpline metodą ByPoles, klikamy punkty z CTRL w polu ‘Poles’) i modelujemy je na kształt dachu.

W wyniku powyższych operacji powinniśmy mieć teraz trzy krzywe : bsplineCurve01, bsplineCurve02 i bsplineCurve03. Zbudowane one są odpowiednio z punktów {point01,point02,point03,point04}, {point05,point06,point07,point08} i {point09,point10,point11,point12}.

Powierzchnie BSpline można budować na wiele sposobów, my użyjemy tutaj metody LoftCurves. Jako ‘Curves’ wprowadźmy trzy krzywe {bsplineCurve01,bsplineCurve02,bsplineCurve03}  (nawias klamerkowy wskazuje na to, że jest to kolekcja). Pole ‘Order’ powinno mieć wartość 4 lub 3.

.. i w rezultacie otrzymujemy parametryczny dach!

Teraz nadszedł dobry moment na to, żeby zastanowić się nad formą. Na tym etapie można bowiem manipulować punktami kontrolnymi i oceniać bezpośrednio skutki tych manipulacji w czasie rzeczywistym. Sugeruję poobracać model z każdej strony i modelować kształt dopóki nie będziemy z niego zadowoleni

(w ikonkach na górze okna po kliknięciu drugiego narzędzia od lewej możemy zmienić tryb graficzny wyświetlania na Illustration bądź Smooth – to pomaga w estetycznej ocenie rozwiązania!)

—————————————–

Panelizacja

Oczywiście w takiej formie dach może istnieć tylko wirtualnie, ponieważ wytworzenie każdej powierzchni podwójnie zakrzywionej to nie lada wyzwanie. Aby to uprościć, spróbujmy go spanelizować – czyli podzielić na mniejsze komponenty, nadające się do wycięcia i fabrykacji.

Aby to zrobić musimy wypełnić dach punktami, które następnie posłużą jako wierzchołki czworokątów. Jak się za to zabrać ? Zacznijmy od pojedynczego punktu :

>> Create Feature >> Point >> ByUVParametersOnSurface (ta metoda umieści punkt na powierzchni używając parametrów U i V).

Surface : bsplineSurface01 (nasza powierzchnia)

U : 0.2

V : 0.4

Zmieniając wartości U i V możemy umieścić punkt w każdym miejscu powierzchni (pamiętając o tym, że muszą one być pomiędzy 0 i 1)

Jak stworzyć więcej punktów ? Oczywiście używając replikacji i funkcji Series() bądź SeriesByCount().

Wyedytujmy teraz transakcję tworzącą punkt (jeśli jej nie widzimy na liście transakcji, kliknijmy przycisk ‘Save’, żeby zapisać skrypt na dysku). W wyedytowanej transakcji zastąpmy linie definiujące wartości U i V następującymi wyrażeniami :

U = SeriesByCount(0, 1, 50);

V = SeriesByCount(0, 1, 25);

i dopiszmy dodatkowo :

Replication = ReplicationOption.AllCombinations;

W rezultacie, zamiast pojedynczego punktu, zobaczymy matrycę jak poniżej :

(wygląda trochę na to, że punktów jest za dużo, więc sugeruję zmniejszyć ilość kroków w SeriesByCount do 25 i 12)

Zanim zabierzemy się za panelizację, ukryjmy naszą powierzchnię BSpline, żeby nie przeszkadzała w wizualnej ocenie paneli (inaczej będzie je trochę zasłaniać). Aby to zrobić, wybieramy narzędzie ‘Toggle Visibility’ (czarno-szara ikonka z ukośnymi kreskami ), najeżdżamy na powierzchnię (aż wyświetli się bsplineSurface01) i klikamy. Alternatywnie, możemy też kliknąć na nią w widoku symbolicznym.

Stworzenie siatki paneli mogłoby być dość skomplikowane, ale ratują nas tutaj twórcy GC, którzy przewidzieli popularność panelizacji, i stworzyli do tego specjalną metodę. Znajduje się ona w elemencie Polygon. Wybierzmy narzędzie ‘Create New Feature’, następnie ‘Polygon’ a potem ‘ByPointGrid’.

Points: point13 (albo poprostu nazwa punktu na powierzchni – może być inna. Zwróćmy uwagę, żeby po kliknięciu na punkt z CTRL usunąć nawiasy kwadratowe i klamerki – bo podajemy całą kolekcję, a nie jej część).

resztę pól pozostawiamy ze standardowymi wartościami,

Wynik to podzielony na panele uproszczony model krzywoliniowego dachu :

I tak oto otrzymaliśmy naszą panelizację!

Jak łatwo zauważyć przyglądając się dokładniej panelom, większość z nich będzie powyginana w różnych kierunkach (będą wyglądać jak ramki z elastyczną tkaniną w środku). Aby wymusić ‘płaskość’ paneli należy użyć podczas tworzenia opcji FacetOption.ForcePlanarQuads lub FacetOption.Triangulation.. W pierwszym przypadku panele ‘wyskoczą’ trochę z powierzchni i pojawią się między nimi luki – ale to normalne, tak jak w dachu Smithsonian Institute. Aby tego uniknąć należy zgłębić tajniki teselacji powierzchni krzywoliniowych.. ale to już temat na inny post

Ciekawy efekt można też uzyskać wybierając opcję FacetOption.Diamond

aby zmienić właściwości elementu, np. sposób teselacji, nie trzeba cofać transakcji i tworzyć jej od początku – zamiast tego użyj opcji edit feature , i zmień odpowiedni parametr.

————————————–

Rozwijanie elementów na płaszczyznę

Aby przygotować elementy do fabrykacji, musimy stworzyć element o typie ‘FabricationPlanning’. Ten typ elementu zazwyczaj służy do takiego rozplanowania elementów na płaszczyźnie, aby były zupełnie płaskie i aby przy np. drukowaniu lub wycinaniu laserowym zachowały identyczne wymiary i kształt do oryginałów. Normalnie nie jest to proste, bo elementy są obrócone wokół kilku osi w przestrzeni, i aby umieścić je w płaszczyźnie poziomej, należy dokonać kilku obrotów.. wykonanie tego na kilkuset elementach nie należy na pewno do zadań  łatwych

W naszym przypadku możemy użyć dwóch metod tworzenia FabricationPlanning : LayoutPolygons, oraz UnfoldPolygonsIntoPlanarStrips.

LayoutPolygons rozkłada każdy element osobno, w równych odstępach. Może to się przydać przy wielokątach umieszczonych w dziwnych konfiguracjach, lub niestykających się krawędziami. Przykładowe wartości do wypełnienia w polach to

CoordinateSystem : baseCS

Polygons : polygon01 (bez nawiasów klamrowych ani kwadratowych, tylko nazwa kolekcji wielokątów)

Xspacing : 1 (odstępy w rozłożonych wielokątach)

Yspacing : 1

UnfoldPolygonsIntoPlanarStrips rozkłada wielokąty w pasach, połączone krawędziami, co czyni je dużo łatwiejszymi do późniejszego montażu (np przy tworzeniu fizycznego modelu). Przykładowe wartości do wpisania w pola :

CoordinateSystem : baseCS (w którym układzie współrzędnych następuje umieszczenie płaskich elementów)

Polygons : polygon01 (jak poprzednio, bez klamerek i nawiasów)

BoundaryEdgeColor : 3 (kolor zewnętrznej obwódki – ma to znaczenie np przy przygotowaniu do wycinania laserowego, gdzie zewnętrzny obwód jest cięty, a wewnętrzne krawędzie tylko lekko nacinane)

InternalEdgeColor : 2 (zielony)

InterRowDistance : 1 (odstępy pomiędzy rozwiniętymi pasami, w metrach)

Tak oto otrzymujemy techniczny rysunek będący bezpośrednio podstawą do stworzenia zaprojektowanego dachu.

——————————————————————–

Oczywiście jest to dopiero początek, ponieważ samo wycięcie paneli nie jest zazwyczaj wystarczające. Oprócz szkła lub innego materiału potrzebujemy także strukturę, ramy, metalowe łączniki i inne detale. O tym jednak innym razem

Przykładowy przybliżony model z detalami i całą resztą mógłby wyglądać tak :

lub tak:

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

Warsztaty podzielone były na dziesięć podgrup : Deep Surfaces (projektowanie powierzchni z tkanin), Nonlinear Systems in Biology and Design (badanie zachowań systemów symulujących biologię w architekturze), Manufacturing Parametric Acoustic Surfaces (tworzenie prototypów kształtujących przestrzeń akustyczną), High Tech Design – Low Tech Construction (testowanie bardzo prostych elementów konstrukcyjnych z zaawansowanymi technikami projektowania), Parametrics and Physical Interactions (podłączanie wirtualnych modeli komputerowych do sensorów światła, temperatury itp i tworzenie fizycznych kinetycznych prototypów reagujących na warunku otoczenia) , Curved Folding (użycie robotów do wycinania i zginania metalowych powierzchni pojedynczo zakrzywionych), Explicit Bricks (testowanie zaawansowanego robota do tworzenia struktur z cegieł), Rapid R&D to Rapid Assembly (projektowanie i wycinanie drewnianych elementów nadających się do natychmiastowego montażu) , Design to Destruction (użycie zaawansowanych analiz i symulacji do zaprojektowania najbardziej wytrzymałego wspornika – testowanego na koniec przez jego komisyjne obciążenie i zniszczenie(!) ) oraz Inflatable Fabric Envelopes (projektowanie i wycinanie podwójnych membran pneumatycznych do tworzenia struktur).

Jedną z najbardziej spektakularnych grup była ‘Explicit bricks’, gdzie do wycinania styropianowych cegieł użyto robota firmy KUKA.

(wideo pokazujące proces cięcia można zobaczyć  tutaj)

Mnie przypadło w udziale organizowanie oraz prowadzenie pod-warsztatu zajmującego się fizycznymi interakcjami (Parametrics and Physical Interactions). Razem z Hugo Mulderem (Arup, Advanced Technology + Research Group) i Florą Salim (SIAL, RMIT Australia) prowadziliśmy uczestników przez proces  ’rozszerzania’ ich parametrycznych wirtualnych modeli  w celu połączenia ich z fizycznym światem. Celem było stworzenie instalacji, która reaguje na warunki otoczenia używając sensorów (światło, ruch, dźwięk), i uzewnętrznia swoje reakcje za pomocą silników, światła, multimedialnych projekcji i kinetyki (fizycznego ruchu). Podsumowanie warsztatu i krótkie, lecz treściwe omówienia projektów można zobaczyć w poniższym filmie :

Więcej informacji o Smart Geometry można znaleźć na stronie  www.smartgeometry.org

Powyżej: Manufacturing Parametric Acoustic Surfaces

Deep Surfaces

Curved Folding

High Tech Design – Low Tech Construction

Model kinetycznie zacienianego dachu stworzony w podgrupie Parametrics and Physical Interactions

W Generative Components praca opiera się głównie na transakcjach – czyli podstawowych krokach tworzących parametryczny model. Zapisane są one w głównym oknie programu, które jest także przez niektórych nazywane ‘transaction player’, bo w istocie, służy ono właśnie do odtwarzania tych transakcji jedna po drugiej.

W pewnym sensie transakcje zapisane są w konwencji ‘akcji’, lub też ‘historii’ zdarzeń podczas konstruowania modelu, co jest czasem krytykowane (w Grasshopperze mamy do czynienia z jednym, finalnym modelem), ale w rzeczywistości pomaga jednak w pracy nad dużymi i skomplikowanymi modelami. Nie wiadomo zresztą do końca jak to będzie wyglądać w przyszłości, gdyż Bentley idzie powoli w kierunku nowych rozwiązań.

Wśród okien widocznych po otwarciu Generative Components widzimy także okno z diagramem symbolicznym (po lewej stronie, na dole). Służy ono do przeglądania logicznych połączeń i hierarchicznych zależności pomiędzy elementami, a szczególnie pomocne bywa podczas tworzenia nowych komponentów (ale o tym kiedy indziej).  Niektórzy jednak nie używają tego okna prawie wogóle, lub sporadycznie podczas poszukiwania błędów w modelu (’nieudane’ elementy pojawią się tutaj na czerwono), więc jest to po części kwestia wyboru – można sobie w GC dać bez niego radę.

Przejdźmy do podstawowych elementów parametrycznego modelu.

Układ współrzędnych

Najważniejszym układem współrzędnych jest baseCS , który widzimy w oknie zaraz po otwarciu GC.

Jest to globalny układ współrzędnych, do którego odnoszą się wszystkie współrzędne punktów, wektorów itp. Graficznie przedstawiony jest jako czerwony punkt (origin), trzy kwadraty (XYPlane, YZPlane, XZPlane), i trzy wektory pokazujące graficznie oś X, Y i Z . Żółty kwadrat pokazuje obecnie aktywną płaszczyznę odniesienia – zawsze na początku jest to XYPlane, czyli pozioma powierzchnia przechodząca przez punkt 0,0,0

Punkt

Punkt to najbardziej podstawowy element parametrycznego modelu. Istnieje wiele metod tworzenia punktów, jedną z najprostszych jest ByCartesianCoordinates(coordinate system, x,y,z). Spróbujmy zatem stworzyć taki punkt. Aby to zrobić, klikamy na ikonę ‘create feature’ (w GC wszystkie obiekty nazywane są ‘features’), i z listy wybieramy ‘Point’. Po wybraniu punktu, lub generalnie po wybraniu obiektu który chcemy stworzyć, otworzy nam się druga pod-lista, która pokaże ‘metody’ jego tworzenia. Zazwyczaj jest ich tam trochę, każda potrzebuje trochę innych danych/zmiennych/obiektów wejściowych. My skupimy się teraz na najprostszej, czyli ‘ByCartesianCoordinates’. Po jej wybraniu, pokazuje się nam lista parametrów wejściowych.

Jako układ współrzędnych, w którym ma się znaleźć nasz punkt, wpisujemy ‘baseCS’ (tak, to jest nasz globalny układ współrzędnych – ale możemy to później zmienić). Należy zwrócić uwagę na duże i małe litery, gdyż np. ‘BaseCS’ nie będzie już działać).

W kolejnych polach wpisujemy współrzędne punktu, dajmy na to X =3 , Y = 2 , Z = 5

Ostatni parametr, zaznaczony na niebiesko jest nieobowiązkowy, więc nie musimy tam nic wpisywać.

Pod spodem widzimy jeszcze pola takie jak ‘name of new feature’, gdzie możemy wpisać np ‘pierwszyPunkt’ , albo ‘poczatekLinii’, lub też zostawić standardową nazwę jaką podpowie nam system (point01). Zdecydowanie warto wpisywać tutaj arbitralne nazwy adekwatne do tego czym jest dla nas dany obiekt, gdyż dużo łatwiej jest się potem połapać w modelu, szczególnie wtedy kiedy jest on już bardzo skomplikowany.

Klikamy zatem ‘OK’ po prawej stronie na dole, i widzimy coś takiego :

Jest to nasz punkt i jego parametry w modelu (po prawej widzimy go jako żółte kółko). Punkt został stworzony, a transakcja została dodana automatycznie do skryptu – możemy ją zobaczyć klikając dolną zakładkę ‘transaction file’, i odświeżając lub zapisując skrypt (odpowiednie ikony są pokazane strzałkami).

Tak więc w transakcji nr 1 stworzyliśmy punkt.  Jest to jednak tylko  jeden ze sposobów tworzenia punktów, spróbujmy więc czegoś innego. Na górze widzimy ikonkę ‘create point’ (linia z żółtym kwadratem). To narzędzie pozwoli wstawić nam punkt bezpośrednio w oknie widoku, przy czym punkt zostanie umieszczony na aktywnej płaszczyźnie odniesienia – w tym przypadku płaszczyźnie XY, pokazanej żółtym kwadratem na układzie współrzędnych baseCS. Po kliknięciu na ‘create point’ możemy wstawić go klikając w oknie widoku. Po tym przechodzimy do zakładki ‘transaction file’ i odświeżamy ich stan, lub zapisujemy zmiany.

Na dole widzimy diagram symboliczny z dwoma punktami. Drugiemu system automatycznie przypisał nazwę point01, ale możemy to zmienić edytując drugą transakcję.

Edytowanie transakcji

Teoretycznie można pracować w GC bez edytowania skryptu, ale na dłuższą metę jest to bardzo ograniczające. Tak więc dokonajmy prostej edycji – kliknijmy prawym przyciskiem myszki na drugą pozycję w transaction playerze, i wybierzmy ‘edit transaction’, po czym zmieńmy ‘point01′ na np. ‘drugiPunkt’

Tytuł transakcji może być dowolny, np ’stworzenie kolejnego punktu’ (zamiast ‘Add point01′) – tutaj też dobrze jest edytować tekst, żeby uczytelnić skrypt.

Jak widać, konstrukcja transakcji jest dość prosta. W pierwszej linii posiada słowa kluczowe transaction i modelBased ,  a potem tytuł. Zawartość zawsze znajduje się w nawiasach. Jako, że transakcja może zawierać w sobie wiele obiektów, każdy z nich również zamyka swój opis w nawiasach { … }. Słowo kluczowe feature zaczyna opis obiektu. Po nim następuje jego nazwa (razem z nazwą przestrzeni nazw, to jest lekko skomplikowane, ale .. uhm, podobno ułatwia sprawę , a następnie typ deklarowanego obiektu- w tym wypadku Bentley.GC.Point

Jak widać na poprzednim zrzucie ekranu, drugi punkt posiada ‘uchwyty’ – służą one do manualnego manipulowania punktem w kierunkach X,Y lub Z. Widać je tylko na drugim punkcie, ponieważ posiada on słowo <free> przed wartością współrzędnej. Możemy dodać <free> przed wartości w pierwszej transakcji (ale muszą one znajdować się wtedy w okrągłym nawiasie), żeby włączyć uchwyty dla pierwszego punktu. Manipulować można nimi za pomocą narzędzia ‘move’ . Spróbuj użyć go, najeżdżając na jeden z uchwytów, klikając a potem przeciągając myszkę – punkt powinien przesuwać się w przestrzeni zgodnie z pozycją kursora.

Krzywa BSpline

Kolejnym obiektem, którego prawdopodobnie będziemy używać dość często jest krzywa Bspline. Jest to krzywa sklejana beziera, czyli złożona krzywa stworzona przez połączone fragmenty prostszych krzywych. Mówiliśmy o nich wcześniej w tym tutorialu. Krzywą taką można skonstruować na dwa sposoby – z punktów kontrolnych (metodą .ByPoles), lub z węzłów znajdujących się na krzywej ( .ByPoints). Generalnie polecam pierwszą metodę, gdyż łatwiej jest wtedy kontrolować  styczność i pochodne krzywizny – w drugiej metodzie, gdy punkty są bardzo daleko od siebie, a potem nagle bardzo blisko, krzywa może wykonywać niespodziewane ‘zakręty’ albo pętle w przestrzeni.

Spróbujmy więc stworzyć taką krzywą dwoma opisanymi tutaj metodami. Stwórzmy zatem nowy szkic, wybierając File >> New Transaction File. Upewnijmy się, że naszą aktywną płaszczyzną jest baseCS.XYPlane, po czym wybierzmy narzędzie ‘place point’ i wstawmy do projektu cztery bądź więcej punktów, jak poniżej.

Następnie klikamy ikonę ‘create feature’ aby stworzyć krzywą, i z dostępnego menu wybieramy ‘BSplineCurve’ a potem ‘ByPoles’, jak poniżej.

Tak oto stworzyliśmy pierwszą krzywą BSpline. Możemy teraz pomanipulować trochę punktami za pomocą narzędzia ’move’ () i poobserwować zachowanie krzywej. Zwróćmy uwagę na fakt, że początek i koniec krzywej są styczne do linii stworzonej przez dwa pierwsze lub dwa ostatnie punkty kontrolne.

Dobrze jest spróbować też drugi wspomniany wcześniej sposób tworzenia krzywej (.ByPoints) i porównać różnice. Przy jednym, i drugim, punktów kontrolnych może być oczywiście więcej.

—————————————————————————————–

Tyle narazie jeśli chodzi o podstawy – a w następnym tutorialu zajmiemy się wykorzystaniem krzywych BSpline do stworzenia parametrycznego dachu  z prawdziwego zdarzenia

Projektowanie komputacyjne w architekturze  

Projektowanie komputacyjne to zagadnienie, które w ostatnim czasie szybko zyskuje na popularności. Obecnie dobrze zakorzenione w przemyśle samochodowym i lotniczym, powoli zaczyna wkraczać także jako narzędzie do świata architektury. Dlaczego? Ponieważ technologie projektowania wspomaganego komputerowo, oraz przede wszystkim fabrykacji stają się coraz bardziej dostępne i tańsze, a co za tym idzie, wzrasta dostępność produkcji niestandardowych elementów na masową skalę (tzw. ‘mass customization’).

Jak pisał Adrian Beukers i Ed van Hinte w swoim eseju ‘Lightness’ (‘Lekkość’), ‘W naturze kształt jest tańszy niż materiał’, zwracając uwagę na to, że koszt wytworzenia formy może być dużo niższy, jeśli znajdziemy optymalne rozwiązania strukturalne lub topologiczne opisujące problem projektowy. Nie jest już dzisiaj niczym zaskakującym, że dokonując strukturalnej optymalizacji topologii połączeń w mega-konstrukcjach można zaoszczędzić do 50% materiału.

Projektowanie komputacyjne, poprzez użycie różnych technik takich jak algorytmy genetyczne i sztuczna inteligencja, razem z metodą elementów skończonych, lub innymi technikami optymizacyjnymi, może pomóc zdefiniować problem projektowy w zupełnie inny sposób i znaleźć nową, często zaskakującą odpowiedź. Czy jest to problem czysto geometryczny, tak jak panelizacja podwójnie zakrzywionych powierzchni, czy też strukturalny, jak minimalizacja stresów w przestrzennej kratownicy, z pomocą mogą przyjść programy lub skrypty pisane w różnych językach oraz narzędzia do modelowania parametrycznego, takie jak Generative Components oraz Rhino Grasshopper. Modelowanie parametryczne pozwala na definiowanie hierarchicznych zależności pomiędzy obiektami geometrycznymi zamiast statycznego układu brył w przestrzeni, do którego przyzwyczajone są osoby korzystające z bardziej standardowych narzędzi CAD. Modelowanie parametryczne, które pozwala na szybkie przeglądanie wersji potencjalnych rozwiązań, jest dzisiaj coraz powszechniej stosowane w projektowaniu stadionów, wieżowców, części fasad, dachów jak i niewielkich detali konstrukcyjnych.

Terminologia związana z projektowaniem komputacyjnym podlega ciągłej transformacji, ponieważ dziedzina jest nowa i wciąż szybko się rozwija. Dosyć szeroko przyjęte jest odróżnianie “projektowania parametrycznego” od “projektowania generatywnego”:

Projektowanie parametryczne to proces w którym wynikowa forma jest zazwyczaj jedną iteracją (przebiegiem) informacji geometrycznych przez ‘drzewo’ hierarchicznych zależności pomiędzy elementami. Po wykonaniu takiej iteracji, otrzymujemy parametryczny model, który jest topologicznie statyczny, możemy za to zmieniać jego geometrię (skalować, rozciągać, manipulować parametrami).

Projektowanie generatywne to proces w którym forma jest generowana na podstawie wielokrotnych iteracji, zazwyczaj dodawania/odejmowania elementów, lub dzielenia ich na mniejsze pod-elementy. Za narzędzia używane w projektowaniu generatywnym można uznać algorytmy genetyczne, sieci neuronowe, oraz wszystkie algorytmy wykorzystujące procesy symulacji sztucznego życia, takie jak automaty komórkowe, systemy samo-organizujące się, systemy cząsteczek-agentów, oraz pomocniczo systemy bazujące na metodzie elementów skończonych (finite element analysis), takie jak dynamiczna relaksacja.

Projektowanie komputacyjne w praktyce architektonicznej

Jednymi z pierwszych spektakularnych projektów wykonanych z użyciem projektowania parametrycznego był Swiss Re (tzw. ‘ogórek’) w Londynie, autorstwa biura Foster+Partners (2004), Centrum handlowe O2 w Birmingham (Future Systems 2003) oraz Kunsthaus w Graz w Austrii (Peter Cook + Colin Fournier 2003). Technikami projektowania parametrycznego posługuje się dzisiaj wiele znanych biur architektonicznych i inżynierskich, takich jak HOK Sport, Arup, Grimshaw+Partners, Zaha Hadid architects, Frank Gehry czy Aedas.

 
Również duża ilość projektów generatywnych doczekała się już realizacji. Przykładem może tu być szklane zadaszenie dziedzińca British Museum, gdzie użyto algorytmu dynamicznej relaksacji dla zoptymalizowania sił i wielkości paneli. Innym jest realizowne obecnie zadaszenie stacji metra w Neapolu projektu Rogers Stirk Harbour + Partners. W tym projekcie konstruktorzy – firma Expedition Engineering – postanowili wykorzystać algorytmy genetyczne, żeby zoptymalizować dystrybucję elementów strukturalnych zadaszenia ze względu na ilość światła dziennego penetrującą wnętrze stacji. Optymalizacja z użyciem ewolucji polega na hodowaniu kolejnych generacji potencjalnych rozwiązań w których osobniki stosunkowo dobrze spełniające zadane kryteria przekazują swoje cechy kolejnym. W tym przypadku optymalizowano na przestrzeni 70 generacji, każda po 400 osobników.

Obszarem zastosowań algorytmów generatywnych jest również urbanistyka, ponieważ użycie zasad samo-organizacji może pomóc w odnalezieniu układów przestrzennych które są lepsze od tych zaprojektowanych tradycyjnymi metodami na przykład pod względem komunikacyjności lub dystrybucji ze względu na nasłonecznienie. ‘Agentom’, które reprezentują bloki zabudowy, można na przykład zadać zadanie znalezienia pozycji i orientacji umożliwiającej najlepsze skorzystanie z dostępnych widoków, oraz dostępu do naturalnego światła. Poprzez lokalne negocjacje na niskim poziomie hierarchii, otrzymujemy globalne (całościowe) rozwiązanie uwzględniające interesy każdego z podmiotów symulacji.

Układ, którego globalny stan jest czymś więcej niż sumą lokalnych stanów wszystkich jego elementów nazywany jest układem emergentnym. Emergencja to zjawisko związane z wykorzystaniem prostych reguł działania na lokalnym poziomie (interakcji pomiędzy pojedycznymi agentami), do stworzenia ‘kolektywnej’ inteligencji na globalnym poziomie całego stanu układu.

Cyfrowe wspomaganie wytwarzania

Wszystkie powyżej opisane techniki zyskują coraz szersze zastosowanie w architekturze, ponieważ znacząco rozwijają się możliwości cyfrowego wspomagania wytwarzania, czyli tzw. cyfrowej fabrykacji. Projektowanie parametryczne i generatywne pozwala automatycznie dostosować elementy projektu do wybranej technologii fabrykacji. Takie ‘dopasowanie’ do fabrykacji, staje się poprostu jeszcze jednym kryterium optymalizacji. Najczęstszym przykładem jest tutaj np. podzielenie dowolnej przestrzennej, podwójnie zakrzywionej formy/powierzchni na elementy płaskie (np szklane panele), współdzielące ze sobą krawędzie (bez pomocy generatywnych procesów jest to bardzo trudne lub wręcz niemożliwe). Można też optymalizować obiekty tak, aby zużywały jak najmniej materiału. Technologie cyfrowego wspomagania wytwarzania dzielą się na addytywne, subtraktywne i formatywne.

Technologie addytywne polegeją na nakładaniu i łączeniu kolejnych warstw materiału. Popularna nazwa tych technik to “druk 3d”. Dzisiaj można drukować na drukarkach proszkowych, nylonowych (drukujących plastikiem), lub nawet takich które układają na sobie warstwy metalu. Nowością (jeszcze niedostępną komercyjnie) jest olbrzymia drukarka budowana przez firmę D-Shape, która może drukować cementem w dużej skali (obszar roboczy to 3×3x3 m). Koszty druku 3d szybko maleją a produceni drukarek zapowiadają technologie, które spowodują, że druk 3d będzie niebawem tak popularny jak druk 2d – używający kartek i atramentu. Byłaby to prawdziwa rewolucja w projektowaniu produktu. W architekturze druk 3d jest na razie wykorzystywany do produkcji modeli.

Technologie subtraktywne to te które polegają na odejmowaniu materiału. Przykładami jest frezowanie CNC i cięcie laserowe. Ograniczenia materiałowe są w tym przypadku niewielkie a skala wykonywanych elementów może sięgać kilkunastu metrów, stąd to te technologie są najczęściej wykorzystywane w architektonicznych realizacjach.

 
Technologie formatywne to na przykład użycie robotów do układania elementów konstrukcji. Dobrym przykładem jest tutaj parametryczna ściana winnicy, projektu duetu Gramazio & Kohler, stworzona za pomocą robota firmy KUKA.

 
Projektowanie komputacyjne może ale nie musi wiązać się z estetyką dominującą obecnie wśród niektórych star-architektów. Jednym z najważniejszych aspektów omówionych technik jest optymalizacja, która zapewnia bardzo dobre wykorzystanie budżetu projektu oraz stworzenie przestrzeni funkcjonującej w odpowiedni sposób. Wzbogacenie polskich pracowni architektonicznych o narzędzia parametryczne i generatywne oraz wprowadzenie tej tematyki na uczelnie jest jednym z warunków, które polska architektura powinna spełnić by pozostać konkurencyjna na rynku międzynarodowym.

Przemysław Jaworski (Foster+Partners, SMG) www.projektowanieparametryczne.pl

Michał Piasecki (Bartlett, UCL) www.michalpiasecki.com

W kolejnej lekcji języka programowania Processing (poprzednia jest tutaj), zajmiemy się krzywymi Beziera. Dlaczego ? Ponieważ krzywe te są bardzo często podstawowym środkiem definiowania nie-liniowej geometrii np. fasad lub dachów. Nie są one co prawda tak popularne jak krzywe B-Spline (chociaż są ich najprostszą wersją), lub ich rozszerzona wersja – NURBS, ale od nich wszystko się zaczęło, więc warto przyjrzeć się im z bliska (są na przykład używane w programie Adobe Illustrator).

Na początek omówimy podstawy tworzenia krzywych, i kilka technicznych elementów pomocnych w kreowaniu trójwymiarowych struktur w Processing. Potem stworzymy program rysujący powierzchnię dachu (jak powyżej) i eksportujący ją do pliku.

————————————————————–

Spróbujmy napisać kilka lini kodu rysujących przykładową krzywą Beziera. Aby to zrobić potrzebujemy czterech punktów – początku, czyli tzw. pierwszego punktu zakotwiczenia, dwóch punktów kontrolnych, i drugiego punktu zakotwiczenia, czyli końca krzywej.

Zdefiniujmy zatem łańcuch współrzędnych: cztery współrzędne X (łańcuch będzie miał nazwę ‘px’), i cztery współrzędne Y (łańcuch o nazwie ‘py’)

float px [] = new float[4];
float py [] = new float[4];

w ten sposób zdeklarowaliśmy oba łańcuchy, które są teraz gotowe do użycia. Każdy z nich ma cztery pozycje, w których będzie trzymał jedną współrzędną. Przypiszmy im zatem teraz wartości – współrzędne punktów kontrolnych i skrajnych dla krzywej, w układzie współrzędnych XY (liczonym od lewego górnego rogu okna).

px[0] = 50; py[0] = 50;  //pierwszy punkt kontrolny – początek krzywej
px[1] = 40; py[1] = 170; //drugi punkt kontrolny
px[2] = 270; py[2] = 170; //trzeci
px[3] = 250; py[3] = 250; //czwarty – koniec krzywej

size(300,300); //otwórzmy okno o rozmiarach 300 x 300 pikseli

noFill(); //wyłączmy wypełnianie obiektów (o tym później)

bezier(px[0],py[0],  px[1],py[1],  px[2],py[2],  px[3],py[3]); //i narysujmy krzywą

Po wpisaniu powyższego kodu do edytora i naciśnięciu przycisku start, powinniśmy zobaczyć poniższy obraz :

Wygląda ciekawie, ale nadal trochę tajemniczo..  Żeby zrozumieć lepiej, jak działają krzywe beziera, narysujmy punkty kontrolne. Dodajmy na końcu poniższe linie :

fill(255,0,0); //zmieniamy kolor na czerwony (podając kolejno wartości r, g, b)
ellipse(px[0], py[0] ,8,8); //punkt nr 1
ellipse(px[1], py[1] ,8,8); //punkt nr 2
ellipse(px[2], py[2] ,8,8); //punkt nr 3
ellipse(px[3], py[3] ,8,8); //punkt nr 4

a żeby zobaczyć jak wygląda tak zwany ‘control polygon’, połączmy je liniami:

stroke(50,100); //ustawiamy kolor i przezroczystość linii
line(px[0], py[0] ,px[1], py[1]);
line(px[1], py[1] ,px[2], py[2]);
line(px[2], py[2] ,px[3], py[3]);

Po dodaniu powyższych linii, uruchamiamy szkic (przyciskiem run, albo ctrl+R) i widzimy krzywą jak poniżej :

Patrząc na ten przykład, można łatwo zauważyć podstawową właściwość krzywej Beziera : początek i koniec są styczne do linii kontrolnych, a to można sprytnie wykorzystać przy tworzeniu bardziej skomplikowanych geometrii.

Spróbujmy teraz zrobić z tego coś ciekawszego, czyli wykorzystać replikację (poprzez użycie pętli FOR – więcej informacji o tym jak jej używać jest w poprzednim tutorialu). Generalnie najciekawsze efekty daje niewielka modyfikacja współrzędnych punktów kontrolnych, i narysowanie wszystkich tak powstałych krzywych razem obok siebie. Dodajmy zatem :

noFill(); //wyłączamy wypełnianie
for (int i=0;i<20;i++) //uruchamiamy pętlę na 20 powtórzeń
{
px[0] = px[0]+5; //przesuwamy punkt 0 w prawo
py[1] = py[1]+8; // punkt 1 w dół
py[2] = py[2]-4; //punkt 2 w górę
px[3] = px[3]+2; //punkt 3 lekko w prawo
bezier(px[0],py[0],  px[1],py[1],  px[2],py[2],  px[3],py[3]); //i rysujemy krzywą
}

Ciekawą wizualizację krzywych razem z liniami kontrolnymi można uzyskać przenosząc dwie linijki kodu:

for (int i=0;i<20;i++)
{

nad linię z komendą fill(255,0,0); , ponieważ wtedy w pętli znajdzie się procedura rysowania linii i czerwonych kółek. Otrzymamy wtedy obraz pokazujący dokładnie ‘wędrówkę’ punktów kontrolnych :

Przy zabawie parametrami można pójść trochę dalej, i dodając do nich kilka sinusów,  otrzymać geometrię jak poniżej :

Pewnie ktoś z czytelników zapyta.. ‘ok, wporządku, ale do czego można tego teraz użyć’ ? Otóż w parametrycznym modelowaniu często spotykamy się z modelowaniem jakiejś powierzchni (np dachu) przez przeciągnięcie jednego profilu wzdłuż krzywej (tzw. szyny – ’sweep profile along rail curve’ ), lub zbudowanie z wszystkich krzywych jednej powierzchni (’loft curves’). Tak też spróbujemy zrobić za kilka chwil.

——————————————————————————-

Najpierw jednak, aby ułatwić nam nieco modelowanie trójwymiarowych obiektów, i ich przestrzenną ocenę, musimy dodać do programu element interaktywny. Inaczej będziemy ciągle w dwuwymiarowym, statycznym świecie. Ta mała dygresja jest raczej konieczna do tego, żeby przejść do kolejnego, bardziej ekscytującego (!) etapu programowania w trzech wymiarach.

W Processing możemy pisać programy na dwa sposoby : liniowy, gdzie zwyczajnie wpisujemy komendy jedna po drugiej, np :

size(300,300,P3D); //ustawiamy okno

translate(150,150); //przesuwamy układ współrzędnych na środek ekranu (połowa szerokości, połowa wysokości)

rotateX(PI/3); //obracamy układ współrzędnych wokół osi X
rotateZ(PI*1.7); //i wokół osi Y

box(50); //i rysujemy sześcian

W ten sposób program wykonuje wszystkie polecenia po kolei, i zatrzymuje się na końcu. Możemy w międzyczasie wykonywać pętle, definiować wiele graficznych elementów i pisać nieskończone ilości instrukcji – ale wszystko zostanie wykonane tylko raz.

Drugi sposób, to sposób nieliniowy, interaktywny i zorientowany zdarzeniowo. To znaczy, że po uruchomieniu programu, instrukcje będą wykonywane w niekończącej się pętli (ok 20-30 razy na sekundę), a program może w tym czasie rysować dowolne rzeczy, wydawać dźwięki, odgrywać video, i co najważniejsze reagować na zdarzenia. Takimi zdarzeniami zazwyczaj są manipulacje myszką i naciskanie klawiszy na klawiaturze, ale może to też być bardziej skomplikowany bodziec, jak na przykład obraz z kamery video, lub dźwięk z mikrofonu.

Program taki wygląda tak:

void setup()
{
println(”ta instrukcja wykona się 1 raz”);
}

void draw()
{
println(”ta instrukcja wykona się wiele razy”);
}

Czyli ma dwie części : setup, i draw. Pierwsza wykonuje się tylko raz, dokonujemy w niej ustawienia okna, początkowych zmiennych, ładujemy czcionki, obrazy i dźwięki. Druga (draw) to część która będzie wykonywać się w nieskończoność, dopóki nie zakończymy programu.

Ten sam program, w wersji interaktywnej będzie wyglądał tak :
void setup()
{
size(300,300,P3D); //ustawiamy okno (włączamy też tryb pracy w trzech wymiarach)
}

void draw()
{
background(160); //czyścimy tło przed narysowaniem czegokolwiek

translate(150,150); //przesuwamy układ współrzędnych na środek ekranu (połowa szerokości, połowa wysokości)

rotateX(mouseY*PI/300); //obracamy układ współrzędnych wokół osi X (wykorzystujemy pozycję myszki!)
rotateZ(mouseX*PI/300); //i wokół osi Y

box(50); //i rysujemy kostkę
}

Po uruchomieniu powyższego kodu, zobaczymy radośnie obracający się sześcian

——————————————————————————-

Po tej małej dygresji zacznijmy więc nowy szkic (wybierając z menu File >> New). Na początek, tak jak poprzednio, deklarujemy współrzędnych punktów kontrolnych

float px [] = new float[4];
float py [] = new float[4];

I przejdźmy do trybu 3D – robi się to poprzez deklarację size(szerokość, wysokość, tryb).  Tryb może być wyrażony przez P3D – standardowy silnik Javy (działa w oknie przeglądarki stron www), albo przez OPENGL – szybszy i dużo lepszy graficznie silnik, ale działający tylko w oknie Processingu albo po skompilowaniu szkicu do pliku .exe.

void setup()
{
size(600,400,P3D); //tworzymy okno (tym razem trochę większe!)
}

i zaczynamy część ‘dynamiczną’

void draw()
{
background(160); //czyścimy tło
translate(300,200);//przesuwamy układ współrzędnych na środek

rotateX(mouseY*PI/300); //i obracamy go wokół osi X
rotateZ(mouseX*PI/300); //i osi Z

noFill(); //bez wypełniania
stroke(250,160); //rysujemy białym, lekko przezroczystym kolorem

Współrzędne punktów będą teraz trochę inne, a nasza krzywa będzie przypominać odwróconą literę ‘U’. Narysujemy ją 120 razy, przesuwając ją stopniowo  (użyjemy znowu pętli FOR). Zauważ, że zamieniliśmy współrzędną Y ze współrzędną Z (gdzie współrzędna Y przesuwa się od -60 do 60).

for (int i=-60;i<60;i++)
{
px[0] = -100; py[0] = -50;
px[1] = -80;     py[1] = 150;
px[2] = 80;      py[2] = 150;
px[3] = 100;    py[3] = -50;

bezier(px[0],  i*2,  py[0],   //współrzędne pierwszego punktu (początku krzywej)
px[1 ],  i*2,  py[1],    //współrzędne drugiego punktu
px[2],  i*2,  py[2],   // trzeciego
px[3],  i*2,  py[3]); //i czwartego (koniec)
}

}

Po uruchomieniu programu, widzimy naszą pierwszą prawdziwie trójwymiarową powierzchnię :

W tym momencie nasz ‘dach’ jest poprostu zwyczajną powierzchnią ‘translacyjną’, czyli powstałą poprzez translację (przesunięcie) profilu w przestrzeni. Prawdziwa zabawa zacznie się jednak dopiero, gdy zaczniemy modulować profil podczas przesuwania. Jak to zrobić ? Wystarczy przy każdym przebiegu pętli zmienić lekko współrzędne punktów kontrolnych. Dobrze jest użyć do tego funkcji Sinus lub Cosinus, ponieważ łatwo nią sterować za pomocą amplitudy i okresu. Na przykład jeśli w naszej pętli zmienna i przechodzi od wartości -60 do 60, to dodając do którejś współrzędnej wyrażenie sin(i/60 * PI) * 50 , wartość wyrażenia przejdzie płynnie od sin(-PI)*50 do sin(PI)*50, czyli od -50 do 50, oczywiście płynnym ruchem, jak na sinusoidzie.

Dodając kilka takich kombinacji można uzyskać poniższy efekt :

A kod generujący krzywiznę wygląda tak :

for (int i=-60;i<60;i++)
{
px[0] = -100;                                             py[0] = -50+sin(i*PI/60.0)*25;
px[1] =  -80+sin(i*PI/45.0)*50;   py[1] = 50;
px[2] =   80;                                                py[2] = 50;
px[3] =  100+sin(i*PI/60.0)*25;  py[3] = -50+sin(i*PI/40.0)*15;

bezier(px[0],    i*2,     py[0],
px[1 ],    i*2+sin(i*PI/120.0)*150,  py[1],
px[2],    i*2,     py[2],
px[3],    i*2,     py[3]);
}

Oczywiście jest to arbitralna zabawa liczbami i wyrażeniami matematycznymi, więc można dodawać i odejmować różne części wyrażeń, żeby uzyskać podobny, lub zupełnie inny efekt (np pionową fasadę zamiast poziomego dachu) – ale to już zależy od inwencji designera.

Aby zapisać tak wygenerowany ‘dach’ musimy użyć biblioteki do eksportowania geometrii do plików DXF. Tak samo jak w poprzednim odcinku, zadeklarujemy użycie tej biblioteki na samym początku programu poprzez dodanie linii

import processing.dxf.*;

Należy pamiętać, żeby używać funkcji beginRaw(..) i endRaw() tylko wtedy kiedy chcemy zapisać geometrię, inaczej będzie ona spowalniać niepotrzebnie nasz program. Poza tym warto zapisywać geometrię bez żadnych obrotów – najlepiej poprostu włączyć i wyłączyć program trzymając kursor myszki poza oknem, wtedy dach będzie leżał poziomo na płaszczyźnie XY.  Można też zamienić linie obracające układ współrzędnych na rotateX(0); rotateZ(0); , lub zupełnie je wyłączyć/skomentować za pomocą symbolu //   (początek komentarza – tekst następujący po tym symbolu jest ignorowany).

Po wyeksportowaniu geometrii do pliku, możemy otworzyć go w programie CAD i zrobić z nim co nam się żywnie podoba

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

Modele tegorocznego pawilonu AA.

Johan Voodrouw i jego ‘Printed Aedicules’ (poniżej), to eksperymentalny projekt prezentacji idei i danych przestrzennych z wykorzystaniem tradycyjnego, płaskiego medium jakim jest książka. Forma została wydrukowana w technologii SLS (biały nylon).

Marilena Skavara z kursu Adaptive Architecture and Computation, prezentuje model fasady reagujący automatycznie na warunki nasłonecznienia. Algorytm sterujący jej elementami ‘uczy się’ przez cały rok warunków pogodowych i dostosowuje zacienienie budynku tak, aby ten utrzymywał komfortową temperaturę.

Instalacja została wykonana z użyciem Arduino, małych serwomotorów i języka programowania Processing. Video dostępne tutaj.

Jedną z większych i bardziej zwracających uwagę instalacji, była ‘The Memory Theatre’ Tetsuro Nagaty, która pokazuje widza w magicznym lustrze, które jest opóźnione w stosunku do rzeczywistości o kilka sekund. Opóźnienie zmienia się, w zależności od położenia oglądającego, a czas przyspiesza lub zwalnia. Dodatkowo twarze widzów łapane są poprzez oprogramowanie do rozpoznawania kształtów, i umieszczane na specjalnej ‘mini wystawie’.

‘Crackology’ to praca operująca technikami parametrycznego urbanizmu, uzupełniająca tkankę miejską Sao Paulo strukturami wplecionymi w komunikacyjne i przestrzenne siatki miejskich interakcji. Bardzo ciekawa warstwa graficzna!

Patrick Usborne

Generalnie trzeba przyznać, że wiele projektów pokazuje tradycyjny styl Bartlett, gdzie warstwa artystyczna dominuje przekaz, nie troszcząc się za bardzo o klarowne wyjaśnienie o co tak naprawdę chodzi w projekcie. Niewiele można tutaj zobaczyć tradycyjnych planów, sekcji, rysunków klatek schodowych i okien. Zamiast tego, wystawiający się ’szybują’ wysoko w świat imaginacji i graficzno-rzeźbiarskich metafor, inspirując, niepokojąc, i grając na szerokim wachlarzu emocji widza.

Mimo wszystko jednak, z tego całego misz-maszu, można zrozumieć, że ten bardzo awangardowy nurt architektury traktuje budynki i przestrzenie miejskie jako żywe organizmy, zwierzęce istoty, czujące i reagujące na zmiany otoczenia, a przede wszystkim na ludzi. To już nie jest tylko biomimetyka, algorytmy, połączenie biologii z komputerami, lecz cała warstwa znaczeń i symboli kreująca nowy paradygmat, w którym ludzie żyją już nie w ‘betonowej pustyni’, lecz ‘magicznym lesie’. Przestrzeń jest tutaj definiowana na nowo z każdym dniem, i potrafi zaskakiwać.

Należy jednak pamiętać, że to wszystko to tylko eksperymenty, a spójna wizja nowoczesnej architektury wynikającej z nowych technologii jest właśnie w trakcie tworzenia (i było to wielokrotnie podkreślane podczas konferencji), więc na klarowne deklaracje nowego stylu, lub epokowe ‘manifesty’ będzie trzeba jeszcze poczekać.

Po pierwsze – do czego może się Processing przydać w codziennej pracy designera ? Przede wszystkim do automatyzacji powtarzalnych zadań. To jednak brzmi mało zachęcająco, więc dodam, że można z powodzeniem używać Processing do definiowania najbardziej skomplikowanych form geometrycznych, takich jak np. powierzchnie dachów i fasad (z tym spotkałem się najczęściej). Tak naprawdę jednak, najwięcej korzyści przynosi użycie go do dynamicznego, i szybkiego wspomagania procesu projektowania, a szczególnie oceny poszczególnych pomysłów, i ewolucji rozwiązań. Tutaj nie chodzi już o to, żeby wygenerować jakąś formę, lecz bardziej o generowanie jej tyle razy, i w takich wariantach, żeby znaleźć jej nalepsze wcielenie (to podejście niektórzy nazywają ‘projektowaniem ewolucyjnym’, bądź ‘generatywnym’).

przykładowy szkic z pulsującymi sześcianami

Po drugie – Processing daje dużą dozę interaktywności. Przede wszystkim w samym procesie projektowania, gdzie możemy oglądać generowaną formę/obiekt podczas jego ewolucji  i na nią wpływać poprzez np. klawiaturę albo myszkę. Możemy także w stosunkowo prosty sposób tworzyć proste instalacje multimedialne reagujące na widza lub otoczenie (ale to już osobny rozdział).

I wreszcie po trzecie – Processing jest na tyle prosty, że może w nim pracować każdy, kto miał trochę do czynienia z prostą matematyką lub logiką. Ma w sobie sporo stworzonych przez użytkowników bibliotek, które pozwalają na szybkie i łatwe zapisanie efektów pracy w plikach PDF, JPG lub np. DWG (przy eksportowaniu trójwymiarowych modeli). Poza tym styl pisania programów na tej platformie jest bardziej luźny, większość ludzi pisze ’szkice’, czyli krótkie zlepki kodu generujące ciekawe efekty, zamiast pisać wielkie skomplikowane programy-giganty.

W skrócie, środowisko to nadaje się dla twórców, którzy nie chcą spędzać długich godzin szukając sposobu na narysowanie np. krzywych Beziera, tylko wolą poprostu usiąść i widzieć gotowy efekt w ciągu kilku chwil.

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

Dobrą rzeczą jest też to, że wokół platformy Processingu stworzyła się dość duża społeczność, która wymienia się doświadczeniami, fragmentami kodu i pomysłami.

Najwięcej ciekawych przykładów z kodem źródłowym można znaleźć na http://www.openprocessing.org/ lub na oryginalnej stronie www.processing.org , powstało też kilka ciekawych książek. Można by śmiało rzec, że Processing jest jedną z najlepszych platform edukacyjnych do nauki programowania i projektowania komputatywnego z tych istniejących na dziś dzień w internecie.

Sam program jest do ściągnięcia tutaj na zasadach General Public License (czyli za darmo).

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

Ok, przejdźmy zatem do środowiska :

Po otwarciu programu ukazuje się nam okno, jak to powyżej. Zintegrowane środowisko programowania, w skrócie IDE (z ang. Integrated Development Environment) jest dość proste, i składa się z kilku przycisków, rozwijalnego menu, okna wprowadzania i edycji kodu, oraz okna komunikatów.

Przyciski (od lewe):

START – służy uruchamianiu kodu, można też zrobić to naciskając CTRL+R, lub wybierając opcję ‘Run’ z górnego menu ‘Sketch’. Powoduje to otwarcie osobnego okna, w którym wyświetla się graficzna manifestacja naszego programu.

STOP – zatrzymuje uruchomiony szkic, i zamyka jego osobne okno

NEW – tworzy nowy (pusty) szkic

OPEN – otwiera istniejący szkic zapisany na dysku

SAVE – zapisuje bieżący szkic

EXPORT – przydatna funkcja eksportująca nasz szkic jako stronę .html z appletem Javy, który uruchamia się po jej otwarciu. Oznacza to, że można bardzo prosto udostępnić DZIAŁAJĄCY szkic internetowej publice, do oglądania w zwykłej przeglądarce internetowej (!).  Dzieje się to oczywiście po zapisaniu tak wyeksportowanego szkicu na jakimś serwerze, lub dołączeniu go do istniejącej strony internetowej.

—————————————————————————-

Pierwszy kod

Standardowo, każdy szkic uruchamia się w oknie, które ma 100 na 100 pikseli. Aby to zmienić, należy na początku programu napisać :

size(500,500);

Co powoduje zwiększenie wymiaru okna do 500 na 500 pikseli, co możemy zobaczyć po naciśnięciu przycisku START.

Zmiany koloru tła dokonujemy za pomocą polecenia

background(255,255,255);

gdzie trzy liczby w nawiasie to kolejno wartość czerwieni, zielonego i niebieskiego (Red Green Blue), w zakresie 0-255, czyli 255,255,255 da nam kolor biały.

aby narysować koło piszemy

ellipse(250,250,200,200);

gdzie pierwsze dwie liczby to współrzędne X i Y środka, a dwie następne to średnica X i średnica Y (jako, że rysujemy tak naprawdę elipsę – ale podając dwie jednakowe liczby dostajemy koło).

Należy tutaj nadmienić, że w większości języków programowania współrzędne pikseli na ekranie liczy się od lewego górnego rogu (0,0) do prawego dolnego (szerokość, wysokość). Do zmiany i przesunięcia układu współrzędnych służą polecenia translate(), scale() i rotate(), ale o tym później.

Tak więc nasz program powinien wyglądać mniej więcej tak :

size(500,500);

background(255,255,255);

ellipse(250,250,200,200);

Po naciśnięciu START ukaże nam się taki obraz :

Nic szczególnego tak naprawdę, ale czego można się spodziewać po trzech liniach kodu

Aby dodać trochę złożoności naszemu prostemu szkicowi, musimy posłużyć się pętlą FOR , oraz sinusoidą. Pętla jest to pewien fragment kodu, który jest wykonywany wielokrotnie (dość ciekawy opis można znaleźć tutaj).  Typowa pętla wygląda tak :

for (int i=0;i<100;i++)  { … tutaj jest kod … }

i jest nazwą używanej zmiennej (może to być k, j, m, a lub b, lub jakakolwiek nazwa, np. mojaZmienna ). 100 to ilość powtórzeń pętli, i++ to operacja wykonywana na zmiennej, ‘++’ znaczy zwiększenie wartości o jeden po każdym przebiegu, analogicznie ‘–’ powodowałoby jej zmniejszenie.

Int to typ zmiennej używanej w pętli, określający ją jako zmienną typu ‘integer’, czyli przyjmującą tylko całkowite wartości. W naszych szkicach będziemy narazie zamiennie używać tylko zmiennych int oraz float (zmiennoprzecinkowych, o większej precyzji).

Funkcję sinusoidalną możemy wykorzystać używając składnię sin(argument), gdzie argument to liczba z dowolnego zakresu, a wynik to liczba z zakresu od -1 do 1.

sin (0) = 0, sin(PI/2) = 1 itp. Podobnie używamy funkcji cos().

Przydadzą się też inne zmienne, np :

float kat = 0; (deklaracja zmiennej ‘kąt’ i nadanie jej wartości zero). Przy każdym kolejnym użyciu nie trzeba już deklarować typu zmiennej, wystarczy napisać po prostu kat = wartość;

oraz float promien; która zdefiniuje promień każdego z kółek.

spróbujmy zatem zamienić linę rysującą kółko na :

for (int i=0; i<50;i++)
{
float kat = i*PI/25.0;
float promien = sin(kat*2)*20+20;
ellipse(250+sin(kat)*200,250+cos(kat)*200,promien,promien);
}

Dla i rosnącego od 0 do 50, kąt przyjmuje wartość od 0 do 2*PI, czyli wykonuje pełny obrót. Promień zaś, arbitralnie zwiększa się i zmniejsza w zależności od zmian kąta – warto poeksperymentować tutaj wpisując różne wartości, można w bardzo łatwy sposób uzyskać bardzo ciekawe efekty graficzne !

Po naciśnięciu START naszym oczom powinna się ukazać następująca grafika :

Zaś aby trochę ją ożywić, możemy dodać też polecenie fill() zmieniające wypełnienie każdego indywidualnego kółka w pętli. Tak samo jak w background() , podajemy kolejno wartości koloru czerwonego, zielonego i niebieskiego (0-255)

fill(i*5,128+i*2.5,255-i*5);

tak więc cały kod powinien teraz wyglądać tak :

size(500,500);
background(255,255,255);

for (int i=0; i<50;i++)
{

float kat = i*PI/25.0;
float promien = sin(kat*2)*20+20;
fill(i*5,128+i*2.5,255-i*5);
ellipse(250+sin(kat)*200,250+cos(kat)*200,promien,promien);

}

a efekt tak :

Grafikę taką można zapisać jako bitmapę za pomocą polecenia saveFrame() , lub jako grafikę wektorową z użyciem biblioteki do eksportu PDF. W tym celu należy dodać deklarację użycia biblioteki :

import processing.pdf.*;

oraz dać znać szkicowi od którego momentu powinien ‘nagrywać’ grafikę i zapisywać ją w pliku PDF – robi się to za pomocą polecenia

beginRecord(PDF, “kolka.pdf”);

a kończy poleceniem

endRecord();

tak więc cały kod wygląda teraz tak :

import processing.pdf.*;

size(500,500);
background(255,255,255);

beginRecord(PDF, “kolka.pdf”);

for (int i=0; i<50;i++)
{

float kat = i*PI/25.0;
float promien = sin(kat*2)*20+20;
fill(i*5,128+i*2.5,255-i*5);
ellipse(250+sin(kat)*200,250+cos(kat)*200,promien,promien);

}

endRecord();

wygenerowany plik PDF można obejrzeć tutaj

————————————————————————–

Trzeba pamiętać, że kod zaprezentowany powyżej jest tylko jednym z dwóch sposobów pisania programów w Processing, gdyż do pisania aplikacji interaktywnych bardziej stosowny będzie układ zapętlony, gdzie program rysuje/tworzy grafikę lub trójwymiarowy model wiele razy na sekundę, pozwalając nam na interakcję.

O tym jednak w następnym odcinku.

Londyńskie lato rozkwita w pełni, i jak co roku na przełomie czerwca i lipca można tu zobaczyć prace studentów wszystkich niemalże uczelni architektonicznych i artystycznych. Całkiem niedawno miałem okazję obejrzeć wystawę RCA Show, która obfitowała w architektoniczne i przestrzenne eksploracje stworzone z użyciem najnowszych parametrycznych i generatywnych narzędzi (mimo, że RCA jest raczej uczelnią artystyczną, zorientowaną na product design, komunikację i grafikę). To samo można było zobaczyć na prezentacji projektów na University of Westminster, więc można śmiało stwierdzić, że temat stał się już stałym elementem studenckiej twórczości. W niniejszym artykule chciałbym zabrać się za dwie najbardziej znane szkoły architektury w Londynie: Bartlett School of Architecture na University College of London, oraz Architectural Association.



Bartlett Show : Mikro Światy

Pierwsze co rzuca się w oczy oglądając projekty zrobione przez podopiecznych tutejszych wykładowców, to to, że technika wykonania, choćby najbardziej wymyślna, nie jest najważniejsza. Na wystawie można obejrzeć prace różnych ‘unitów’, które prowadzone są przez innych nauczycieli, i skupiają się na innych aspektach procesu projektowania. Niektóre zbaczają dość daleko z typowo architektonicznych trajektorii, i zagłębiają się w takie dziedziny jak produkcja filmowa, malarskie wizualizacje, trójwymiarowa typografia oraz ruchome ‘maszyny’, roboty i instalacje przestrzenne. Wszystko jednak ma bardzo szeroką i stabilną teoretyczną bazę, powstałą przez wytrwałe studiowanie esejów i filozoficznych wywodów oraz poszukiwanie odpowiedzi na fundamentalne pytania, a co najważniejsze, jest bardzo ‘ludzkie’ w odbiorze. Projekty próbują wciągnąć nas w interakcję, lub złapać i utrzymać naszą uwagę pewną ‘teatralnością’ i sposobem przedstawienia – w większości jako trójwymiarowe modele, lub kilkuplanowe(warstwowe) przezroczyste, lub przestrzennie powycinane rysunki, przekroje i plany – wszystkie tworzące swoiste ‘mikro światy’, w które można się zagłębić, i studiować godzinami.

Unit 15 zajmujący się produkcją wideo prezentuje prace studentów na jednym dużym, i kilku mniejszych ekranach. Krótkie filmy używają różnych technik, najczęściej dwu- lub trzywymiarowej animacji, do przedstawienia np. przyszłościowej wizji miasta, albo stworzenia całkiem innej, niemalże fantastyczneo-komiksowej rzeczywistości, w której architektura jest pierwszoplanowym środkiem wyrazu.

W tej pracy z Unitu 18, parametryczne projektowanie zostało użyte do stworzenia części modelu (chociaż wydaje się, że nie jest ono najważniejszym elementem pomysłu, tylko środkiem wyrazu). Gdzieniegdzie widać ludzkie sylwetki pokazujące skalę.

W niektórych częściach wystawy spotkać można prace takie jak ta, skonstruowane z wielu niemalże mikroskopijnych elementów tworzących ‘mikro świat’. Wszystko ma tutaj sens, choć żeby go odkryć , trzeba poświęcić trochę czasu na studiowanie modelu i opisów, bo projekty takie jak ten opowiadają jakąś ‘historię’, czasem w lekko ‘teatralny’ sposób, zamiast poprostu prezentować koncepcję.

Drewniana struktura tensegrity podwieszona pod sufitem.

Parametryczne studia przekryć dachowych różnych zastosowań – wydruki SLS.

“Ekowizualne Morfologie” – wydruk SLS skorelowany z mapą świata.

Projekty studentów z pierwszego roku.

AA Project Review : Cyfrowe poszukiwania formy

Pierwsze co się rzuca w oczy po przybyciu na Bedford Square to duży, drewniany pawilon, tegoroczny zwycięzca konkursu przeprowadzonego wśród studentów AA. Ten, w przeciwieństwie do zeszłorocznego, nie stara się udawać, że spełnia jakąkolwiek funkcję – jest poprostu architektoniczną rzeźbą, wydzielającą przestrzeń i zachęcającą do jej eksploracji. Zaprojektowany cyfrowo szkielet został obłożony płatami cienkiego, elastycznego drewna sprowadzonego z Finlandii ( cały projekt był sponsorowany przez fińską firmę FinnForest ), które tworzy przyjemną atmosferę i jest przyjazne w odbiorze.

Testowe modele pawilonu z etapu konkursu. Na trójwymiarowym przekroju można dostrzec przestrzenną strukturę tworzącą rdzeń na którym spoczywają zewnętrzne warstwy drewna.

Generalnie oglądając wystawę prac studentów, ma się wrażenie, że technologie cyfrowego projektowania i fabrykacji są w AA nauczane i opanowane do granic perfekcji – na dzisiejsze techniczne możliwości – i posiadając umiejętności ich zastosowania można zbudować prawie wszystko. Głównymi technikami prezentacji są modele przestrzenne wycinane laserowo z kartonu, lub trójwymiarowe wydruki z drukarek proszkowych lub SLS, do większości prezentowanych obiektów dodane są także plansze z prezentacją idei, ale zawsze wyeksponowane drugoplanowo – główny nacisk jest położony na dobry model, z logiczną i przejrzystą konstrukcją i topologią połączeń elementów.

Niektóre modele studiują zupełnie organiczne sposoby na ‘hodowanie’ struktury budynku, z wykorzystaniem algorytmów genetycznych lub samo-organizacji. Zazwyczaj projekty wykonane tymi technikami nadają się jedynie do wydrukowania na drukarce 3D, ze względu na stopień skomplikowania, który trudno oddać innymi technikami.

Prace unitu ‘Intermediate 8‘ koncentrującego się na technikach algorytmicznych, w tle widać bardzo interesujący projekt tamy/zapory wodnej pełnej organicznych, płynnych elementów zaskakująco dobrze pasujących do wykresów sił i naprężeń w elementach konstrukcji.

Dach chroniący przed słońcem i deszczem na tarasie drugiego piętra szkoły jest także przedmiotem konkursu wśród studentów. W tym roku wygrała koncepcja zaprojektowana przez studentów kierunku Emegent Technologies, wymodelowana w programie Grasshopper. Płaty drewna zostały wycięte maszyną CNC (razem z odpowiednio ustawionymi otworami na łączenia), następnie poddane procesowi laminacji, i zaraz po tym skręcone razem śrubami.

DRL  (Design Research Laboratory), które zostało założone przez Patricka Schumachera i Zahę Hadid, prezentuje  się dość ciekawie, jak zwykle wystawa obfituje w modele parametryczne i generatywne. Odniosłem jednak lekkie wrażenie, że to ciągle to samo.. ciekawe, ale chwilowo wygląda to jak powtórka z poprzednich lat. Może na świeższe powiewy pomysłowości przyjdzie nam czekać do następnego roku.

Bardzo ciekawe przekrycie dachowe wykonane z płaskich elementów wyciętych laserem, różnice w odstępach pomiędzy ‘żebrowaniem’ modułów, oraz sama krzywizna powstają na skutek zróżnicowania położenia punktów podparcia (można by rzec, że jest to dość prosty adaptywny system konstrukcyjny).

Wydruki trójwymiarowe koncepcji generatywnych systemów konstrukcyjnych.

Bardzo ciekawy modularny model. Warto zwrócić uwagę na to jak  moduły reagują na zmianę lokalnej geometrii, odpowiadając zniekształceniem swojej wewnętrznej krzywizny.

Poza tym coraz większy nacisk widać też w nauczaniu tzw. parametrycznego urbanizmu – czyli różnych algorytmicznych technik analizy  i projektowania w dużej skali, gdzie modele takie jak te powyżej nie pokazują projektu masterplanu w sensie finalnym, lecz są specyficznymi sposobami prezentacji pewnych danych odzwierciedlających sposób funkcjonowania miasta. Nawet jeśli modele te są statyczne, zazwyczaj przedstawiają jakiś aspekt dynamicznych procesów zachodzących w tkance miejskiej, które to w oczach twórcy są ważne dla zrozumienia sposobu jej powstawania. W ten sposób można dojść do bardzo daleko idących, odkrywczych i ciekawych wniosków, bez narzucania jakiegoś konkretnego rozwiązania – co jest bardzo pomocne na pierwszych etapach projektowania w tak dużych skalach.

Obie szkoły prezentują bardzo wysoki poziom nauczania nowych technik projektowania, oraz zupełnie świeży i czasem nawet (pozornie) odrealniony sposób spoglądania na problemy architektoniczne. Studenci uczeni są zupełnie nowego, świeżego sposobu konstruowania przestrzennych rozwiązań, bez zbytniego przykładania wagi do już uznanych, istniejących standardów tworzenia koncepcji architektonicznych czy planistycznych. Zamiast tego każdy problem traktowany jest jako unikatowy, jedyny w swoim rodzaju.

Takie podejście ma swoją rację bytu, szczególnie w AA, i jest bardzo dobre właśnie wtedy kiedy używa się nowoczesnych algorytmicznych technik projektowania, które w wielu przypadkach produkują zaskakujące wyniki – często lepsze od tych przewidywanych. Nic nie jest tutaj pewne dopóki nie zostanie sprawdzone na kilka różnych sposobów, i przeanalizowane pod kątem różnych funkcjonalno-socjalno-ekologicznych kryteriów, oczywiście z pomocą nowoczesnego oprogramowania lub specjalnie pisanych (przez studentów) programów komputerowych.

Widać jednak dużą różnicę w podejściu konceptualnym do procesu projektowania w AA i Bartlett – AA koncentruje się bardziej na technologii, sposobie wynajdywania nowych rozwiązań przestrzennych i strukturalnych, podczas gdy Bartlett poprzez twórczość podopiecznych emanuje poetycką ekspresją formy, nie zawsze do końca popartą inżynierskimi analizami i ‘wyszlifowaną’ cyfrową optymizacją – za to dużo bardziej artystyczną, wysublimowaną i awangardową.

Obie szkoły jednak prezentują najwyższy światowy poziom i sposób w jaki podchodzą do zagadnień projektowania przestrzeni dla człowieka pozwala przypuszczać, że szykuje nam się jakaś rewolucja. Kiedy nabierze ona rozpędu – nie wiadomo, ale z pewnością architektura nie jest już tym czym była kiedyś.

AA Project Review oraz Bartlett Show można zobaczyć co roku na przełomie czerwca i lipca, odpowiednio przy Bedford Square oraz przy głównym dziedzińcu University College of London w Londynie.

Strona AA www.aaschool.ac.uk , Bartlett www.bartlett.ucl.ac.uk

Poniżej załączam animację kilku technik parametrycznych i generatywnych, stworzonych z użyciem GC i Processing. Niektórzy ludzie spekulują, że projektowanie parametryczne nie jest do końca powiązane z generatywnym podejściem, dlatego załączam tą animację – pokazuje ona dość dobrze jak procesy generatywne ‘informują’ parametryczne komponenty (np wiklina, lub tuby tworzące tetrahedrony – czworoboki foremne) i dopełniają siebie nawzajem.
Oczywiście projektowanie parametryczne może istnieć bez generatywnego, a także generatywne bez, lub jedynie z niewielką pomocą projektowania parametrycznego – ale uważam, że to dwa komplementarne procesy.

A’propo generatywności, wśrod linków wideo wyświetlonych po powyższej animacji można znaleźć animację procesu tworzenia pola wektorów za pomocą cząsteczek (agentów), które tworzą ślady swoich trajektorii, stworzoną w Processing 1.0.3. Grafika została użyta na okładkę magazynu ‘Grafik’ (wydanie czerwiec 2009).
Program używa takich technik jak flocking (grupowanie w ’stada’) i prostą sztuczną inteligencję.

Głównie skoncentrowaliśmy się na :

- replikacji punktów, linii, krzywych i płaszczyzn – czyli operowaniu na jednym obiekcie , który ma kilka lub więcej ‘instancji’. Generalnie, chodzi o odpowiednie wykorzystanie funkcji Series( początek, koniec, krok ).

- dziedziczeniu cech geometrycznych, czyli hierarchii połączeń w modelu. Punkty kontrolne sterują krzywymi, krzywe sterują powierzchniami, powierzchnie sterują panelami itp. Ta cecha była też wykorzystana do stworzenia reagującej na słońce  fasady, gdzie każdy element dziedziczy swoją orientację porównując swoje początkowe ustawienie z kierunkiem padania promieni słonecznych.

- tworzeniu powierzchni krzywoliniowych, i budowaniu na ich podstawie siatek punktów za pomocą listy parametrów UV (w dwuwymiarowym łańcuchu na przykład).

- fabrykacji stworzonych elementów.

Praca Macieja Starowicza, krzywe BSpline użyte jako materiał do stworzenia wzoru perforacji fasady budynku.

Praca Karoliny, parametryczny amfiteatr dostosowujący się do rzeźby terenu.

Katarzyna Dudycz, eksperymentalna forma konstrukcji dachu.

Jakub Szkiłądź, przekrycie części miasta organiczną strukturą o dużej skali.

Kasia Filipiak, przestrzenna forma i jej rozwinięcia na płaszczyznę.

Olga Woronowicz, parametryczny dach. Topologia podziałów rozrysowana na płaszczyźnie, a następnie podniesiona na krzywoliniową powierzchnię jako pionowa projekcja. Czworokąty powstały jako połączenie punktów na krzywych bspline będących offsetem krawędzi dachu, wypełnienie środka środka już za pomocą arbitralnych trójkątów.

Izabella Cichońska, projekt szaletu miejskiego. Wykorzystano tutaj łatwo rozwijalne, pojedynczo zakrzywione powierzchnie .

elementy projektów przygotowane do fabrykacji.

(…)