1
ALGORITMI GENERATIVI con GRASSHOPPER
ZUBIN KHABAZI Edizione Italiana a cura di Antonino Marsala, www.mandarinoblu.com antonio@mandarinoblu.com © 2010 Zubin Mohamad Khabazi Questo libro è prodotto e pubblicato in formato digitale per uso pubblico. Non è consentita la riproduzione totale o parziale senza il permesso dell'autore, eccetto per le revisioni. Per vedere gli ultimi aggiornamenti o in caso di chiarimenti, visitate il mio sito web,
www.MORPHOGENESISM.com zubin.khabazi@googlemail.com
2
Introduzione Avete mai giocato con il LEGO Mindstorms NXT robotic set? Bene, la modellazione associativa è qualcosa del genere. Se tutto inizia a diventare algoritmico e parametrico, perchè non anche l'architettura? Durante il mio master "Emergent Technologies and Design (EmTech)" presso l'Architectural Association (AA), ho deciso di condividere l'esperienza nell'ambito degli Algoritmi Generativi e nella modellazione parametrico-associativa con Grasshopper, che trovo essere una piattaforma molto potente per questo tipo di progettazione. In questa seconda edizione, così come ho modificato il nome da "Modellazione Algotmica" a "Algoritmi Generativi", ho provato ad aggiornare alcuni esperimenti e temi viste le modifiche che sono state apportate al progetto di Grasshopper, ancora in evoluzione. Spero che questi tutorial vi possano aiutare per capire meglio Grasshopper e gli algoritmi generativi. Mi sarebbe piaciuto aggiornarli, ma bisogna considerare che la maggior parte degli esperimenti e degli esempi sono stati fatti su una versione precedente del plug-in, quindi se trovate delle differenze potrebbe dipendere da questo. Credo che il libro necessiti di revisioni editoriali, visto però che si tratta di un un prodotto non-profit e non commerciale, vi prego di perdonarmi per questa mancanza. Sono molto soddifatto dal fatto che, da quando ho pubblicato questo libro, ho trovato grandi amici in tutto il mondo. Consideratevi dunque liberi di contattarmi per ogni richiesta e spiegazioni tecniche. Buon lavoro e buona fortuna! Ringraziamenti Prima di tutto vorrei ringraziare Bob McNeel per il suo aiuto conGrasshoper3D e David Rutten per l'ispirazione, oltre che per il suo supporto. Sono anche felice di rigrazione i direttori del AA/EmTech e i tutor, Mike Weinstock, Michael Hensel, oltre che Achim Menges che ha verificato i miei concetti parametrici e computazionali. Ancora un ringraziamento per Stylianos Dritsas (AA/KPF) , Dr.Toni Kotnik (AA/ETH) per i loro corsi di calcolo, scripting e geometria avanzata. Sono estremamente grato agli studenti, architetti e progettisi che mi hanno contattato e hanno condiviso le loro conoscenze e mi hanno fatto notare gli errori presenti. Zubin M Khabazi Marzo 2010 Nota del traduttore Innanzitutto vorrei ringraziare Zubin Khabazi per aver prima condiviso questo testo, e poi per aver accettato la mia proposta di collaborazione. Durante i miei anni di lavoro con Rhinoceros ho appreso tanto da chi, come Zubin, ha messo a disposizione le proprie esperienze e conoscenze che mi hanno permesso non solo di utilizzare il programma, ma anche di capire cosa c'è dietro ogni singola scelta, in modo da insegnarlo e trasmetterlo ai miei studenti. Ho cercato di essere più fedele possibile al testo originale aggiornandolo dalla versione 0.6 (sulla quale è stata fatta le seconda edizione) all'attuale 0.8. . Come dice lo stesso autore per la versione originale, anche la traduzione necessiterebbe di una revisione editoriale più accorta. Abbiamo però preferito anche qui privilegiare la pubblicazione, lasciandoci aperta la possibilità di raffinare la scorrevolezza del testo. Invito quindi tutti coloro che hanno dei suggerimenti o dei dubbi a contattarmi per spiegare meglio alcuni passaggi che potrebbero non risultare completamente chiari.
Antonino Marsala – Febbraio 2011
3
Contenuti Capitolo_1_AlgoritmiGenerativi 1_1_Algoritmi Generativi
......................................................................6
..............................................................................................................6
Capitolo_2_L'inizio
......................................................................9
2_1_ Metodo ................................................................................................10 2_2_Conoscenze di base ................................................................................................10 2_2_1_Interfaccia, area di lavoro ................................................................................................10 2_2_2_Componenti ................................................................................................10 2_2_3_Combinazione di dati ….............................................................................................18 2_2_4_Help per i componenti (menù contestuale) .............................................................20 2_2_5_ Ricerca e aggiunta di un componente tramite tastiera …...................................................20
Capitolo_3_Insiemi di dati e Matematica …..........................................................21 3_1_Insiemi di dati numerici 3_2_Punti e griglie di punti 3_3_Altri insiemi numerici 3_4_Funzioni 3_5_Dati Booleani 3_6_Cull list 3_7_Liste di dati 3_8_Pattern per geometrie planari
...............................................................................................22 ...............................................................................................24 ...............................................................................................26 ...............................................................................................28 ...............................................................................................31 ...............................................................................................32 ...............................................................................................34 ...............................................................................................38
Capitolo_4_Trasformazioni
…......…..................................................................50
4_1_Vettori e Piani ................................................................................................51 4_2_Curve e geometrie lineari ................................................................................................52 4_3_Esperimento combinato: Swiss Re ....................................................................................58 4_4_Attrattori ................................................................................................66
Capitolo_5_Spazio Parametrico
…......…........................................................76
5_1_Spazio parametrica monodimensionale ........................................................................77 5_2_Spazio parametrico bidimensionale ....................................................................................78 5_3_Transizioni tra gli spazi ................................................................................................79 5_4_Componenti parametrici di base ....................................................................................80 5_4_1_Valutazione di curve ................................................................................................80 5_4_2_Valutazione di superfici ................................................................................................81 5_4_3_Punto più vicino alla curva e alla superficie .............................................................83 5_5_Proliferazione di oggetti nello spazio parametrico .............................................................83 5_6_Alberi di dati ................................................................................................91
Capitolo 6_Deformazioni e morphing 6_1_Deformazioni e moprhing 6_2_Pannellizzazione 4
…......….............................................100
..............................................................................................101 ..............................................................................................103
6_3_Manipolazioni di micro livello ..............................................................................................106 6_4_Modulazione reattiva ..............................................................................................109
Capitolo_7_Superfici NURBS e Mesh …......…......................................................116 7_1_Superfici NURBS parametriche ..............................................................................................117 7_2_Geometria e Topologia ..............................................................................................124 7_3_Mesh ..............................................................................................125 7_4_Analisi cromatica ..............................................................................................134 7_5_Manipolazione delle mesh come metodo progettuale ...............................................137
Capitolo_8_Fabbricazione
…................…......................................................140
8_1_Datasheet ..............................................................................................141 8_2_Tagli laser e manifatturazione basata sul taglio ...........................................................152
Capitolo_9_Strategia di design Bibliografia
5
…...............................................................167 …......…................................................................171
1_1_ Algoritmi Generativi Se guardiamo all'architettura come ad un oggetto rappresentato nello spazio, per comprenderlo appieno e per progettarlo, dobbiamo sempre ragionare con la geometria e un po' di matematica. Nella storia dell'architettura, diversi stili architettonici hanno presentato diverse tipologie di geometria e logiche di articolazione, e ogni periodo ha trovato un modo di dialogare con le sue problematiche e le sue domande inerenti la geometria. Da quando i computer hanno iniziato ad aiutare gli architetti, simulando lo spazio e le articolazioni geometriche, questi sono diventati uno strumento integrante del processo progettuale. La Geometria computazionale è divenuta un'interessante materia di studio e la combinazione di programmazione algoritmica con la geometria, ha prodotto delle geometrie algoritmiche note come Algoritmi Generativi. Sebbene gli applicativi 3D abbiano aiutato a simulare parte di ogni spazio visualizzato, è stata la nozione di Algoritmo Generativo che ha portato le attuali possibilità di progettazione, come la “progettazione parametrica”, nel regno dell'architettura. Gli Architetti hanno iniziato ad usare curve free form e superfici per disegnare e progettare gli spazi andando oltre le limitazioni della geometria convenzionale dello “spazio euclideo”. E' stata una combinazione tra Architettura e Digitale che ha portato “i blob” alla ribalta, facendoli ulteriormente progredire. Nonostante la crescita del calcolo sia estremamente veloce, l'architettura ha provato a tenere il passo di questo veloce ritmo digitale. Dopo l'era del “blob”, l'architettura contemporanea sembra essere più chiara riguardo a questo argomento. La progettazione architettonica è stata influenzata dalle potenzialità delle geometrie algoritmiche computazionali, con gerarchie multiple e alto livello di complessità. Progettare e modellare superfici free form e curve come se fossero elementi di costruzioni associati con diversi componenti e aventi pattern multipli, non è un lavoro facile da portare avanti con metodi tradizionali. La potenza degli algoritmi e degli script che spostano in alto l'asticella della progettazione, è proprio questa. E' ovvio che anche solo per pensare a geometrie complesse abbiamo bisogno di strumenti appropriati, specialmente applicativi capaci di simulare le geometrie e controllarne le proprietà. Come risultato, gli architetti sono interessati ora ad usare Swarms, Cellular Automata o Genetic Algorithms per creare progetti algoritmici ed andare oltre gli attuali limiti di forme e spazio. All'orizzonte si profila un catalogo pieno di complessità e molteplicità che combina insieme creatività e ambizione.
Fig.1.1 Modellazione parametrica per “Evolutionary Computation and Genetic Algorithm, Zubin Mohamad khabazi, Emergence Seminar, AA” tenuto da Michael Weinstock , Autunno 2008 Facendo un passo avanti, ora sembra possibile incorporare le proprietà dei sistemi materiali in una progettazione algoritmica con il concetto parametrico. Guardando agli effetti materiali e alle loro 6
reazioni all'ambiente ospitante nella fase progettuale, ora la innate potenzialità dei componenti e dei sistemi possono essere applicate ai modelli parametrici per la progettazione. Non solo questi algoritmi generativi dialogano con la generazione della forma, ma palesano anche un grande potenziale per incorporare la logica dei materiali. “La logica di base della progettazione parametrica, può essere qui strumentalizzata come un metodo progettuale alternativo, uno in cui il rigore geometrico della modellazione parametrica può essere distribuito prima per integrare i vincoli della manifattura, le logiche del montaggio e le caratteristiche del materiale nella definizione di semplici componenti, e poi per la riproduzione dei componenti dentro costruzioni e sistemi più grandi. Questo approccio impiega l'esplorazione di variabili parametriche per capire il comportamento di un tipo di sistema e quindi usa queste conoscenza per studiare una strategia di risposta al sistema per le condizioni ambientali e le forze esterne” (Hensel, Menges, 2008) Per lavorare con oggetti complessi, il processo progettuale parte da un primo semplice livello, a cui vengono aggiunti nuovi strati; le forme complesse sono composte da gerarchie differenti, ognuna associata con la propria logica e propri dettagli. Questi livelli sono anche tra loro interconnessi, e i loro membri influiscono l'uno con l'altro. In questo senso questo metodo viene definito “associativo”. In generale, la modellazione associativa si riferisce ad un metodo in cui gli elementi progettuali sono costruiti gradualmente in gerarchi multiple e ad ogni livello, alcuni parametri di questi elementi sono estratti per generare altri elementi in un altro livello e questo procedimento va avanti, passo dopo passo per produrre la geometria complessiva. Quindi il punto estremo di una curva può esser il centro di una circonferenza: ogni cambiamento nella curva comporta un cambiamento associato della circonferenza. Fondamentalmente questo metodo di progettazione dialoga con una grande quantità di dati e di calcoli e avviene attraverso il flusso degli algoritmi. Una cosa fondamentale è che tutte queste geometrie sono facilmente regolabili dopo il processo. I progettisti hanno sempre accesso agli elementi di design del prodotto, dal punto di partenza fino ai dettagli. Effettivamente, poiché il design del prodotto è frutto di un algoritmo, gli input dell'algoritmo possono essere modificati e il risultato può essere aggiornato di conseguenza. E ora dunque possibile fare uno schizzo digitale di un modello e generare centinaia di variazioni, regolando i più semplici parametri geometrici. E' inoltre possibile incorporare le proprietà dei sistemi materiali, i vincoli di fabbricazione e le logiche di assemblaggio in parametri. E' inoltre possibile rispondere all'ambiente ed essere associativi in senso largo. “ … il design parametrico permette il riconoscimento dei modelli del comportamento geometrico, e la relativa capacità performativa e le tendenze del sistema. In un riscontro continuo con l'ambiente esterno, queste tendenze comportamentali possono quindi informare lo sviluppo ontogenetico di uno specifico sistema attraverso la differenziazione parametrica dei sottogruppi” (Hensel, Menges, 2008).
7
Fig.1.2.Ricerca nel campo delle membrane e delle superfici minime, modello fisico, Movimento di membrane di B. modellate con Grasshopper Zubin Mohamad Khabazi, EmTech Core-Studio, AA, tenuto da Michael Hensel and Achim Menges, Autunno 2008 Grasshopper è una piattaforma che attraverso Rhinoceros permette di rapportarsi con gli algoritmi generativi e le tecniche di modellazione associativa. I prossimi capitoli sono pensati per combinare le tematiche geometriche con gli algoritmi per indirizzare alcune problematiche progettuali architettoniche verso un metodo 'Algoritmico'. Gli esempi sono pensati allo scopo di allargare la tematica della geometria e di usare più comandi possibile.
8
CAPITOLO_2_L'inizio
9
2_1_Metodo Questa nuova edizione del precedente “Modellazione Algoritmica” chiamato ora “Algoritmi generativi” è stata fatta grazie alle richieste dei miei amici di Grasshopper sparsi per il mondo, in conseguenza ai cambiamenti che sono stati fatti al plugin. Visto che Grasshopper è un progetto in evoluzione che viene modificato e integrato in maniera veloce, mi è sembrato necessario aggiornare il libro in questo momento (e non sono totalmente convinto che nel momento in cui lo leggerete, non saranno necessari nuovi aggiornamenti). Considerate che la maggior parte degli esperimenti sono stati fatti con una versione precedente del plugin, ma ho provato ad aggiornarli dove necessario e sono convito che se troverete qualche differenza, non sarà troppo difficile andare avanti da soli. L'obiettivo principe del libro è quello di focalizzare l'attenzione su alcune problematiche geometriche e architettoniche, sui progetti, e sullo sviluppo della comprensione degli algoritmi generativi e della modellazione parametrica, basata su esperimenti progettuali invece che su di una descrizione di tipo matematica o geometrica. Per fare ciò, nella maggiora parte dei casi, presumerò che voi conosciate gli ingredienti di base della discussione e non entrerò nella definizione di grado della curva, se non in alcuni casi in cui lo riterrò necessario. Grasshopper cresce velocemente e sta diventato una piattaforma adeguata per la progettazione di architetture. Più che uno strumento o un applicativo, presenta un modo di pensare la progettazione, un metodo chiamato parametrico, o associativo. Questo metodo di sta sviluppando attraverso gli utenti di tutto il mondo come un esempio pratico di intelligenza distribuita. Poichè questi sviluppi di metodi avvengono costantemente, e ci sono sempre aggiornamenti nel software, oltre che discussioni interessanti, ti consiglio di controllare la pagina di Grasshopper. In ogni caso in questo capitolo vorrei discutere brevemente le problematiche generali dell'area di lavoro e le basi di ciò che dovremo conoscere quello che dovremo conoscere in anticipo.
http://www.Grasshopper3d.com/
2_2_Conoscenze di base 2_2_1_Interfaccia , area di lavoro Accanto ai menu tipici di Windows, ci sono altri due parti importanti nell'interfaccia di Grasshopper: il pannello dei componenti e il Canvas. Il pannello dei componenti fornisce tutti gli elementi di cui necessitiamo per i nostri progetti, mentre il Canvas rappresenta l'area di lavoro dove inserire i componenti e impostare i nostri algoritmi. Potete cliccare su qualunque oggetto dai pannelli e cliccare ancora sul canvas per portarli nell'area di lavoro, oppure trascinarli. Le altri zone 10
dell'interfaccia sono facili da esplorare e diventeranno familiari con l'utilizzo. Maggiori informazioni potrete trovarle qui http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryPluginInterfaceExplained.html
Fig.2.1. Pannello dei componenti e Canvas 2_2_2_Componenti In Grasshopper vi sono diversi tipi di oggetti, pannelli e componenti, menu che useremo per progettare. Li potrai trovare sotto dieci differenti tabelle chiamate: Params, Math, Sets, Vector, Curve, Surface, Mesh, Intersect, XForm
Ogni scheda contiene diversi pannelli e altrettanti oggetti. I comandi sono ordinati all'interno di questi pannelli. Ci sono oggetti che disegnano geometrie quali linee, cerchi e ci sono inoltre diversi comandi per spostare, scalare, dividere e deformare queste geometrie. Quindi alcuni oggetti disegnano e generano dati, alcuni modificano geometrie o dati esistenti. I parametri sono oggetti che rappresentato i dati come un punto o una linea. Li potete disegnare dai parametri attinenti o li potete definire manualmente da un oggetto disegnato direttamente su 11
Rhinoceros. I componenti sono invece oggetti che fanno qualcosa, come muovere, orientare o scomporre. Solitamente abbiamo bisogno di provvedere a recuperare i dati pertinenti per farli funzionare. Come ho già detto, ad ogni funzione corrisponde un oggetto che può essere portato sul canvas. In questo manuale userò il termine componente per parlare di ogni oggetto presente nel pannello dei componenti per semplificare le cose. Userò la dicitura <> per nominarli, in modo che sia facile individuarli nel testo. Per esempio per indicare il componente che genera un punto, usero
.
Componente (punto) Cliccando con il tasto destro su un componente, apparirà un menu che contiene alcuni aspetti di base: questo menu è chiamato “menu contestuale”
Menu contestuale Da ora in poi dovrete trovare i componenti giusti dai pannelli ed impostare le connessione tra questi componenti per poter generare il vostro algoritmo progettuale, in modo da vedere i risultati nell'area di lavoro di Rhinoceros. Se lo scripting rappresentauna versione astratta e codificata degli algoritmi, con Grasshopper, il canvas diventa luogo di rappresentazione visuale degli algoritmi, come un diagramma di flusso che tra le mani del progettista risulta più sensibile e flessibile. 12
Fig.2.2 Diagramma di flusso vs Algoritmo di Grasshopper Definizione delle geometrie esterne La maggior parte delle volte, partiremo con l'importazione sul canvas di Grasshopper di oggetti disegnati su Rhino. Potrà trattarsi di un punto, una curva o una superficie fino ad oggetti multipli e complessi. Significa che potremo usare i nostri oggetti creati manualmente, oppure oggetti generati tramite script da Rhinoceros su Grasshopper come sorgente esterna. Poiché ogni geometria di Grasshopper necessita di un componente nel canvas per poterci lavorare, dobbiamo definire le nostre geometrie esterne nel canvas attraverso i giusti componenti. Per questa motivo possiamo guardare nella scheda Params, nel pannello Geometry. C'è una lista di diverse tipi di geometrie che potete usare per definire un oggetto esterno dall'area di lavoro di Rhinoceros. Dopo aver portato il componente geometrico appropriato, definiamo l'oggetto di rhino cliccando con il tasto destro sul componente e scegliendo “set one.../set multiple...” (imposta un..../imposta multipli.....) per assegnare gli oggetti ai componenti. Ora avete bisogno di selezionare la vostra geometria su Rhinoceros. Importando uno o più oggetti con un componente, questi diventano oggetti di Grasshopper e possono ora essere usati per ogni scopo.
Fig.2.3 I diversi tipi di geometria in Params>Geometry 13
Facciamo un semplice esempio Abbiamo tre punti nella finestra di Rhinoceros e vogliamo disegnare un triangolo passante per questi tre punti in Grasshopper. Come prima cosa dobbiamo importare questi punti in Grasshopper. Abbiamo bisogno di tre componenti che possiamo trovare in Params>Geometry>Point e per ognuno possiamo andare sul menu contestuale (tasto destro) e selezionare 'set one point' (imposta un punto) e quindi selezione il punto dalla finestra di rhino. (Fig. 2.4)
Fig.2.4. Impostare il punto da Rhinoceros attraverso un componente di Grasshopper
Fig. 2.5. Il canvas di Grasshopper e i tre punti definiti che diventano delle croci (x) rosse nella finestra di rhino. Ho rinominato i componenti con il nome Point A/B/C tramite la prima voce del menu contestuale, in modo da riconoscerli facilmente sul canvas. 14
Connessione di componenti Ci sono diverse azioni che possiamo applicare ai componenti. Generalmente un componente prende dei dati da una o da più sorgenti e restituisce dei risultati. Abbiamo bisogno di connettere dei componenti che includano i dati in ingresso verso dei componenti che li processino e collegare a loro volta i risultati ad altri componenti che necessitano di questi risultati e così via. Tornando all'esempio, se andiamo nella scheda delle Curve, nel pannello Primitive, troverete il componente . Portatelo sul canvas. Connettete quindi all'ingresso A di e all'ingresso B (per connettere i componenti, cliccate semplicemente sul semicerchio nella parte destra di e trascinatalo verso l'altro semicerchio sul componente destinazione (l'ingresso A/B di ). A queste punto vederete che Rhinoceros ha disegnato una linea tra i due punti.
Fig.2.6 Connessione del componente al componente trascinando dall'uscita del all'ingresso di . Ora aggiungete un altro componente per il e . Stessa cosa tra e con il terzo componente . Eh si! C'è un triangolo nella finestra di Rhino.
Fig. 2.7. Componente disegnato tra due componenti . Come vedete ogni componente può essere usato più di una volta come sorgente di informazione per altre azioni
15
Fig. 2.8 Se ora cambiate manualmente la posizione dei punti direttamente su Rhino, la posizione dei punti su Grasshopper (quelli con la X) e il triangolo risultante verranno modificati di conseguenza, ma le linee tra i punti (il triangolo) rimarranno e si aggiorneranno. Come vedete in questo primo esempio, la tecnica associativa rende possibile manipolare i punti, mantenendo la geometria del triangolo fatto di punti senza che siano necessarie ulteriori modifiche. L'idea è quindi di preparare gli oggetti ('alimentare' gli input degli algoritmi), impostare le relazioni tra gli oggetti e aggiungere altre manipolazioni (le funzioni degli algoritmi) e generare il progetto (risultato dell'algoritmo). Lavoreremo ancora su questo concetto per sviluppare la comprensione degli algoritmi. Input/Output Come già detto, ogni componente di Grasshopper ha dei connettori in ingresso (input) e in uscita (output), il che significa che il componente processa i dati in ingresso e li restituisce in uscita. La porta di Input si trova sulla parte sinistra del componente, mentre quella di output si trova a destra. I dati arrivano da ogni sorgente collegata alla sezione Input del componente e in Output abbiamo il risultato che il componente genera attraverso una specifica funzione. Per saperne di più (testo in inglese) http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryVolatileDataInheritance.html E' sempre necessario sapere di che tipo di input avete bisogno per quella specifica funzione e cosa si otterrà dopo il processo. Parleremo ancora in seguito dei diversi tipi di dati che dovremo procurarci. Per avere maggiori spiegazioni, vi suggerisco di tenere il mouse sopra ogni connettore in ingresso o uscita: apparirà una nota in cui potrete leggere il nome, il tipo di dato necessario, se è stato impostato un valore predefinito o no, e soprattutto la funzione del componente.
Fig.2.9 Lasciando il puntatore del mouse sopra il connettore input/output del componente appare una finestra di suggerimento. 16
Connessioni Multiple A volte è necessario connettere ad un componente più di una sorgente di dati. Immaginate, nell'esempio seguente, di voler tracciare due linee dal al e poi per il . Potete usare due diversi componenti oppure usare un componente connettendo entrambi il punto B e il punto C alla lettera B del componente . Per fare ciò, è necessario premere il tasto Shift nel momento in cui si connette la seconda sorgente di dati al componente. Senza questo accorgimento Grasshopper sostituirà il secondo connettore al primo. Quando si preme Shift, sul puntatore appare una circonferenza verde con una piccola icona (+) che normalmente è grigia. Potete anche usare Ctrl per disconnettere un componente da un altro (normalmente è possibile farlo anche usando il menu contestuale). In questo caso la circonferenza attorno al puntato verrà mostrata in rosso con una piccola icona (-)
Fig. 2.10 Connessione multipla per un componente usando il tasto Shift Il codice dei colori Su Grasshopper esiste un sistema di codici dei colori il cui scopo è mostrare lo “stato” del componente.
Fig. 2.11 Il codice dei colori Un componente di colore grigio indica che non ci sono problemi e il tipo di dato definito è giusto o comunque il componente lavora in maniera corretta. L'arancio indica invece che dobbiamo fare attenzione! C'è almeno un problema che dove essere risolto affinchè il componente continui a funzionare. Il componente rosso indica una errore e non può funzionare in questa situazione. La sorgente di errore deve essere scoperta e risolta per consentirne l'utilizzo. Potrete trovare un primo aiuto riguardante l'errore nel menu contestuale del componente (menu contestuale> Runtime warning/error) e quindi controllare i dati in ingresso per capire il motivo del problema. Il colore verde significa invece che il componente è selezionato. La geometria associata al 17
componente stesso diventa anch'essa verde nella finestra di Rhinoceros (mentre tutte le geometrie predefinite su Grasshopper sono rosse). Anteprima Tutti i componenti che producono un oggetto in Rhinoceroshanno un'opzione di visualizzazione di anteprima nel proprio menu. La possiamo usare per nascondere o mostrare le geometrie nell'area di lavoro. Ogni anteprima non selezionata (output nascosto) fa si che il nome del componente diventi retinato. Solitamente usiamo l'opzione di anteprima per nascondere geometrie non desiderate, quali punti di base e le linee in modelli complessi, per evitare distrazioni. Questa opzione, in modelli complessi, consente di processare i dati in maniera più veloce, perciò è meglio nascondere le geometrie di base quando non è necessario vederle. 2_2_3_ Combinazione di dati Per tanti componenti di Grasshopper, è sempre possibile indicare una lista di dati anziché un solo input. Si tratta, in pratica, di creare una lista di punti, per esempio, e connetterli ad un componente per rappresentare più linee contemporaneamente anziché una sola. Procurandoci le informazioni necessarie sarà dunque possibile disegnare centinaia di oggetti partendo da un solo componente. Guardiamo il seguente esempio: Ho due diversi insiemi, ognuno dei quali contenente sette punti. Ho usato due componenti e ho impostato 'set multiple point' (imposta punti multipli) per immettere tutti i punti più alti in un gruppo e tutti i quelli più bassi nell'altro. Come vedete, connettendo questi due gruppi di punti ad un componente , vengono generate sette linee passanti per i punti. Possiamo quindi generare più di un oggetto da ciascun componente. (fig. 2.12)
Fig.2.12 Impostazione di punti multipli tramite i quali vengono generate delle linee Ma cosa potrebbe succedere se nei due insiemi il numero di punti non è lo stesso ? Nell'esempio che segue, ho sette punti nella riga superiore e dieci in quella inferiore. Abbiamo dunque bisogno dunque di introdurre il concetto di amministrazione dei dati in Grasshopper, chiamato combinazione (o incrocio) dei dati. Se date un'occhiata al menu contestuale del componente, potrete vedere che ci sono tre opzioni chiamate 18
Shortest list (lista più corta) Longest list (lista più lunga) Cross Reference (riferimento incrociato) Date un'occhiata alle differenze mostrate in figura 2.13 E' evidente che shortest list produrrà come risultato una serie di linee pari al numero dei dati della lista più corta, mentre la longest list creerà un numero di linee pari al numero di dati presenti nella lista più lunga, combinando l'ultimo valore della lista più corta più di una volta. L'opzione Cross Reference connette tutti i punti secondo tutte le possibili combinazioni. E' un'opzione ad alto consumo di memoria e qualche volte è possibile sia necessario un po' di tempo perchè la scena venga aggiornata. Visto che le immagini sono chiare, mi fermo qui con la descrizione. Per maggiori informazioni consultate il seguente link (testo in inglese) http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryDataStreamMatchingAlgorithms.html
Fig. 2.13 combinazione di dati A: shortes list, B: longest list e C: cross reference
19
2_2_4 Help per i componenti (menù contestuale) Considerando che non è utile spiegare tutti i componenti, la cosa migliore è quella di provarli e capire come usarli gradualmente durante gli esperimenti. Suggerisco dunque di giocarci, scegliere un componente, andare sul menu contestuale dello stesso (tasto destro) e leggere l'Help che sarà di grande aiuto per capire come questo funzioni, quale tipo di dati siano necessario e che tipo di dati in uscita produce. Ci sono altre utili caratteristiche nel menu che vedremo più avanti.
Fig. 2.14 Menu contestuale e parte relativa all'Help del componente 2_2_5 Ricerca e aggiunta di un componete tramite tastiera Per trovare rapidamente un componente di cui conosciamo il nome, anziché perdere tempo all'interno delle schede dei componenti, è possibile fare doppio click sul canvas e scrivere il nome del componente stesso per portarlo nell'area di lavoro. Per coloro che sono soliti usare la tastiera per lavorare, questo potrebbe essere un bel trucco. Fig. 2.15 Ricerca del componente nel menu contestuale. Per attivarlo è necessario fare doppio click sul canvas, e digitare il nome. Il componente verrà in questo modo portato nell'area di lavoro.
20
CAPITOLO_3_ Insiemi di dati e Matematica
21
Capitolo_3_ Insiemi di dati e Matematica Sebbene negli applicativi per il 3D possiamo selezionare le geometrie dai menu e disegnarle in maniera esplicita senza pensare agli aspetti matematici che stanno dietro, per poter lavorare con gli algoritmi generativi, come suggerisce il nome, dobbiamo pensare ai dati e alla matematica per creare dei valori in entrata per alimentare l'algoritmo e generare oggetti. Poiché non vogliamo disegnare tutto a mano, abbiamo bisogno di alcune sorgenti di dati come ingredienti di base per alimentare l'algoritmo in modo da farlo lavorare più di una volta per produrre più di un oggetto. Il modo in cui l'algoritmo lavora (il flusso di lavoro) è semplice. Prevede che ci siano dei dati in ingresso, il processo di questi dati, e un risultato in output. Questo processo avviene in tutto l'algoritmo o, se guardiamo attentamente, in ogni sua singola parte. Quindi invece di usare il metodo di disegno convenzionale, abbiamo bisogno di procurarci le informazioni, le quali verranno processate attraverso un algoritmo e verrà creata una geometria come risultato finale. Come già detto, per esempio, anziché copiare un elemento per '100 volte' nella 'direzione della x positiva' una distanza di '3' possiamo dire all'algoritmo di copiare l'elemento '100 volte' in una 'direzione positiva di X' con un interspazio di 3. Per fare ciò definiamo '100' come numero di copie, 'x positiva' come direzione e '3' come distanza e l'algoritmo farà il lavoro per voi automaticamente. Tutto ciò che facciamo in geometria ha un minimo di matematica alle spalle. Possiamo usare queste semplici funzioni matematiche nei nostri algoritmi con i numeri come oggetti, per generare infinite combinazioni geometriche. Si parte con numeri e insiemi di dati numerici. Diamo un'occhiata, è molto più facile di quanto sembri!
3_1_ Insiemi di dati numerici Tutta la matematica e gli algoritmi iniziano con i numeri. I numeri sono il codice nascosto dell'universo! Per iniziare, prima di tutto abbiamo bisogno di dare un'occhiata ai componenti numerici, per vedere come è possibile generare diversi insiemi di dati numerici in Grasshopper, e quindi il modo in cui li possiamo usare per disegnare qualcosa. Singolo valore numerico
Il generatore di numeri più usato è il componente (Params>Special>Number slider) che genera un numero modificabile manualmente. Può essere un intero, reale, pari o dispari con dei limiti inferiori o superiori. Queste impostazioni possono essere regolate dalla voce 'Edit' del menu contestuale. Per impostare un singolo valore numerico potete andare su Params>Primitive>Integer / Number per impostare un valore intero o reale attraverso il menu contestuale di / Serie di numeri
22
Possiamo produrre una lista di numeri attraverso il componente (Sets>Sequence>series) Questo componente produce una lista di numeri che è possibile modificare attraverso il primo numero (S), il passo (N), e il numero di valori della serie (C) 0, 1, 2, 3, … , 100 0, 2, 4, 6, … , 100 10, 20, 30, 40, … , 1000000 Range di numeri
Possiamo dividere un range numerico tra un valore minimo e massimo con il numero di step e produrre un range numerico. Dobbiamo definire un intervallo per definire il limite inferiore e superiore oltre che il numero di step in cui è diviso (Sets>Sequence>Series) Ogni intervallo numerico (per esempio da 1 a 10) può essere diviso in un numero infinito di parti 1, 2, 3, … , 10 1, 2.5, 5, … , 10 1, 5, 10
23
Domain (Intervals)
Domain ('Interval' nelle versioni precedenti) crea un range di numeri reali tra un valore inferiore e superiore. Esistono domini monodimensionali e bidimensionali di cui si tratterà in seguito. E' possibile definire un dominio prefissato usando il componente Params>Primitive> Domain / Domain2 o possiamo andare in Math>Domain>Domain / Domain 2 per generare un gruppo di componenti per lavorare in maniera più flessibili. I domini da soli non producono numeri. Solo solo degli estremi, con un limite superiore e inferiore. Come sapete, ogni due numeri reali ne esistono infiniti. Possiamo usare diverse funzioni per dividerli e usare i fattori di divisioni come valori numerici. Per vedere le differenze e gli usi, proviamo altri esempi.
3_2_ Punti e griglie di punti I punti sono tra gli elementi di base per le geometrie e gli algoritmi generativi. I punti segnano posizioni precise nello spazio, possono essere usati come punti di partenza per le curve, centri di circonferenze, origini di piani o svolgere altri ruoli. In Grasshopper possiamo generare punti in diversi modi: - Possiamo semplicemente scegliere un punto o una serie di punti dalla scena e importarli dentro lo spazio di lavoro attraverso il componente (Params>Geometry>point) ed usarli per qualunque scopo (Questi punti possono essere modificati spostandoli manualmente sulla scena di rhino, e incidere sull'intero progetto – Controllate gli esempi nel capitolo 2). - Possiamo inserire i punti attraverso il componente (vector>point>point xyz) e alimentare le coordinate dei punti attraverso dei numeri, oppure alimentarli da diversi insiemi di dati, in base alle nostre necessità. -Possiamo creare una griglia di punti attraverso i componenti e -Possiamo estrarre i punti da altri geometrie in diversi modi, quali punti finali, punti centrali etc (OSNAP) -Talvolta possiamo usare i piani (origini) e i vettori (estremità) come punti di partenze per altre 24
geometrie e viceversa. Avete visto i primi esempi per la creazione di punti nel capitolo 2, ma possiamo dare un'occhiata a delle modalità che producano sistemi di punti attraverso i componenti , e e altri strumenti che generano dati numerici.
Fig. 3.1 Alimentazione di un componente o attraverso tre per generare un punto, inserendo manualmente le coordinate per x,y e z
Fig. 3.2 Generazione di una griglia di punti attraverso i componenti e . Mentre il controlla la distanza attraverso i punti (dimensione dello step) e il secondo controlla il numero di punti nella griglia attraverso il numero di valori del componente (La combinazione dei dati di è impostata su cross reference per creare una griglia, ma potete provare tutte le combinazioni).
Fig. 3.3 Divisione di un range numerico da 0 a 1 attraverso un numero (5) controllabile manualmente e alimentazione di un componente con la combinazione 'longest list'. In questo caso abbiamo diviso il range per 5, creando 6 punti tra il punto di origine (0,0) e (1,1) sulla finestra di Rhinoceros(è possibile modificare il limite inferiore o superiore del range per modificare le coordinate dei punti. Per fare ciò è necessario cliccare con il tasto destro nel connettore D del componente (indicante il dominio) e modificarlo). In seguito vedremo altri modi per lavorare con gli intervalli e e modificarli. Poiché il nostro primo esperimento sembra facile, possiamo andare avanti, ma dovete provvedere 25
a sperimentare il funzionamento di questi componenti per conto vostro, creando differenti griglie di punti con differenti posizioni e distanze
3_3_ Altri insiemi numerici Set di numeri casuali Vogliamo ora creare una distribuzione casuale di numeri per diversi scopi. Ciò di cui abbiamo bisogno, è un set di numeri casuali al posto dei componenti e . Selezioni quindi un componente (casuale) da Set>Sequence>Random. Un componente genera una lista di numeri casuali di cui possiamo controllare il dominio. Il componente produce dunque un insieme di numeri casuali, ma noi non vogliamo avere gli stessi valori per x,y e z. Per evitare gli stessi valori, ogni direzione deve avere dei numeri casuali indipendenti. Abbiamo quindi bisogno o di mischiare la lista con i numeri, oppure di tre liste di numeri casuali, create da tre componenti con differenti seeds (il seed, seme, è la parte che 'innesca' la generazione di numeri casuali). Attraverso l'alimentazione del componente per la sua porta S con numeri diversi, generiamo diversi numeri casuali: se non facessimo in questo modo, tutti i componenti random, genererebbero gli stessi valori.
Fig. 3.4 Generazione un set di punti casuali. Il componente produce 10 numeri casuali che sono controllati da un . La lista è quindi mischiata dal componente (Sets>Sequence>Jitter) per le coordinate delle Y, e ancora un'altra volta per le coordinate Z. Volendo è possibile vedere altri ordinamenti di pattern all'interno della griglia (connettendo un alla x, y e z del senza usare ). La combinazione di dati è impostata su longest list. In figura 3.4 tutti i punti sono distribuiti in uno spazio compreso tra 0 e 1 in ogni direzione del sistema di riferimento. Per modificare l'area di distribuzione, possiamo modificare il dominio numerico, nel quale il componente produce numeri. Questo è possibile impostando manualmente il 'dominio del range numerico casuale' direttamente su Rhinoceros cliccando con il tasto destro sulla porta R (random numbers domain / dominio dei numeri casuali) del componente o definendo il dominio dell'intervallo modificando i valori attraverso gli slider (fig. 3.5)
26
Fig. 3.5 Impostazione di un dominio attraverso il componente per modificare l'area di distribuzione dei punti (date un'occhiata alla densità delle griglia in scena rispetto a quella della fig. 3.4) Serie di Fibonacci Che ne dite di creare una griglia con una spaziatura non uniforme? Diamo un'occhiata ai componenti che abbiamo a disposizione. E' necessario dotarsi di una serie di numeri che crescano rapidamente e ancora, sotto la scheda Sets e il pannello Sequence, possiamo trovare il componente Questo rappresenta una serie di i numeri in cui i primi due numeri definiti (0 e 1) e il numero successivo, sono la somma dei due precedenti. N(0)=0, N(1)=1, N(2)=1, N(3)=2, N(4)=3, N(5)=5, … , N(i)=N(i-2)+N(i-1) Di seguito alcuni numeri della serie: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, … Come potete vedere i numeri crescono velocemente In questo caso ho usato una serie (Sets>Sequence>Fibonacci) per produrre numeri incrementali che alimentino il componente
Fig. 3.6 Usando una serie produciamo un incremento delle distanza (con una spaziatura variabile) per generare dei punti. Il numero dei punti può essere controllato con un 27
3_4_Funzioni I componenti predefiniti contenuti su Grasshopper, potrebbero non essere sempre il modo migliore per disegnare. Potreste avere bisogno di generare dei dati particolari o almeno manipolare quelli dei componenti esistenti. Per fare ciò, è necessario utilizzare funzioni matematiche e modificare la potenza, le distanze,....di numeri. Il componente funzione è dunque un oggetto capace di eseguire funzioni matematiche su Grasshopper. Esistono funzioni con diverse variabili (Math>Script). Talvolta potrebbe essere necessario alimentare le funzioni con dati pertinenti (non sempre numeri, ma anche valori booleani, stringhe etc) che verranno eseguite in base agli input. Per definire una funzione è possibile cliccare con il tasto destro sulla porta F del componente e digitarla direttamente o usare l'editor di espressioni matematiche. Questo editor, ha tante funzioni predefinite e una libreria di funzioni matematiche come aiuto. E' importante porre attenzione al nome delle variabili da usare nelle espressioni e i dati associati che possono essere combinati nel componente delle funzioni. Funzioni matematiche Come già scritto, usare un componente predefinito non è sempre basta, ma per ottenere i risultati auspicati possiamo usare le funzione matematiche per modificate i set di dati e alimentarli per generare geometrie.
Fig. 3.7 Cerchio parametrico creato tramite funzione matematica. Possiamo trovare sia la funzione (seno) e (coseno) in Math>Trig. (F(x)=x*2Pi)
Fig. 3.8 Altri esperimenti. Serie di punti in cui si è definita una serie e semplici funzioni matematiche (x: F(x)=x/100, y: F(x)=x/10). La funzione selezionata in verde F(x) è una funzione che aggiunge 2 al valore del (F(x)=x+2) per creare valori di una serie equivalenti ai numeri di Fibonacci (la serie di fibonacci ha altri due primi valori). L'obiettivo è di mostrare com'è semplice manipolare questi set di dati e generare di conseguenza diverse geometrie. 28
Fig. 3.9 Un di numeri da 0 a 2 moltiplicato per 2Pi con che crea un range numerico da 0 a 4Pi. Questo range è diviso in 60 parti. Il risultato alimenta il componente attraverso la seguente funzione matematica: X=t * Sin(t), Y=t * Cos(t) La conoscenza trigonometriche per i componenti e è data per scontata . Per applicare t*sin/cos ho usato il componente da Math>Operators. Qui sarà possibile trovare gli strumenti adatti per ulteriori operazioni matematiche.
Fig. 3.10. Eccone una complessa! Algoritmo creata da due spirali invertite create da due insiemi di punti. Il dominio del componente va da 0 a 4, ed è diviso in 400 punti e quindi moltiplicato attraverso la funzione che alimenta i due punti: Primo : X: F(x) = x * Sin(x*2 Pi), Y: F(x) = x * Cos(x * 2 Pi) Il secondo ha la stessa funzione ma invertita 29
Fig. 3.11 Moebius da un insieme di punti. e sono componenti successivamente rinominati. Il dominio numerico di ognuno può essere letto nella scena. La funzione matematica che genera un Moebius è la seguente X= Sin(u)*(-2+v*sin(u/2)) Y= Cos(u)*(-2+v*sin(u/2)) Z= v*Cos(u/2) Giocherellare con le funzioni matematiche può portare via un'infinità di tempo! Potrete trovare tante risorse matematiche da combinare i vostri insiemi numerici. La cosa importante è che avete la possibilità di manipolare i dati originali e generare diversi valori numerici, e con questi alimentari altri componenti. Come avete visto da semplici set di dati numerici, è possibile partire per generare geometrie: questo mostra come funzionano gli algoritmi. Da ora in avanti, abbiamo bisogno di costruire la nostra conoscenza basata su diversi concetti geometrici con il metodo degli algoritmi, per affrontare i problemi e le situazioni progettuali, come questa splendida superficie Enneper (dal plugin Math function di rhino)
30
3_5_ Dati Booleani I dati non si limitano ai soli numeri. Ci sono altri tipi di dati che sono utili per differenti scopi nella programmazione algoritmica. Visto che stiamo trattando algoritmi, dovremo sapere che il loro percorso non è sempre lineare. Talvolta abbiamo bisogno di decidere quando fare qualcosa e quando fare altro. I programmatori chiamano questa costruzione 'costrutto condizionale.' Il risultato del costrutto decisionale è un semplice si o no. Per gli algoritmi usiamo i dati booleani per rappresentare questo tipo di risposta. I dati booleani rappresentano solo il TRUE/ VERO e il FALSE/FALSO. Se il costrutto rispecchia i criteri, il responso sarà TRUE, altrimenti FALSE. Come vedremo in seguito, questo tipo di dato è veramente utile in diverse situazioni, soprattutto quando è necessario decidere relativamente a qualcosa, selezionare degli oggetti secondo un criterio, ordinare oggetti etc.
Fig. 3.12 Sono stati generati dieci valori e, attraverso il componente (più grande) (Math>Operators>Larger), voglio vedere se questi numeri sono inferiori ad un determinato (limite superiore) (valore stabilito tramite un ) oppure no. Come vedete, se i numeri rispecchiano i criteri (cioè che sono più piccoli del limite superiore), il componente restituirà 'TRUE' oppure 'FALSE' se non li rispecchia. Ho usato il componente da Params>Special per mostrare il contenuto di e il risultato del componente .
Fig. 3.13 Per il prossimo passo, ho generato 30 valori con il componente . Ho usato il componente (Math>Operators>Modulus) per cercare il resto della divisione dei numeri per tre e ho passato il risultato al componente (uguale) per vedere se il risultato è uguale a zero oppure no. Come puoi vedere il risultato è un altro con i valori TRUE/FALSE Come potete vedere negli esempi, ci sono diversi possibilità di controllare i criteri attraverso i valori 31
numerici ed avere dei valori booleani come risultati. Ma talvolta è necessario sapere se le situazioni vanno incontro ad altri criteri, e vogliamo decidere in base ai risultati. Per esempio, in base all'esperimento precedente, vogliamo vedere quando un valore è inferiore ad un determinato limite superiore e allo stesso tempo se è divisibile per tre. Per conoscere il risultato, abbiamo bisogno di operare sul risultato di entrambe le funzioni, il che significa che dobbiamo operare con un valore booleano. Se controllate sotto la scheda Math nel pannello Boolean, scoprirete che ci sono diversi componenti che lavorano con i dati di tipo booleano.
Fig. 3.14 Combinazione di entrambi i concetti. E' stato usato il componente (Math>Boolean> Gate And) e ho collegato entrambe le funzioni per creare una congiunzione tra loro. Come vedete, questi valori numerici, che sono inferiori di un limite superiori e divisibile per tre, vanno incontro ai criteri e passano il valore TRUE alla fine. Nel pannello Boolean, possiamo trovare diversi operatori booleani, che potete usare in maniera combinata per costruire i vostri criteri decisionali, e costruire i vostri progetti basati su queste responsi. Discuteremo ancora in seguito su come usare i valori booleani.
3_6_ Cull list Ci sono molte ragioni per cui possiamo possiamo avere la necessità di selezionare alcuni oggetti da un dato insieme e non applicare una stessa funzione a tutti. Per fare questo, abbiamo bisogno sia di selezionare alcuni elementi specifici da una lista, sia di ometterne altri. Tra le innumerevoli strade a disposizione possiamo iniziare con quella che ci porta ad omettere / filtrare le liste di dati. Al momento esistono tre componenti di tipo per filtrare una lista di dati su Grasshopper. Mentre tralascia un elemento ogni N di una lista data, prende un pattern di tipo booleano (TRUE/FALSE) e filtra una lista di dati basata su questo pattern. Questo significa che ogni elemento associato ad un valore True nella lista booleane passa, mentre quelli associati a False, vengono omesso dalla lista stessa. invece, filtra una lista di dati attraverso degli indici numerici. Se i numeri dei valori nella lista di dati e nella lista booleana sono gli stessi, ogni elemento della lista di dati viene valutato dal corrispondente elemento nella lista booleana. Ma è possibile definire 32
un semplice pattern di valori booleani (p.e. FALSE/FALSE/TRUE/TRUE già predefiniti nei componenti) e il componente riepeterà lo stesso pattern per tutte gli elementi della lista di dati. Per capire meglio, vogliamo qui introdurre alcuni modi per poter selezione le nostre geometrie desiderate (in questo caso punti) fuori da un insieme di dati predefinito. Esempio della distanza Pensiamo di selezionare alcuni elementi da un insieme costituito di punti, in base alla distanza da un altro punto (riferimento). Sia i set di punti che il punto di riferimento sono definiti da un componente . Prima di tutto necessitiamo di un componente (Vector>Point>Distance) che misuri le distanze tra i punti e il riferimento, ottenendo come risultato una lista di numeri (distanze). Compariamo queste distanze attraverso un numero definito dall'utente () con un componente (Math>Script>f2 / funzione a due variabili). Questo confronto genererà dei valori booleani (True/False) per mostrare sia che il valore sia più piccolo (true) o più grande (false) del limite superiore F=x>y (cioè la stesso andamento del componente ). Userò per questo scopo, i valori booleani per alimentare il componente . Come già riferito, prende una lista di dati generici e una lista di dati booleani e elimina quei membri della lista generica di dati associata con 'False' . In questo caso il risultato del componente è un gruppo di punti associati al valore TRUE. Ciò significa che sono più vicini al riferimento rispetto al numero specificato nel perché la funzione x>y restituisce sempre un valore TRUE per tutti i numeri più piccoli di Y, il che significa distanze minori (y=distance). Per vedere meglio li ho solo connessi al punto di riferimento attraverso un semplice componente
Fig. 3.15 Selezione di punti presi da un insieme attraverso la distanza da un riferimento attraverso il componente . Esempio topografico Avendo provato la prima distanza logica, voglio selezione alcuni punti che sono associate alla curva di livello su un modello topografico in base loro altezza.
33
Fig. 3.16 Topografia con punti associati alle curve di livello Ciò che ho qui, è un insieme di punti definiti da un componente (chiamato topografia). Ho bisogno dell'altezza dei punti e con la stesso logica dell'esempio sulla distanza, posso selezione gli oggetti desiderati. Ho dunque usato un componente (Vector>Point>Decompose) per ottenere il valore Z delle coordinate dei punti (altezza). Il componente mi restituisce le coordinate X,Y, e Z di ogni punto di Input. Ho comparato questi valori con un dato numero (dal ) con un componente per creare una lista valori booleani associativi. Il componente passa i punti associati con il valore TRUE, cioè i punti selezionati saranno più alti di quelli definiti dall'utente per l'altezza.
Fig. 3.17 I punti selezionati hanno un'altezza superiore a 4.7550 unità (impostato come valore dell'utente). Questi punti sono ora pronti per piantare i vostri Pini!
3_7_ Liste di dati E' ora quasi chiaro che uno degli algoritmi fondamentali è la lista di dati. La lista di dati potrebbe contenere ogni sorta di oggetti, quali numeri, punti, geometrie e così via. Scorrendo la scheda Sets, sotto il pannello List, ci sono diversi componenti che manipolano liste di dati. Possiamo estrarre un elemento attraverso il loro indice numerico, possiamo estrarre parte di una lista attraverso un indice inferiore e superiore. Queste liste gestiscono gli elementi, aiutandoci ad ottenere una insieme di dati per i nostri scopi progettuali.
34
Fig. 3.18 Lista di punti. Vogliamo selezionare i punti con i valori di x più bassi. Come già detto prima, il componente ci restituisce la coordinate di punti stessi. Ciò di cui abbiamo bisogno è di trovare il valore più basso di X tra tutti questi punti. Per permettere questo, ho bisogno prima di ordinare tutte i valori di X , e poi trovare il minore. Questo è quanto farà per noi. Fondamentalmente il componente , ordina una o più liste di dati, in base ad una lista di dati numerici , come se fossero chiavi ordinabili. Quindi quando queste chiavi sono ordinate, lo saranno anche i dati associati. Qui sono stati dunque ordinati tutti i valori di X come dati chiave. Ciò di cui abbiamo ora bisogno, è di selezionare il primo elemento della lista. Per fare ciò è necessario un componente - (elemento ) il cui compito è di estrarre un elemento attraverso il suo indice numerico. Visto che il primo elemento (ad indice zero) ha il valore minore di X, viene estratto l'indice in modo da ottenere come risultato un punto il cui valore di X sia quello minimo dell'insieme,. Vediamo altri esempi Triangoli Sviluppiamo ora i nostri esperimenti con un gestore di dati. Immaginiamo di avere una rete di punti e di voler disegnare delle linee per creare dei triangoli seguendo il pattern mostrato in figura 3.19. Questo concetto è utile per la generazione delle mesh, nella pannelizzazione e in altre situazioni, ma per questa volta è importante essere capaci di produrre i concetti di base.
Fig. 3.19 Generazione di triangoli attraverso una rete di punti. 35
Il primo passo è quello di creare una griglia di punti attraverso i componenti e . Il passo successivo prevede invece di trovare i punti giusti per tracciare delle linee. Ogni volta abbiamo bisogno di una linea che parta da un punto e termini nel punto successivo della stessa riga e colonna successiva, e poi un'altra linea che vada da quest'ultimo punto alla colonna precedente e alla riga successiva ed una linea finale che torni indietro al punto di partenza. Per farlo sarebbe meglio fare tre liste di punti, una per ogni 'primo punto', una per ogni 'secondo punto' e un'altra per ogni 'terzo punto' e quindi disegnare delle linee. E' possibile usare il punto originale come la lista per tutti i punti di partenza. Il primo 'secondo punto' è il secondo punto nel gruppo di punti e quindi la lista va avanti, uno alla volta. Quindi per selezione il 'secondo punto' ho solo spostato la lista originale tramite il componente (Sets>list>Shift list) con una distanza di spostamento pari a 1, il che significa che il secondo elemento della lista (indice 1) diventa il primo elemento (indice 0) e il resto della lista procede allo stesso modo. Questa nuova lista è la lista del 'secondo punto' I 'terzo punto' dei triangoli sono nella stessa colonna dei 'primo punto' ma nella riga successiva. In termini di indici numerici, se la griglia contiene N colonne, il primo punto della seconda riga ha l'indice pari all'indice del primo punto (0)+N In una griglia con 6 colonne, l'indice del primo punto della seconda riga è 6. Ho qui spostato ancora la lista originale di punti con una distanza di spostamento pari al numero delle colonne, in modo da ottenere il primo punto della riga successiva (la distanza di offset dipende dal che indica il numero di colonne) per trovare tutti i terzi punti.
Fig. 3.20 L'elemento selezionato è il punto spostato attraverso una distanza di spostamento pari al numero di colonne che producono tutti i 'terzo punto' dei triangoli. Per completare l'operazione abbiamo bisogno di manipolare questa lista un po' di più, quindi concentratevi ancora: 1. Prima di tutto, nella lista 'primi punti' i punti dell'ultima colonna non potranno mai essere i primi punti della lista 'secondo punto'. 2. Anche i punti della prima colonna non potranno mai essere 'secondo punto', abbiamo quindi bisogno di eliminarli dalla lista 'secondo punto'. 3. Stessa cosa per i 'terzo punti', dove i punti nell'ultima colonna non potranno mai essere i terzi punti.
36
Se combiniamo tutte queste tre parti, li immaginiamo e li disegniamo, capiremo che in tutte queste tre liste, i punti dell'ultima colonna non potranno essere usati. Fondamentalmente, abbiamo quindi bisogno di omettere l'ultima colonna da ciascuna lista di dati. Ed è per questo che abbiamo collegato tutte le liste di punti ad un componente . Questo componente, elimina un elemento ogni N numeri di una lista di dati ed N viene chiamata frequenza di raccolta (cull frequency) (Fig 3.20). In questo caso tutte le liste di dati sono filtrate attraverso il numero di colonne. Questo perchè, per esempio, se abbiamo 6 colonne, elimina ogni un elemento ogni sei, cioè l'elemento dell'ultima colonna. Il risultato sarà dunque una nuova lista con le ultime colonne eliminate. Abbiamo quindi connesso il che definisce il numero di colonne ad ogni componente per stabilire la frequenza di raccolta.
Fig. 3.21 Usiamo per eliminare le ultime colonne dalle prime, seconde e terze liste di punti. L'ultimo passo è quello di alimentare i componenti e connettere i primi punti ai secondi, quindi i secondi con i terzi e per finire, i terzi con i primi.
Fig. 3.22 Creazione delle linee tramite le connessione dei punti della lista filtrata al componente . Non dimenticate di impostare l'opzione cross reference per il componente , e longest list per il componente .
37
Fig. 3.23 Ora modificando il è possibile avere diverse griglie di punti che producono questi triangoli. Sebbene ci siano ancora diversi problemi con il nostro progetto, sappiamo che non vorremo far partire alcun triangolo dai punti dell'ultima riga (e dovremo eliminarli dalla lista dei 'primi punti'), ma il concetto è chiaro....andiamo avanti. Torneremo indietro a questo concetto quando parleremo delle geometrie mesh e proveremo a limare i concetti. L'idea principale è quella di vedere come i dati possono essere generati e maneggiati. Porteremo avanti i concetti attraverso altri esperimenti.
3_8_ Pattern per geometrie planari I pattern geometrici sono tra le tematiche più interessanti da trattare con gli algoritmi generativi in Grasshopper. Abbiamo il potenziale per disegnare dei motivi e quindi farli crescere come pattern che possono essere usati come base per altri prodotti progettuali. Nel caso di progettazione di pattern, possiamo dare un'occhiata al nostro progetto/modello ed estrarre la logica che produce l'intera forma nel momento stesso in cui viene ripetuta. Attraverso il disegno della geometria di base, possiamo copiarla per produrre i pattern delle dimensioni volute(Fig. 3.22)
38
Fig. 3.24 Estrazione del concetto del pattern da geometrie semplici. Continuiamo ad insistere sul lavorare attraverso gli insiemi di dati e sulle semplici funzioni matematiche, invece di usare altri utili componenti proprio per vedere come queste semplici operazioni e gli insiemi di dati numerici abbiano un grande potenziale per generare forme, anche geometrie classiche.
Fig. 3.25 Geometrie complesse nella Moschea Sheikh Lotfollah in Iran. Le mattonelle sono formate da pattern semplici, che sono create attraverso calcoli matematico/geometrico. Pattern lineari semplici Ho qui deciso di progettare un pattern con alcuni punti di base e linee. L'obbiettivo è quello di usare concetti semplici come quelli in figura 3.26
39
Fig. 3.26 Concetti di base per generare pattern Prima di tutto vogliamo generare alcuni punti di base come geometrie di partenza e quindi disegnare le linee tra questi punti. Ho iniziato la mia definizione, tramite una che rende possibile il controllo dei valori numerici (numero di punti), la dimensione del passo ( distanza tra punti). Attraverso questa ho generato un insieme di punti con solo valori sulla X (con y e z pari a zero).
Fig. 3.27 Sono stati generati il primo set di punti con i componenti e . Aggiungiamo qui un componente che possiamo trovare in Params>Special>Receiver. Questo componente prende i dati da un altro componente e li passa ad un altro rimuovendo i cavi di connessione dal canvas. In progetti complessi, quando si voglia usare una sorgente di dati per tanti componenti, ci aiuta a ripulire l'area di lavoro in modo da evitare distrazioni dovute alle tracce delle connessioni. Come potete vedere nella seconda figura, il componente , riceve i dati da .
Fig. 3.28 Per creare una forma a zig zag abbiamo bisogno di due righe di punti come geometria di base. E' stato usato un altro per avere dati da una e con un altro è stato generata la seconda riga di punti aventi valori y, provenienti da un 40
Fig. 3.29 Nei passi successivi, dobbiamo eliminare alcuni punti da ogni lista per procurarci i punti per il pattern a zig zag. Qui sono stati eliminati i punti attraverso un , in una riga usando il pattern booleano TRUE/FALSE e nell'altra usando FALSE/TRUE
Fig. 3.30 Ora se connette entrambi i componenti ad un componente da Curve>spline>Polyline che disegna curve lineari passanti più vertici anziché solo due, vedrete come risultato delle linee che formano una Z. Questo perchè i punti non sono ordinati e devono essere posizionati in una lista in questa sequenza: primo punto della prima riga, primo punto della seconda riga, secondo punto della prima riga, secondo punto della seconda riga.
41
Fig. 3.31 Il componente che ordina i punti nel modo descritto è il (Sets>list>Wave). Prende i dati da diverse fonti e li ordina in base ad un pattern che dovrebbe essere definito nella sua porta P (come sempre, leggete l'help del componente per vedere le informazioni più dettagliate). Il risultato sarà una lista di elementi ordinati che una volta connessi ad componente mostreranno il primo zigzag.
Fig. 3.32 Con lo stesso concetto, è stata generata la terza riga di punti, e con un altro componente e , è stata disegnata una seconda linea a zig-zag
42
Fig. 3.33 Sebbene ci siano dei modi più veloci per generare queste linee, anche qui ho usato lo stesso concetto per i punti e polilinee della terza riga. E' stata deselezionata l'opzione preview (anteprima) per , e (dal loro menu contestuale) per nascondere tutti i punti e vedere la sola polilinea.
Fig. 3.34 Se si copia ancora lo stesso processo e questa volta invertiamo il valore di Y del componente in negativo, (possiamo usare lo stesso con una funzione di tipo f(x)=-x) si otterrà un gruppo di polilinee specchiate. Ora, manipolando le distanze, è possibile avere dei pattern con scale e forme diverse.
Fig. 3.35 E' possibile cambiare il modo con cui generate i punti di base o filtrate dati delle liste. Il risultato potrebbero essere pattern diversi, di semplici intersezioni di linee, ma potrebbe essere una geometria generativa per produrre modelli complessi.
Fig. 3.36 Questo è il primo risultato del progetto. Il motivo viene ripetuto in maniera semplice e il 43
risultato può essere usato in ogni modo, in base alle varie necessità.
Fig. 3.37 Questo è solo uno degli esempi tra le centinaia di possibilità per usare i pattern come base di sviluppo per i progetti. In seguito avrete le potenzialità per differenziare i pattern di base e per modificare i risultati dei progetti. Pattern circolari La modellazione associati ci permette di infinite possibilità per creare motivi e pattern. La fig. 3.38 mostra altri motivi in cui i disegni sono basati sulla geometria circolare anzichè che quella lineare. Poichè vi sono diverse curve aventi tutte la stessa logica, verrà descritta una parte degli algoritmi mentre il resto spetterà a voi.
Fig. 3.38 Pattern geometrico circolare. Il punto di partenza di questo pattern è un insieme di dati che produce una serie di punti lungo una circonferenza, come l'esempio fatto in precedenza. Questi dati possono essere scalati dal centro per creare diverse circonferenze concentriche. Questo set di punti verrà filtrato allo stesso modo 44
dell'ultimo esempio. Quindi verrà generato un pattern zig zag ripetitivo tramite questi punti scalati, i quali, una volta connessi l'uno con l'altro, disegneranno una curva a forma di stella. La sovrapposizione di queste stelle potrebbe creare una parte di questo motivo.
Fig. 3.39 Creando un range da 0 a 2Pi e usando le funzioni di seno e coseno, creiamo il primo gruppo di punti in una geometria circolare. Ho usato questa funzione con due variabili per moltiplicare il risultato di seno e coseno attraverso un altro per cambiare il raggio di una circonferenza.
Fig. 3.40 Incremento di seno e coseno, grazie alla moltiplicazione attraverso da un e creazione del secondo insieme di punti con un raggio maggiore. Come potete vedere il risultato di questa sezione è un set di due punti. I componente sono stati rinominati.
45
Fig. 3.41 La prima e la seconda circonferenza di punti Per poter filtrare i punti, possiamo semplicemente usare il per i punti e usare TRUE/FALSE come nell'ultimo esempio. Ma come è possibile ordinare la lista di punti? Se anche è possibile usare lo stesso metodo, qui ho deciso di optare per un altro, in modo da usare un altro concetto relativo all'ordinamento, che crediamo possa usare utile in seguito: vogliamo ordinare i punti in base al loro indice numerico nell'insieme. Prima di tutto abbiamo bisogno di generare un indice di numeri. Visto che abbiamo prodotto un componente di numeri reali, abbiamo bisogno di un componente per procurarci numeri interi come indici dei punti nella lista. Gli N parametri del definiscono il numero dei passi o delle divisioni, quindi il componente produrrà N+1 numeri. Ed è per questo che necessitiamo di un con N+1 valori per essere gli indici dei punti.
Fig. 3.42 Generazione dell'indice numerico per i punti (la lista di numeri interi parte da 0)
46
Fig. 3.43 A questo punto ho bisogno di scegliere i punti e gli indici come nell'esempio precedente. Ho quindi usato il componente (Sets>Tree>Merge) per generare una lista di dati entrambe le liste . L'operazione è stata applicati sia ai punti che agli indici. Sebbene il risultato dell'unione delle produrrà ancora i numeri dell'intero set di dati, l'ordine non sarà lo stesso e sarà più vicino a quello dei punti. Ora attraverso l'ordinamento degli indici come chiavi ordinate, possiamo ordinare allo stesso modo anche i punti.
47
Fig. 3.44 I punti sono ordinati con un componente mentre la loro chiave di ordinamento è l'indice. Viene disegnata una polilinea tra i punti ordinati.
Fig. 3.45 Gli indici prima e dopo l'ordinamento, e i punti ordinati e associati che generano una polilinea a forma di stella La stessa logica potrebbe essere usate per creare geometrie più complesse con una semplice generazione di set di altri punti, filtrati e connessi per produrre i pattern desiderati. Il trucco è quello di scegliere il miglior gruppo di punti e il modo di connetterli ad altri set.
48
Fig. 3.46 E' possibile pensare ad altre possibilità di pattern e di geometrie lineari e loro applicazioni come per esempio, le proiezioni su altre geometrie. Sebbene abbia insistito per genere tutti i precedenti modelli attraverso set di dati e semplici funzioni matematiche, vogliamo vedere altri semplici componenti che rendono possibile ridurre l'intero processo o modificare il modo in cui recuperiamo i dati. Li discuteremo tutti insieme
Fig. 3.47 Modello Finale
49
CAPITOLO 4_ Trasformazioni
50
Capitolo 4_ Trasformazioni Le trasformazioni sono operazioni essenziali, sia nella modellazione che nella geometria generativa. Permettono infatti di ottenere variazioni da semplici oggetti iniziali, aiutandoci a scalare, orientare, muovere, copiare o specchiare le nostre geometrie. Esistono diversi tipi di trasformazioni, ma per classificarle le possiamo dividere in gruppi: la prima divisione che possiamo indicare è quella tra trasformazioni lineari e trasformazioni spaziali. La trasformazione lineare è attuata in uno spazio 2D, mentre quella spaziale avviene in uno 3D. Un altro modo per classificare le trasformazioni, potrebbe essere quello di dividerle in base allo stato iniziale dell'oggetto: trasformazioni quali traslazioni, rotazioni, riflessioni, mantengono la forma originale, mentre la scalatura e l'inclinazione la modificano. Esistono anche della trasformazioni non lineari. In aggiunta alla traslazione, rotazione e riflessione, abbiamo diversi tipi di deformazioni e scale non uniforme nello spazio 3D, oltre che trasformazioni spiraliformi o a forma di elica e proiezioni che creano variazioni nello spazio tridimensionale. Per poter trasformare, dobbiamo muovere o orientare gli oggetti ( o loro parti, quali vertici o angoli ) nello spazio, e per fare ciò abbiamo bisogno di usare vettori e piani come basi per queste operazioni matematico/geometriche. Non discuteremo le basi della geometria o della logica matematica, ma daremo un'occhiata ai vettori e ai piani, perchè ci serviranno per il nostro lavoro.
Fig. 4.1 Le trasformazioni palesano grandi potenziali nelle generazioni di forme complesse partendo da quelle semplici. La natura presenta nelle sue opere grandi esempi di trasformazioni.
4_1_ Vettori e Piani Il vettore è un oggetto matematico che presenta un modulo (o lunghezza), una direzione ed un verso. Parte da un punto, procede in direzione di un altro in una specifica direzione. I vettori hanno una ampio raggio di utilizzo e sono usati, oltre che per le trasformazioni, in diversi campi della scienza e della geometria.
51
Fig. 4.2 Elementi base di un vettore; spostamento di un punto tramite un vettore Se abbiamo un punto ed un vettore, questo vettore può trasportare il punto alla distanza data dal modulo e verso una direzione stabilita, in modo da creare una nuova posizione finale per il punto stesso. Useremo questo semplice concetto per generare, muovere, scalare e orientare le geometrie con il nostro metodo associativo. I piani sono un altro gruppo di geometrie utili e possono essere descritti come superfici piatte e infinite, aventi un punto di origine. I piani di costruzioni di Rhino, rappresentano questo tipo di oggetto. Possiamo usare questi piani per inserirci le nostre geometrie, applicare determinate trasformazioni basate sul loro orientamento e origine. Per esempio, nello spazio 3D, non possiamo orientare un oggetto su un solo vettore, ma abbiamo bisogno di due vettori per creare un piano capace di contenere la geometria. I vettori hanno una direzione e un modulo mentre i piani hanno un orientamento ed un'origine rappresentati da X, Y e Z quali vettori unitari e i piani XY, XZ e YZ. Nei prossimi esempi tratteremo di altri diversi componenti che li producono e li modificano. Iniziamo dunque i nostri esperimenti progettuali partendo con uno degli usi più semplici per i nostri vettori, per poi andare avanti passo dopo passo.
4_2_Curve e geometrie lineari Abbiamo già fatto esperimenti con i punti che sono geometrie a dimensione 0, possiamo ora iniziare a pensare alle curve come a degli oggetti monodimensionali. Come i punti, le curve possono essere la base per costruire diversi tipi di oggetti. Possiamo estrudere una curva lungo un'altra per creare una superficie, possiamo collocare diverse curve insieme per creare superfici e quindi solidi, possiamo distribuire ogni oggetto lungo una curva con uno specifico intervallo o possiamo pensare tanti altri modi per sfruttare questa geometria come base per generare altri oggetti.
52
Spostamenti Nel capitolo 3, abbiamo generato diverse griglie di punti attraverso i componenti e , ma ora è giunto il momento di introdurre un altro componente, chiamato (Vector>Grids>Grid rectangular) che produce una griglia di punti. Possiamo controllare sia le distanze tra i punti (uguali in entrambe le direzioni) che la quantità sia in direzione X che Y.
Fig. 4.3 Un semplice componente con i suoi valori predefiniti. E' possibile cambiare la dimensione della griglia attraverso un connesso all'input (S) indicante la distanza. Possiamo inoltre anche modificare l'orientamento dei punti. Per fare ciò abbiamo bisogno di un piano su cui inserire la griglia. Abbiamo introdotto il componente (Vector>Plane>XY plane) che rappresenta un piano infinito nell'orientamento prodotto dagli assi X e Y e lo abbiamo spostato lungo l'asse Z, attraverso il componente (Vector>Vector>Z Unit) che rappresenta un vettore parallelo all'asse Z con la lunghezza pari a uno. Possiamo modificare l'altezza di questo spostamento attraverso la dimensione del vettore collegandolo ad un connesso con l'input del componente . Modificando la posizione del lungo l'asse Z, sarà possibile cambiare la posizione della griglia
Fig. 4.4 Le griglie (selezionate in verde) sono modificate da un che scala la distanza tra i punti, e da un altro slider connesso ad un e un per modificare le coordinate dei punti della griglia sull'asse Z. 53
Quindi, se date un'occhiata al risultato di una è possibile vedere che abbiamo accesso a tutti i punti delle celle della griglia e i centri delle celle. Per questo esperimento, cerchiamo un insieme di linee che partono dal centro delle celle della griglia, ed escono verso lo spazio. Possiamo semplicemente connettere i punti dai due componenti attraverso la porta M al componente per generare un gruppo di linee. Quindi cambiando le dimensioni della seconda griglia verranno disegnate delle linee con direzioni diverse. Il problema è dato dalla lunghezza delle linee, che in questo caso sarà diversa una dall'altra, mentre noi vogliamo disegnare linee della stessa lunghezza. Per fare ciò abbiamo bisogno di un'altra strategia ed è per questo che andremo ad usare il componente . Un componente disegna una linea partendo da un punto (S), con una direzione (D) ed una lunghezza (L). Quindi la lunghezza delle linee è controllabile. Esattamente ciò di cui abbiamo bisogno; abbiamo sia il punto di partenza (centro della cella) che la lunghezza della linea (qualunque sia). E per quanto riguardo la direzione? Vogliamo usare il punto centrale delle celle della seconda griglia quale secondo punto delle linee, quindi la direzione delle mie linee sarà la direzione delle linee connesse al punto centrale della griglia. Per definire queste direzioni abbiamo bisogno di vettori. Ed è per questo che creiamo un set di vettori con queste due punti per creare le direzioni per il mio componente .
Fig. 4.5 Creazione di vettori dal punto centrale della prima griglia verso il punto centrale della celle della seconda griglia attraverso il componente (Vector>Vector>vector 2pt). Questo componente crea dei vettori attraverso il suo punto di partenza e di arrivo.
Fig. 4.6 Il componente genera diverse linee dal punto centrale di una griglia che si muove verso lo spazio a causa della maggior distanza della seconda griglia. E' possibile cambiare la lunghezza di linee attraverso il ed è possibile cambiare la loro direzione cambiando la dimensione della seconda griglia.
54
Per il passo successivo vogliamo aggiungere un poligono alla fine di ciascuna linea ed estruderlo verso il punto di inizio delle linee per vedere il potenziale generativo. Per generare i poligoni abbiamo aggiunto diversi piani ai punti finali delle linee come piano base per poter creare dei poligoni.
Fig. 4.7 Usando il componente (Curve>Analysis>End Point) e usando questo punto finale quale punto di origine per un set di piani è possibile generare i piani di base. E' stato qui usato il componente (Vector>Plane>Plane Normal) che produce una piano per un punto di origine (punti finali delle linee) e un vettore di direzione Z normale al piano (un vettore normale, è un vettore perpendicolare al piano). Abbiamo qui usato gli stessi vettori delle linee come direzioni normali per i piani.
Fig. 4.8 Aggiunta di un componente e uso dei piani generati come piani di base per i poligoni, questo produrrà un set di poligoni alla fine di ogni linea e perpendicolare alle linee stesse. Come potete vedere questi poligoni hanno la stessa dimensione, ma vogliamo applicare un sistema di diversificarne le misure per avere una forma smussata alla fine.
55
Fig. 4.9 Con un componente otteniamo i numeri delle linee, mentre il componente successivo il quale è una radice quadrate dell'input (F(x)=Sqrt(x)), calcola il numero delle linee per ogni riga. E' stato usato un componente con il punto di partenza con la dimensione del passo pari a 0.1, mentre il numero dei valori proviene dal numero delle righe. E' stata quindi generata una lista di numeri che crescono gradualmente, in numero pari a quello dei poligoni di ciascuna riga. Per poter usare questi valori per tutti i poligoni, sono stati duplicate le liste di dati con il valore delle colonne (in questo caso uguale a quello delle righe) e collegate all'Input del raggio dei poligoni. Come potete vedere nel modello, ad ogni riga, le dimensioni dei poligoni gradualmente si modifica e questo pattern si ripete fino all'ultimo.
Fig. 4.10 Nell'ultimo passo, è stato usato un componente (Surface>freeform>Extrude Point) e collegato il punto iniziale della linea quale punto verso il quale voglio venga estruso il mio poligono.
56
Fig. 4.11 Usando il 'Remote control panel' cioè il pannello di controllo in remoto, si può facilmente cambiare il valore dei numeri per diverse opzioni e controllare l'aspetto finale del modello e selezionare il migliore. Non dimenticate di deselezionare l'anteprima per gli oggetti non necessari.
57
Fig. 4.12 Modello finale
4_3 Esperimento combinato: Swiss Re Oggigiorno è molto comune progettare il concetto delle torri con il metodo della modellazione associativa. Questo permette ai progettisti di generare modelli differenziati, in maniera facile e veloce. Il potenziale per differenziare i progetti è molto vasto e i risultati migliori possono essere ottenuti velocemente. Abbiamo deciso di modellare una torre, e la “Swiss Re” di “Foster and Partner” sembra essere abbastanza sofistica per un esperimento di modellazione. Innanzitutto diamo un'occhiata al progetto
58
Fig.4.13 Swiss Re HQ, 30 St Mary Axe, London, UK, 1997-2004, Fotografie provenienti dal sito web di Foster and Partners , http://www.fosterandpartners.com. Innanzitutto l'idea: stiamo per disegnare delle circonferenze per identificare l'ingombro della torre e copiarli in modo tale da formare i piani nei quali la facciata cambi curvatura. Scaleremo i piani per farli combaciare alla forma, e quindi costruiremo il rivestimento usando i piani. Per concludere, aggiungeremo delle sezioni poligonali per gli elementi strutturali della facciata. Per fare questo ipotizzerò sia le dimensioni che le proporzioni e mi occuperò del modello con geometrie semplici in modo da rendere più facile il processo. Partiamo con i piani. Sappiano che i piani della Swiss Re sono delle circonferenze che hanno alcuni tagli a forma di V, ma qui abbiamo usato una semplice circonferenza come profilo. Copiamo questi piano ad una certa altezza, il che renderà possibile poter giocare visualmente con le proporzioni. Come già detto, questi punti sono posizionati nei punti in cui cambia la curvatura della facciata.
Fig. 4.14 Componente con un come raggio esterno della torre. Questa circonferenza è copiata per sei volte lungo la direzione Z positiva, grazie al componente , attraverso un vettore . Questi numeri sono forniti attraverso l'impostazione manuale 'set 59
multiple numbers' e sono assunti quali distanze delle diverse parti della torre (fatta sulla base della dimensione della circonferenza di partenza). Sebbene siano state generate queste circonferenze di base tutte uguali, sappiamo che i piani non hanno la stessa dimensione, e abbiamo quindi bisogno di riscalarli. Se diamo un'occhiata alla sezione della torre, vedremo che dalla base le circonferenze iniziano a crescere fino ad una certa altezza, rimangono costanti nella parte centrali e quindi iniziano a decrescere fino alla punta della torre. Anche qui ipotizzeremo i fattori di scala per i piani. Sarà possibile modificare questi valori per verificare che il progetto risulti simile a quello originale.
Fig. 4.15 Abbiamo bisogno di un componente (Xform>Affine>Scale) per ridimensionare i piani di riferimento. Il componente necessita di una geometria da modificare, un punto di riferimento ed un fattore di scala. Abbiamo quindi bisogno di alimentare la parte geometrica attraverso i nostri piani o circonferenze che risulteranno essere l'output del componente . Il centro predefinito per la scalatura è il punto di origine ma se scaliamo tutti i piani attraverso lo stesso centro, questi verranno spostati nello spazio poiché verrà scalata anche la loro altezza. Abbiamo quindi bisogno che il centro di scalatura della torre sia allo stesso livello di ogni piano. Dovrebbe esserci uno per ognuno ed esattamente al centro del pavimento. Per questo motivo abbiamo usato il componente (Curve>analysis>center) che ci restituisce il centro delle circonferenze. Connettendolo al potremo vedere che tutte le circonferenze saranno scalate al loro livello senza spostamenti. Ricordiamo che i fattori di scala sono presunti, proprio come quelli delle altezze fatte in precedenza. Questi valori possono essere cambiati per vedere quale combinazione calza meglio alla visuale totale. Sono tutti impostati da un componente .
60
Fig. 4.16 Se ora applichiamo una superficie loft a questi piani (attraverso un componente (surface>freeform>loft)), apparirà la prima immagine della torre. Piano piano, dovremo deselezionare l'opzione di anteprima dai punti generati in precedenza per ripulire la scena. A questo punto possiamo iniziare gli elementi di facciata. Gli elementi strutturali della facciata sono di forma elicoidale, ed hanno una sezione composta da due triangoli interconnessi, ma per semplificare modelleremo solo la parte visibile, la quale somiglia ad un triangolo in piano. Useremo il loft tra queste sezioni per creare il loro volume. Vogliamo generare queste sezioni triangolari sulla facciata. Per fare ciò, abbiamo prima bisogno di trovare la posizione di questi triangoli sulla facciata. Penso che se creiamo una curva sulla superficie della facciata e le dividiamo, potrebbe risultare in un posto accettabile per posizionare tutti i triangoli prima di ogni trasformazione.
Fig. 4.17 Abbiamo usato il componente per avere i punti iniziale/finale dei miei piani campione. Collegando questi punti come vertici di un componente (curve>spline>interpolate) sarà possibile avere una curva posizionata nella facciata. 61
Fig. 4.18. Qui sono state divise le curve in 40 parti. Il numero delle divisioni aiuta alla smussatura degli elementi quando vorremo regolare la facciata.
Fig. 4.19 Ora i punti di divisione diventano punti di base per generare i sulla facciata. Sono state impostati tre lati per generare triangoli e la loro dimensione, la parte 'R' (raggio) è controllabile attraverso un
Fig. 4.20 Gli elementi della facciata strutturale sono spirali che girano attorno alla pelle, fino alla punta superiore della torre. Per permettere questo, dobbiamo ruotare le sezioni triangolari gradualmente. Vogliamo usare il componente e per questo abbiamo bisogno degli angoli di rotazione. Come detto, gli angoli di razione dovrebbero essere una lista di numeri che crescono 62
gradualmente. Il componente genera i nostri angoli di rotazione e contiene elementi in numero pari al componente (punti-triangoli). Come risultato tutte le sezioni triangolari ruotano attorno alla facciata.
Fig. 4.21 Ora dobbiamo creare un loft tra tutti i triangoli, e vedremo apparire un singolo elemento di facciata. L'angolo di rotazione e le dimensione degli elementi saranno controllabili in modo da far combaciarli con la facciata nel suo modo migliore. Domains Come già detto il Dominio è un intervallo numerico. Sono numeri reali che vanno da un limite inferiore ad uno superiore. Poiché abbiamo parlato di numeri reali, significa che tra due numeri appartenenti a questo insime, abbiamo infiniti numeri, il che permette diversi tipi di utilizzo per questi domini numerici. Come già sperimentato prima, possiamo dividere il range numerico ed avere le divisioni equamente distribuite attraverso due estremi. Vogliamo dunque distribuire gli elementi della facciata attorno alla circonferenza di base. Per fare ciò abbiamo bisogno di un intervallo per coprire l'intera circonferenza di base.
63
Fig. 4.22 Un componente (Math>Domain>Domain ) è stato usato per definire un range numerico da 0 a 360. Questo intervallo numerico è diviso attraverso un componente in 10 parti e il risultato è usato come fattore angolare per un componente . Quindi come mostrato nell'immagine, gli elementi di facciata sono distribuiti nella circonferenza di base.
Fig. 4.23 Se facciamo un (specchio)(Xform>Euclidian>Mirror) attraverso un (Vector>Plane>YZ plane) delle geometria, avremo gli elementi della facciata in una forma elicoidale specchiata che alla fine produrrà un reticolo attorno alla torre.
Fig. 4.24 Ecco un'altra anteprima della facciata che mostra una rappresentazione non rifinita della “Swiss re” con una tecnica associativa. 64
Fig. 4.25 Per generare la geometria su Rhino, selezioniamo i componenti che creano le geometria desiderata, e quindi optiamo per 'bake selected object', dalla barra sopra il canvas o dal menu contestuale del componente.
Fig. 4.26 Modello finale. Sebbene non sia identico all'originale, per essere un modello di partenza e creato in poco tempo, funziona bene. 65
Fig. 4.27 In mezzo agli elementi strutturali principali, ci sono altri piccole strutture che potete modellare da soli. Immagini dell'autore
4_4_ Attrattori 'L'attrattore è un insieme di stati verso il quale tende ad evolvere un sistema fisico dinamico, senza tener conto delle condizioni di partenza del sistema. Un punto attrattore è un attrattore che consiste in un singolo stato. Per esempio, una pallina che rotola in una tazza si fermerà alla fine, sempre nel punto più basso, al centro inferiore; lo stato finale della posizione una volta terminato il moto è un punto di attrazione' (Dictionary.com/Science Dictionary).
Fig.4.28. Strange Attractor (Illustrazione presa da
http://www.cs.swan.ac.uk/~cstony/research/star/)
66
Nel caso della progettazione e della geometria, gli attrattori sono elementi (solitamente punti ma potrebbero essere anche curve o ogni altra geometria) che producono effetti su altre geometrie nello spazio, cambiando il loro comportamento facendoli spostare, ri-orientare, riscalare etc. Possono articolare lo spazio attorno a loro stessi e introducono il campo del raggio di attrazione. Gli attrattori hanno diversi applicazioni nel design parametrico, poiché hanno il potenziale di modificare tutti gli oggetti costantemente. Definendo un campo, gli attrattori possono inoltre influenzare gli agenti di un sistema con diverse azioni. Le modalità di influenza e la potenza degli attrattori, dipendono da parametri regolabili. Vedremo il concetto di attrattori in diverse occasioni, quindi iniziamo subito con i primi semplici esempi. Punti di attrazione Abbiamo una griglia di punti e vogliamo generare un set di poligoni a partire da questi punti. Abbiamo inoltre un punto chiamato a cui abbiamo disegnato attorno un , giusto per renderlo più chiaro. Voglio che il mio influenzi tutti i miei nel suo campo di azione. Significa che, in base alla distanza tra ogni e il e nel dominio di ogni risponde all'attrattore modificando la sua dimensione.
Fig. 4.29 Base di con e L'algoritmo è veramente semplice. In base alla tra e il vogliamo influenzare il raggio del poligono, in modo che la realzione tra gli attrattori e i poligoni sia definita in base alla distanza. Necessitiamo di un componente per misurare la distanza tra e il centro del poligono o la . A causa del numero che potrebbe essere troppo grande, abbiamo bisogno di (Math>Operators>Division) la distanza con un numero dato da un per ridurre la potenza di
