Algoritmi Generativi con Grasshopper by Zubin Khabazi by Pablo C. Herrera

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

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

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

…...............................................................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).

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.

CAPITOLO_2_L'inizio

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

Componente <point> (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 <point> 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 <line>. Portatelo sul canvas. Connettete quindi <point A> all'ingresso A di <line> e <point B> all'ingresso B (per connettere i componenti, cliccate semplicemente sul semicerchio nella parte destra di <point> e trascinatalo verso l'altro semicerchio sul componente destinazione (l'ingresso A/B di <line>). A queste punto vederete che Rhinoceros ha disegnato una linea tra i due punti.

Fig.2.6 Connessione del componente <point> al componente <line> trascinando dall'uscita del <point B> all'ingresso di <line>. Ora aggiungete un altro componente <line> per il <point B> e <point C>. Stessa cosa tra <point C> e <point A> con il terzo componente <line>. Eh si! C'Ă¨ un triangolo nella finestra di Rhino.

Fig. 2.7. Componente <line> disegnato tra due componenti <point>. Come vedete ogni componente puĂ˛ essere usato piĂš di una volta come sorgente di informazione per altre azioni

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 <point A> al <point B> e poi per il <point C>. Potete usare due diversi componenti <line> oppure usare un componente <line> connettendo entrambi il punto B e il punto C alla lettera B del componente <line>. 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 <line> 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 <point> 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 <line>, 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

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

CAPITOLO_3_ Insiemi di dati e Matematica

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 <Number slider> (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 <Int>/<Num> Serie di numeri

Possiamo produrre una lista di numeri attraverso il componente <series> (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

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 <point> (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 <point xyz> (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 <grid hexagonal> e <grid rectangular> -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 <series>, <range> e <number slider> e altri strumenti che generano dati numerici.

Fig. 3.1 Alimentazione di un componente <point xyz> o <pt> attraverso tre <number slider> 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 <series> e <pt>. Mentre il <number slider> 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 <series> (La combinazione dei dati di <pt> è 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 <pt> 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 <series> e <pt>. Selezioni quindi un componente <random> (casuale) da Set>Sequence>Random. Un componente <random> genera una lista di numeri casuali di cui possiamo controllare il dominio. Il componente <random> 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 <random> con differenti seeds (il seed, seme, è la parte che 'innesca' la generazione di numeri casuali). Attraverso l'alimentazione del componente <random> 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 <random> produce 10 numeri casuali che sono controllati da un <number slider>. La lista è quindi mischiata dal componente <jitter> (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 <random> alla x, y e z del <pt> senza usare <jitter>). 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 <random> 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)

Fig. 3.5 Impostazione di un dominio attraverso il componente <domain> 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 <fibonacci> 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, â&#x20AC;Ś , 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, â&#x20AC;Ś Come potete vedere i numeri crescono velocemente In questo caso ho usato una serie <fibonacci> (Sets>Sequence>Fibonacci) per produrre numeri incrementali che alimentino il componente <pt>

Fig. 3.6 Usando una serie <fibonacci> produciamo un incremento delle distanza (con una spaziatura variabile) per generare dei punti. Il numero dei punti puĂ˛ essere controllato con un <number slider> 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 <sin> (seno) e <cos> (coseno) in Math>Trig. (F(x)=x*2Pi)

Fig. 3.8 Altri esperimenti. Serie di punti in cui si è definita una serie <fibonacci> 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 <number slider> (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 <range> di numeri da 0 a 2 moltiplicato per 2Pi con <Function> che crea un range numerico da 0 a 4Pi. Questo range è diviso in 60 parti. Il risultato alimenta il componente <pt> attraverso la seguente funzione matematica: X=t * Sin(t), Y=t * Cos(t) La conoscenza trigonometriche per i componenti <sin> e <cos> è data per scontata . Per applicare t*sin/cos ho usato il componente <multiplication> 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 <range> va da 0 a 4, ed è diviso in 400 punti e quindi moltiplicato attraverso la funzione che alimenta i due punti: Primo <pt>: X: F(x) = x * Sin(x*2 Pi), Y: F(x) = x * Cos(x * 2 Pi) Il secondo <pt> ha la stessa funzione ma invertita 29

Fig. 3.11 Moebius da un insieme di punti. <u> e <v> sono componenti <range> 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)

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 <random> e, attraverso il componente <larger> (più grande) (Math>Operators>Larger), voglio vedere se questi numeri sono inferiori ad un determinato <upper_limit> (limite superiore) (valore stabilito tramite un <number slider>) 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 <panel> da Params>Special per mostrare il contenuto di <random> e il risultato del componente <larger>.

Fig. 3.13 Per il prossimo passo, ho generato 30 valori con il componente <series>. Ho usato il componente <modulus> (Math>Operators>Modulus) per cercare il resto della divisione dei numeri per tre e ho passato il risultato al componente <equals> (uguale) per vedere se il risultato è uguale a zero oppure no. Come puoi vedere il risultato è un altro <panel> 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 <Gate And> (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 <cull> per filtrare una lista di dati su Grasshopper. Mentre <cull Nth> tralascia un elemento ogni N di una lista data, <cull pattern> 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. <Cull index> 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 <cull> 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 <point>. Prima di tutto necessitiamo di un componente <distance> (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 (<number slider>) con un componente <F2> (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 <Larger>). Userò per questo scopo, i valori booleani per alimentare il componente <cull pattern>. Come già riferito, <cull pattern> 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 <cull pattern> è un gruppo di punti associati al valore TRUE. Ciò significa che sono più vicini al riferimento rispetto al numero specificato nel <number_slider> 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 <line>

Fig. 3.15 Selezione di punti presi da un insieme attraverso la distanza da un riferimento attraverso il componente <cull pattern>. 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.

Fig. 3.16 Topografia con punti associati alle curve di livello Ciò che ho qui, è un insieme di punti definiti da un componente <point> (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 <Decompose> (Vector>Point>Decompose) per ottenere il valore Z delle coordinate dei punti (altezza). Il componente <decompose> mi restituisce le coordinate X,Y, e Z di ogni punto di Input. Ho comparato questi valori con un dato numero (dal <number slider>) con un componente <larger> per creare una lista valori booleani associativi. Il componente <cull pattern> 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.

Fig. 3.18 Lista di punti. Vogliamo selezionare i punti con i valori di x più bassi. Come già detto prima, il componente <point decompose> 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 <sort list> farà per noi. Fondamentalmente il componente <sort>, 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 <item> (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 <series> e <pt>. 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 <shift list> (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 <number slider> 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.

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 <Cull Nth>. 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 <number slider> che definisce il numero di colonne ad ogni componente <cull nth> per stabilire la frequenza di raccolta.

Fig. 3.21 Usiamo <cull nth> per eliminare le ultime colonne dalle prime, seconde e terze liste di punti. L'ultimo passo Ă¨ quello di alimentare i componenti <line> 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 <line>. Non dimenticate di impostare l'opzione cross reference per il componente <pt> , e longest list per il componente <line> .

Fig. 3.23 Ora modificando il <number slider> Ă¨ 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)

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

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 <series> che rende possibile il controllo dei valori numerici (numero di punti), la dimensione del passo ( distanza tra punti). Attraverso questa <series> 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 <series> e <pt>. Aggiungiamo qui un componente <receiver> 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 <receiver>, riceve i dati da <series>.

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 <receiver> per avere dati da una <series> e con un altro <pt> Ă¨ stato generata la seconda riga di punti aventi valori y, provenienti da un <number slider> 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 <cull pattern>, in una riga usando il pattern booleano TRUE/FALSE e nell'altra usando FALSE/TRUE

Fig. 3.30 Ora se connette entrambi i componenti <cull> ad un componente <poly line> 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.

Fig. 3.31 Il componente che ordina i punti nel modo descritto Ă¨ il <wave> (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 <pline> mostreranno il primo zigzag.

Fig. 3.32 Con lo stesso concetto, Ă¨ stata generata la terza riga di punti, e con un altro componente <weave> e <pline>, Ă¨ stata disegnata una seconda linea a zig-zag

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 <pt>, <cull> e <weave> (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 <pt> in negativo, (possiamo usare lo stesso <number slider> 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 <number slider> per cambiare il raggio di una circonferenza.

Fig. 3.40 Incremento di seno e coseno, grazie alla moltiplicazione attraverso da un <number slider> 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 <pt> sono stati rinominati.

Fig. 3.41 La prima e la seconda circonferenza di punti Per poter filtrare i punti, possiamo semplicemente usare il <cull pattern> 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 <range> di numeri reali, abbiamo bisogno di un componente <series> per procurarci numeri interi come indici dei punti nella lista. Gli N parametri del <range> definiscono il numero dei passi o delle divisioni, quindi il componente <range> produrrĂ N+1 numeri. Ed Ă¨ per questo che necessitiamo di un <series> 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)

Fig. 3.43 A questo punto ho bisogno di scegliere i punti e gli indici come nell'esempio precedente. Ho quindi usato il componente <Merge> (Sets>Tree>Merge) per generare una lista di dati entrambe le liste <cull>. L'operazione Ă¨ stata applicati sia ai punti che agli indici. Sebbene il risultato dell'unione delle <series> 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.

Fig. 3.44 I punti sono ordinati con un componente <sort> 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.

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

CAPITOLO 4_ Trasformazioni

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.

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.

Spostamenti Nel capitolo 3, abbiamo generato diverse griglie di punti attraverso i componenti <seris> e <pt>, ma ora Ă¨ giunto il momento di introdurre un altro componente, chiamato <grid rectangular> (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 <grid rectangular> con i suoi valori predefiniti. E' possibile cambiare la dimensione della griglia attraverso un <number slider> 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 <XY plane> (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 <Z unit> (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 <number slider> connesso con l'input del componente <z unit>. Modificando la posizione del <xy plane> lungo l'asse Z, sarĂ possibile cambiare la posizione della griglia

Fig. 4.4 Le griglie (selezionate in verde) sono modificate da un <number slider> che scala la distanza tra i punti, e da un altro slider connesso ad un <z unit> e un <xy plane> per modificare le coordinate dei punti della griglia sull'asse Z. 53

Quindi, se date un'occhiata al risultato di una <grid rectangular> è 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 <grid> attraverso la porta M al componente <line> 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 <line SDL>. Un componente <line SDL> 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 <line SDL>.

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 2p> (Vector>Vector>vector 2pt). Questo componente crea dei vettori attraverso il suo punto di partenza e di arrivo.

Fig. 4.6 Il componente <line SDL> 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 <number slider> ed è possibile cambiare la loro direzione cambiando la dimensione della seconda griglia.

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 <end point> (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 <Plane Normal> (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 <polygon> 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.

Fig. 4.9 Con un componente <list lenght> otteniamo i numeri delle linee, mentre il componente successivo <function> il quale Ă¨ una radice quadrate dell'input (F(x)=Sqrt(x)), calcola il numero delle linee per ogni riga. E' stato usato un componente <series> 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 <extrude point> (Surface>freeform>Extrude Point) e collegato il punto iniziale della linea quale punto verso il quale voglio venga estruso il mio poligono.

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.

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

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 <circle> con un <number slider> come raggio esterno della torre. Questa circonferenza è copiata per sei volte lungo la direzione Z positiva, grazie al componente <move>, attraverso un vettore <z unit> . 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 <scale> (Xform>Affine>Scale) per ridimensionare i piani di riferimento. Il componente <scale> 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 <move>. 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 <centre> (Curve>analysis>center) che ci restituisce il centro delle circonferenze. Connettendolo al <scale> 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 <number>.

Fig. 4.16 Se ora applichiamo una superficie loft a questi piani (attraverso un componente <loft> (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 <end point> per avere i punti iniziale/finale dei miei piani campione. Collegando questi punti come vertici di un componente <interpolate> (curve>spline>interpolate) sarĂ possibile avere una curva posizionata nella facciata. 61

Fig. 4.18. Qui sono state divise le curve <interpolate> 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 <polygon> sulla facciata. Sono state impostati tre lati per generare triangoli e la loro dimensione, la parte 'R' (raggio) Ă¨ controllabile attraverso un <number slider>

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 <rotate> 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 <series> genera i nostri angoli di rotazione e contiene elementi in numero pari al componente <divide> (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.

Fig. 4.22 Un componente <domain> (Math>Domain>Domain ) è stato usato per definire un range numerico da 0 a 360. Questo intervallo numerico è diviso attraverso un componente <range> in 10 parti e il risultato è usato come fattore angolare per un componente <rotate>. Quindi come mostrato nell'immagine, gli elementi di facciata sono distribuiti nella circonferenza di base.

Fig. 4.23 Se facciamo un <mirror> (specchio)(Xform>Euclidian>Mirror) attraverso un <XY plane> (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/)

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 <attractor 1> a cui abbiamo disegnato attorno un <circle>, giusto per renderlo piĂš chiaro. Voglio che il mio <attractor_1> influenzi tutti i miei <polygon> nel suo campo di azione. Significa che, in base alla distanza tra ogni <polygon> e il <attractor_1> e nel dominio di <attractor_1> ogni <polygon> risponde all'attrattore modificando la sua dimensione.

Fig. 4.29 Base di <point_grid> con <polygon> e <attractor_1> L'algoritmo Ă¨ veramente semplice. In base alla <distance> tra <attractor_1> e il <pt-grid> 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 <distance> per misurare la distanza tra <attractor_1> e il centro del poligono o la <pt_grid>. A causa del numero che potrebbe essere troppo grande, abbiamo bisogno di <divide> (Math>Operators>Division) la distanza con un numero dato da un <number slider> per ridurre la potenza di <attractor_1> a mio piacimento.

Fig. 4.3 La <Distance> viene divisa con un numero per controllare la potenza del componente <attractor_1>. Sebbene abbiamo creato un gruppo attraverso <attractor_1> e la sua circonferenza, sembra che la nuova versione di Grasshopper non accetti più i cluster, ed è quindi consigliabile usare un semplice <pt> come <attractor_1> Se ora connettiamo il componente <div> al raggio (R) del poligono, potremo vedere che la scala del poligono aumenta quando ci avviciniamo all' <attractor_1>. Sebbene questo possa sembrare un buon risultato, vogliamo controllare il raggio massimo del poligono, altrimenti andando oltre, c'è il rischio che diventino troppo grandi, intersecandosi uno con l'altro (è la stessa cosa che succede se la potenza degli attrattori è troppo grande). Dobbiamo quindi avere un controllo manuale del raggio del poligono.

Fig. 4.31 Usando un componente <minimum> (Math>Util>minimum) ed un numero definito dall'utente, creiamo un costrutto decisionale che dice all'algoritmo di scegliere il valore dal componente <div> se è più piccolo del numero che abbiamo definito come raggio massimo attraverso il <number slider>. Come potete vedere dalle immagini, questi poligoni che crescono per diventando più grandi del <max_rad> rimangono costanti, e possiamo dire che non sono sotto l'azione del campo di attrazione. Se nell'area di lavoro di Rhino, cambiamo manualmente la posizione del <attractor_1>, possiamo vedere che tutti i poligono avranno il loro raggio in accordo con la posizione di <attractor_1> 68

Fig. 4.32 Effetti dell'attrattore su tutti i poligoni. Lo spostamento degli attrattori, influenza ogni poligono

Fig. 4.33 Con la stessa modalitĂ , possiamo spostare i poligoni in direzione Z, in base al numero che arriva da <min> o cambiando le funzioni matematiche, se necessario. Quindi l'utilizzo degli attrattori non Ă¨ solo legato alle dimensioni. Semplice !!!. Possiamo applicare qualunque funzione su questi poligoni, per ruotarli, cambiare il colore, etc. Ma proviamo ora a pensare cosa potrebbe succedere se avessimo due attrattori nel campo. Creiamo un altro cluster, il che significa un altro punto su Rhinoceros associato al <point> e al <circle> su Grasshopper. La prima parte dell'algoritmo risulta la stessa. Ancora una volta, abbiamo bisogno di misurare la distanza tra questo <attractor_2> e il centro del poligono o il <pt_grid> e quindi dividerlo per lo stesso <number slider> qui rinominato <att_power> per controllare la potenza dell'attrattore

Fig. 4.34 Introduzione di un secondo attrattore e applicazione dell'algoritmo. Ora abbiamo due diverse liste di dati che includono la distanza del poligono da ogni attrattore. Visto che l'attrattore più vicino può influenzare ancora di più il poligono, dobbiamo trovare quale è più vicino e usarlo come sorgente di azione. Useremo un <min> per trovare quale distanza è minore e di conseguenza quale punto è più vicino.

Fig. 4.35 Trovare l'attrattore più vicino. Dopo aver trovato quello più vicino attraverso il componente <min>, il resto del processo continuerà in questo modo. Ora tutti i poligoni, sono influenzati dai due attrattori.

Fig. 4.36 E' possibile cambiare nuovamente la posizione degli attrattori e vedere come i poligoni reagiscono di conseguenza. 70

Aggiungiamo altri attrattori, con l'obbiettivo di trovare quello più vicino ad ogni poligono e applicare gli effetti predefiniti. Questo concetto è utile per dialogare con le problematiche di progettazione con un largo numero di elementi di piccola scala. Curva attrattore: progetto del muro Poiché in diversi casi necessitiamo di articolare il campo degli oggetti con attrattori lineari anziché puntuali, completiamo il discorso con un altro esempio, ma in questo caso attraverso una curva usata come attrattore. Il nostro obiettivo è quello di progettare un muro traforato per uno spazio interno, per avere una vista incorniciata verso l'altro lato. Questa parte di lavoro potrebbe essere tagliata da fogli materiali. Nel mio spazio progettuale abbiamo un foglio piano (il muro), due curve e una serie di punti distribuiti casualmente come punti di base per forme di taglio. Abbiamo deciso di generare alcuni rettangoli attraverso questi punti, tagliarli dai fogli per creare un muro traforato. Inoltre vogliamo organizzare i rettangoli attraverso le due curve date in modo che alla fine, non risultino solo dei rettangoli sparsi, ma distribuiti in maniera casuale in base alle curve che hanno un livello di organizzazione in una macro scala ma vengono controllate in micro scala. Ciò di cui abbiamo bisogno è di generare questa serie di punti casuali e spostarli verso le curve, in base alla potenza che ricevono da queste. Ho inoltre deciso di spostare i punti lungo entrambe le curve in modo da non avere bisogno di selezionare quello più vicino. Ora ho bisogno di generare i miei rettangoli oltre questi punti per definire, infine, la dimensione di questi rettangoli in relazione alla loro distanza dagli attrattori.

Fig. 4.37 Generazione una lista di punti distribuiti casualmente, e introduzione degli attrattori attraverso due componenti <curve> (Params>Geometry>Curve) nello spazio del foglio. Ho usato un componente <domain> per definire l'intervallo tra lo zero (definito manualmente) e il <number slider> per il range dei punti casule. Abbiamo rinominato il <pt> in <Rnd_Pt_Grid>.

Fig. 4.38 Quando l'attrattore è un punto, potete spostare la geometria verso di loro. Ma quando l'attrattore è una curva, dovete trovare un punto relativo sulla curva e spostare la vostra geometria, lungo questo specifico punto. E questo punto deve essere unico per ogni geometria., perchè ci deve essere una sola relazione tra gli attrattori e ogni geometria. Se immaginiamo un attrattore come una calamita, questo potrà attirare la geometria, dal suo punto più vicino all'oggetto. Quindi, fondamentalmente ciò di cui abbiamo bisogno all'inizio è di trovare il punto più vicino al <Rnd_pt_grid> su entrambi gli attrattori. Questi punti sono quelli più vicini agli attrattori, per ogni membro del <Rnd_Pt_Grid> separatamente. Ho usato il componente <Curve CP> (Curve>Analysis>Curve CP) che restituiscono il punto più vicino della curva al mio <Rnd_Pt_Grid>.

Fig. 4.39 Per poter spostare i punti verso gli attrattori, ho bisogno di definire un vettore per ogni punto in <Rnd_Pt_Grid>, dal punto al suo punto più vicino sugli attrattori. Poiché ho il punto di partenza e il punto finale del vettore, uso il componente <vector 2Pt>. Il secondo punto del vettore (porta B del componente) è il punto più vicino sulla curva.

Fig. 4.40 Ora ho connesso tutti i miei <Rnd_Pt_Grid> ai due componenti <move> per spostarli verso gli attrattori. Ma se uso i vettori che ho creato nell'ultimo passaggio, questo sposterĂ tutti i punti sulle curve, ma non Ă¨ quello che voglio. Se guardate il componente <Curve CP> possiede un outpunt che restituisce la distanza tra ogni punti e il punto rilevante piĂš vicino sulla curve. Bene! Non abbiamo bisogno di misurare la distanza dagli altri componenti. Ho appena usato un componente <Function> e l collegato la distanza alla X e un <number slider> alla Y per dividere X/Log/(y) in modo da controllare il fattore di spostamento (La funzione logaritmica modifica la relazione lineare tra le distanza e i fattori risultanti). Ora ho bisogno di modificare la dimensione dei miei vettori, in base ai nuovi fattori creati. Ho bisogno di un componente per modificare la dimensione dei vettori ed Ă¨ per questo che ho usato un componente <multiply> (Vector>Vector>Multiply) che lo fa per me, quindi ho collegato il <vector 2P> come base di vettori ed ho cambiato la loro dimensione attraverso il fattore dimensione e ho collegato i vettori risultanti al componente <move> che sposta il <Rnd_Pt_Grid> in relazione alla loro distanza dagli attrattori, e verso di loro.

Fig. 4.41 Il <number slider> cambia la potenza con cui ogni attrattore sposta gli oggetti verso di loro

Fig. 4.42 IL passo successivo Ă¨ quello di generare dei rettangoli. Ho collegato i punti spostati, usati come punti di base, al componente rettangolo (curve>primitive>rectangle). Ma come giĂ detto, voglio cambiare la dimensione dei rettangoli in base alla loro distanza da ogni attrattore. Ho quindi usato gli stessi valori numerici che ho usato per il modulo del vettore e li ho modificati attraverso due funzioni. Ho diviso questi fattori per 5 sul valore di X dei rettangoli e li ho divisi per 25 nella loro dimensione di Y. Come potete vedere i rettangoli hanno dimensioni diverse, in base alla loro distanza originale dagli attrattori, ma hanno tutti le stesse proporzioni a causa del fattore di divisione applicato. Potete cambiare questo fattore (5, 25) a qualunque valore o usare lo slider per modificarli gradualmente per vedere quale proporzione Ă¨ quella piĂš delicata per il vostro gusto.

Fig. 4.43 Manipolando le variabili otterremo diversi modelli tra i quali potremo scegliere il migliore per i nostri scopi progettuali.

Fig. 4.44 Modello del progetto finale di un sistema di muri traforati. I diversi effetti di ombreggiatura possono essere considerati come fattori per controllare la dimensione delle aperture. 75

Capitolo 5_ Spazio Parametrico

Capitolo_5_Spazio Parametrico Il nostro studio delle geometria osserva gli oggetti nello spazio, la rappresentazione digitale delle forme e della tettonica, la diversa articolazione degli elementi e i processi multipli di generazione di forme; delle idee classiche di simmetria e pattern fino alle NURBS e alle MESH. Stiamo dunque dialogando con gli oggetti. Questi oggetti possono essere parallelepipedi, sfere, coni, superfici o qualunque loro articolazione. In termini di loro rappresentazione nello spazio, generalmente sono generalmente divisi in punti zero dimensionali , curve monodimensionali, superfici bidimensionali e solidi quali oggetti a 3 dimensioni. Formuliamo lo spazio attraverso un sistema di coordinate per identificare alcune proprietà di base quali posizione, direzione e misure. Il sistema di coordinate cartesiane è uno spazio tridimensionale che ha un punto di origine O=(0,0,0) e tre assi che in questo punto che creano le direzioni X, Y e Z. Ma dovremo considerare che questo sistema tridimensionale di coordinate, include anche sistemi bidimensionali (spazi piatti (x,y)) e monodimensionali (spazi lineari (x)). Ciò che conosciamo come progetto parametrico comunica con questi spazi. Per disegnare curve free form e superfici in maniera parametrica, abbiamo bisogno di andare oltre questi spazi. Visto che il disegno parametrico si sposta tra questii spazi, abbiamo bisogno di capirli come spazi parametrici.

5_1_Spazio parametrico monodimensionale L'asse X è una linea infinita che contiene alcuni numeri associati, occupanti diverse posizioni. Semplicemente X=0 indica l'origine e x=2.35 un punto nella direzione della X positiva che dista 2.35 unità dall'origine. Questa semplice sistema di coordinate monodimensionale può essere parametrizzato con differenti posizioni, ma anche una curva nello spazio contiene la possibilità di essere parametrizzata attraverso una serie di numeri reali che mostrano una differente posizione nella curva. Nel nostro spazio parametrico 1D, quando si parla di punti, questi potrebbero essere descritti attraverso dei numeri reali che sono associati ad un punto specifico in una curva presa in considerazione. La cosa importante da sapere è che, poiché non stiamo lavorando più sull'asse X, ogni curva ha il suo proprio spazio parametrico e questi parametri non combaciano esattamente con il sistema di misura universale. Ogni curva in Grasshopper ha uno spazio parametrico che parte da zero e termina in un numero reale positivo (fig. 5.1)

Fig. 5.1. Spazio parametrico monodimensionale di una curva . Ad ogni valore di 't' è associato un numero reale con una posizione nella curva. 77

Quindi parlando di curve e lavorando e riferendoci ad alcuni punti specifici, non abbiamo l'obbligo di confrontarci sempre con punti nello spazio 3D con p=(x,y,z) ma possiamo richiamare un punto su una curva attraverso un parametro specifico p=t. Ed Ă¨ ovvio che possiamo sempre convertire questo spazio parametrico in un punto in un sistema coordinate generale globali (Fig. 5.2)

Fig. 5.2 Spazio parametrico e conversione in unsistema di coordinate 3D

5_2_Spazio parametrico bidimensionale Due assi, X e Y in un sistema di coordinate generale globale, dialogano con i punti di una infinita superficie piatta nella quale, ad ogni punto di questo spazio Ă¨ associato con una coppia di numeri p=(x,y). Quasi come in uno spazio 1D, possiamo immaginare che tutti i valori di uno spazio 2D possono essere tracciati non solo in un sistema generale di coordinate di una superficie piana, ma anche in ogni superficie spaziale. Quindi possiamo parametrizzare un sistema di coordinate su una superficie curva nello spazio, e nominare i diversi punti attraverso una coppia di numeri qui chiamati spazio UV, nei quali ogni punto P sulla superficie risponde a P=(u,v). Ancora una volta, non abbiamo bisogno di lavorare con tre valori P=(x,y,z) come in uno spazio 3D per trovare i punti, ma, possiamo lavorare con i parametri UV sulla superficie (Fig. 5.3).

Fig. 5.3 Spazio parametrico UV e 2D 78

Questi 'parametri' sono specifici per ogni superficie e non sono dei dati generici come il sistema di coordinate globale, ed è per questo che li chiamiamo parametrici! Abbiamo accesso allo spazio 3D e alle coordinate equivalenti per ogni punto sulla superficie (Fig. 5.4)

Fig. 5.4. Equivalenza del punto p=(u,v) in un sistema di coordinate generali p=(x,y,z)

5_3_ Transizione tra gli spazi Una parte fondamentale nel pensare un progetto parametrico, è quella di conoscere esattamente di quale sistema di coordinate o di spazio parametrico abbiamo bisogno per poter progettare. Lavorando con curve free form e superfici, abbiamo bisogno di procurarci dei dati per la creazione o la trasformazione di altre geometrie. Con lo scripting risulta più complicato, ma con l'interfaccia visuale di Grasshopper, rispetto al codice, è possibile identificare semplicemente quale tipo di dati necessitiamo per centrare i nostri scopi progettuali. Notiamo che per richiamare una geometria con gli Algoritmi Generativi e Grasshopper, non sempre ciò di cui abbiamo bisogno è un parametro, o un valore in un sistema di coordinate, ma qualche volte abbiamo bisogno solo di un indice numerico. Se stessimo lavorando con un gruppo di punti, linee o quant'altro, e fossero generate come un gruppo di oggetti, come una nuvola di punti, poiché ogni oggetto è associato con un numero naturale che mostra la posizione in una lista di oggetti, avremo solo bisogno di nominare i numeri degli oggetti come indici al posto di un sistema di coordinate. L'indicizzazione dei numeri, come delle serie variabili in programmazione è un sistema di calcolo basato sullo zero.

Fig. 5.5 Indicizzare numericamente in un gruppo di oggetti è il modo più semplice di nominarli. Questo è un sistema di calcolo basato sullo zero, significa che i numeri partono da zero. 79

Quindi, come precedentemente menzionato, nella modellazione associativa, generiamo le nostre geometrie passo dopo passo come alcuni oggetti relazionati e per questo motivo usiamo lo spazio parametrico per ogni oggetto, in modo da estrarre informazioni specifiche sullo spazio e usarle come base di dati per i passi successivi. Questa potrebbe partire da un semplice campo di punti come generatori di base e terminare ai dettagli sottili del modello risultante.

5_4_ Componenti parametrici di base 5_4_1 Valutazione di curve Il componente <evaluate> è la funzione che trova i punti su una curva o su una superficie, in base al parametro passato. Il componente <evaluate curve> (Curve>Analysis>Evaluate curve) prende una curva ed un parametro (un numero) e restituisce un punto su una curva in base a questo parametro.

Fig.5.6 Il punto valutato su <curve> in base ad un parametro specifico, che proviene da un <number slider>

Fig. 5.7 Possiamo usare qualunque <curve> disegnata su Rhinoceroso su Grasshopper perchè venga valutata. E possiamo usare una <series> di numeri come parametrici per <evaluate> al posto di un parametro. Nell'esempio precedente, a causa di alcuni numeri del componente <series> che sono più grandi del dominio della curva, è possibile che il componente <evaluate> restituisce un warning (attenzione!) e diventi arancione poiché i i punti sono posizionati nell'immaginaria continuazione della curva

Fig. 5.8 Sebbene l'output 'D' di un componente <curve> restituisca il dominio di una curva (parametri minimo e massimo di una curva) alternativamente possiamo passare una curva esterna (Params>Geometry>curve) e nel suo menu contestuale possiamo scegliere 'reparameterize' (riparametrizza). Questo imposta il dominio della curva in valori compresi tra zero ed uno. Fondamentalmente possiamo dunque scorrere tutte le curve attraverso un <number slider> o insieme numerico compreso tra zero e uno, e non essere preoccupati che i parametri possano andare oltre il dominio numerico della curva stessa. Ci sono altri componenti utili per lo spazio parametrico in Curve>Analysis / division di cui parleremo in seguito

5_4_2 Valutazione di una superficie Se per valutare una curva abbiamo bisogno di un numero come parametro (perchĂ¨ la curva ha uno spazio monodimensionale) per le superfici abbiamo bisogno di una coppia di numeri come parametri (u,v) mediante i quali possiamo valutare uno specifico punto su una superficie. Possiamo usare il componente <evaluate surface> (Surface>Analysis>Analysis) per valutare un punto su una superficie con un parametro specifico. Possiamo usare un componente <point> per valutare la superficie usandolo come input per UV del componente <evaluate surface> (ignorerĂ la dimensione Z) e sarĂ possibile scorre i punti sulla superficie solo con la parte X e Y del punto, quale parametri U e V.

Fig. 5.9 Un punto valutato su una superficie, basato sui parametri U e V, provenienti da <number slider>, con un componente <point> che crea una coppia di numeri. Ancora, come con le curve Ă¨ possibile scegliere il 'reparameterize' sul menu contestuale della superficie e impostare il dominio della superficie compreso tra zero e uno in entrambe le direzioni U e V. Cambiate U e V attraverso un <number slider> e osservate come questi punti valutati si muovono sulla superficie (Ho rinominato gli input X,Y,Z, dei componenti in U e V)

Fig. 5.10 poichĂŠ abbiamo bisogno di <points> per valutare una <surface> come vedete, possiamo usare ogni metodo che abbiamo trattato per generare. Le nostre opzioni non sono limitate solo ad una coppia di parametri provenienti da un <number slider>, e possiamo scorrere una superficie in tanti modi.

Fig. 5.11 Per dividere una superficie (come nell'esempio precedente) in alcune righe e colonne, possiamo anche usare il <divide surface> o, se c'Ă¨ bisogno di alcuni piani che incrocino alcune righe e colonne di una superficie possiamo usare <surface frame> entrambi dal menu Surface, sotto il pannello Util. 82

5_4_3_ Punto più vicino alla curva e alla superficie Ma non sempre usiamo parametri per cercare i punti, talvolta abbiamo il punto e vogliamo sapere i suoi parametri per altri usi. Questo succede quando entra in gioco la problematica di trovare il punto più vicino. I componenti <curve CP> e <surface CP> (punto più vicino alla curva/superficie) sono due componenti che ci aiutano a fare questo.

Fig. 5.12 <Curve Cp> e <Surface Cp> ci aiutano a trovare il parametro di un punto su una curva o su una superficie. Esistono anche altri componenti che è necessario alimentare con altri parametri.

5_5 Proliferazione di oggetti nello spazio parametrico Per diverse ragioni di design, i progettisti usano delle superfici per riprodurci velocemente sopra, altre geometrie. Le superfici sono oggetti bidimensionali flessibili e continui che rappresentano delle basi adatte a questo scopo. Esistono tanti metodi che dialogano con le superficie come la Pannellizzazione. In ogni caso voglio iniziare con uno dei metodi più semplici, mentre degli altri discuteremo più avanti. Abbiamo una superficie free-form e una geometria semplice, come per esempio un parallelepipedo. La domanda ora è: come faccio a riempire la superficie con un certo numero di parallelepipedi, in modo da avere superfici differenziate (come per esempio un involucro), per il quale dobbiamo avere il controllo della macro scala (superficie) e della micro scala (parallelepipedo) separatamente, ma in maniera associativa? Ecco il metodo: per poter portare a termine l'operazione, dovremo dividere la superficie nella parti desiderate e generare i nostri parallelepipedi su queste posizioni specifiche della superficie e rimodificarle in modo da avere manipolazioni locali di questi oggetti. Individuare i posizionamenti desiderati sulla superficie è semplice. Possiamo dividere la superficie o possiamo generare alcuni punti basati su un dato insieme numerico. Per quanto riguarda la manipolazione locale delle geometrie, abbiamo ancora bisogno di set di dati che possono essere usati per le trasformazioni quali rotazione, spostamenti locali, ridimensionamenti, correzioni etc.

Fig. 5.13 Una superficie free form riparametrizzata, valutata attraverso un intervallo numerico che parte da zero a uno, diviso per 30 elementi attraverso un <number slider> in entrambe le direzioni U e V (qui possiamo usare <divide surface>, ma ho preferito usare il componente <point> per ricordare che tutte le tecniche per la generazione di punti dal capitolo 2 sono opzioni possibili per il nostro esperimento).

Fig. 5.14 Come potete vedere il componente <evaluate> restituisce un 'normal' (normale) e un 'plane' (piano) per ogni punto valutato sulla superficie. Ho usate questi piani o cornici per generare serie di parallelepipedi (<box>) sulla superficie finchĂ¨ le loro dimensioni sono state controllate attraverso <number slider>. Il componente <box> (Surface>primitive>center box) necessita di un centro per il parallelepipedo e della sua lunghezza in X, Y, Z. Per poter modificale localmente i parallelepipedi, ho deciso di ruotarli. Voglio impostare ll'asse di rotazione parallelo alla direzione U della superficie e in base alla situazione di questa semplice superficie, sceglierĂ˛ il piano XZ, come base per la loro rotazione (fig. 5.15)

Fig. 5.15 Rotazione locale di un parallelepipedo

Fig. 5.16 Il componente <rotate> necessita di tre input. Il primo è la geometria, cioè i parallelepipedi. Il secondo elemento è l'angolo di rotazione. Li voglio ruotare con dei valori casuali (è possibile ruotarli gradualmente o in qualunque modo). Voglio quindi genere un gruppo di numeri casuali (<random>) il cui numero sarà pari a quello dei parallelepipedi. Quindi ho usato un componente <list lenght> per capire quanti sono i parallelepipedi e l'ho collegato alla porta N del componente <random> e collegato i valori casuali come angoli di razione al componente <rotate>. Infine, per definire il piano dell'asse, ho generato un <XZ plane> su ogni punto che ho valutato sulla superficie e l'ho collegati al componente <rotate> Per migliorare le performance del processo, prima di generare gli oggetti, non scordate di deselezionare l'anteprima ('preview')

Fig. 5.17 Geometria finale

Fig. 5.18 Provate a combinare concetti differenti sui vostri progetti. Qui, anzichĂŠ usare valori casuali per le rotazioni dei parallelepipedi, ho usato un attrattore puntiforme e ho impostate la sua distanza da ogni parallelepipedo come fattore di rotazione e come vedete, i risultati sono mostrati in figura. Queste sono tecniche di manipolazione locale dei parallelepipedi, ma sapete che potete applicare modifiche anche alla scala globale. 86

Uso non uniforme della valutazione Durante un progetto mi è venuto in mente che non c'è motivo di usare una distribuzione uniforme dei punti sua una superficie. Mi sono chiesto se è possibile impostare alcuni criteri e valutare la superficie in base a questo e selezionare posizioni specifiche sulla superficie. Poiché usiamo i parametri U e V, lo spazio e l'insieme di dati incrementali (o loop incrementali nello scripting), mi sono anche chiesto se siamo sempre limitati ad una divisione rettangolare di una superficie. Esistono diversi domande riguardo l'individuazione delle tracce su una superficie, ma qui sto per cimentarmi in un semplice esempio per mostrare come in situazioni specifiche possiamo usare alcuni dei parametri U e V di una superficie per crearci sopra una griglia rettangolare non uniforme. L'esempio delle colonne Ho due superfici free form per coprire uno spazio e sto pensando di creare uno spazio sociale aperto in mezzo. Voglio aggiungere alcune colonne tra le superfici ma, visto che sono free form e e non voglio creare una griglia di colonne, ho deciso di limitare la lunghezza della colonne e aggiungerne il più possibile in determinate posizioni con specifici limiti di altezza. Voglio inserire in questo spazio due coni come colonne, invertiti e intersecati, per creare una forma semplice.

Fig. 5.19 Ho inserito due generiche superfici in Grasshopper, attraverso <srf _top> e <srf_bottom> come spazio coperto l'ho riparametrizzato. Ho inoltre generato un intervallo numerico compreso tra zero e uno, diviso attraverso un <number slider> e usando il componente <point> ho valutato queste superfici ai punti.

Fig. 5.20 In seguito, ho generato una serie di <line> tra tutti questi punti, ed ho inoltre misurato la distanza tra ogni coppia di punti.

Fig. 5.21 Ora ho bisogno di estrarre le mie linee desiderate dalla lista. Ho usato un componente <dispatch> (Sets>List> Dispatch) per selezionare le linee dalla lista. Un componente <dispatch> necessita di dati booleani associati con i dati della lista, per mandare quelli associati a TRUE verso l'output A e quelli associati a FALSE, verso l'output B. I dati booleani arrivano da una semplice funzione di comparazione. In questa funzione ho comparato la lunghezza delle linee con dei numeri dati come lunghezza massima della linea (x>y, x=<number slider>, y=<distance>). Ogni lunghezza di linea minore del <number slider> creano un valore TRUE, attraverso la loro funzione e li passano attraverso il componente <dispatch> all'output A. Quindi se uso le linee provenienti da un output A di <dispatch>, sono sicuro che saranno minori di una certa lunghezza, saranno quindi le mie colonne.

Fig. 5.22 La geometria della colonne è composta da due coni invertiti uno rispetto all'altro, che si intersecano nella sommità. Poiché qui ho l'asse delle colonne, voglio disegnare due circonferenze nei punti terminali degli assi e estruderli verso i punti sulle curve, in modo da rendere possibile l'intersezione.

Fig. 5.23 Usando il componente <end point> posso avere entrambe le estremità delle colonne. Quindi posso connettere questi punti e usarli come punti base per creare delle circonferenze con un raggio dato. Avete già appreso che queste circonferenze sono piane mentre le nostre superfici non lo sono. Ho quindi bisogno di proiettarle attraverso il componente <project> (Curve>Util>Project) per questo motivo. La parte B di <project> sarà connessa alle superficie inferiore e superiore. 89

Fig. 5.24 L'ultimo passo Ă¨ quello di estrudere queste circonferenze proiettate verso punti specifici sull'asse della colonna (Fig. 5.23). Ho usato il componente <extrude point> e l'ho quindi collegate alle circonferenze proiettate come curve di base. Per l'estrusione verso un punto, ho collegato tutti agli assi delle colonne al componente <curve>, li ho riparametrizzati, quindi valutati in due parametri specifici distanti 0.6 dalla cima e 0.4 dalla parte inferiore.

Fig. 5.25 Sebbene in questo esempio ho usato ancora il tracciamento basato sulla griglia su una superficie, ho usato ulteriori criteri per scegliere alcuni punti e non tutti in maniera uniforme.

Fig. 5.26 Modello finale L'idea di usare spazi parametrici delle curve e delle superfici per proliferare oggetti sulle stesse superfici, comporta diverse opzioni e metodi. Non fermatevi ad uno solo, ma provatene diversi. Vediamo ancora qualcos'altro.

5_6_Alberi di dati Parlando di spazi parametrici e usando i componenti relativi, Ă¨ ora di aprire un nuovo capitolo riguardo l'amministrazione dei dati su Grasshopper, chiamato 'data tree' (albero dei dati) che, poco alla volta, potrebbe servirvi quando lavorate con modelli complessi, specialmente nello spazio parametrico di curve e superfici. Le grandi potenzialitĂ degli algoritmi generativi consentono di creare e governare centinaia di oggetti tra loro associativi. Lavorando con un grande numero di oggetti, talvolta abbiamo bisogno di applicare dei comandi a tutti gli oggetti contemporaneamente e, talvolta, abbiamo bisogno di estrarre un elemento a cui applicare un comando. Abbiamo quindi bisogno di avere accesso ai nostri oggetti e gestire i nostri dati (oggetti) in maniere differenti. Immaginiamo di avere 5 curve nel nostro spazio progettuale e doverle dividere in 10 parti. Ora vogliamo estrarre tutti i secondi punti su queste curve e connetterli insieme con una curva interpolata.

Fig. 5.27 Il componente <curve> importa 5 curve dentro Grasshopper, tutte divise in 10 parti. Se selezioniamo l'indice numerico 1 attraverso il componente <item> dai punti di divisione, vedrete che non verrà selezionato solo il secondo punto della prima curva, ma tutti quelli che hanno indice 1 (cioè tutti i secondi punti di tutte le curve)Bene! Ma se colleghiamo questi punti ad un componente <interpolate>, per disegnare una curva, vedrete che il componente mostrerà un errore e non disegnerà niente. Per capire il problema, introduciamo un componente molto utile e osserviamo la situazione. Questo componente è il <param viewer> da Params>Special. Compariamo i risultati

Fig. 5.28 Il componente <param viewer> mostra all'interno del componente informazioni interessanti sui dati, che ci fanno capirela ragione dell'errore del componente. Ciò che vedete in <param viewer> è il concetto del data tree in Grasshopper. Come si evince dalla figura 5.28, il componente <curve> contiene 5 elementi, ma mentre queste curve sono divise e generano alcuni punti per ogni curva, i punti sono elencati in una lista di dati differenti, chiamati 'Rami' (branches). Questo significa che il risultato del componente <divide> non è solo una lista di dati contenente 55 punti, ma ora abbiamo cinque liste di dati ognuna con 11 punti all'interno. Questo significa che il tree (albero) è stato diviso in branches (rami) in modo da facilitare usi futuri e renderli accessibili in maniera più semplice nei nostri progetti. Perciò, quando selezioniamo <item> indice 1, vengono selezionati gli elementi di indice 1 di ogni lista 92

Fig. 5.29 <param viewer> con l'opzione 'data tree' attivata dal menu contestuale, il cui compito Ă¨ di mostrare la differenza tra i rami di dati in ogni componente. Chiediamoci ora perchĂ¨ il componente <interpolate> non disegna una curva: dov'Ă¨ il problema? Diamo un'occhiata ravvicinata alle informazioni tratte dalla nostra situazione.

Fig. 5.30 <Param viewer> e <Panel> di A: curve e B: selezioni dei punti di indice 1 93

Nella prima immagine della figura 5.30 <Param Viewer> del componente <curve> mostra uno dei rami principali. Se date un'occhiata al suo pannello, vedrete che c'Ă¨ una lista di curve sotto il titolo di {0}. Qui in Grasshopper la notazione { } rappresenta il simbolo dell'albero dei dati, e mostrano i rami in cui sono posizionati gli oggetti. Quindi tutte le curve nella prima immagine sotto {0} sono situate nel ramo principale. Se tornate indietro alla fig. 5.28 vedrete che i <param viewer> per le curve indicano (Paths=1) che significa che abbiamo un solo ramo di dati e in questo ramo {0} (N=5) abbiamo 5 elementi. Ma nella seconda immagine della Fig. 5.30 possiamo vedere che i dati nel componenti <item> inseriti nella lista sotto 5 diversi rami e quando vengono trasferiti dentro un <interpolate>, sono separati l'uno dall'altro e il componente <interpolate> non puĂ˛ disegnare le polilinea attraverso 5 punti separati. Come possiamo risolvere il problema?

Fig. 5.31 Per risolvere il problema ho usato il componente <flatten> (Sets>Tree) che, come dice il nome, converte i dati da ramificazioni multiple in un unico ramo, visibile in <param viewer>. Come potete vedere nel secondo <panel> ora abbiamo 5 punti sotto il ramo {0} e il componente <interpolate> puĂ˛ disegnare una polilinea attraverso questi cinque punti. Per riassumere il concetto dobbiamo capire che, lavorando con oggetti multipli a livelli differenti, i dati si dispongono in una struttura gerarchica in rami, e ogni ramo di dati ha il proprio percorso e indice numerico che mostra il suo indirizzo univoco del ramo (p.e. {0;1}). E' importante sapere che lavorando con i componenti che gestiscono le liste, questi dovranno sottostare alle regole lavorando su ogni ramo come se fossero liste separate. Potremo avere bisogno, inoltre, sia di generare rami di dati per conto nostro sia far convergere le ramificazioni di dati in un unico flusso, o altri trattamenti dei dati. Negli esperimenti successivi ho provato a mettere in pratica queste situazioni.

Fig. 5.32 Ramificazione di dati su un 'data tree' Per concludere con questa tematica, vediamo un altro esempio. Il nostro scopo Ă¨ quello di progettare una superficie forata come quella schizzata in fig. 5.33 basata su una data superficie. Il processo sarĂ affrontato in maniera veloce per vedere subito il risultato finale.

Fig. 5.33 Schizzo della superficie desiderata. Per disegnare questa superficie forata, voglio generare tante piccole linee nel bordo superiore e inferiore della superficie e unirle attraverso un loft. Questo creerĂ tante piccole superfici che, tutte 95

insieme, daranno l'idea della mia superficie forata. Dovrei fare attenzione alla direzione delle linee per poter controllare le graduali modifiche delle superfici e quindi del risultato finale.

Fig. 5.34 Ho introdotto una generica <surface> nel canvas e l'ho esplosa attraverso <Brep Components> (Surface>Analysis>Brep Components) per avere accesso ai suoi bordi. Quindi ho selezionato i bordi superiori ed inferiori con <item> attraverso l'indice 0 e 2.

Fig. 5.35. Ho applicato una distanza di offset al bordo inferiore e ho anche modificato la direzione del bordo superiore con <flip> (Curve>Util>Flip) perchĂ¨ so che i due bordi non hanno la stessa direzione. A questo punto ho usato il componente <divide> per dividere questi bordi e avere un insieme di punti da gestire (Possiamo anche usare un solo componente <divide> ma ora preferiscono non renderlo piĂš complesso).

Fig. 5.36 Il componente <line> Ă¨ stato usato per connettere i punti della parte inferiore ai punti che stanno sulla curva distanziata dal bordo inferiore. Un altro componente <line> Ă¨ usato per connettere tutti i punti appartenenti al bordo superiore con il loro punto successivo della lista (shift offset=1)

Fig. 5.37 Se ora uso i componenti <line> per fare un loft, vedremo che viene generata una superficie, ma non quella che voglio io. Anche l'utilizzo del componente <wave> non aiuta. 97

Fig. 5.38 Se guardiamo il <param viewer> dei componenti <line>, vedremo che entrambi hanno un solo ramo di dati e quindi il loft non Ă¨ stato applicato a coppie separate di linee, ma ad un unico blocco. Chiaramente voglio che le linee vengano inserite in liste differenti per essere trattate come dati singoli e quando usate per il loft, diventino coppie di linee.

Fig. 5.39 Per risolvere questo problema ho usato un componente molto utile, il <Graft> (Sets>Tree>Graft Tree>. Come potete vedere, come risultato abbiamo che le liste di dati in entrambi i componenti <line> sono stati divisi in rami, un ramo per ogni elemento della lista. Ora il componente <loft> puĂ˛ creare la superficie da ogni linea della prima lista di dati ad una linea associata nella seconda lista di dati. A questo punto possiamo vedere che il risultato Ă¨ la geometria schizzata in precedenza. Qui, a differenza del primo esempio, dobbiamo ordinare i nostri dati in rami differenti per poter geometrie multiple come risultato , altrimenti avremo avuto una sola superficie continua.

Fig. 5.40 Vi ricordo che se volete disegnare una curva interpolata passante per punti specifici, provenienti da una superficie valutata, dobbiamo 'spianare' la lista di dati con il componente <flatten>, creando un ramo di dati per i punti e passarli alla curva interpolata. Questo perchĂ¨ tutte queste superfici sono inserite in rami diversi cosĂŹ come i punti valutati. Dobbiamo dunque capire che in componenti diversi e situazione progettuali, dobbiamo processare i dati in uno o piĂš rami. I componenti che ci possono aiutare, li troviamo in Sets>Tree

Fig. 5.41 Modello finale della superficie. 99

CAPITOLO_ 6_Deformazioni e Morphing

100

6_1_Deformazioni e Morphing La geometria non Ă¨ sempre fatta di oggetti puri. Per poter realizzare alcuni tipi di progetti, abbiamo bisogno di cambiare le porzioni e le condizioni generali dei volumi e di altri prodotti geometrici. La deformazione e il morphing sono tra le funzioni piĂš potenti nel campo del design free form. Attraverso le deformazioni, possiamo torcere, inclinare, piegare le geometrie e attraverso il morphing possiamo trasformare le geometrie da una condizione limite all'altra. Diamo un'occhiata ad una deformazione semplice. Se abbiamo un oggetto, come la Sfera, sappiamo che esiste un parallelepipedo limite (gabbia) attorno, la cui manipolazione deforma l'intera geometria.

Fig. 6.1 Deformazione di un oggetto attraverso il parallelepipedo limite. In base al tipo di trasformazione (se fatta attraverso un angolo, spostamento etc), possiamo chiamarla inclinazione, piegatura o deformazione libera. Per ogni funzione di deformazione, potremo avere bisogno dell'intero parallelepipedo limite, o solo uno dei suoi lati come piano oppure uno dei suoi punti. Se controllate i diversi componenti per le deformazioni, potrete facilmente trovare la il costruzioni geometriche di base per ottenere la deformazione. Nel campo dell'animazione il termine morphing indica il processo di transizione da un'immagine ad un'altra in maniera leggera e scorrevole. I componenti di Morphing in Grasshopper, lavorano allo stesso modo. Per esempio qui il componente <Box Morph> (Xform>Morph>Box Morph) deforma un oggetto attraverso un parallelepipedo di riferimento (Parallelepipedo limite), in un parallelepipedo destinazione (target box), mentre il componente <Surface morph> lavora con una superficie di base sulla quale Ă¨ possibile, nel dominio specificato, deformare le vostre geometrie e l'altezza dell'oggetto. Nella scheda Xform troverete <Box Morph>, <Surface Morph> e altri componenti aggiuntivi che possono provvedere alla raccolta di dati. Considerato che abbiamo diversi comandi che deformano un parallelepipedo, se usiamo questi parallelepipedi deformati come parallelepipedi di bersaglio, allora possiamo deformare ogni geometria in Grasshopper attraverso la combinazione del componente Box Morph. Come vedete in figura 6.2, abbiamo un oggetto importato su Grasshopper attraverso il 101

componente <geometry>. Questo oggetto Ă¨ inscritto in un parallelepipedo limite che ho disegnato io solo per migliorare la visualizzazione. Ho inoltre disegnato un altro parallelepipedo con valori inseriti manualmente.

Fig. 6.2 L'oggetto iniziale (sfera) e il parallelepipedo impostato manualmente.

Fig. 6.3 Un componente <Box morph> (Xform>Morph>Box Morph) deforma un oggetto da un parallelepipedo di riferimento ad un parallelepipedo di bersaglio. Visto che ho un solo oggetto, l'ho collegato sia come geometria che come parallelepipedo di riferimento (in caso di piĂš geometrie potete usare il componente <Bounding box> (Surface>Primitive>Bounding box>)). Ho deselezionato l'anteprima del <box> per vedere meglio la geometria trasformata.

102

Fig. 6.4 Ora, cambiando la dimensione del parallelepipedo bersaglio potete vedere la geometria modificata.

Fig. 6.5 Qui possiamo vedere che al posto di un parallelepipedo, se produco una serie di parallelepipedi posso iniziare a modificare i miei oggetti con il Morph più di una volta. Come vedete, i parallelepipedi differenzianti attraverso il componente <series> nella loro dimensione Y, provocano differenziazioni negli oggetti modificati.

6_2_ Pannelizzazione Una delle applicazioni più comuni del morphing è la pannellizzazione. Questa idea proviene dalla divisione di una superficie free form in piccole parti, specialmente a scopo produttivo. Sebbene le superfici free form sono largamente usate nell'industria automobilistica, non è facile trasferirle in campo architettonico per gli usi su scala maggiore. I vantaggi della pannallizzazione sono quelli di dividere una superficie in piccole parti (chiamate componenti) rendendo più semplice il processo di fabbricazione e il trasporto, rendendoli anche più controllabili in termini di precisione finale del prodotto. E' inoltre possibile, talvolta, dividere una superficie curva in piccole parti piatte e quindi ottenere la curvatura totale dall'assemblaggio delle geometrie piane che possono essere prodotte da fogli di materiale. Ci sono diversi motivi che riguardano la dimensione, la curvatura, le regolazioni etc, di cui proveremo a discutere. 103

Iniziamo con una superficie semplice ed un componente come modulo per pannellizzare la superficie.

Fig. 6.6 Una generica superficie a doppia curvatura pronta per la pannellizzazione.

Fig. 6.7 IL componente che voglio usare per popolare la superficie....niente di speciale, solo un esempio.

Fig.6.8 Prima di tutto ho bisogno di importare la superficie e l'oggetto da ripetere come componente di Grasshopper. Facendo riferimento ai componenti disponibili in Grasshopper, possiamo generare diversi parallelepipedi sulla superficie e usarli come oggetti di bersaglio, ed applicargli modulo trasformato. Ho quindi importato un <box morph> e ho usato il modulo come geometria e come parallelepipedo limite. Ora ho bisogno di generare il parallelepipedo bersaglio per fare il Morph del componente.

104

Fig 6.9 Il componente di cui ho bisogno per creare il parallelepipedo bersaglio, è <surface box> (Xform>Morph>Surface Box). Questo componente genera parallelepipedi sopra una una superficie, in base all'intervallo indicato dal dominio della superficie e all'altezza del parallelepipedo. Gli ho quindi connesso la superficie e il risultato sarà il bersaglio per il componente <box morph>. Ho bisogno di di definire il dominio dei parallelepipedi, oppure dividere l'intervallo numerico della superficie nelle sue direzioni U e V, per creare i parallelepipedi.

Fig. 6.10 Per poter dividere il dominio della superficie, ho usato <divide interval2> che dice al <surface box>, quante divisioni in U e V sono necessarie. Un altro <number slider>, definisce l'altezza del parallelepipedo bersaglio, cioè dei componenti trasformati. Quindi fondamentalmente l'idea è semplice. Creiamo un modulo (un componente) e disegniamo la nostra superficie. Quindi generiamo la quantità di parallelepipedi sopra questa superficie (come parallelepipedo bersaglio) e quindi morfizziamo il modulo dentro parallelepipedi. Dopo questo passaggio, sarà possibile modificare il numeri di elementi in entrambe le direzioni U e V e cambiare anche il modulo e avere sempre un aggiornamento dinamico sulla superficie.

105

Fig. 6.11 Superficie finale creata con il nostro modulo.

6_3_Manipolazioni di micro livello Sebbene sia fantastico gestire un modulo su una superficie, potrebbe sembrare che questo sia un modo generico di progettare. Sappiamo che possiamo modificare il numero dei moduli, o cambiare il modulo stesso, ma il risultato sarĂ una generica superficie e non avremo un controllo locale del nostro sistema. Sto quindi pensando di creare un sistema basato sui componenti con cui potremo avere maggior controllo e permettere di progettare superfici generiche che non rispondono a nessuno criterio di micro scala. Per poter introdurre il concetto, partiamo prima con un esempio semplice, per poi procedere verso uno piĂš pratico. Abbiamo usato l'idea degli attrattori per applicare manipolazioni locali ad un gruppo di oggetti. Sto pensando di applicare lo stesso metodo per progettare un sistema basato sui componenti con manipolazioni locali date da un attrattore. L'idea Ă¨ quella di cambiare la dimensione del componente (in questo caso l'altezza) in base agli effetti di un punto attrattore.

106

Fig. 6.12 Diamo un'occhiata agli ingredienti: una superficie a doppia curvatura importata attraverso un <base_srf>, un cono importato come <component> in Grasshopper, un <divide interval2> per la divisione della superficie, e un <bounding box> come parallelepipedo di riferimento. Più tardi, cambiando la dimensione del parallelepipedo limite, potrò cambiare la dimensione di tutte i miei componenti sulla <base_Srf> grazie al cambiamento del parallelepipedo di riferimento. L'input altezza del componente <surface box> richiede l'altezza del parallelepipedo nel dato intervallo. L'idea è quella di usare altezze relative al posto di quelli costanti. Quindi, al posto di numeri, potremo creare della relazioni tra le posizioni di ogni parallelepipedo e i punti attrattori e generare numeri diversi come altezze associativa. Ciò di cui ho bisogno ora è di misurare la distanza tra ogni parallelepipedo e l'attrattore. Il problema tecnico è che ancora non c'è alcun parallelepipedo generato, quindi ho bisogno di un punto sulla superficie, che diverrà poi centro di ogni parallelepipedo, per misurare la distanza.

Fig. 6.13 Qui ho usato lo stesso <divide interval2> che voglio usare per <surface box>, per un componente <isotrim> (Surface>Util>Isotrim). Questo componente divide la superficie in subsuperfici. Attraverso queste sub-superfici posso usare un altro componente <Brep Area> (Surface>Analysis>BRep area) per usare il sottoprodotto di questo componente, cioè il 'Centroide dell'area' per ogni sub-superficie. Ho misurato la distanza tra questi punti (centroidi) dagli <attractor> per usarla come fattore di riferimento per l'altezza del parallelepipedo bersaglio nel componente <surface box> 107

Fig. 6.14 Ora ho diviso la distanza misurata con un numero preso dal un <number slider> per controllare l'effetto dell'attrattore e ho usato il risultato come input per l'altezza, in modo da generare parallelepipedi bersaglio con il componente <surface box>. La superficie proviene da <base_Srf>, il <divide_interval2> restituisce il dominio della superficie, mentre l'altezza Ă¨ data dalla relazione tra la posizione del parallelepipedo e dell'attrattore. Come vedete, le altezze dei parallelepipedi sono differenti, in base alla posizioni del punto <attractor>.

Fig. 6.15 Per la parte rimanente, connettete il <component>, i parallelepipedi scalati e la <surface box> al componente <morph box> che produrrĂ i componenti sulla superficie. Cambiando il fattore di scala, potete cambiare la dimensione di tutti i componenti e come sempre, la posizione degli attrattori, sarĂ controllabile manualmente.

108

Fig. 6.16 Modello finale Come vedete, la dimensione dei componenti inizia ad accettare manipolazioni locali, basate su proprietà esterne che sono i punti attrattori. Sebbene l'idea sia basata su un semplice attrattore, il risultato potrebbe essere interessante e l'idea è quella di mostrare che possiamo differenziare i parallelepipedi ed ottenere risultati diversi. Ora sappiamo che il concetto di morphing e di pannellizzazione non sono necessariamente generici. Avendo provato il concetto, proseguiamo con un altro esperimento pratico.

6_4_ Modulazione reattiva Per il nostro esperimento progettuale, l'idea è quella di modulare una superficie data con un controllo su ogni modulo, che significa che ogni modulo di questo sistema deve rispondere ad alcuni determinati criteri. Quindi ancor più della differenziazione locale dei moduli, qui voglio avere un controllo specifico sul mio sistema, attraverso dei dati criteri che possono essere ambientali, funzionali, visuali o ogni altro comportamento associativo a cui vogliamo che il nostro modulo risponda. Nel prossimo esempio, per poter rendere l'involucro di un edificio, reattivo all'ambiente in cui si trova, voglio usare un sistema che risponde in base alla luce solare. Nei vostri esperimenti, la variabile, potrebbe essere il vento, la pioggia o le funzioni interne o ogni altro criterio di cui avete bisogno, nonché la combinazione di questi. Ho qui una superficie semplice come l'involucro di un edificio che voglio coprire con due diversi tipi di componenti. Il primo è chiuso e non permette la penetrazione della luce solare, mentre l'altro ha delle aperture. Questi componenti dovrebbero proliferare sull'involucro in base alla direzione principale della 109

luce solare nel sito. Ho usato un angolo definito dall'utente per dire all'algoritmo che per una determinato grado di incidenza delle luce solare dovremo avere un componente chiuso, e per gli altri, uno aperto. La definizione di Grasshopper non contiene niente di nuovo, ma il concetto mi permette di creare della variazioni sull'involucro invece di creare una superficie generica. Fondamentalmente quando la superficie Ă¨ di tipo free form, si muove e ha diversi orientamenti, la luce solare la colpisce da entrambe le direzione per diversi gradi di incidenza. In base alla differenza di angolo tra la superficie e la luce solare, questa variazione nel componente avviene nel sistema

Fig. 6.17 Primi schizzi del modulo reattivo su un sistema di facciata Ingredienti:

Fig. 6.18 Superficie esterna di un edificio come involucro che dobbiamo pannellizzare

110

Fig. 6.19 I due diversi tipi di componenti per la pannellizzazione

Fig. 6.20 Il primo passo è simile a quello precedente. Ho introdotto una <surface> e ho usato <divide interval2> per dividerla nelle direzioni U e V. Ho generato dei parallelepipedi bersaglio attraverso <surface box>. Ho anche usato <isotrim> con lo stesso intervallo dei parallelepipedi per trovare la posizione degli stessi sulla superficie e ho inserito un <Brep area> per trovare il centroide di questa area (selezionata in verde). Allo stesso tempo ho usato un componente <curve> per importare l'angolo principale della luce solare del sito e con i suoi <end points> ho creato un <vector 2pt> che specifica la direzione della luce solare. Potete manipolare e cambiare questa curva per vedere l'effetto della luce solare sui componenti nelle diverse direzioni. Come potete vedere dalla prima immagine, c'è una superficie – l'involucro - divisa in parti per generare i componenti ed è presente anche un vettore per la luce solare. Voglio conoscere l'angolo tra questo vettore e la superficie nella posizione di ogni componente. Devo avere un unico risultato per il calcolo dell'angolo e il modo migliore è quello di usare la normale alla superficie che è unica per ogni punto. Una normale è un vettore perpendicolare alla superficie in un punto specifico, Posso quindi usarlo per controllare l'angolo per ogni componente.

111

Fig. 6.21 Per poter valutare l'angolo tra la luce solare e la superficie, voglio misurare questo ancolo tra la luce solare e la normale alla superficie nella posizione di ogni componente. Posso quindi decidere per ogni intervallo di angoli, che tipo di componente può andare bene. Quindi, dopo aver generato i punti centrali, ho bisogno delle normali alla superfici e usare questi parametri per <evaluate> la superficie in questi punti per poter avere le normali delle superficie in questi punti.

Fig. 6.22 Ora ho usato un componente <angle> (Vector>vector>angle) per valutare l'angolo tra la direzione del sole e la facciata. Ho quindi convertito questo angolo in gradi e ho usato una <function> per vedere se questo angolo è più grande del <max angle> oppure no. Questa funzione (x>y) restituisce dati booleani: TRUE per gli angoli più piccoli, e FALSE per quelli più grandi

112

Fig. 6.23 In base ai dati booleani provenienti dalla comparazione degli angoli, ho creato un componente <dispatch> che spedisce i dati che sono i parallelepipedi bersaglio (Ho diversi parallelepipedo bersaglio, come punti centrali e normali, quindi posso usare il parallelepipedo al posto dei punti). Quindi ho diviso in miei parallelepipedi bersaglio in due gruppi differenti in cui la differenza Ă¨ l'angolo che ricevono dalla fonte luminosa. Il resto dell'algoritmo Ă¨ semplice e simile a quello precedente. Ho solo bisogno di morfizzare i miei componenti in un parallelepipedo parallelepipedo bersaglio, che qui sono due diversi.

113

Fig. 6.24 Ho qui introdotto due componenti diversi come geometria unica ed ho usato due componenti <morph box>, ognuno associato con una parte dei dati spediti (con <dispatch>) per generare i componenti <C_close> o <C_Open> sulla facciata.

Fig. 6.25 Se ora guardiamo da pi첫 vicino, potremo vedere che le diverse parti della facciata e in base alla sua curvatura e direzione, genera diversi tipi di componenti. Fig. 6.26 Modello finale. La biforcazione del parallelepipedo bersaglio (e dei componenti) potrebbe essere pi첫 complessa e non composta da solo due algoritmi. Dipende dal nostro progetto e dai criteri utilizzati. 114

Possiamo pensare ad una facciata basata sui componenti, nella quale alcuni di loro sono chiusi e altri sono aperti. Quelli aperti hanno delle parti regolabili che sono orientate rispetto a delle forze esterne e riflettono anche le funzioni interne dell'edificio e cosĂŹ via. Potete vedere che l'idea Ă¨ quella di avere un controllo sulla micro scala sul sistema e permette progettazioni generiche. Ed Ă¨ anche chiaro che abbiamo ancora un controllo globale (la superficie) e locale (i componenti).

115

CAPITOLO 7 Superfici NURBS e Mesh

116

7_1 Superfici NURBS parametriche Nel capitolo precedente, abbiamo fatto diversi esperimenti con le superfici trattando lo strumento Loft per la loro creazione. Abbiamo anche usato superfici NURBS free form. In molti casi la generazione delle superfici dipende da altre geometrie di base, come le curve o i punti. All'interno di Grasshopper, esistono diversi componenti per generare queste geometrie, e per chi di voi ha un minimo di esperienza nella modellazione tradizionale con Rhinoceros, questi dovrebbero essere noti. Le superfici geometriche sembrano essere il prodotto finale del nostro progetto, in quanto rappresentano facciate, muri, etc ed Ă¨ per questo che abbiamo bisogno di tanta lavoro per generare dati come punti e curve che ci servono come geometrie di base. Ho qui deciso di disegnare un edificio in maniera schematico e molto semplice, solo per indicare che i numerevoli componenti di Grasshopper hanno il potenziale di disegnare diversi oggetti con delle semplici costruzioni. So che il processo progettuale da solo potrebbe non essere soddisfacente, ma qui voglio solo concentrarmi sull'uso dei nuovi componenti. Torre parametrica Nell'area portuale del Tamigi a Londra, vicino al Canary Warf, dove possono essere costruiti edifici molto alti, ci sono le potenzialitĂ per costruire delle torri. Ipotizziamo di crearne uno insieme, in maniera veramente semplice e schematica solo per testare alcuni delle idee di base per lavorare con superfici free form. Diamo un'occhiata all'area

Fig. 7.1 Vista dell'area, Canary Warf, Londra (immagine: www.maps.live.com, Microsoft Virtual Earth). Il sito che ho scelto per il progetto Ă¨ nella sponda del Tamigi, con una vista molto prestigiosa sul fiume e vicino alla piazza di ingresso dell'area centrale di Canary Warf (Westferry Road). Non voglio essere troppo specifico sul sito, quindi diamo giusto un'occhiata al luogo dove sto per proporre il progetto e continuiamo con le tematiche geometriche.

117

Fig. 7.2 Area per la proposta di Torre. Disegno a mano Esistono diversi modi per iniziare questa bozza. Posso disegnare il piano terra e copiarlo in alto, iniziare a manipolarlo e aggiungere dettagli. Ho deciso di usare alcuni componenti per le superfici, quindi la tecnica potrebbe non essere appropriata ma lo scopo è quello di espandere i nostri esperimenti, anche perchè sono sicuro che avete già cercato sul web e avuto già in mente diverse idee progettuali per lavorare sulla torre in maniera associativa. L'idea che ho in mente non è ben definita, ma so che la mia torre avrà una superficie generale di vetro, coperta da alcuni elementi lineari in facciata. Visto che non mi piace progettare una torre convenzionale, voglio anche avere alcuni spazi cavi nel suo involucro esterno, sparsi lungo la facciata. Questi volumi dovrebbero intersecarsi con gli elementi lineari in modo da tagliarli. Voglio anche disegnare uno spazio pubblico vicino al fiume e connetterlo alla torre con gli stessi elementi della facciata, in moda da creare una continuità dalla torre verso l'ansa del fiume. Come vedete in figura 7.3 ho disegnato le mie curve di base manualmente su rhino. Queste curve corrispondono con le specifiche del sito, per le limitazione nell'altezza e per la forma e bordi del. La prima curva è stata disegnata e quindi specchiata nell'angolo successivo e ancora specchiata per quello successivo e così via. Altre due curve sono state disegnate come bordi dello spazio pubblico, che partono da terra e quindi salgono fino ad essere paralleli ai bordi della torre. Tenete conto che queste sono curve sperimentali e che otete disegnare qualunque cosa vogliate e andare avanti per la parte mancante.

118

Fig. 7.3 Linee di base per il sito della torre Elementi di base per la facciata

Fig. 7.4 come primo passo, ho importato queste quattro curve in Grasshopper attraverso un componente <curve> e le ho quindi divise con <divide curve> in 40 parti come i piani della torre. Come vedete, i punti risultanti dalla divisione sono ordinati in differenti rami di dati.

Fig. 7.5 Ora devo disegnare le curve di base con questi punti di divisione, per realizzare gli elementi della facciata stessa. Voglio disegnare linee dai punti di divisione per ogni curva, fino al punto corrispondente della curva successiva. Per fare ciĂ˛, ho usato un <explode tree> rinominandolo <Bang!> (Sets>Tree>Explode tree) per accedere ai diversi rimani separatamente. Ho aggiunto delle 119

linee da tutti i punti dei rami a quelli successivi.

Fig. 7.6 In questo step ho aggiunto gli spazi cavi per la facciata, con una distribuzione casuale. Sono degli ellissoidi importanti tutti insieme su Grasshopper con il componente <geometry>. Ho inoltre unito tutte le linee generate precedentemente, tramite il componente <merge>.

Fig. 7.7 In questo passo ho tagliato (componente <trim>), e unito (<merge>) le linee con queste geometrie. Il componente <trim> restituisce le parti tagliate all'interno e all'esterno dell'area di taglio. Qui ho usato la parte esterna. Ho estruso queste parti come gli elementi lineari della facciata.

120

Fig. 7.8 Questa Ă¨ una curva chiusa che connette quattro lati della pianta della torre. Visto che ho bisogno di creare superfici differenti, ho esploso la curva (<explode>) per ottenere i segmenti e ho inoltre usato <graft> per generare un ramo per ogni curva. PoichĂŠ ho una sezione planare e due curve di bordo che definiscono il imite della facciata per ogni lato, voglio usare il componente <sweep 2> per creare la superficie di facciata con lo sweep a 2 binari.

Fig. 7.9 Ho inserito un componente <sweep 2> per generare le superfici di facciata. Ho usato le curve planari innestate con <graft> come curve di sezione per lo sweep. I binari saranno i bordi delle curve. Il componente <receiver> Ă¨ connesso alle curve di bordo. Le ho quindi innestate (<graft>) una volta e spostate (<shift>) e ancora innestate (<graft>) per generare tutte le prime e le seconde curve di binario associate alle curve planare di sezione. !!Nota: se non ottenete lo stesso risultato dell'immagine, l'ordine della curve di bordo (binari) non Ă¨ associato correttamente all'ordine delle curve planari (curve di sezione) e dovete quindi cambiarne l'ordine delle curve di bordo nella lista, o manualmente riassegnandole al 121

componente <curve> in ordine diverso oppure spostando la lista in Grasshopper

Fig. 7.10 In questo passo voglio sottrarre gli spazi cavi <Geo> dalla facciata precedentemente generata. Poichè la direzione delle normali delle superfici è fondamentale per questo comando, ho invertito (<Flip>) le normali della superfici e il risultato è la superficie principale con il <Geo> che è stato rimosso.

Fig. 7.11 Con lo stesso procedimento, ho importato entrambe le curve dello spazio pubblico, le ho divise, esplose e disegnato tra loro altre linee. Posso connettere questi componenti <line> allo stesso componente <extrude> quale elemento di facciata per generare geometrie identiche.

Fig. 7.12 Dopo le generazione delle geometrie, cucinate (bake) i componenti <differnce> e <extrude>. 122

Fig. 7.13 Bozza finale del modello.

123

7_2_ Topologia e Geometria Fino ad ora abbiamo usato diversi componenti e lavorato con superfici NURBS. Ma, come già detto, esistono altri tipi di superfici che in altri contesti, risultano utili. Non sempre vogliamo ottenere la bellezza e la dolcezza delle NURBS, ma potremo avere bisogno di un controllo più preciso, di processi più semplici o equazioni più facili. Oltre la classica superficie di rivoluzione, righe o tubi, abbiamo diverse superfici free form come quelle di Bezier, o le B-Spline. Tratteremo ora la tematica delle mesh, che rappresentano un altro tipo di superficie. Le mesh rappresentano un altra tipologia di superfici free form, composte di piccole parti (facce)la cui accumulazione crea l'intera superficie. Non esiste quindi alcuna funzione matematica interna o nascosta che generi la forma della superficie, la quale viene invece definita dall'insieme delle facce. Osservando le mesh, concentriamoci sulle facce. Queste possono essere triangolari, rettangolari o esagonali. Guardandole più attentamente, possiamo vedere la griglia di punti che le crea. Questi punti sono elementi di base della superficie mesh. Ogni piccolo gruppo di questi punti (per esempio ogni tre nelle mesh triangolari) creano una faccia, che con il resto della geometria diventa una superficie. Questi punti sono connessi tra di loro da linee dritte. Ci sono due concetti fondamentali che riguardano le mesh: la posizione di questi punti e la loro connessione. La posizione dei punti è collegata alla geometria delle mesh e la connessione dei punti è collegata alla topologia. Geometria vs Topologia Mentre la geometria ha a che fare con la posizione degli oggetti nello spazio, la Topologia riguarda la loro relazione. Matematicamente parlando, la topologia rappresenta le proprietà degli oggetti che le trasformazioni e le deformazioni non possono modificare. Quindi per esempio una circonferenza ed un'ellisse sono topologicamente identiche, e hanno solo differenze geometriche. Osserviamo la fig. 7.14. Come vedete ci sono quattro punti connessi tra loro. Nella prima immagine, entrambi A e B hanno la stessa topologia perchè hanno la stessa relazione tra i loro punti (stessa connessione). Sono però geometricamente diversi a causa dello spostamento di un punto. Nella seconda immagine la geometria dei punti è la stessa mentre la loro connessione è diversa e non sono topologicamente equivalenti.

Fig. 7.14 Topologia e Geometria Il concetto di topologia è molto importante per le mesh. Ogni faccia in un oggetto mesh, ha dei punti angolari e questi punti sono connessi l'uno con l'altro con un identico ordine per tutte le facce dell'oggetto mesh. Possiamo quindi applicare ogni trasformazione ad un oggetto mesh e spostarne i vertici in uno spazio anche se non uniformemente, ma la connessione dei vertici 124

dovrebbe essere preservata per preservare le facce, altrimenti crollerà.

Fig. 7.15 Entrambe le superficie rosse e grigie sono mesh con le stesse facce e vertici. In quella grigia i vertici sono spostati, creando una diversa configurazione geometrica delle mesh, ma la connettività delle mesh non cambia ed entrambe le superfici sono topologicamente uguali. Sappiamo dunque l'importanza degli aspetti topologici nelle mesh, le quali sono geometrie molto potenti fin tanto che abbiamo diversi punti e abbiamo bisogno di un tipo di superficie per rappresentarli come spazio continuo. Possiamo applicare alle mesh diversi tipi di algoritmi che lavorano con i punti poiché ne preservano la topologia. Per esempio, usando elementi finiti di analisi o applicazioni specifiche come dynamic relaxation, e sistemi particellari, è più semplice lavorare con le mesh che con altri tipi di superfici poiché la funzione può lavorare con i vertici delle mesh. Le mesh sono semplici da migliorare e veloci da lavorare ma possono contenere dei buchi e delle discontinuità nella loro geometria. Ci sono tanti algoritmi per rifinire le mesh e creare delle superfici più lisce. Poiché facce differenti possono avere inizialmente diversi colori, le mesh sono buone per la rappresentazione a scopi di analisi (per colore). Nella scheda 'Mesh' possiamo trovare diversi componenti che lavorano con questo tipo di geometria.

7_3_Mesh Ho un gruppo di punti e voglio creare, attraverso gli stessi, una superficie. In questo esempio il gruppo di punti è semplificato in una struttura a griglia. Sto pensando ad una griglia verticale che rappresenti i parametri di base di una superficie, la quale è sottoposta all'effetto di un vento immaginario. Voglio quindi spostare questi punti in base al fattore vento (o rispetto ad ogni forza che può essere rappresentata da un vettore), e rappresentare la superficie deformata risultante. Quindi, cambiando il fattore del vento, possiamo vedere come il risultato di questa superficie reagisca di conseguenza.

125

Fig. 7.16 Il primo passo è semplice. Usando un componente <series> con un numero di punti gestito dallo slider <N_pt>e una distanza tra loro definita da <distance_pt> (ancora uno slider), ho generato una griglia di punti creati con il riferimento incrociato. La pressione di questo vento immaginario, influenza tutti i punti della griglia. Facciamo però finta che la forza del vento aumenti quando andiamo in alto, quindi la pressione del vento aumenta con valori di Z più alti. Allo stesso tempo, la forza del vento, influenza i punti interni più dei punti vicini ai bordi. I punti sul bordo della sezione piana non si muovono per niente (punti fissi).

Fig. 7.17 Diagramma del vento che influenza la superficie. A: sezione; effetto verticale della forza, B: pianta; effetto orizzontale. Fondamentalmente ho bisogno di due diversi meccanismi per modellare questi effetti, uno per il diagramma in sezione, e un altro per la pianta. Ho semplificato le equazioni solo per imitare il modo in cui vogliamo che le forze agiscano. Per questo primo meccanismo impostiamo una semplice equazione matematica; ho usato (X^2) dove X è il valore di Z del punto sottoposto alla 126

forza. Quindi per ogni punto ho bisogno di estrarre le coordinate di Z del punto. Per semplificare il tutto, ho fatto finta che la direzione della forza sia quella della Y, rispetto al sistema globale delle coordinate. Quindi per ogni punto della griglia, ho bisogno di generare un vettore nella direzione Y e ho impostato la forza attraverso il numero che ho ricevuto dalle coordinate Z del punto. Per il secondo diagramma abbiamo bisogno di qualcosa di piĂš di un'equazione. Diamo un'occhiata alla prima parte.

Fig. 7.18 Coordinate Z dei punti estratti attraverso il componente <decompose> e quindi attivati da una funzione X^2 e divise per un numero passato da un <number slider> per controllare il movimento generale. Il risultato Ă¨ un fattore che moltiplica (<multiply>) il vettore forza (Vector>vector>Multiply) che Ă¨ un semplice vettore <unit Y> rispetto al sistema globale.

Fig. 7.19 Spostando i punti con questi vettori potete vedere la griglia di punti risultanti che soddisfa il primo passo di questo processo. Vediamo ora la seconda parte delle forze descritte: nella sezione planare i punti sui bordi rimangano fissi, mentre i punti nel mezzo si spostano piĂš degli altri. La Fig. 7.20 mostra questo spostamento per ogni riga della griglia dei punti. 127

Fig. 7.20 Spostamento dei punti in riga (vista planare). Poiché per ogni punto ho i vettori forza, devo controllarli e impostare ancora una volta il valore, per essere sicuro che il loro spostamento nella sezione planare incontri anche il secondo criterio. Quindi per ogni riga di punti nella griglia voglio generare una fattore che controlli il modulo del vettore. Qui ho assunto che, per i punti nel mezzo, i vettori forza saranno al massimo, mentre per i punti sui bordi diventano zero, cioè uno spostamento nullo. Gli altri punti un valore di forza e quindi di spostamento intermedio.

Fig. 7.21 Per il secondo meccanismo, ho bisogno di un <range> compreso tra e 0 e 1 da applicare ad ogni punto. 0 per il bordo e 1 per il centro. Ho bisogno dunque di un range da 0 a 1 spostandomi dal bordo al centro e uno che varia da 1 a 0 dal centro al bordo. Ho bisogno che questo componente <range> generi valori in quantità pari al numero di punti per ogni riga. Ho impostato il <N_pt> in modo da generare solo numeri pari e li ho divisi per 2, quindi ho sottratto 1 (perchè il componente <range> prende i numeri di queste divisioni e non i numeri dei valori). Vedete che il primo <panel> nostra 4 numeri compresi tra 0 e 1 per la prima metà dei punti. Ho quindi invertito una lista e l'ho collegato all'altra. Come vedete nel secondo pannello, ho generato una lista da 0 a 1 a 0 e i il numeri dei valori nella lista è lo stesso dei numeri dei punti in ogni riga. L'ultimo passo è quello di generare questi elementi per tutti i punti nella griglia. Ho quindi duplicato (<duplicate>) i punti in quantità pari a <N_pt> (i numeri delle righe e delle colonne sono gli stessi). Ora ho un fattore per tutti i punti della griglia, basato sulla loro posizione nella loro riga.

128

Fig. 7.22 Ora ho bisogno di moltiplicare (<multiply>) ancora i vettori forza per i nuovi fattori. Se sposto i punti con questi nuovi vettori, possiamo vedere come due differenti meccanismi agiscano sull'intera griglia di punti. In realtà, questa parte di esempio necessita di un'analisi più attenta. I metodi come quelli di Particle Spring Systems (Sistemi di particelle a molla) o Finite Element Analysis (Analisi degli elementi finiti) usano il concetto che tutti i vettori influenzano i punti dell'insieme e i punti si influenzano l'uno con l'altro. Quindi, quando applicate le forze tutti i punti vengono influenzati e questi punti si influenzano l'uno con l'altro simultaneamente. Questo processo dovrebbe essere calcolato in loop iterativi, in modo da calcolare la posizione di riposo dell'intero sistema. Qui voglio solo fare un semplice esempio senza questi effetti, e voglio solo mostrare una semplice rappresentazione di un tipo di sistema che dialoga con forze multiple. Ho usato equazioni matematiche molto semplici, che nella realtà sono un po' più complicate! L'idea riguarda la rappresentazione mesh del processo, quindi vediamo la parte relativa alla generazione di mesh Mesh

Fig. 7.23 Generazione delle mesh. Ora potete semplicemente aggiungere un componente <mesh> (Mesh>Primitive>Mesh) nel canvas e connettere tutti i punti che sono stati spostati ai suoi vertici: vedrete che nella scena non succede niente. Abbiamo bisogno di definire la facce della geometria mesh da generare. Le facce delle mesh sono serie di numeri che definiscono il modo in cui i punti 129

sono interconnessi per creare delle facce per ogni superficie. Quindi i vertici sono parti geometriche delle mesh, ma ora abbiamo bisogno della definizione topologica delle mesh, per poterle generare. Ogni 4 punti angolari della griglia, si definisce una faccia del quadrante per l'oggetto mesh. Se guardiamo alla griglia di punti, vedremo che ci sono degli indici numerici per ogni punto della griglia. Conosciamo ogni punto attraverso il suo indice, e sappiamo che questo sostituisce le coordinate in modo da poter dialogare con la sua topologia.

Fig. 7.24 Indice numerico dei punti nella griglia Per definire le facce della mesh, abbiamo bisogno di etichettare i 4 punti angolari che riteniamo essere una faccia, mettergli insieme e passargli il componente <mesh> in modo da creare la superficie.

Fig. 7.25 In una data griglia di punti, una semplice quadrante viene definito attraverso una sequenza di punti che, connessi mediante una curva, creano una faccia. La curva parte da un punto della griglia, si muove verso il punto successivo, quindi su quello della riga successiva, torna indietro di una colonna rimanendo sulla stessa riga, e si chiude tornando al primo punto. Vediamo che la prima faccia, nella sua definizione Ă¨ composta dai punti [0,1,6,5]. La seconda faccia ha [1,2,7,6] e cosĂŹ via.

130

Per definire le facce dell'intera mesh, dovremo trovare la relazione tra questi punti e quindi creare un algoritmo che generi la regola per la creazione della facce. Se guardiamo la matrice delle faccia, vediamo che per ogni prima primo punto, possiamo definire il secondo come quello successivo nella griglia. Quindi, per ogni punto (n) nella griglia, il punto successivo sulla faccia è (n+1). Semplice! Andando avanti, sappiamo che si sposta sempre di una riga: quindi se aggiungiamo il numero delle colonne (c) all'indice (n) del punto, potremo ottenere il punto nella seconda riga (n+c). Quindi, per esempio, nel suddetto esercizio, abbiamo 5 colonne (c=5) e per il punto (1) il punto successivo della faccia della mesh è (n+c) cioè il punto (6). Quindi per ogni punto (n) come primo punto, il terzo sarà (n+1+c). Ci siamo! L'ultimo punto, è sempre localizzato un una colonna dietro il terzo punto. Quindi, per ogni punto (n+1+c) come terzo punto, il punto successivo sarà (n+1+c-1) il che significa (n+c). Quindi per esempio, per il punto (6) come terzo punto, il punto successivo diventa (5) Riassumendo: per ogni punto (n) nella griglia, la faccia che inizia da questo punto singolo avrà come punti nella lista dei vertici la seguente combinazione : [n,n+1,n+1+c,n+c] dove (c) è il numero di colonne nella griglia.

Fig. 7.26 Dopo aver definito tutte le facce della mesh, la superficie può essere generata. Guardando i vertici della mesh, vediamo che c'è ancora qualcosa da considerare. Se ricordate l'esempio del 'Triangolo' del capitolo 3, avevamo trattato il problema della selezione dei punti che potevano essere considerati 'primo punto' della griglia. Se guardiamo la griglia dell'esempio appena trattato, vedremo che i punti dell'ultima colonna e dell'ultima riga non possono essere punti di partenza per le facce. Quindi oltre all'algoritmo per generare facce, abbiamo bisogno anche un po' di maneggiare i dati per generare i primi punti dell'intera griglia e passare questi primi punti all'algoritmo e quindi generare le facce delle mesh. Fondamentalmente, nella lista di punti, dovremo omettere i punti dell'ultima riga e dell'ultima colonna e quindi iniziare a generare la faccia matrice. Per generare la lista di facce, abbiamo bisogno di generare una lista di numeri come indici dei punti.

131

Fig. 7.27 Generazione di un indice numerico dei primi punti nella griglia con un componente <series> . Il numero dei valori delle serie, deriva da Npt> come numero delle colonne (alcune come righe) a attraverso l'utilizzo della funzione <x*(x-1)> voglio generare una serie di numeri come <columns*(rows-1) per generare l'indice per tutti i punti nella griglia omettendo l'ultima riga. Il passo successivo Ă¨ quello di selezionare (<cull>) l'indice della lista attraverso il numero di colonne (<N_pt>) per eliminare l'indice dei punti anche nell'ultima colonna.

Fig. 7.28 Indice numerico finale del possibile primo punto della faccia mesh nella griglia (con 8 punti in ogni colonna).

132

Fig. 7.29 Il componente <mesh quad> (Mesh>Primitive>Mesh quad) ha il compito di generare le facce. Ho collegato la lista dei primi numeri al primo punto del <quad> Ora è il momento di generare la lista di indici per le facce.

Fig. 7.30 Mentre (n) è l'indice del primo punto e (c) è il numero delle colonne, il secondo punto sarà (n+1), il terzo ((n+1)+c) (l'indice del secondo punto più il numero delle colonne), e l'ultimo punto sarà ((n+1+c)-1) (l'indice del terzo punto meno 1).

133

Fig. 7.31 La mesh risultante.

7_4 Analisi cromatica Per concludere l'esempio, diamo un'occhiata a come possiamo rappresentare la nostra mesh finale, attraverso l'uso dei colori come strumento di analisi. Ci sono diversi componenti in Grasshopper che ci danno una rappresentazione cromatica e questi colori sono adeguati per i nostri scopi di analisi. Nell'esempio, ancora per mostrare meglio il concetto, ho ipotizzato che alla fine vogliamo vedere il valore di deviazione della nostra superficie finale dal punto iniziale (superficie verticale). Voglio applicare un gradiente di colori che parta dai punti che rimangono fissati al il fondo colorandosi fino ai punti che hanno il valore massimo di deviazione dalla posizione verticale con il piĂš alto colore del gradiente. Semplicemente, per trovare la quantitĂ di deviazione, ho bisogno di misurare lo stato finale di ogni punto dal suo stato originale. Quindi posso usare questi valori per assegnare il colore alle facce della mesh in base alla loro distanza.

Fig. 7.32 Tornando indietro ho il punto iniziale della griglia generato nel primo passaggio e ho inoltre lo spostamento finale che ho usato per generare i vertici della mesh. Posso usare un componente <distance> per misurare la distanza tra la posizione iniziale dei punti e la loro posizione finale per vederne la deviazione. 134

Fig. 7.33 Per i nostri scopi analitici, voglio usare un componente <gradient> (Params>special>Gradient) per assegnare un gradiente di colore alla mesh. Ho collegato i valori <distance> all'input (t) di <Gradient> e l'ho collegato all'input colore (c) della mesh. Ma per completare il processo, ho bisogno di definire il limite inferiore e superiore del range del gradiente (L0 e l1). Il limite inferiore Ă¨ il valore minimo nella lista mentre limite superiore Ă¨ il valore massimo: gli altri valori sono divisi nei gradienti intermedi. Per avere i valori inferiori e superiori della lista delle deviazioni, ho bisogno di ordinare i dati e ottenere il primo e l'ultimo valore del range numerico.

Fig. 7.34 Usando un componente <sort> per ordinare le distanze, ottengo il primo elemento della lista di dati (index=0) come limite inferiore e l'ultimo (indice = <list lenght> -1) come limite superiore del set di dati (valori di deviazione) per connettere il componente <gradient> per assegnare i colori in base al loro range.

135

Fig. 7.35 Cliccando sulla piccola icona colorata nell'angolo del componente <gradient> possiamo cambiare i colori dei gradienti.

Fig. 7.36 Cliccando con tasto destro sul componente, sul menu contestuale avrete pi첫 opzioni per manipolare il vostro oggetto risultante e diversi tipi di gradienti colorati per soddisfare le rappresentazioni grafiche per l'analisi.

136

Fig. 7.37 Diverse soglie di gradienti.

7_5 Manipolazione delle mesh come metodo progettuale. In base agli oggetti e agli scopi della modellazione, personalmente preferisco ottenere la mesh attraverso la manipolazione di semplici geometrie, invece che generare le mesh partendo da una bozza fino alla definizione del set di punti e alla faccia matrice che non sempre risultano semplici semplice. Attraverso la manipolazione, possiamo usare un semplice oggetto mesh, estrarre i suoi componenti e modificarli e quindi ancora fare una mesh con svariati vertici e facce. Non ho quindi bisogno di generare punti come vertici e matrici di facce. Diamo un'occhiata a questo semplice esempio.

Fig.7.38 In questo esempio ho usato un componente <mesh plane> e ho estratto i suoi dati usando un <mesh component> per aver accesso ai suoi vertici e facce. Ho quindi spostato i vertici lungo la direzione Z con dei valori casuali attivati da un <number slider> a ancora l'ho collegato ad un componente <mesh> per generare altre mesh. Ho inoltre usato un componente <cull pattern> (seleziona pattern) ed ho omesso alcune delle facce delle mesh originali e le ho quindi usate come nuove facce per creare altre mesh. La mesh risultante ha differenze geometriche e topologiche dalla sua mesh iniziale e puĂ˛ essere usato per altri scopi di design. L'idea di manipolare geometricamente i vertici e cambiare topologicamente le facce presenta tante diverse possibilitĂ che possono essere usate negli esperimenti progettuali. PoichĂŠ le mesh possono trascurare alcune delle loro facce rimanendo sempre una superficie, l'idea di creare una superficie permeabile puĂ˛ essere perseguita in modi diversi. 137

Fig. 7.39 Risultato di mesh manipolate (solo una situazione casuale)

Fig. 7.40 Bozze di mesh manipolate. Triangolazioni

138

Fig. 7.41 Esempio di componenti triangolati Ci sono tanti componenti sotto il pannello 'Triangulation' nella scheda Mesh, che contengono utili algoritmi come il Delaunay o il Voronoi o il Convex hull. Questi algoritmi interni possono essere utili per disegnare oggetti complessi e, cosa piĂš importante, questi possono usare insiemi di punti per generare le loro geometrie. Non voglio approfondire la questione, anche perchĂ¨ questi componenti sono molto semplici da esplorare e potete trovare tantissimi esempi on-line.

139

CAPITOLO_8_ Fabbricazione

140

Capitolo_8_ Fabbricazione Oggigiorno c'è un interesse crescente nella pratica della manifattura assistita dal computer e sulla fabbricazione digitale. A causa dei cambiamenti e delle nuove mode nel processo di design, sembra essere diventata una scelta cruciale e uno dei 'must', quello di spostarsi all'interno del territorio della fabbricazione digitale. Ogni decisione progettuale nello spazio digitale, può essere testata in scale differenti per mostrare l'abilità di fabbricazione e assemblaggio. Poiché è ovvio che questo nuovo processo progettuale e gli algoritmi non rientrano nella tradizionali tecniche di costruzione, i progettisti provano ora ad usare le moderne tecnologie di fabbricazione e adattano i loro prodotti progettuali per venire incontro a queste necessità. Dal momento in cui le macchine CNC hanno iniziato a servire l'industria delle costruzioni fino ad adesso, si è instaurata una grande relazione tra il progetto digitale e la fabbricazione fisica. Sono stati inventati tanti macchinari e sviluppate tante tecnologie per poter svolgere questo tipo di operazione. Allo scopo di progettare e fabbricare elementi di edifici, necessitiamo di avere una conoscenza concisa del processo di fabbricazione per i diversi tipi di materiali e saper preparare i nostri progetti allo scopo. In base agli oggetti che progettiamo, ad i materiali usati, alle logiche di assemblaggio, trasporto, scala etc, abbiamo bisogno di dati opportuni dai nostri progetti e ottenere i risultati desiderati per far funzionare i macchinari. Se i metodi tradizionali nella realizzazione dei progetti richiedevano piante, sezioni e dettagli, oggi, abbiamo bisogno di dati e codici da trasferire alle macchine per realizzare i progetti. Il punto è dunque che i designer devono essere coinvolti nel 'rifornimento' dei dati richiesti, poiché questa fase è strettamente legata con l'oggetto progettuale. I designer qualche volta dovrebbero tenere conto dei riscontri della preparazione dei dati per la fabbricazione per le correzioni del progetto. Talvolta l'obiettivo del designer dovrebbe cambiare per tener conto dei limiti dei macchinari o dell'assemblaggio. Fino a qui, già conosciamo le diverse potenzialità che propone Grasshopper nella modifica dei progetti, e queste variazioni di design potrebbero essere agevolare la fabbricazione, al pari degli altri criteri usati. Voglio aprire l'argomento e toccare alcuni punti in relazione alla fase di preparazione dei dati, per dare un'occhiata alle possibilità di estrazione di dati dai progetti di design per la fabbricazione. Sappiamo che questo argomento è aperto a diverse tecniche, macchinari, materiali etc.

8_1_ Datasheet Allo scopo di preparare i dati per realizzare un oggetto, talvolta abbiamo semplicemente bisogno di una serie di misure, angoli, coordinate o genericamente, dati numerici. Ci sono diversi componenti all'interno di Grasshopper per computare misure, distanze, angoli etc. Il punto importante è la corretta e precisa selezioni dei punti di cui abbiamo bisogno per indirizzarli ad uno scopo preciso. Dovremo essere attenti ad ogni complessità geometrica che che il nostro progetto presenta, in modo da scegliere la posizione desiderata per la misurazione. Il passo successivo è quello di trovare le posizione che ci diano i dati corretti per le nostre produzioni ed evitare di generare numeri che potrebbero risultare dei mangia tempo senza utilità. Alla fine abbiamo bisogno di esportare i dati dal software 3D ai fogli di calcolo e talvolta abbiamo bisogno di manipolare questi dati in base alle esigenze. 141

Progetto fatto con strisce di carta Per continuare a investigare queste tematiche, le strisce di carta mi sembrano un'ottima soluzione. Per capire la logica dell'assemblaggio, ho iniziato con semplici combinazione per il primo livello e ho provato ad aggiungere semplici combinazioni insieme al secondo livello di assemblaggio. All'inizio Ă¨ stato interessante, ma si Ă¨ capito subito che non avrei ottenuto i risultati previsti. Alla fine ho provato ad essere piĂš preciso per confrontarmi con la geometria complessa.

Fig. 8.1 Strisce di carta: primo esempio Nel passo successivo ho provato ad iniziare con una semplice situazione per capire la logica geometrica e usarla come base per la modellazione digitale. Ho assunto che, attraverso l'uso del modello digitale non sarei stato capace di fare un modello fisico ed ero sicuro che avevo bisogno di fare dei test con la carta per i primi passi. Il mio obiettivo era quello di usare tre strisce di carta e connetterle insieme: una al centro e altre due ad entrambi i lati rispetto a quella centrale, ma con una lunghezza maggiore e ristretti nella parte finale. Questo potrebbe essere il modulo di base da ripetere e generare assemblaggi piĂš grandi.

Fig. 8.2 Semplice combinazione di strisce di carta per capire le connessioni e la logica.

142

Modellazione digitale Voglio modellare le strisce di carta digitalmente dopo aver capito le basi del modello fisco. Dal punto di partenza ho bisogno di una semplice curva mediana, che funga da base del progetto. Questa deve poter essere divisa e i punti di divisione devono poter essere selezionati (attraverso i valori booleani TRUE/FALSE dati da un <cull pattern>): i punti che rispondo al valore TRUE devono essere mossi perpendicolarmente alla curva centrale e devono essere usati (sia quelli spostati che quelli rispondenti al FALSE) come vertici per due curve interpolate che posso modellare in maniera simile a quelle che ho descritto con le strisce di carta .

Fig. 8.3 Primo metodo di modellazione con la striscia centrale e le curve interpolate come strisce laterali. Ma cosĂŹ sembra troppo semplice e lineare. Ho quindi deciso di aggiungere una differenziazione di dimensione graduale nei punti di connessione in modo da far risultare una geometria un po' piĂš complessa. Ora andiamo su Grasshopper e continuiamo la nostra discussione sulla modellazione. Voglio provare a descrivere in maniera succinta la definizione e andare verso la parte relativa ai dati.

Fig. 8.4 Il componente <curve> Ă¨ la striscia centrale, rappresentata su Rhinocerosda una semplice curva. L'ho riparametrizzata e ora voglio valutarla in intervalli decrescenti. Ho usato un componente <range> e l'ho collegato ad un componente <graph mapper> (Params>Special>Graph mapper) per generare i parametri di valutazione. Un <graph Mapper> (mappatore grafico) rimappa un set di numeri in tanti modi diversi, attraverso la scelta di un particolare tipo di grafico. Come vedete, ho valutato la curva con <graph mapper> con il grafico tipo parabola e i punti risultanti nella curva sono chiari. Potete cambiare il tipo di grafico per modificare la mappatura del range 143

numerico (per ulteriori informazioni visita l'help del componente). Dopo questo ho valutato questi parametri sulla curva iniziale (ho connesso <receiver> con la <curve>).

Fig. 8.5 Dopo aver rimappato i dati numerici e valutato i punti, voglio trovare i punti centrali ogni due punti del set precedente. Devo quindi trovare i parametri delle curve, tra ogni punto di base e quello successivo, da valutare. PoichĂŠ ho i parametri di ogni primo punto, ho spostato (<shift>) i dati per trovare i punti successivi. Ho inoltre usato un <cull> con la frequenza data dalla lunghezza della lista (<list lenght>) per escludere l'ultimo elemento della lista principale in modo da avere gli stessi elementi come la lista spostata. Il componente <function> trova il parametro intermedio (f(x)=(x+y)/2). Potete vedere i parametri risultanti essere valutati (il <receiver> connesso con <crv>).

Fig. 8.6 Ora voglio spostate il punto medio e creare dei vertici deviati della striscia laterale. Questi punti devono sempre spostarsi in una direzione perpendicolare alle curva centrale. Quindi per poterli spostare, ho bisogno di vettori, perpendicolari alla curva centrale nella posizione di ogni punto. Con il componente <evaluate> ottengo anche un vettore tangente ad ogni punto ma abbiamo bisogno di quello perpendicolare. Sappiamo che il prodotto vettoriale di due vettori Ă¨ ancora un vettore, sempre perpendicolare ad entrambi (Fig. 8.7). Per esempio il vettore unitario Z, potrebbe essere il prodotto vettoriale dei 144

vettori unitari X e Y. La nostra curva centrale è una curva planare quindi sappiamo che il vettore Z in ogni punto della curva sarà sempre perpendicolare al piano della curva. Il vettore tangente ad ogni punto della curva, è situato anch'esso nel piano della curva. Quindi se trovo il prodotto vettoriale del vettore tangente e del vettore unitario Z di ogni punto, il risultato dovrebbe essere un vettore perpendicolare alla curva intermedia che appartiene sempre al piano della curva. Ho usato la tangente del punto dal componente <evaluate> e il vettore <unit Z> per trovare il loro <Xprod> (prodotto vettoriale) che so essere perpendicolare alla curva anche se la modifico manualmente. Altro trucco! Ho usato i valori di <graph mapper> come fattori di potenza di questi vettori Z, in modo da aumentare il movimento dei punti. Quindi, maggiore sarà la distanza tra i punti, più grande sarà il loro spostamento.

Fig. 8.7 Prodotto vettoriale. Il vettore A e B sono nel piano di base. Il vettore C è il prodotto vettoriale di A e B ed è perpendicolare al piano di base e di conseguenza ai vettori A e B.

Fig. 8.8 Ora ho i punti di base (i primi punti valutati) e i punti spostati. Li ho intrecciati (<weave>) insieme per avere una lista ordinata di dati. Ora se uso questi punti per generare una curva interpolata, potrete vedere la curva di base della striscia laterale. 145

Fig. 8.9 Usando un componente <mirror curve> (Xform>Morph>Mirror curve) posso specchiare la curva interpolata usando la curva intermedia connessa al <receiver>. In questo modo avrĂ˛ quindi entrambi i lati con strisce di carta modulate sullo stesso concetto

Fig. 8.10 Se ora connetto la curva intermedia e le curve laterali ad un componente <extrude> posso vedere la mia prima combinazione di strisce di carta, con uno spazio vuoto decrescente tra i punti.

Fig. 8.11 Posso iniziare a modificare la strisce intermedia e vedere come Grasshopper aggiorna le tre strisce di carta che sono connesse l'una con l'altra, o posso modificare i valori degli slider e controllare la geometria risultante per selezionare quello piĂš vicino al modello fisico.

146

Dopo aver trovato la configurazione per le mie strisce di carta, ho bisogno di estrarre le dimensioni e i posizionamenti per costruire il mio modello basato su questi dati. Sebbene sia facile modellare tutte queste strisce su fogli di carta e tagliarle con il laser, qui voglio creare un processo più generale ed ottenere i dati iniziali necessari in modo da non essere limitato ad una specifica macchina e ad uno specifico metodo di manifattura. Potete usare questi dati come generici codici per la produzione. Facendo un semplice modello di carta so che ho bisogno della posizione dei punti di connessione sulle strisce ed è ovvio che questi punti di connessione avranno una lunghezza diversa nella striscia sulla parte sinistra rispetto alla striscia della parte destra nonché rispetto a quella intermedia. Quindi se ottengo la lunghezza di divisione da Grasshopper, possono segnarla sulle strisce. Poiché le strisce sono curve il componente <distance> non mi aiuta per questa misura. Ho bisogno di una distanza tra un punto a un'altro o dal punto iniziale della striscia ma rispetto alla curva, in modo che quando lo uso sulla carta stesa mi possa dare la posizione corretta. Per ottenere questa lunghezza ho bisogno di trovare i parametri dei punti di connessione sulle strisce (curve) e valutare la loro posizione. Gli stessi componenti mi restituiranno la distanza di questi punti da un punto iniziale della curva.

Fig. 8.12 Come vedete ho usato il primo gruppo di punti valutati che ho chiamato punti della curva principale (main curve points) nelle striscia centrale (curva iniziale). L'output L del componente mi restituisce la distanza dei punti (punti di connessione) dal punto di partenza della striscia per la striscia intermedia. Ho anche usato questi punti per trovare i loro parametri su un lato della curva. Ho quindi usato un componente <curve cp> per trovare i parametri di ogni punto sulla curva (t). Questi parametri sono stati utilizzati per valutare la curva e trovare la loro distanza dai punti iniziali. Vorrei fare lo stesso per la parte successiva delle striscia. Assicuratevi che la direzione di tutte le curve sia la stessa e controllate dov'è il punto di partenza della curva (origine della misurazione).

147

Esportazione di dati

Fig. 8.13 Cliccate con il tasto destro sul componente <panel> e selezionate 'stream content'. Con questa opzione sarete in grado di salvare i vostri dati in diversi formati ed usarli come generici dati numerici. Qui li ho salvati con un semplice formato .txt per poterli usare in Microsoft Excel.

Fig. 8.14 Su un foglio di Excel, cliccate su una cella vuota e selezionate la scheda Data sotto 'Get External Data' . Scegliete a questo punto 'from text'. Selezionate il file salvato in txt dal percorso in cui l'ho avete posizione e seguite le istruzioni di Excel. Questi passi vi permetteranno di amministrare diversi tipi di dati riguardanti, per esempio, come dividere i vostri dati in diverse celle e colonne etc. 148

Fig. 8.15 Ora potete vedere i vostri dati posizionati su un foglio di calcolo di excel. Potete fare lo stesso per le strisce rimanenti

Fig. 8.16 Tavola delle distanza dei punti di connessione lungo la striscia.

Se avete una lista di coordinate 3D di punti e le volete esportare su Excel, avete diverse opzioni a disposizione. Se esportate le coordinate 3D con il metodo sopra descritto, vedrete che ci sono tante parentesi e virgole non necessarie che dovrete cancellare. Potete anche aggiungere delle colonne cliccando sul tasto import text su excel e mettere in altre colonne le virgole e le parentesi per poi cancellarle ancora. 149

In alcuni casi raccomando di decomporre i punti nei loro componente ed esportarli separatamente. Non è gran problema esportare tre liste di dati anziché una.

Fig. 8.17 Usando il componente <decompose> per avere le coordinate X, Y e Z in maniera seperata per poi esportarle in questo modo verso un foglio di calcolo. Vi raccomando fortemente di lavorare in maniera professionale con Excel o altri fogli di calcolo, perchè ci aiutano nella gestione dei dati.

Con la modellazione ci siamo! Ho usato i dati procurati per segnare le mie strisce di carta e connetterle insieme e creare dei semplici modelli. Per provare anche a me stesso, ho fatto questo processo a mano, per dimostrare che la fabbricazione non necessariamente significa macchine da taglio laser ma, come ha detto un volta Achim Menges (Tutor AA di EmTech), qualche volta il CAM può essere sostituito dal HAM cioè Manifattura Manuale (Hand Aided Manifacturing!!! Giusto per ridere). Ho passato un'ora a tagliare tutte le strisce mentre il processo di assemblaggio ha preso un po' più di tempo ma è stato comunque fatto a mano. 150

Fig. 8.18 Progetto finale di strisce di carta.

151

8_2 Tagli laser e manifatturazione basata sul taglio Per fabbricare geometrie complesse oggigiorno viene usata comunemente l'idea di tagliare fogli di materiali attraverso il laser. Esistono diversi modi in cui possiamo usare questa possibilità per fabbricare oggetti. I tagli laser vanno bene per oggetti costruiti con superfici sviluppabili o piegate. E' possibile distendere su un piano una geometria digitale e semplicemente ritagliarla da un foglio e piegare il materiale per costruirla. Per le geometrie complesse, può anche risultare appropriato ridurle in pezzi separati di superfici piane: l'intero modello può essere disassemblato in diverse parti separate, annidate in fogli piani e possono essere aggiunte le parti sovrapposte per le connessione (incollaggio per esempio) e per il taglio al fine di un assemblaggio fisico. E' anche possibile fabbricare oggetti a doppia curvatura con questo metodo. Sono stati fatti diversi esperimenti per trovare le diverse sezioni di un oggetto a forma di 'blob'. Queste sezioni tagliano l'oggetto in almeno due direzioni e una volta assemblate, vengono unite (solitamente imbrigliate) a creare la forma della gabbia del modello. Poiché gli incisori laser sono degli strumenti generici, ci sono vari metodi, ma per tutti la cosa importante è trovare il modo per ridurre la geometria ad elementi piatti in modo da tagliarla da un foglio di materiale (non importa se carta o metallo, cartone o legno) e alla fine assemblarli insieme. Dei i diversi modi discussi qui, voglio testarne uno su Grasshopper. Sono sicuro che potrete facilmente sperimentare gli altri per conto vostro Fabbricazione di superfici free form Ho deciso di fabbricare una superficie free form per fare esperimenti, preparando e nidificando i pezzi degli oggetti free form da tagliare e tutte le altre cose di cui abbiamo bisogno.

Fig. 8.19 Qui abbiamo la superficie che importata su Grasshopper attraverso il componente <geometry>. Questo per mostrare che è possibile introdurre ogni geometria che avete progettato o usare ogni oggetto di Grasshopper che avete generato. Nervature delle sezioni Per poter fabbricare queste forme free form generiche, voglio creare le sezioni di questa superficie, annidarle su un foglio e preparare i file per essere tagliati con un incisore laser. Se l'oggetto su cui state lavorando ha un certo spessore che potete tagliare, il modello è piatto, avete quindi bisogno di aggiungere uno spessore per tagliare le parti.

152

Fig. 8.20 Nel primo passo ho usato un componente <bounding box> (parallelepipedo limite) per trovare l'area su cui voglio lavorare. Ho usato anche un componente <Box corners> (Surface>Analysis>Box corner) per trovare gli angoli opposti del parallelepipedo e usarli come limite del range che voglio per generare le nervature lungo la geometria. Quindi grazie al calcolo della lunghezza e dell'altezza del parallelepipedo, ho potuto usare questi valori come domini che voglio dividere attraverso un componente <range>. Fondamentalmente, usando un <number slider>, posso dividere la lunghezza e l'altezza del parallelepipedo nelle parti desiderate.

Fig. 8.21 Il mio obiettivo Ă¨ di generare piani accanto la lunghezza e larghezza del parallelepipedo in quantitĂ pari a quella delle nervature di cui ho bisogno. Prima di tutto ho generato due piani, uno <xy plane> e l'altro <xz plane>:il primo perpendicolare alla lunghezza del parallelepipedo e il secondo perpendicolare alla larghezza. Ho generato entrambi nel primo vertice del parallelepipedo connettendoli all'output A del <box corner>. Ora posso generare i vettori <unit X> e <unit Y> di fianco la lunghezza e la larghezza del parallelepipedo e attraverso la connessione del componente <range>, posso creare dei vettori per tutti i punti di divisione. Posso quindi spostare (<move>) i piani XZ e YZ con questi vettori e generare serie di armature lungo la lunghezza del parallelepipedo limite. 153

Fig. 8.22 Armature generate lungo la direzione della lunghezza e della larghezza del parallelepipedo limite dell'oggetto, perpendicolarmente al bordo.

Fig. 8.23 Ora se trovo le intersezioni di questi piani con la superficie, posso effettivamente generare le nervature arrivando a metĂ strada del nostro processo di fabbricazione delle superfici. Qui ho usato il componente <Brep | Plane> (Intersect>Mathematical>Brep | Plane) per risolvere il problema. Ho usato <Geometry> (la mia superficie iniziale) come Brep e i piani dei passi precedenti, come piani per alimentare i componenti della sezione.

154

Fig. 8.24 Intersezioni tra le armature e le superfici, che creano una di serie di curve sulla superficie. Annidamento Il passo successivo Ă¨ quello di annidare queste curve di sezione su un foglio piatto per prepararle al processo di taglio. Ho disegnato un rettangolo in Rhinoceroscon il mio foglio. Ho copiato questo rettangolo per generare tanti fogli sovrapposti l'uno con l'altro e ho disegnato una superficie che copra tutti questi rettangoli.

Fig. 8.25 Fogli di carta e superfici sottostanti per rappresentarle su Grasshopper UserĂ˛ il componente <orient> (Xform>Euclidian>Orient) per annidare le mie curve in una superficie che rappresenti i fogli per i tagli. Osservando il componente <orient> potete vedere che abbiamo bisogno del piano di riferimento dell'oggetto e il piano destinazione che dovrebbe essere sul foglio. Quindi dovrei generare questi piani per annidare i miei oggetti di taglio. PoichĂŠ ho usato questi piani per intersecare la superficie iniziale e generare le curve di sezione, possono usarli ancora come piani di riferimento, ho quindi solo bisogno di generare i piani di destinazione.

155

Fig. 8.26 Ho importato la superficie di taglio su Grasshopper e ho usato un componente <surface frame> (Surface>Util>Surface frames) per generare serie di strutture trasversali alla superficie. Possiamo generare piani, quanti ne necessita la geometria.

Fig. 8.27 Orientamento. Ho connesso le curve di sezione come geometrie di base e i piani che ho usato per genere queste sezione come geometria di riferimento per il componente <orient>. Ma è ancora necessaria una piccola modifica al piano di destinazione. Se osservate i risultati del <surface frame>, vedrete che dividendo la direzione U per 1, verranno generate 2 colonne per dividere la superficie. Ho quindi un numero di piani superiore alle mie necessità. Ed è per questo che ho diviso la lista (<split>) del piano di destinazione con i numeri che provengono dal numero di curve di riferimento. Ho quindi usato piani in quantità pari alle curve presenti e li ho spostati di una unità in direzione X per permettere la sovrapposizione con i bordi dei fogli. Ora possono connettere questi piani al componente <orient>. A questo punto possiamo vedere che tutte le curve sono annidate nel piano di taglio.

156

Fig. 8.28 curve annidate nel foglio di taglio Generazione delle nervature

Fig. 8.29 Dopo aver annidato le curve nei fogli di taglio, visto che i nostri oggetti non hanno spessore, abbiamo bisogno di provvedere a tal requisito per poterli tagliare. A questo scopo ho creato un <offset> delle curve con il valore dell'altezza desiderata e ho anche aggiunto delle linee ad entrambe le estremitĂ di queste curve e di quelle 'offsettate' in modo da chiudere l'intero disegno ed avere la nervatura completa per il taglio. Generare le giunture (imbrigliatura) Il passo successivo Ă¨ quello di generare le nervature nelle altre direzione e creare le giunture per assemblare dopo il taglio. Sebbene abbia usato lo stesso metodo di divisione dell'altezza del 157

parallelepipedo limite per generare piani e quindi sezioni, posso generarli manualmente in ogni posizione desiderata. Quindi, se non volete dividere entrambe le direzioni e generare le sezioni, potete usare altri metodi.

Fig. 8.30 Come vedete in questo caso, al posto dei piani precedentemente generati, ho usato piani definiti manualmente per le sezione nelle altre direzioni delle superfici. Un piano è statp generato attraverso un valore di X direttamente da un <number slider> ed un altro piano proveniene da un piano specchiato sull'altro lato della superficie (lunghezza della superficie (y) – number slider (x)). Le sezione di questi due piani e superfici sono calcolate per i passi successivi. Ora posso orientare queste nuove curve su un altro foglio da tagliare, usando lo stesso processo precedente. Generiamo quindi le giunture per l'assemblaggio della parti.

Fig. 8.31 Poiché abbiamo le curve nelle due direzioni, possiamo trovare i loro punti di intersezione per disegnare le giunture nella posizione corretta. A questo scopo ho usato il componente <CCX> (Intersect>Physical>Curve|Curve) per trovare le posizioni di intersezione tra queste curve cioè le posizioni delle giunture (Il componente <CCX> è impostato in modalità riferimento incrociato (cross reference)). 158

Ho bisogno di disegnare disegnare qualcos'altro per preparare la giunture al taglio. Ho intenzione di usare un'imbrigliatura e ho quindi bisogno di tagliare metĂ di ogni nervatura nella posizione di giuntura per poter unirle alla fine. Per prima cosa ho bisogno di trovare queste intersezioni nelle nervature nidificate e quindi disegnare la linea di taglio.

Fig. 8.32 Se osservate la porta di output del componente <CCX> potrete vedere che restituisce il parametro in cui ogni curva si interseca con l'altra. Posso quindi valutare le curve nidificate o orientate con questi parametri per trovare la posizione di giuntura sui fogli di taglio.

Fig. 8.33 Ora che abbiamo la posizione delle giunture, dobbiamo disegnarle. Per prima cosa ho disegnato le linee con il componente <line SDL> con il punto di giunzione quale punto di partenza, direzione <unit Y> e ho usato mezza altezza della nervatura come valore per la lunghezza. Ora possiamo vedere che punto sulla curva nidificata ha una linea sottile associata. 159

Fig. 8.34 Passo successivo, disegnate una linea in direzione X dal punto finale della precedente linea con la lunghezza del <sheet_thikness> (spessore del foglio, che dipende dal materiale).

Fig. 8.35 Per disegnare la terza linea ho bisogno di trovare il punto dove questa linea si connette alla curva di base perchĂ¨ non conosco esattamente la lunghezza. In questo passaggio, ho aggiunto un altra <linea SDL> con direzione Y ma segno negativo per disegnare la terza linea, ma piĂš lunga di quanto necessario, per intersecare la curva di base in un punto. Il <receiver> Ă¨ connesso alla curva orientata. Ho quindi usato <CLX> (Intersect>Mathematical>Curve|line) per trovare l'intersezione con la curva di base. Ho 'appiattito' (<flatten>) e aggiunto delle linee, ancora dal punto finale della seconda linea a questo punto di intersezione. Come risultato, ora le connessioni sono complete. Devo completare il lavoro per entrambi i lati di giunzione.

160

Fig.8.36 Usando un componente <join curves> (Curve>Util>Join curves), come potete vedere ho una scanalatura (chiamata <join curve>) che possono usare per tagliare, come imbrigliatura dentro la struttura. Applichiamo lo stesso metodo per l'altra estremitĂ della curva (seconda serie di giunzioni sull'altro lato della curva orientata).

Fig. 8.37 Nervature con il punto di giunzione disegnato su entrambe le estremitĂ . Posso tagliare la parte sottile della curva di base dentro la giuntura, ma, visto che non modifica la geometria, la posso lasciare. Etichettatura Mentre stiamo lavorando nella fase di fabbricazione, potrebbe non essere una grande idea, tagliare centinaia di piccole parti e lasciarle senza nome e indicazioni. Visto che stiamo andando ad 161

assemblarle, sarebbe opportuno indicarne l'ordine per sapere quale va per prima. E' ovvio che visto che tutte le parti sono diverse, abbiamo bisogno di etichettarle per poterle assemblare facilmente. L'etichetta può essere semplicemente rappresentata da un numero o da una combinazione di numeri e testi utili a collocare i pezzi. Se l'oggetto è composto da una serie di piccoli pezzi divis, possiamo dare un nome alle parti principali e usare il nome o le iniziali con i numeri per collocare i pezzi (p.e. left_wing_01 – ala_sinistra_01). Possiamo usare anche delle logiche gerarchiche per poter nominare anche le parti (p.e. layer_01_p_45). Ho dunque bisogno di una serie di numeri per mostrare la posizione delle nervature nella lista. Posso usare il componente <text tag> per poter aggiungere il testo alla mia geometria e per fare ciò, ho bisogno di indicare la posizione e l'altezza del testo.

Fig. 8.38 Come ricorderete, ho una serie di piani che usati come piani di destinazione per orientare le curve di sezione sul foglio. Andrò quindi ad usare i piani per creare le posizione per il testo. Poiché i piani sono esattamente agli angoli dellenervature, li devo prima spostare.

Fig. 8.39 Ho spostato gli angoli dei piani di una unità in direzione X e di mezza unità in direzione Y (come somma (<sum>) di vettori) ed ho usato questi piani per la posizione delle etichette testuali. Qui ho usato <text tag 3D> e ho generato una serie di elementi pari al numero delle nervature e li userò come testo. Per convertire 12.0 in 12 ho usato il componente <integer> ma è possibile farlo anche con una funzione. Come risultato potete vedere tutte gli elementi che presentano un unico numero nel loro angolo sinistro. 162

Fig. 8.40 Ora potete cambiare i fattori di divisione delle superfici di taglio per comprimere le nervature, in modo da evitare di sprecare materiale. Come vedete nell'esempio precedente, dal punto di partenza del foglio 3 (sheet_3), le nervature iniziano ad essere piĂš piatte e questo consente di avere piĂš spazio tra loro. Qui potete suddividere le vostre nervature in due diverse superfici da tagliare e cambiare i punti di divisione, per comprimerli in base alla loro forma. Ma se non state tenendo conto di alcune parti potete fare questo tipo di cose manualmente su rhino: non Ă¨ necessario che tutte le parti siano fatte in maniera associativa! Ora ho le nervature in una direzione e posso fare le stessa cosa nell'altra direzione. L'unico cosa da considerare Ă¨ la direzione dei giunti invertita, quindi mentre stavo lavorando con la geometria orientata nella parte precedente, qui devo lavorare con quella creata dall'<offset> Taglio Quando tutte le geometrie diventano pronte per essere tagliate, ho bisogno di 'cucinarle' (bake) e modificarle un altro po' sui fogli. Come vedete in fig. 8.41 gli oggetti sono tutti nidificati in tre fogli. Ho generato tre forme diverse per le nervature nella direzione della larghezza dell'oggetto per verificarle. Il materiale Ă¨ ora pronto per essere tagliato.

Fig. 8.41 Nervature annidate, pronte per essere tagliate. 163

Fig. 8.42 Esempi di nervature, pronte per essere assemblate. Assemblaggio

Nel nostro caso, l'assemblaggio, Ă¨ relativamente semplice. Talvolta sarĂ necessario controllare ancora il file per avere un aiuto nell'assemblare le parti con diversi metodi di fabbricazione. Qui abbiamo tutte le superfici fatte con i fogli di carta.

164

Fig. 8.43 Modello finale La fabbricazione è un argomento di discussione molto vasto. Dipende principalmente su cosa si vuole fabbricare, qual'è il materiale, qual'è la macchina da utilizzare, come le parti fabbricate vanno assemblate e così via. Come già detto, in base al progetto su cui si intende lavorare, avrete bisogno di recuperare i dati per per le fasi di fabbricazione. Qualche risulterà più importante avere la logica di assemblaggio, per esempio quando state lavorando con componenti semplici che creano posi una geometria complessa come risultato dell'assemblaggio.

165

Fig. 8.44 Logica di assemblaggio: i materiali e i giunti sono semplici. Posso lavorare sulla logica di assemblaggio e usare i dati per fare i miei modelli.

166

CAPITOLO_9_ Strategia di Design

167

9_Strategia di Design Gli algoritmi generativi sono algoritmi e rappresentano modalità associativo/parametrico di operare sulla geometria nelle problematiche progettuali. Con il metodo algoritmico, meglio che con che con gli oggetti geometrici convenzionali, possiamo avere tutte le possibilità date dalla geometria computazionale, e allo stesso tempo possiamo gestire un'immensa quantità dai dati, numeri e calcoli. La problematica è quella di non limitare la progettazione in esperimenti predefiniti, ed esplorare le infinite potenzialità; ci sono sempre modi alternativi per impostare gli algoritmi di design. Sebbene sembri che i comandi degli applicativi sulla modellazione parametrica possano limitare alcune operazioni o possano imporre dei metodi, le soluzioni alternative sono sempre presenti: fate volare la fantasia e scavalcate i limiti! Per poter progettare qualcosa,aiuta sempre avere una strategia progettuale. Questa permetterà di impostare il miglior algoritmo per trovare la soluzione al nostro problema. Pensando alle proprietà generali degli oggetti di design, disegnare alcune parti e fare dei modelli fisici, potrebbe aiutare a capire meglio gli algoritmi in modo da scegliere i migliori componenti per la modellazione digitale. Pensando ai parametri fissi, questi possono essere cambiati durante il progetto: i dati numerici e gli oggetti geometrici necessari, aiutano sempre a migliorare l'algoritmo. Sarebbe veramente d'aiuto capire analiticamente le problematiche progettuali, schizzarle e quindi iniziare un algoritmo che possa risolvere il problema. Per poter progettare algoritmicamente, dobbiamo pensare algoritmicamente!

168

Fig. 9.1 Progetto Weaving, dalla comprensione analitica alla modellazione associativa.

169

Fig. 9.2 Progetto di un muro forato, Dalla comprensione analitica alla modellazione associativa. 170

Bibliografia Pottman, Helmut and Asperl, Andreas and Hofer, Michael and Kilian, Axel, 2007: ‘Architectural Geometry’, Bently Institute Press. Hensel, Michael and Menges, Achim, 2008: ‘Morpho-Ecologies’, Architectural Association. Rutten, David, 2007: ‘RhinocerosScript 101’, digital version by David Rutten and Robert McNeel and Association. Flake, Gary William, 1998: ‘The computational beauty of nature, computer explorations of fractals, chaos, complex systems, and adaptation’, The MIT Press. De Berg, Mark and Van Kreveld, Marc and Overmars, Mark, 2000: ‘Computational Geometry’, Springer. Grasshopper tutorials on Robert McNeel and Associates http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryExamples.html

wiki:

Axel Kilian and Stylianos Dritsas: ‘Design Tooling - Sketching by Computation’, http://www.designexplorer.net/designtooling/inetpub/wwwroot/components/sketching/index.ht ml Wolfram Mathworld: http://mathworld.wolfram.com/ Stylianos Dritsas, http://jeneratiff.com/ Main Grasshopper web page: http://Grasshopper3d.com

171

172