Gli elenchi rappresentano il modo in cui vengono organizzati i dati. Nel sistema operativo del computer, sono presenti file e cartelle. In Dynamo, è possibile considerare questi elementi rispettivamente come voci ed elenchi. Analogamente al sistema operativo in uso, esistono molti modi per creare, modificare e sottoporre a query i dati. In questo capitolo, verrà descritto come vengono gestiti gli elenchi in Dynamo.
Un elenco è una raccolta di elementi o voci. Si prenda, ad esempio, un casco di banane. Ogni banana è una voce all'interno dell'elenco (o del casco). È più semplice raccogliere un casco di banane piuttosto che ogni singola banana e ciò vale anche per il raggruppamento di elementi secondo relazioni parametriche in una struttura di dati.
Photo by Augustus Binu.
Quando si fanno acquisti nei negozi di alimentari, si mettono tutti gli oggetti acquistati in una borsa. Questa borsa è anche un elenco. Per fare il pane alla banana, occorrono 3 caschi di banane (servono per fare molto pane alla banana). La borsa rappresenta un elenco di caschi di banane e ogni casco rappresenta un elenco di banane. La borsa è un elenco di elenchi (bidimensionali) e il casco di banane è un elenco (unidimensionale).
In Dynamo, i dati dell'elenco vengono ordinati e la prima voce di ogni elenco ha un indice 0. Di seguito, saranno descritte la modalità di definizione degli elenchi in Dynamo e la modalità di relazione reciproca tra più elenchi.
Una cosa che potrebbe sembrare strana all'inizio è che il primo indice di un elenco è sempre 0; non 1. Così, quando si parla della prima voce di un elenco, si intende in realtà la voce che corrisponde all'indice 0.
Ad esempio, se si dovesse contare il numero di dita della mano destra, è probabile aver contato da 1 a 5. Tuttavia, se si dovessero inserire le dita in un elenco, in Dynamo sarebbero stati assegnati loro indici compresi tra 0 e 4. Sebbene questo possa sembrare un po' strano ai principianti in fatto di programmazione, l'indice in base zero è una pratica standard nella maggior parte dei sistemi di calcolo.
Nell'elenco sono ancora presenti 5 voci, questo perché l'elenco sta utilizzando un sistema di conteggio in base zero. E le voci memorizzate nell'elenco non devono essere solo numeri. Possono essere qualsiasi tipo di dati supportato da Dynamo, ad esempio punti, curve, superfici, famiglie e così via.
a. Indice
b. Punto
c. Elemento
Spesso il modo più semplice per esaminare il tipo di dati memorizzati in un elenco è collegare un nodo di controllo all'output di un altro nodo. Per default, il nodo di controllo mostra automaticamente tutti gli indici sul lato sinistro dell'elenco e visualizza gli elementi di dati sul lato destro.
Questi indici sono un elemento fondamentale quando si utilizzano gli elenchi.
Per quanto riguarda gli elenchi, input e output variano a seconda del nodo di Dynamo utilizzato. Ad esempio, è possibile utilizzare un elenco di 5 punti e collegare questo output a due diversi nodi di Dynamo: PolyCurve.ByPoints e Circle.ByCenterPointRadius:
L'input points per PolyCurve.ByPoints cerca “Point\[]”. Rappresenta un elenco di punti.
L'output per PolyCurve.ByPoints è una PolyCurve singola creata da un elenco di cinque punti.
L'input centerPoint per Circle.ByCenterPointRadius richiede "Point".
L'output per Circle.ByCenterPointRadius è un elenco di cinque cerchi i cui centri corrispondono all'elenco originale di punti.
I dati di input per PolyCurve.ByPoints e Circle.ByCenterPointRadius sono gli stessi, tuttavia il nodo Polycurve.ByPoints fornisce una PolyCurve mentre il nodo Circle.ByCenterPointRadius fornisce 5 cerchi con centri in ogni punto. In modo intuitivo, questa operazione ha senso: la PolyCurve viene disegnata come curva che collega i 5 punti, mentre i cerchi creano un cerchio diverso in ogni punto. Quindi cosa sta succedendo con i dati?
Posizionando il cursore sull'input points per Polycurve.ByPoints, si noterà che l'input cerca “Point\[]”. Notare le parentesi alla fine. Rappresenta un elenco di punti e, per creare una PolyCurve, l'input deve essere un elenco per ogni PolyCurve. Questo nodo comprimerà pertanto ogni elenco in una PolyCurve.
Dall'altro lato, l'input centerPoint per Circle.ByCenterPointRadius richiede "Point". Questo nodo cerca un punto, come elemento, per definire il punto centrale del cerchio. Per questo motivo, si ottengono cinque cerchi dai dati di input. Riconoscere queste differenze con gli input in Dynamo aiuta a comprendere meglio il funzionamento dei nodi durante la gestione dei dati.
La corrispondenza dei dati è un problema senza una soluzione chiara. Si verifica quando un nodo ha accesso a input di dimensioni diverse. La modifica dell'algoritmo di corrispondenza dei dati può portare a risultati molto diversi.
Si immagini un nodo che crea segmenti di linea tra punti (Line.ByStartPointEndPoint). Avrà due parametri di input che forniscono entrambi le coordinate dei punti:
Il modo più semplice consiste nel collegare gli input uno ad uno finché uno dei flussi non si esaurisce. Viene definito l'algoritmo "l'elenco più breve". Questo è il funzionamento di default per i nodi di Dynamo:
L'algoritmo "l'elenco più lungo" continua a collegare gli input e a riutilizzare gli elementi, finché tutti i flussi non si esauriscono:
Infine, il metodo Globale rende possibili tutti i collegamenti:
Come si può vedere, esistono diversi modi in cui è possibile disegnare linee tra questi gruppi di punti. Per trovare le opzioni del collegamento, fare clic con il pulsante destro del mouse sul centro di un nodo e scegliere il menu Collegamento.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Per dimostrare le operazioni di collegamento riportate di seguito, si utilizzerà questo file di base per definire l'elenco più breve, l'elenco più lungo e il collegamento globale.
Si modificherà il collegamento in Point.ByCoordinates, ma non cambierà nient'altro del grafico riportato sopra.
Scegliendo Più breve come opzione di collegamento (anche l'opzione di default), si ottiene una linea diagonale di base composta da cinque punti. I cinque punti indicano la lunghezza dell'elenco minore, pertanto il collegamento con l'elenco più breve viene interrotto dopo che si è arrivati alla fine di un elenco.
Modificando il collegamento in Più lungo, si ottiene una linea diagonale che si estende verticalmente. Con lo stesso metodo del diagramma concettuale, l'ultima voce nell'elenco di 5 voci verrà ripetuta per raggiungere la lunghezza dell'elenco più lungo.
Modificando il collegamento in Globale, si ottiene ogni combinazione tra ciascun elenco, fornendo una griglia di punti 5 x 10. Si tratta di una struttura di dati equivalente secondo il metodo globale come mostrato nel diagramma concettuale riportato sopra, tranne per il fatto che i dati sono ora un elenco di elenchi. Collegando una PolyCurve, è possibile vedere che ogni elenco viene definito dal relativo valore X, restituendo una riga di linee verticali.
Si aggiunge un altro livello alla gerarchia. Se si prende il mazzo di schede dell'esempio originale e si crea una scatola che contiene più mazzi, la scatola ora rappresenta un elenco di mazzi e ogni mazzo rappresenta un elenco di carte. Questo è un elenco di elenchi. Per analogia in questa sezione, l'immagine riportata di seguito contiene un elenco di rotoli di monete e ogni rotolo contiene un elenco di penny.
Foto di Dori.
Quali query è possibile eseguire dall'elenco di elenchi? Consente di accedere alle proprietà esistenti.
Numero di tipi di moneta? 2.
Valori del tipo di moneta? $0.01 e $0.25.
Materiale dei quarti? Rame al 75% e nichel al 25%.
Materiale dei penny? Zinco al 97,5% e rame al 2,5%.
Quali azioni è possibile eseguire nell'elenco di elenchi? In questo modo si modifica l'elenco di elenchi in base ad una determinata operazione.
Selezionare una pila specifica di quarti o penny.
Selezionare un quarto o un penny specifico.
Ridisporre le pile di quarti e penny.
Mischiare le pile insieme.
Anche in questo caso, Dynamo dispone di un nodo analogico per ciascuna delle operazioni riportate sopra. Poiché si sta lavorando con dati astratti e non con oggetti fisici, occorre una serie di regole per controllare il modo in cui ci spostiamo verso l'alto e verso il basso nella gerarchia dei dati.
Quando si utilizzano elenchi di elenchi, i dati sono stratificati e complessi, ma questo offre l'opportunità di eseguire alcune incredibili operazioni parametriche. Si esamineranno i principi fondamentali e si discuterà di alcune altre operazioni nelle lezioni riportate di seguito.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Il concetto fondamentale da apprendere da questa sezione: Dynamo tratta gli elenchi come oggetti di per sé. Questa gerarchia dall'alto verso il basso viene sviluppata tenendo a mente la programmazione orientata agli oggetti. Anziché selezionare elementi secondari con un comando quale List.GetItemAtIndex, Dynamo selezionerà tale indice dell'elenco principale nella struttura di dati. E quell'elemento può essere un altro elenco. Verrà esaminato dettagliatamente con un'immagine di esempio:
Con Code Block, sono stati definiti due intervalli:
0..2; 0..3;Questi intervalli sono connessi ad un nodo Point.ByCoordinates con il collegamento impostato su Globale. In questo modo viene creata una griglia di punti e viene inoltre restituito un elenco di elenchi come output.
Notare che il nodo Watch fornisce 3 elenchi con 4 elementi in ogni elenco.
Quando si utilizza List.GetItemAtIndex, con un indice 0, Dynamo seleziona il primo elenco e tutto il relativo contenuto. Altri programmi possono selezionare il primo elemento di ogni elenco nella struttura di dati, ma Dynamo utilizza una gerarchia dall'alto verso il basso durante la gestione dei dati.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Livella rimuove tutti i livelli di dati da una struttura di dati. Ciò è utile quando le gerarchie dei dati non sono necessarie per l'operazione desiderata, ma può essere rischioso perché rimuove le informazioni. L'esempio seguente mostra il risultato della riduzione di livelli di un elenco di dati.
Inserire una riga di codice per definire un intervallo in Code Block:
-250..-150..#4;Se si inserisce il blocco di codice nell'input x e y di un nodo Point.ByCoordinates, è necessario impostare il collegamento su Globale per ottenere una griglia di punti.
Il nodo Watch mostra che è presente un elenco di elenchi.
Un nodo PolyCurve.ByPoints farà riferimento a ciascun elenco e creerà la rispettiva PolyCurve. Nell'anteprima di Dynamo, sono presenti quattro PolyCurve che rappresentano ogni riga della griglia.
Inserendo un riduzione di livelli prima del nodo PolyCurve, è stato creato un singolo elenco per tutti i punti. Il nodo PolyCurve.ByPoints fa riferimento ad un elenco per creare una curva. Poiché tutti i punti si trovano in un elenco, si otterrà una PolyCurve zig-zag che corre in tutto l'elenco di punti.
Sono inoltre disponibili opzioni per la riduzione di livelli isolati di dati. Utilizzando il nodo List.Flatten, è possibile definire un numero impostato di livelli di dati da ridurre nella parte superiore della gerarchia. Questo è uno strumento molto utile se sono presenti strutture di dati complesse che non sono necessariamente rilevanti per il workflow. Un'altra opzione consiste nell'utilizzare il nodo Flatten come funzione in List.Map. Ulteriori informazioni su List.Map sono disponibili di seguito.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Quando si utilizza la modellazione parametrica, talvolta può essere utile modificare la strutture di dati in un elenco esistente. Anche per questo sono disponibili molti nodi, mentre la suddivisione è la versione più semplice. Con la suddivisione, è possibile suddividere un elenco in sottoelenchi con un determinato numero di elementi.
Il comando di suddivisione suddivide gli elenchi in base ad una determinata lunghezza dell'elenco. In alcuni modi, il comando di suddivisione è l'opposto della riduzione di livelli: anziché rimuovere la struttura di dati, ad esso vengono aggiunti nuovi livelli. Questo è uno strumento utile per operazioni geometriche come l'esempio seguente.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
List.Map/Combine applica una funzione impostata ad un elenco di input, ma ad un livello inferiore nella gerarchia. Le combinazioni sono identiche a quelle delle mappe, tranne per il fatto che le combinazioni possono avere più input corrispondenti all'input di una funzione specificata.
Nota Questo esercizio è stato creato con una versione precedente di Dynamo. In gran parte il funzionamento di List.Map è stato risolto con l'aggiunta della funzionalità List@Level. Per ulteriori informazioni, vedere List@Level di seguito.
Come introduzione rapida, si esaminerà il nodo List.Count di una sezione precedente.
Il nodo List.Count conteggia tutti gli elementi di un elenco. Verrà utilizzato per illustrare il funzionamento di List.Map.
Inserire due righe di codice in Code Block:
-50..50..#Nx; -50..50..#Ny;Dopo aver digitato questo codice, il blocco di codice creerà due input per Nx e Ny.
Con due Integer Slider, definire i valori Nx e Ny collegandoli a Code Block.
Collegare ogni riga del blocco di codice ai rispettivi input X e Y di un nodo Point.ByCoordinates. Fare clic con il pulsante destro del mouse sul nodo, selezionare Collegamento e scegliere Globale. In questo modo viene creata una griglia di punti. Poiché è stato definito l'intervallo da -50 a 50, la griglia di Dynamo di default viene estesa.
Un nodo Watch mostra i punti creati. Notare la struttura di dati. È stato creato un elenco di elenchi. Ogni elenco rappresenta una riga di punti della griglia.
Associare un nodo List.Count all'output del nodo Watch del passaggio precedente.
Collegare un nodo Watch all'output List.Count.
Notare che il nodo List.Count fornisce un valore pari a 5. Questo valore è uguale alla variabile "Nx" come definito nel blocco di codice. Perché?
Innanzitutto, il nodo Point.ByCoordinates utilizza l'input "x" come input principale per la creazione di elenchi. Quando Nx è 5 e Ny è 3, viene visualizzato un elenco di 5 elenchi, ciascuno con 3 elementi.
Poiché Dynamo tratta gli elenchi come oggetti di per sé, all'elenco principale della gerarchia viene applicato un nodo List.Count. Il risultato è un valore di 5 o il numero di elenchi nell'elenco principale.
Utilizzando un nodo List.Map, si scende di un livello nella gerarchia ed è possibile eseguire una "function" a questo livello.
Notare che il nodo List.Count non contiene input. Viene utilizzato come funzione, pertanto il nodo List.Count verrà applicato a ogni singolo elenco, scendendo di un livello nella gerarchia. L'input vuoto di List.Count corrisponde all'input dell'elenco di List.Map.
I risultati di List.Count ora forniscono un elenco di 5 elementi, ciascuno con un valore pari a 3. Rappresenta la lunghezza di ogni sottoelenco.
Nota Questo esercizio è stato creato con una versione precedente di Dynamo. In gran parte, il funzionamento di List.Combine è stato risolto con l'aggiunta della funzionalità List@Level. Per ulteriori informazioni, vedere List@Level di seguito.
In questo esercizio, si utilizzerà List.Combine per dimostrare come tale nodo può essere utilizzato per applicare una funzione in elenchi separati di oggetti.
Iniziare impostando due elenchi di punti.
Utilizzare il nodo Sequence per generare 10 valori, ciascuno con un incremento di 10 passi.
Collegare il risultato all'input x di un nodo Point.ByCoordinates. In questo modo verrà creato un elenco di punti in Dynamo.
Aggiungere un secondo nodo Point.ByCoordinates all'area di lavoro, utilizzare lo stesso output Sequence dell'input x, ma utilizzare un Interger Slider come input y e impostarne il valore su 31 (può essere qualsiasi valore, purché non si sovrapponga al primo gruppo di punti) in modo che i 2 gruppi di punti non si sovrappongano l'uno sull'altro.
Successivamente, verrà utilizzato List.Combine per applicare una funzione agli oggetti in 2 elenchi separati. In questo caso, si tratta di una funzione della linea di disegno semplice.
Aggiungere List.Combine all'area di lavoro e collegare i 2 gruppi di punti come il relativo input list0 e list1.
Utilizzare un Line.ByStartPointEndPoint come funzione di input per List.Combine.
Una volta completato, i 2 gruppi di punti vengono compressi/associati tramite una funzione Line.ByStartPointEndPoint e restituiscono 10 righe in Dynamo.
Fare riferimento all'esercizio in Elenchi n-dimensionali per vedere un altro esempio di utilizzo di List.Combine.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Preferita a List.Map, la funzionalità List@Level consente di selezionare direttamente il livello di elenco che si desidera utilizzare nella porta di input del nodo. Questa funzionalità può essere applicata a qualsiasi input in entrata di un nodo e consentirà di accedere ai livelli degli elenchi più rapidamente e più facilmente rispetto ad altri metodi. È sufficiente indicare al nodo il livello dell'elenco che si desidera utilizzare come input e lasciare che il nodo faccia il resto.
In questo esercizio, si utilizzerà la funzionalità List@Level per isolare un livello specifico di dati.
Si inizierà con una semplice griglia di punti 3D.
Poiché la griglia è costruita con un intervallo per X, Y e Z, i dati sono strutturati in 3 ordini: un elenco X, un elenco Y e un elenco Z.
Questi ordini esistono in livelli diversi. I livelli sono indicati nella parte inferiore del simbolo circolare di anteprima. Le colonne dei livelli di elenco corrispondono ai dati dell'elenco riportati sopra per aiutare ad identificare il livello da utilizzare.
I livelli di elenco sono organizzati in ordine inverso, in modo che i dati del livello più basso siano sempre in "L1". In questo modo si garantisce che i grafici funzionino come previsto, anche se qualcosa è cambiato a monte.
Per utilizzare la funzione List@Level, fare clic su '>'. All’interno di questo menu, verranno visualizzate due caselle di controllo.
Usa livelli: attiva la funzionalità List@Level. Dopo aver fatto clic su questa opzione, sarà possibile fare clic e selezionare i livelli di elenco di input che si desidera utilizzare per il nodo. Con questo menu, è possibile provare rapidamente diverse opzioni di livello facendo clic verso l'alto o verso il basso.
Mantieni struttura elenco: se questa opzione è attivata, sarà possibile mantenere la struttura dei livelli dell'input. Talvolta, è possibile organizzare i dati in sottoelenchi in modo specifico. Selezionando questa opzione, è possibile mantenere intatta l'organizzazione degli elenchi senza perdere alcuna informazione.
Grazie alla semplice griglia 3D, è possibile accedere alla struttura dell'elenco e visualizzarla attivando e disattivando i livelli di elenchi. Ogni combinazione di indice e livello di elenco restituirà un gruppo di punti diverso dell'insieme 3D originale.
"@L2" in DesignScript consente di selezionare solo l'elenco al livello 2. L'elenco al livello 2 con l'indice 0 include solo il primo gruppo di punti Y, restituendo solo la griglia XZ.
Se si modifica il filtro del livello in "L1", sarà possibile vedere tutto nel primo livello di elenco. L'elenco al livello 1 con indice 0 include tutti i punti 3D in un elenco non strutturato.
Se si prova la stessa procedura per "L3", sarà possibile vedere solo i punti del terzo livello di elenco. L'elenco al livello 3 con l'indice 0 include solo il primo gruppo di punti Z, restituendo solo una griglia XY.
Se si prova la stessa procedura per "L4", sarà possibile vedere solo i punti del terzo livello di elenco. L'elenco al livello 4 con l'indice 0 include solo il primo gruppo di punti X, restituendo solo una griglia YZ.
Sebbene questo esempio particolare possa essere creato anche con List.Map, List@Level semplifica notevolmente l'interazione, semplificando così l'accesso ai dati dei nodi. Di seguito è riportato un confronto tra i metodi List.Map e List@Level:
Sebbene entrambi i metodi consentano di accedere agli stessi punti, il metodo List@Level ci consente di passare facilmente da un livello di dati all'altro all'interno di un singolo nodo.
Per accedere ad una griglia di punti con List.Map, sarà necessario disporre di un nodo List.GetItemAtIndex insieme a List.Map. Per ogni livello di elenco inferiore, sarà necessario utilizzare un nodo List.Map aggiuntivo. A seconda della complessità degli elenchi, potrebbe essere necessario aggiungere una quantità significativa di nodi List.Map al grafico per accedere al livello di informazioni appropriato.
In questo esempio, un nodo List.GetItemAtIndex con un nodo List.Map restituisce lo stesso gruppo di punti con la stessa struttura dell'elenco di List.GetItemAtIndex con l'opzione "@L3" selezionata.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Trasponi è una funzione fondamentale quando si lavora con elenchi di elenchi. Come nei programmi con fogli di calcolo, una trasposizione inverte le colonne e le righe di una struttura di dati. Verrà mostrata questa funzione con una matrice di base di seguito e nella seguente sezione sarà illustrato come utilizzare un trasposizione per creare relazioni geometriche.
Si eliminano i nodi List.Count dell'esercizio precedente e si passa ad una geometria per vedere la struttura di dati.
Collegare un nodo PolyCurve.ByPoints all'output del nodo Watch da Point.ByCoordinates.
L'output mostra 5 PolyCurve e le curve vengono visualizzate nell'anteprima di Dynamo. Il nodo di Dynamo sta cercando un elenco di punti (o un elenco di elenchi di punti in questo caso) e sta creando una singola PolyCurve da essi. Essenzialmente, ogni elenco è stato convertito in una curva nella struttura di dati.
Un nodo List.Transpose sposterà tutti gli elementi con tutti gli elenchi in un elenco di elenchi. Ciò risulta complicato, ma si tratta della stessa logica della trasposizione in Microsoft Excel: il passaggio tra colonne e righe in una struttura di dati.
Notare il risultato astratto: la trasposizione ha modificato la struttura dell'elenco da 5 elenchi con 3 elementi ciascuno a 3 elenchi con 5 elementi ciascuno.
Notare il risultato geometrico: utilizzando PolyCurve.ByPoints, si ottengono 3 PolyCurve nella direzione perpendicolare alle curve originali.
La sintassi abbreviata del blocco di codice utilizza "[]" per definire un elenco. Questo è un modo molto più rapido e più fluido per creare un elenco rispetto al nodo List.Create. Code Block viene descritto in modo più dettagliato in Code Block e DesignScript. Fare riferimento all'immagine seguente per osservare come è possibile definire un elenco con più espressioni con un blocco di codice.
La sintassi abbreviata di Code Block utilizza "[]" come metodo rapido e semplice per selezionare gli elementi specifici desiderati da una struttura di dati complessa. I Code Block vengono descritti in modo più dettagliato nel capitolo Code Block e DesignScript. Fare riferimento all'immagine seguente per osservare come è possibile eseguire query su un elenco con più tipi di dati con un blocco di codice.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
In questo esercizio viene utilizzata una parte della logica stabilita in un esercizio precedente per modificare una superficie. L'obiettivo è intuitivo, ma la navigazione nella struttura di dati risulterà più impegnativa. Si desidera articolare una superficie spostando un punto di controllo.
Iniziare con la stringa di nodi riportata sopra. Si sta creando una superficie di base che estende la griglia di default di Dynamo.
Utilizzando Code Block, inserire queste due righe di codice e collegarle rispettivamente agli input u e v di Surface.PointAtParameter:
-50..50..#3;-50..50..#5;.Assicurarsi di impostare il collegamento di Surface.PointAtParameter su Globale.
Il nodo Watch mostra che è presente un elenco di tre elenchi, ciascuno con 5 elementi.
In questo passaggio, si desidera eseguire una query sul punto centrale nella griglia creata. Per eseguire questa operazione, selezionare il punto centrale nell'elenco centrale. Ha senso, giusto?
Per confermare che si tratta del punto corretto, è anche possibile fare clic sugli elementi del nodo Watch per confermare che è quello corretto.
Utilizzando Code Block, si scriverà una riga di codice di base per l'esecuzione di una query su un elenco di elenchi:
points[1][2];.Utilizzando Geometry.Translate, si sposterà il punto selezionato verso l'alto nella direzione Z di 20 unità.
Selezionare anche la riga centrale dei punti con un nodo List.GetItemAtIndex. Nota Analogamente a un passaggio precedente, è anche possibile eseguire una query sull'elenco con Code Block, utilizzando una riga di
points[1];.
Finora è stata eseguita correttamente la query sul punto centrale ed è stato spostato verso l'alto. Ora è necessario reinserire il punto spostato nella struttura di dati originale.
Innanzitutto, si desidera sostituire l'elemento dell'elenco isolato in un passaggio precedente.
Utilizzando List.ReplaceItemAtIndex, si sostituirà l'elemento centrale utilizzando un indice di "2", con l'elemento sostitutivo collegato al punto spostato (Geometry.Translate).
L'output mostra che è stato inserito il punto spostato nell'elemento centrale dell'elenco.
Dopo aver modificato l'elenco, è necessario reinserire l'elenco nella struttura di dati originale, ovvero l'elenco di elenchi.
Seguendo la stessa logica, utilizzare List.ReplaceItemAtIndex per sostituire l'elenco centrale con l'elenco modificato.
Notare che i Code Block che definiscono l'indice per questi due nodi sono 1 e 2, che corrisponde alla query originale di Code Block (points[1][2]).
Selezionando l'elenco in corrispondenza dell'index 1, viene visualizzata la struttura di dati evidenziata nell'anteprima di Dynamo. Il punto spostato è stato unito correttamente nella struttura di dati originale.
Esistono molti modi per creare una superficie da questo gruppo di punti. In questo caso, si creerà una superficie eseguendo il loft delle curve insieme.
Creare un nodo NurbsCurve.ByPoints e collegare la nuova struttura di dati per creare tre curve NURBS.
Collegare un nodo Surface.ByLoft all'output di NurbsCurve.ByPoints. Ora è presente una superficie modificata. È possibile modificare il valore Z originale della geometria. Eseguire la traslazione e osservare l’aggiornamento della geometria.
Ora che è stato definito un elenco, si può parlare delle operazioni eseguibili su di esso. Si immagini un elenco come un mazzo di carte da gioco. Un mazzo è l'elenco e ogni carta da gioco rappresenta una voce.
Quali query è possibile eseguire dall'elenco? Consente di accedere alle proprietà esistenti.
Numero di carte nel mazzo? 52.
Numero di semi? 4.
Materiale? Carta.
Lunghezza? 3,5" o 89 mm.
Larghezza? 2,5" o 64 mm.
Quali azioni è possibile eseguire nell'elenco? In questo modo l'elenco cambia in base ad una determinata operazione.
È possibile mischiare il mazzo.
È possibile ordinare il mazzo in base al valore.
È possibile ordinare il mazzo in base al seme.
È possibile dividere il mazzo.
È possibile spartire il mazzo con singole mani.
È possibile selezionare una carta specifica nel mazzo.
Tutte le operazioni elencate sopra hanno nodi di Dynamo analoghi per l'utilizzo di elenchi di dati generici. Nelle lezioni riportate di seguito saranno illustrate alcune delle operazioni fondamentali che è possibile eseguire sugli elenchi.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
L'immagine seguente è il grafico di base che si sta disegnando tra due cerchi per rappresentare le operazioni di base con gli elenchi. Verrà illustrato come gestire i dati all'interno di un elenco e verranno mostrati i risultati visivi attraverso le azioni con gli elenchi riportate di seguito.
Iniziare con un Code Block con un valore di
500;.Collegarlo all'input x di un nodo Point.ByCoordinates.
Collegare il nodo del passaggio precedente all'input origin di un nodo Plane.ByOriginNormal.
Utilizzando un nodo Circle.ByPlaneRadius, collegare il nodo del passaggio precedente all'input plane.
Utilizzando Code Block, designare un valore di
50;per radius. Questo è il primo cerchio che verrà creato.Con un nodo Geometry.Translate, spostare il cerchio verso l'alto di 100 unità nella direzione Z.
Con un nodo Code Block, definire un intervallo di dieci numeri compreso tra 0 e 1 con questa riga di codice:
0..1..#10;.Collegare il Code Block del passaggio precedente all'input param di due nodi Curve.PointAtParameter. Collegare Circle.ByPlaneRadius all'input curve del nodo superiore e Geometry.Translate all'input curve del nodo sottostante.
Utilizzando Line.ByStartPointEndPoint, collegare i due nodi Curve.PointAtParameter.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Il nodo List.Count è semplice: calcola il numero di valori in un elenco e restituisce tale numero. Questo nodo si diversifica sempre di più quando si utilizzano elenchi di elenchi, come dimostreremo nelle sezioni successive.
Il nodo **List.Count ****** restituisce il numero di linee nel nodo Line.ByStartPointEndPoint. In questo caso, il valore è 10, che corrisponde al numero di punti creati dal nodo Code Block originale.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
List.GetItemAtIndex è un modo fondamentale per eseguire una query su una voce dell'elenco.
Innanzitutto, fare clic con il pulsante destro del mouse sul nodo Line.ByStartPointEndPoint per disattivare la relativa anteprima.
Utilizzando il nodo List.GetItemAtIndex, selezionare l'indice "0" o la prima voce dell'elenco di linee.
Modificare il valore del dispositivo di scorrimento compreso tra 0 e 9 per selezionare un elemento diverso utilizzando List.GetItemAtIndex.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
List.Reverse inverte l'ordine di tutte le voci di un elenco.
Per visualizzare correttamente l'elenco invertito di linee, creare più linee modificando Code Block in
0..1..#50;.Duplicare il nodo Line.ByStartPointEndPoint, inserire un nodo List.Reverse tra Curve.PointAtParameter e il secondo Line.ByStartPointEndPoint.
Utilizzare i nodi Watch 3D per visualizzare in anteprima due risultati diversi. Il primo mostra il risultato senza un elenco invertito. Le linee si collegano verticalmente ai punti adiacenti. L'elenco invertito, tuttavia, collegherà tutti i punti all'ordine opposto nell'altro elenco.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
List.ShiftIndices è un buono strumento per creare torsioni o modelli elicoidali o qualsiasi altra manipolazione di dati simile. Questo nodo sposta le voci di un elenco in base ad un determinato numero di indici.
Nello stesso processo dell'elenco inverso, inserire List.ShiftIndices in Curve.PointAtParameter e Line.ByStartPointEndPoint.
Utilizzando un Code Block, è stato designato un valore di "1" per spostare l'elenco in base ad un indice.
Notare che la modifica è lieve, ma tutte le linee nel nodo Watch 3D inferiore sono state spostate in base ad un indice quando vengono collegate all'altro gruppo di punti.
Modificando Code Block in un valore superiore, ad esempio "30", si noterà una differenza significativa nelle linee diagonali. In questo caso, lo spostamento funziona come il diaframma di una fotocamera, creando una torsione nella forma cilindrica originale.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
List.FilterByBooleanMask rimuoverà alcune voci in base ad un elenco di valori booleani o valori che riportano "true" o "false".
Per creare un elenco di valori che riportano "true" o "false", è necessario un po' più di lavoro.
Utilizzando un Code Block, definire un'espressione con la sintassi:
0..List.Count(list);. Collegare il nodo Curve.PointAtParameter all'input list. Si esaminerà in maniera dettagliata questa configurazione nel capitolo sul blocco di codice, ma in questo caso la riga di codice fornisce un elenco che rappresenta ogni indice del nodo Curve.PointAtParameter.Utilizzando un nodo %** (modulo)**, collegare l'output di Code Block all'input x e un valore di 4 all'input y. Questo fornirà il resto quando si divide l'elenco di indici per 4. % (modulo) è un nodo molto utile per la creazione di modelli. Tutti i valori verranno letti come possibili resti di 4: 0, 1, 2, 3.
Dal nodo %** (modulo)**, si sa che un valore di 0 indica che l'indice è divisibile per 4 (0, 4, 8 e così via). Utilizzando un nodo = =, è possibile verificare la divisibilità provando con un valore di "0".
Il nodo Watch mostra solo questo: è presente un modello true/false che riporta: true, false, false, false....
Utilizzando questo modello true/false, collegarlo all'input mask di due nodi List.FilterByBooleanMask.
Collegare il nodo Curve.PointAtParameter ad ogni input list per List.FilterByBooleanMask.
L'output di Filter.ByBooleanMask riporta "in" e "out". "In" rappresenta i valori che hanno un valore mask di "true", mentre "out" rappresenta i valori che hanno un valore di "false". Collegando gli output "in" agli input startPoint ed endPoint di un nodo Line.ByStartPointEndPoint, è stato creato un elenco filtrato di linee.
Il nodo Watch 3D mostra che le linee sono minori dei punti. È stato selezionato solo il 25% dei nodi filtrando solo i valori true.
Foto di
Per rendere le cose più complicate, aggiungere ancora più livelli alla gerarchia. La struttura di dati può essere espansa ben oltre un elenco bidimensionale di elenchi. Poiché gli elenchi sono elementi di per sé in Dynamo, è possibile creare dati con il maggior numero possibile di quote.
Qui come analogia si utilizzeranno le bambole matrioske russe. Ogni elenco può essere considerato come un contenitore contenente più elementi. Ogni elenco ha le sue proprietà ed è anche considerato come il suo oggetto.
Una serie di bambole matrioske russe (foto di Zeta) è un'analogia per gli elenchi n-dimensionali. Ogni livello rappresenta un elenco e ogni elenco contiene voci al suo interno. Nel caso di Dynamo, ogni contenitore può avere più contenitori all'interno (che rappresentano le voci di ogni elenco).
Gli elenchi n-dimensionali sono difficili da spiegare visivamente, ma in questo capitolo sono stati creati alcuni esercizi che si concentrano sull'utilizzo di elenchi che si estendono per oltre due dimensioni.
Il mappaggio è probabilmente la parte più complessa della gestione di dati in Dynamo ed è particolarmente importante quando si utilizzano gerarchie complesse di elenchi. Con la serie di esercizi riportati di seguito, sarà illustrato quando utilizzare il mappaggio e le combinazioni quando i dati diventano multidimensionali.
Le introduzioni preliminari di List.Map e List.Combine sono disponibili nella sezione precedente. Nell'ultimo esercizio riportato di seguito, questi nodi verranno utilizzati in una struttura di dati complessa.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Questo esercizio è il primo di una serie di tre che si concentra sull'articolazione della geometria importata. Ogni parte di questa serie di esercizi incrementerà la complessità della struttura di dati.
Si inizia con il file .sat nella cartella dei file degli esercizi. È possibile selezionare questo file utilizzando il nodo File Path.
Con Geometry.ImportFromSAT, la geometria viene importata nell'anteprima di Dynamo come due superfici.
Per questo esercizio, si desidera eseguire una procedura semplice e utilizzare una delle superfici.
Selezionare l'indice di 1 per acquisire la superficie superiore. Questa operazione viene eseguita con il nodo List.GetItemAtIndex.
Disattivare l'anteprima della geometria dall'anteprima di Geometry.ImportFromSAT.
Il passaggio successivo consiste nel dividere la superficie in una griglia di punti.
1. Utilizzando Code Block, inserire queste due righe di codice:
0..1..#10;0..1..#5;.2. Con Surface.PointAtParameter, collegare i due valori di Code Block a u e v. Modificare il collegamento di questo nodo in Globale.
3. L'output mostra la struttura di dati, visibile anche nell'anteprima di Dynamo.
Quindi, utilizzare i punti dell'ultimo passaggio per generare dieci curve lungo la superficie.
Per esaminare come è organizzata la struttura di dati, collegare NurbsCurve.ByPoints all'output di Surface.PointAtParameter.
Per ora, è possibile disattivare l'anteprima del nodo List.GetItemAtIndex per ottenere un risultato più chiaro.
Un nodo List.Transpose di base inverte le colonne e le righe di un elenco di elenchi.
Collegando l'output di List.Transpose a NurbsCurve.ByPoints, si ottengono cinque curve che percorrono orizzontalmente la superficie.
È possibile disattivare l'anteprima del nodo NurbsCurve.ByPoints nel passaggio precedente per ottenere lo stesso risultato nell'immagine.
Viene aumentata la complessità. Si supponga di voler eseguire un'operazione sulle curve create nell'esercizio precedente. Forse si desidera correlare queste curve ad un'altra superficie ed eseguire il loft tra di esse. Ciò richiede maggiore attenzione alla struttura di dati, ma la logica sottostante è la stessa.
Iniziare con un passaggio dell'esercizio precedente, isolando la superficie superiore della geometria importata con il nodo List.GetItemAtIndex.
Utilizzando Surface.Offset, eseguire l'offset della superficie di un valore di 10.
Allo stesso modo dell'esercizio precedente, definire un Code Block con queste due righe di codice:
0..1..#10;0..1..#5;.Collegare questi output a due nodi Surface.PointAtParameter, ciascuno con il collegamento impostato su Globale. Uno di questi nodi è collegato alla superficie originale, mentre l'altro è collegato alla superficie di offset.
Disattivare l'anteprima di queste superfici.
Come nell'esercizio precedente, collegare gli output a due nodi NurbsCurve.ByPoints. Il risultato mostra le curve corrispondenti a due superfici.
Utilizzando List.Create, è possibile combinare i due gruppi di curve in un elenco di elenchi.
Notare dall'output che sono presenti due elenchi con dieci voci ciascuno, che rappresentano ogni serie di curve NURBS collegate.
Se si esegue Surface.ByLoft, è possibile rendere visivamente chiara questa struttura di dati. Il nodo esegue il loft di tutte le curve in ogni sottoelenco.
Disattivare l'anteprima del nodo Surface.ByLoft nel passaggio precedente.
Utilizzando List.Transpose, tenere presente che si stanno invertendo tutte le colonne e le righe. Questo nodo trasferirà due elenchi di dieci curve in dieci elenchi di due curve. Ora si ha ogni curva NURBS correlata alla curva adiacente sull'altra superficie.
Utilizzando Surface.ByLoft, si arriva a una struttura con nervatura.
Successivamente, verrà illustrato un processo alternativo per ottenere questo risultato.
Prima di iniziare, disattivare l'anteprima di Surface.ByLoft nel passaggio precedente per evitare confusione.
In alternativa a List.Transpose utilizzare List.Combine. In questo modo verrà eseguito un "combinatore" in ogni sottoelenco.
In questo caso, si utilizza List.Create come "combinatore", che crea un elenco di ogni voce nei sottoelenchi.
Utilizzando il nodo Surface.ByLoft, si ottengono le stesse superfici del passaggio precedente. La trasposizione è più semplice da utilizzare in questo caso, ma quando la struttura di dati diventa ancora più complessa, List.Combine è più affidabile.
Tornando indietro di alcuni passaggi, per cambiare l'orientamento delle curve nella struttura con nervatura, si desidera utilizzare List.Transpose prima di collegarsi a NurbsCurve.ByPoints. In questo modo verranno invertite le colonne e le righe, ottenendo 5 nervature orizzontali.
Adesso si farà un passo avanti. In questo esercizio, si utilizzeranno entrambe le superfici importate, creando una gerarchia di dati complessa. Tuttavia, il nostro obiettivo è completare la stessa operazione con la stessa logica sottostante.
Iniziare con il file importato dell'esercizio precedente.
Come nell'esercizio precedente, utilizzare il nodo Surface.Offset per eseguire l'offset di un valore di 10.
Notare dall'output che sono state create due superfici con il nodo di offset.
Allo stesso modo dell'esercizio precedente, definire un Code Block con queste due righe di codice:
0..1..#20;0..1..#20;.Collegare questi output a due nodi Surface.PointAtParameter, ciascuno con il collegamento impostato su Globale. Uno di questi nodi è collegato alle superfici originali, mentre l'altro è collegato alle superfici di offset.
Come nell'esercizio precedente, collegare gli output a due nodi NurbsCurve.ByPoints.
Osservando l'output di NurbsCurve.ByPoints, si noterà che questo è un elenco di due elenchi, che è più complesso rispetto all'esercizio precedente. I dati vengono suddivisi in categorie in base alla superficie sottostante, pertanto è stato aggiunto un altro livello ai dati strutturati.
Notare che le cose diventano più complesse nel nodo Surface.PointAtParameter. In questo caso abbiamo un elenco di elenchi di elenchi.
Prima di procedere, disattivare l'anteprima delle superfici esistenti.
Utilizzando il nodo List.Create, le curve NURBS vengono unite in una struttura di dati, creando un elenco di elenchi di elenchi.
Collegando un nodo Surface.ByLoft, si ottiene una versione delle superfici originali, in quanto ciascuna di esse rimane nel proprio elenco, così come è stata creata dalla struttura di dati originale.
Nell'esercizio precedente, è stato possibile utilizzare List.Transpose per creare una struttura a nervatura. Questo metodo non funzionerà qui. Una trasposizione deve essere utilizzata in un elenco bidimensionale e, poiché disponiamo di un elenco tridimensionale, un'operazione di "inversione di colonne e righe" non sarà facile. Tenere presente che gli elenchi sono oggetti, pertanto List.Transpose inverte gli elenchi con sottoelenchi, ma non inverte le curve NURBS ad un elenco inferiore nella gerarchia.
List.Combine funzionerà meglio in questo caso. Per ottenere strutture di dati più complesse, si desidera utilizzare i nodi List.Map e List.Combine.
Utilizzando List.Create come "combinatore", verrà creata una struttura di dati che funzionerà meglio.
La struttura di dati deve ancora essere trasposta ad un livello più basso nella gerarchia. Per eseguire questa operazione, utilizzare List.Map. Funziona come List.Combine, tranne che con un elenco di input, anziché due o più.
La funzione che verrà applicata a List.Map è List.Transpose, che consente di invertire le colonne e le righe dei sottoelenchi all'interno dell'elenco principale.
Infine, è possibile eseguire il loft delle curve NURBS con una gerarchia di dati corretta, restituendo una struttura con nervatura.
Aggiungere un po' di profondità alla geometria con un nodo Surface.Thicken con le impostazioni di input come mostrato.
Sarà utile aggiungere una superficie di supporto a questa struttura, quindi aggiungere un altro nodo Surface.ByLoft e utilizzare il primo output di NurbsCurve.ByPoints di un passaggio precedente come input.
Poiché l'anteprima sta diventando ingombra di oggetti, disattivare l'anteprima di questi nodi facendo clic con il pulsante destro del mouse su ciascuno di essi e deselezionare Anteprima per vedere meglio il risultato.
E con l'ispessimento di queste superfici selezionate, l'articolazione è completata.
Non è la sedia a dondolo più comoda di sempre, ma include molti dati.
Come ultimo passaggio, invertire la direzione dei membri striati. Dal momento che è stata utilizzata la trasposizione nell'esercizio precedente, si farà qualcosa di simile qui.
Poiché c'è un livello in più nella gerarchia, è necessario utilizzare List.Map con una funzione List.Tranpose per modificare la direzione delle curve NURBS.
Potrebbe essere necessario aumentare il numero di pedate, in modo da poter modificare Code Block in
0..1..#20;0..1..#30;.
La prima versione della sedia a dondolo era elegante, quindi il secondo modello offre una versione sportiva e informale della seduta.
