Una volta pronti ad approfondire lo sviluppo di programmi visivi, sarà necessario acquisire una comprensione più dettagliata degli elementi di base che si utilizzeranno. In questo capitolo sono presentati i concetti fondamentali relativi ai dati, ovvero gli oggetti che attraversano i fili del programma Dynamo.
Formalmente, una stringa è una sequenza di caratteri che rappresenta una costante letterale o un tipo di variabile. Informalmente, una stringa sta programmando un linguaggio per il testo. Sono stati utilizzati i numeri, sia interi che decimali, per determinare i parametri ed è possibile fare lo stesso con il testo.
Le stringhe possono essere utilizzate per una vasta gamma di applicazioni, tra cui la definizione di parametri personalizzati, l'annotazione di gruppi di documentazione e l'analisi tramite set di dati basati su testo. Il nodo String si trova in Core > Input Category.
I nodi di esempio riportati sopra sono stringhe. Un numero può essere rappresentato come una stringa, una lettera o un'intera matrice di testo.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
È possibile analizzare una grande quantità di dati rapidamente eseguendo una query sulle stringhe. Saranno descritte alcune operazioni di base che possono accelerare un workflow e aiutare ad ottenere l'interoperabilità del software.
Nell'immagine riportata di seguito è mostrata una stringa di dati proveniente da un foglio di calcolo esterno. La stringa rappresenta i vertici di un rettangolo nel piano XY. Si eseguiranno alcune operazioni di divisione delle stringhe nel mini-esercizio:
Il separatore ";" divide ogni vertice del rettangolo. In questo modo viene creato un elenco con 3 voci per ogni vertice.
Premendo il pulsante "+" al centro del nodo, si crea un nuovo separatore.
Aggiungere una stringa "," all'area di disegno e collegarla all'input del nuovo separatore.
Il risultato è ora un elenco di dieci voci. Il nodo viene prima diviso in base a separator0, quindi in base a separator1.
Sebbene possa sembrare che l'elenco di voci riportato sopra contenga numeri, tali elementi vengono comunque considerati come singole stringhe in Dynamo. Per creare punti, è necessario convertire il tipo di dati da una stringa in un numero. Questa operazione viene eseguita con il nodo String.ToNumber.
Questo nodo è semplice. Collegare i risultati di String.Split all'input. L'output non risulta diverso, ma il tipo di dati è ora un numero anziché una stringa.
Con alcune operazioni aggiuntive di base, ora si dispone di un triangolo disegnato in corrispondenza dell'origine in base all'input di stringa originale.
Poiché una stringa è un oggetto di testo generico, ospita un'ampia gamma di applicazioni. Si esamineranno alcune delle principali azioni in Core > String Category in Dynamo:
Questo metodo consente di unire insieme due stringhe in ordine. In questo modo, si acquisisce ogni stringa letterale in un elenco e si crea una stringa unita.
Nell'immagine seguente è rappresentata la concatenazione di tre stringhe:
Aggiungere o sottrarre stringhe alla concatenazione facendo clic sui pulsanti +/- al centro del nodo.
L'output fornisce una stringa concatenata, con spazi e segni di punteggiatura inclusi.
Il metodo di unione è molto simile a quello della concatenazione, tranne per il fatto che presenta un livello aggiunto di punteggiatura.
Se è stato utilizzato Excel, è possibile che sia stato notato un file CSV. Questo è l'acronimo di Comma Separated Values, ossia valori separati da virgola. Per creare una struttura dei dati simile, si potrebbe utilizzare una virgola (o in questo caso, due trattini) come separatore con il nodo String.Join.
Nell'immagine seguente è rappresentata l'unione di due stringhe:
L'input separator consente di creare una stringa che divide le stringhe unite.
In questo esercizio, si utilizzeranno i metodi di esecuzione delle query e manipolazione delle stringhe per analizzare l'ultima strofa di Fermandosi accanto a un bosco in una sera di neve di Robert Frost. Non è l'applicazione più pratica, ma aiuterà a cogliere le azioni concettuali delle stringhe mentre vengono applicate alle righe leggibili di ritmo e rima.
Iniziare con una stringa di base divisa della strofa. Si noti innanzitutto che la scrittura è formattata in base alle virgole. Questo formato verrà utilizzato per separare ogni riga in singoli elementi.
La stringa di base viene incollata in un nodo String.
Un altro nodo String viene utilizzato per indicare il separatore. In questo caso, si utilizza una virgola.
Un nodo String.Split viene aggiunto all'area di disegno e collegato alle due stringhe.
L'output ora mostra che le righe sono state separate in singoli elementi.
Ora, viene la parte interessante della poesia: le ultime due righe. La strofa originale era un elemento di dati. Questi dati sono stati separati in singoli elementi nel primo passaggio. Ora occorre cercare il testo in questione. E sebbene sia possibile farlo selezionando le ultime due voci dell'elenco, se si trattasse di un intero libro, non si vorrebbe leggere tutto e isolare manualmente gli elementi.
Invece di cercare manualmente, utilizzare un nodo String.Contains per eseguire una ricerca di un set di caratteri. Questa operazione è simile all'esecuzione del comando "Trova" in un elaboratore di testi. In questo caso, se all'interno della voce viene trovata una sottostringa, viene restituito "true" o "false".
Nell'input searchFor, definire una sottostringa che si sta cercando all'interno della strofa. Utilizzare un nodo String con il testo "And miles".
L'output fornisce un elenco di false e true. Questa logica booleana verrà utilizzata per filtrare gli elementi nel passaggio successivo.
List.FilterByBoolMask è il nodo che si desidera utilizzare per escludere false e true. L'output "in" restituisce le istruzioni con un input "mask" di "true", mentre l'output "out" restituisce quelle che sono "false".
L'output di "in" è come previsto e fornisce le due righe finali della strofa.
Ora, si desidera enfatizzare la ripetizione della strofa unendo insieme le due righe. Quando si visualizza l'output del passaggio precedente, si noterà che nell'elenco sono presenti due voci:
Utilizzando due nodi List.GetItemAtIndex, è possibile isolare le voci utilizzando i valori di 0 e 1 come l'input index.
L'output per ogni nodo fornisce, in ordine, le due righe finali.
Per unire questi due voci in una, utilizzare il nodo String.Join:
Dopo aver aggiunto il nodo String.Join, si noterà che è necessario un separatore.
Per creare il separatore, aggiungere un nodo String all'area di disegno e digitare una virgola.
L'output finale ha unito le ultime due voci in un unico elemento.
Può sembrare complesso isolare le ultime due righe ed è vero, perché le operazioni di stringa spesso richiedono un lavoro iniziale. Ma sono scalabili e possono essere applicate a set di dati di grandi dimensioni con relativa facilità. Se si lavora in modo parametrico con fogli di calcolo e interoperabilità, assicurarsi di tenere a mente le operazioni di stringa.
I dati sono gli oggetti dei nostri programmi. Viaggiano attraverso i fili, fornendo input per i nodi in cui vengono elaborati in una nuova forma di dati di output. Quindi si esaminerà la definizione di dati e la relativa struttura e si inizierà ad utilizzarli in Dynamo.
I dati sono un insieme di valori di variabili qualitative o quantitative. Il formato più semplice di dati è costituito da numeri quali 0, 3.14 o 17. Tuttavia, i dati possono anche essere di diversi tipi: una variabile che rappresenta numeri che cambiano (height), caratteri (myName), geometria (Circle) o un elenco di elementi di dati (1,2,3,5,8,13,...).
In Dynamo vengono aggiunti/inviati dati alle porte di input dei nodi, pertanto è possibile disporre di dati senza eseguire alcuna azione, ma per eseguire le azioni rappresentate dai nodi sono necessari i dati. Quando è stato aggiunto un nodo all'area di lavoro, se non sono stati forniti eventuali input, il risultato sarà una funzione, non il risultato dell'azione stessa.
Dati semplici
Dati ed esecuzione corretta di un'azione (un nodo)
Restituzione di una funzione generica tramite un'azione (nodo) senza input di dati
Attenzione ai valori null. Il tipo 'null' rappresenta l'assenza di dati. Sebbene si tratti di un concetto astratto, è probabile incontrarlo utilizzando la programmazione visiva. Se un'azione non crea un risultato valido, il nodo restituirà un valore null.
I test per i valori null e la rimozione dei valori null dalla struttura dei dati sono una parte fondamentale per la creazione di programmi efficienti.
Quando si è in presenza della programmazione visiva, è possibile generare molto rapidamente parecchi dati e richiedere un metodo per gestirne la gerarchia. Questo è il ruolo delle strutture dei dati, ovvero gli schemi organizzativi in cui si memorizzano i dati. Le specifiche delle strutture dei dati e il loro utilizzo variano a seconda del linguaggio di programmazione.
In Dynamo, si aggiunge la gerarchia ai dati tramite gli elenchi. Questo argomento verrà approfondito nei capitoli successivi. Si inizierà in maniera semplice:
Un elenco rappresenta una raccolta di elementi posizionati in una struttura di dati:
Ho cinque dita (elementi) sulla mia mano (elenco).
Ci sono dieci case (elementi) sulla mia strada (elenco).
Un nodo Number Sequence definisce un elenco di numeri utilizzando un input start, amount e step. Con questi nodi, sono stati creati due elenchi distinti di dieci numeri, uno che comprende 100-109 e un altro che include 0-9.
Il nodo List.GetItemAtIndex seleziona una voce di un elenco in corrispondenza di un indice specifico. Quando si sceglie 0, viene visualizzata la prima voce dell'elenco (in questo caso 100).
Applicando lo stesso processo al secondo elenco, si ottiene un valore di 0, la prima voce dell'elenco.
Ora si uniscono i due elenchi in uno utilizzando il nodo List.Create. Notare che il nodo crea un elenco di elenchi. Questa operazione modifica la struttura dei dati.
Quando si utilizza di nuovo List.GetItemAtIndex, con l'indice impostato su 0, si ottiene il primo elenco nell'elenco di elenchi. Questo è ciò che significa considerare un elenco come voce, che è in qualche modo diverso da altri linguaggi di scripting. Nei capitoli successivi verranno fornite informazioni più avanzate sulla manipolazione degli elenchi e sulla struttura dei dati.
Il concetto chiave da comprendere sulla gerarchia dei dati in Dynamo: rispetto alla struttura dei dati, gli elenchi vengono considerati come voci. In altre parole, Dynamo funziona con un processo dall'alto in basso per la comprensione delle strutture dei dati. Ciò che cosa significa? Si esaminerà un esempio.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
In questo primo esempio, si assembla un cilindro svuotato che mostra la gerarchia della geometria descritta in questa sezione.
1. Aggiungere Point.ByCoordinates: dopo aver aggiunto il nodo all'area di disegno, viene visualizzato un punto in corrispondenza dell'origine della griglia di anteprima di Dynamo. I valori di default degli input x, y e z sono 0.0, per fornire un punto in questa posizione.
2. Plane.ByOriginNormal: il passaggio successivo nella gerarchia della geometria è un piano. Esistono diversi modi per costruire un piano e si sta utilizzando un'origine e una normale per l'input. L'origine è il nodo del punto creato nel passaggio precedente.
Vector.ZAxis: questo è un vettore unitario nella direzione z. Notare che non sono presenti input, ma solo un vettore di valore [0,0,1]. Viene utilizzato come input normal per il nodo Plane.ByOriginNormal. In questo modo si ottiene un piano rettangolare nell'anteprima di Dynamo.
3. Circle.ByPlaneRadius: passando al livello superiore nella gerarchia, a questo punto si crea una curva dal piano del passaggio precedente. Dopo il collegamento al nodo, si ottiene un cerchio in corrispondenza dell'origine. Il raggio di default sul nodo è il valore di 1.
4. Curve.Extrude: ora è possibile far comparire questo oggetto assegnandogli profondità e rendendolo tridimensionale. Questo nodo crea una superficie da una curva tramite l'estrusione. La distanza di default sul nodo è 1. Nella finestra dovrebbe essere visualizzato un cilindro.
5. Surface.Thicken: questo nodo fornisce un solido chiuso eseguendo l'offset della superficie ad una determinata distanza e chiudendo la forma. Il valore dello spessore di default è 1. Nella finestra viene visualizzato un cilindro svuotato in linea con questi valori.
6. Number Slider: anziché utilizzare i valori di default per tutti questi input, aggiungere al modello un controllo parametrico.
Modifica del dominio: dopo aver aggiunto il dispositivo di scorrimento numerico all'area di disegno, fare clic sull'accento circonflesso in alto a sinistra per visualizzare le opzioni di dominio.
Min/Max/Step - modificare rispettivamente i valori min, max e step in 0,2 e 0.01. Questa operazione consente di controllare la dimensione della geometria complessiva.
7. Number Slider: in tutti gli input di default, copiare e incollare questo dispositivo di scorrimento numerico (selezionare il dispositivo di scorrimento, premere CTRL+C, quindi CTRL+V) più volte, finché tutti gli input con valori di default non mostreranno un dispositivo di scorrimento. Alcuni dei valori del dispositivo di scorrimento devono essere maggiori di zero per far funzionare la definizione (ossia, è necessaria una profondità di estrusione per avere una superficie da ispessire).
8. Ora è stato creato un cilindro svuotato parametrico con questi dispositivi di scorrimento. Provare a regolare alcuni di questi parametri e vedere l'aggiornamento dinamico della geometria nella finestra di Dynamo.
Dispositivi di scorrimento: per fare un ulteriore passo avanti, sono stati aggiunti molti dispositivi di scorrimento all'area di disegno e occorre ripulire l'interfaccia dello strumento appena creato. Fare clic con il pulsante destro del mouse su un dispositivo di scorrimento, selezionare Rinomina e assegnare ad ogni dispositivo di scorrimento il nome appropriato per il relativo parametro (thickness, radius, height, etc).
9. A questo punto, è stato creato un fantastico cilindro ispessito. Attualmente, questo è un oggetto. Si può vedere come creare una serie di cilindri che restano dinamicamente collegati. Per eseguire questa operazione, si creerà un elenco di cilindri, anziché utilizzare un singolo elemento.
Aggiunta (+): l'obiettivo è aggiungere una fila di cilindri accanto al cilindro creato. Se si desidera aggiungere un cilindro adiacente a quello corrente, è necessario considerare sia il raggio del cilindro che lo spessore dell'involucro. Si ottiene questo numero aggiungendo i due valori dei dispositivi di scorrimento.
10. Questo passaggio è più complicato, quindi occorre esaminarlo lentamente: l'obiettivo finale è creare un elenco di numeri che definiscano le posizioni di ogni cilindro in una riga.
a. Moltiplicazione (*): per prima cosa, si desidera moltiplicare il valore del passaggio precedente per 2. Il valore del passaggio precedente rappresenta un raggio e si desidera spostare il cilindro in base al diametro completo.
b. Number Sequence: viene creata una serie di numeri con questo nodo. Il primo input è il nodo della moltiplicazione del passaggio precedente che viene collegato al valore step. Il valore start può essere impostato su 0.0 utilizzando un nodo Number.
c. Dispositivo di scorrimento di numeri interi: per il valore amount, collegare un dispositivo di scorrimento di numeri interi. In questo modo si definirà il numero di cilindri creati.
d. Output: questo elenco mostra la distanza di spostamento per ogni cilindro nella serie e viene parametricamente determinato dai dispositivi di scorrimento originali.
11. Questo passaggio è abbastanza semplice: collegare la sequenza definita nel passaggio precedente all'input x del nodo Point.ByCoordinates originale. Questa operazione sostituirà il dispositivo di scorrimento pointX che è possibile eliminare. Ora nella finestra è visibile una serie di cilindri (assicurarsi che il dispositivo di scorrimento di numeri interi sia maggiore di 0).
12. La catena di cilindri è ancora collegata dinamicamente a tutti i dispositivi di scorrimento. Regolare ogni dispositivo di scorrimento per controllare l'aggiornamento della definizione.
La logica, o più specificatamente, la logica condizionale, consente di specificare un'azione o un gruppo di azioni in base ad un test. Dopo aver valutato il test, sarà presente un valore booleano che rappresenta True o False che è possibile utilizzare per controllare il flusso del programma.
Le variabili numeriche possono memorizzare un intero intervallo di numeri diversi. Le variabili booleane possono memorizzare solo due valori indicati come True o False, Yes o No, 1 o 0. Per eseguire i calcoli, raramente vengono utilizzati valori booleani a causa del loro intervallo limitato.
L'istruzione "If" è un concetto chiave nella programmazione: "Se ciò è vero, allora accade questo, altrimenti succede qualcos'altro. L'azione risultante dell'istruzione è determinata da un valore booleano. Esistono diversi modi per definire un'istruzione "If" in Dynamo:
| Icona | Nome (Sintassi) | Input | Output |
|---|
Si esaminerà un breve esempio per ciascuno di questi tre nodi in azione utilizzando l'istruzione "If" condizionale.
In questa immagine, Boolean è impostato su True, ovvero il risultato è una stringa che riporta: "This is the result if true”. I tre nodi che creano l'istruzione If funzionano in modo identico in questo contesto.
Anche in questo caso, i nodi funzionano in modo identico. Se Boolean viene modificato in False, il risultato è il numero Pi, come definito nell'istruzione If originale.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Si utilizzerà la logica per separare un elenco di numeri in un elenco di numeri pari e un elenco di numeri dispari.
a. Range: aggiungere un intervallo di numeri all'area di disegno.
b. Number: aggiungere tre nodi di numeri all'area di disegno. Il valore per ogni nodo Number deve essere: 0.000 per start, 10.000 per end e 1.000 per step.
c. Output: l'output è un elenco di 11 numeri da 0 a 10.
d. % (modulo): collegare Range a x e 2.000 a y. In questo modo viene calcolato il resto per ogni numero dell'elenco diviso per 2. L'output di questo elenco fornisce un elenco di valori alternati tra 0 e 1.
e. = = (test di uguaglianza): aggiungere un test di uguaglianza all'area di disegno. Collegare l'output del modulo all'input x e 0.000 all'input y.
f. Watch: l'output del test di uguaglianza è un elenco di valori alternati tra true e false. Questi sono i valori utilizzati per separare le voci dell'elenco. 0 (o true) rappresenta i numeri pari e (1 o false) rappresenta i numeri dispari.
g. List.FilterByBoolMask: questo nodo filtra i valori in due elenchi diversi in base al valore booleano di input. Collegare il nodo Range originale all'input list e l'output del test di uguaglianza all'input mask. L'output in rappresenta valori true, mentre l'output out rappresenta valori false.
h. Watch: il risultato è ora un elenco di numeri pari e un elenco di numeri dispari. Sono stati utilizzati operatori logici per separare gli elenchi in modelli.
Partendo dalla logica stabilita nel primo esercizio, si applicherà questa configurazione ad un'operazione di modellazione.
2. Partire dall'esercizio precedente con gli stessi nodi. Le uniche eccezioni (oltre a modificare il formato sono):
a. Utilizzare un nodo Sequence con questi valori di input.
b. È stato scollegato l'input list da List.FilterByBoolMask. Questi nodi verranno messi da parte per ora, ma saranno presto utili più avanti nell'esercizio.
3. Iniziare creando un gruppo separato del grafico come mostrato nell'immagine precedente. Questo gruppo di nodi rappresenta un'equazione parametrica per definire una curva di linea. Ecco alcune note:
a. Il primo Number Slider rappresenta la frequenza dell'onda, deve avere un minimo di 1, un massimo di 4 e un passo di 0.01.
b. Il secondo Number Slider rappresenta l'ampiezza dell'onda, deve avere un minimo di 0, un massimo di 1 e un passo di 0.01.
c. PolyCurve.ByPoints: se il diagramma dei nodi riportato sopra viene copiato, il risultato è una curva seno nella finestra di anteprima di Dynamo.
Il metodo indicato qui per gli input è questo: utilizzare i nodi Number per ottenere proprietà più statiche e i dispositivi di scorrimento numerici su quelle più flessibili. Si desidera mantenere l'intervallo di numeri originale definito all'inizio di questo passaggio. Tuttavia, la curva seno creata qui dovrebbe avere una certa flessibilità. È possibile spostare questi dispositivi di scorrimento per controllare l'aggiornamento della frequenza e dell'ampiezza della curva.
4. Si passerà alla definizione, quindi si osserverà il risultato finale in modo da poter fare riferimento a quello che si sta ottenendo. I primi due passaggi vengono eseguiti separatamente. Ora si desidera collegarli. Si utilizzerà la curva seno di base per determinare la posizione dei componenti della cerniera e si utilizzerà la logica true/false per alternare tra caselle di piccole dimensioni e caselle più grandi.
a. Math.RemapRange: utilizzando la sequenza numerica creata nel passaggio 02, creare una nuova serie di numeri riassociando l'intervallo. I numeri originali del passaggio 01 sono compresi tra 0 e 100. Questi numeri variano da 0 a 1, rispettivamente in base agli input newMin e newMax.
5. Creare un nodo Curve.PointAtParameter, quindi collegare l'output Math.RemapRange del passaggio 04 come il relativo input param.
Questo passaggio crea punti lungo la curva. I numeri sono stati riassociati da 0 a 1 perché l'input di param sta cercando valori in questo intervallo. Un valore di 0 rappresenta il punto iniziale, mentre un valore di 1 rappresenta i punti finali. Tutti i numeri compresi vengono valutati nell'intervallo [0,1].
6. Collegare l'output da Curve.PointAtParameter a List.FilterByBoolMask per separare l'elenco di indici pari e dispari.
a. List.FilterByBoolMask: collegare Curve.PointAtParameter del passaggio precedente all'input list.
b. Watch: un nodo di controllo per in e un nodo di controllo per out indicano che sono presenti due elenchi che rappresentano indici pari e indici dispari. Questi punti sono ordinati nello stesso modo sulla curva, che è possibile mostrare nel passaggio successivo.
7. Quindi, si utilizzerà il risultato dell'output di List.FilterByBoolMask nel passaggio 05 per generare geometrie con dimensioni in base ai relativi indici.
Cuboid.ByLengths: ricreare i collegamenti visti nell'immagine riportata sopra per ottenere una cerniera lungo la curva seno. Un cuboide qui è solo un parallelepipedo e si sta definendo la sua dimensione in base al punto della curva al centro del parallelepipedo stesso. La logica della divisione pari/dispari dovrebbe ora essere chiara nel modello.
a. a. Elenco di cuboidi in corrispondenza di indici pari.
b. b. Elenco di cuboidi in corrispondenza di indici dispari
Voila! È stato appena programmato un processo per definire le quote della geometria in base all'operazione logica illustrata in questo esercizio.
| Icona | Nome/Sintassi | Input | Output |
|---|
Object.IsNull | obj | booleano |
If (If) | test, true, false | risultato |
Formula (IF(x,y,z)) | x, y, z | risultato |
Code Block ((x?y:z);) | X, Y, Z | risultato |
Se il formato più semplice di dati è rappresentato dai numeri, il modo più semplice per correlare tali numeri è la matematica. Dai semplici operatori come la divisione fino alle funzioni trigonometriche e alle formule più complesse, la matematica è un ottimo modo per iniziare ad esplorare relazioni e modelli numerici.
Gli operatori sono un insieme di componenti che utilizzano funzioni algebriche con due valori di input numerico, che producono un valore di output (addizione, sottrazione, moltiplicazione, divisione e così via). Questi sono disponibili in Operators > Actions.
| Icona | Nome (Sintassi) | Input | Output |
|---|---|---|---|
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Combinare operatori e variabili per formare una relazione più complessa mediante le formule. Utilizzare i dispositivi di scorrimento per creare una formula che possa essere controllata con i parametri di input.
1. Creare una sequenza di numeri che rappresenta la "t" nell'equazione parametrica, pertanto si desidera utilizzare un elenco di dimensioni sufficienti per definire una spirale.
Number Sequence: definire una sequenza di numeri in base a tre input: start, amount e step.
2. Con il passaggio precedente è stato creato un elenco di numeri per definire il dominio parametrico. Quindi, creare un gruppo di nodi che rappresenta l'equazione della spirale aurea.
La spirale aurea viene definita come l'equazione:
L'immagine seguente rappresenta la spirale aurea sotto forma di programmazione visiva. Quando si scorre il gruppo di nodi, provare a prestare attenzione al parallelo tra il programma visivo e l'equazione scritta.
a. Number Slider: aggiungere due dispositivi di scorrimento numerici all'area di disegno. Questi dispositivi di scorrimento rappresenteranno le variabili a e b dell'equazione parametrica. Rappresentano una costante flessibile o parametri che è possibile regolare per ottenere il risultato desiderato.
b. Multiplication (*): il nodo della moltiplicazione è rappresentato da un asterisco. Questa opzione verrà utilizzata ripetutamente per collegare le variabili della moltiplicazione.
c. Math.RadiansToDegrees: i valori "t" devono essere convertiti in gradi per la loro valutazione nelle funzioni trigonometriche. Tenere presente che, in Dynamo, per default vengono utilizzati i gradi per valutare queste funzioni.
d. Math.Pow: come funzione di "t" e del numero "e" si crea la sequenza di Fibonacci.
e. Math.Cos e Math.Sin: queste due funzioni trigonometriche differenziano rispettivamente la coordinata x e la coordinata y di ogni punto parametrico.
f. Watch: ora è possibile vedere che l'output comprende due elenchi, che saranno le coordinate x e y dei punti utilizzati per generare la spirale.
Ora, la maggior parte dei nodi del passaggio precedente funzionerà correttamente, ma richiede molto lavoro. Per creare un workflow più efficiente, esaminare DesignScript per definire una stringa di espressioni di Dynamo in un nodo. In questa serie successiva di passaggi, verrà utilizzata l'equazione parametrica per disegnare la spirale di Fibonacci.
Point.ByCoordinates: collegare il nodo della moltiplicazione superiore all'input "x" e quello inferiore all'input "y". Viene visualizzata una spirale parametrica di punti sullo schermo.
Polycurve.ByPoints: collegare Point.ByCoordinates del passaggio precedente a points. È possibile lasciare connectLastToFirst senza input perché non si sta creando una curva chiusa. In questo modo si crea una spirale che passa per ogni punto definito nel passaggio precedente.
A questo punto è stata completata la spirale di Fibonacci. Da qui procedere ulteriormente con due esercizi separati, che si chiameranno Nautilus e Girasole. Si tratta di astrazioni di sistemi naturali, ma le due diverse applicazioni della spirale di Fibonacci saranno ben rappresentate.
Circle.ByCenterPointRadius: in questo caso, verrà utilizzato un nodo Circle con gli stessi input del passaggio precedente. Il valore di default del raggio è 1.0, pertanto viene visualizzato un output immediato dei cerchi. Diventa immediatamente evidente l'ulteriore divergenza dei punti rispetto all'origine.
Number Sequence: questa è la serie originale di "t". Collegando questo valore al valore del raggio di Circle.ByCenterPointRadius, i centri dei cerchi sono ancora più divergenti dall'origine, ma il raggio dei cerchi aumenta, creando uno stravagante grafico a forma di cerchio di Fibonacci.
Punti bonus se lo si rende 3D.
Ora che è stata creata una conchiglia Nautilus circolare, si può passare alle griglie parametriche. Si utilizzerà una rotazione di base sulla spirale di Fibonacci per creare una griglia di Fibonacci e il risultato verrà modellato dopo la crescita dei semi di girasole.
Come punto di partenza, iniziare con lo stesso passaggio dell'esercizio precedente: la creazione di una serie di punti della spirale con il nodo Point.ByCoordinates.
Quindi, seguire questi mini passaggi per generare una serie di spirali con rotazione diversa.
a. Geometry.Rotate: sono disponibili diverse opzioni di Geometry.Rotate; assicurarsi di aver scelto il nodo con geometry, basePlane e degrees come input. Collegare Point.ByCoordinates all'input geometry. Fare clic con il pulsante destro del mouse su questo nodo e verificare che il collegamento sia impostato su Globale.
b. Plane.XY: collegare all'input basePlane. Si ruoterà attorno all'origine, che è la stessa posizione della base della spirale.
c. Range: per l'input degrees, si desidera creare più rotazioni. È possibile farlo rapidamente con un componente di Range. Collegarlo all'input degrees.
d. Number: per definire l'intervallo di numeri, aggiungere tre nodi di numeri all'area di disegno in ordine verticale. Dall'alto verso il basso, assegnare rispettivamente i valori di 0.000, 360.000 e 120.000. Questi determinano la rotazione della spirale. Notare i risultati di output del nodo Range dopo aver collegato i tre nodi di numero al nodo stesso.
L'output sta iniziando a somigliare ad un vortice. Regolare alcuni dei parametri di Range e vedere come cambiano i risultati.
Modificare la dimensione di incremento del nodo Range da 120.000 a 36.600. Notare che in questo modo si creano più rotazioni e quindi si fornisce una griglia più densa.
Modificare la dimensione di incremento del nodo Range da 36.000 a 3.600. In questo modo si ottiene una griglia molto più densa e la direzionalità della spirale non è chiara. Ecco, è stato creato un girasole.
Add (+)
var[]...[], var[]...[]
var[]...[]
Subtract (-)
var[]...[], var[]...[]
var[]...[]
Multiply (*)
var[]...[], var[]...[]
var[]...[]
Divide (/)
var[]...[], var[]...[]
var[]...[]
Il colore è un ottimo tipo di dati per la creazione di effetti visivi accattivanti e per il rendering delle differenze nell'output del programma visivo in uso. Quando si utilizzano dati astratti e numeri variabili, a volte è difficile vedere cosa cambia e in che misura. Questa è un'ottima applicazione per i colori.
I colori in Dynamo vengono creati utilizzando gli input ARGB. Corrispondono ai canali alfa, rosso, verde e blu. L'alfa rappresenta la trasparenza del colore, mentre gli altri tre vengono utilizzati come colori primari per generare l'intero spettro dei colori.
| Icona | Nome (Sintassi) | Input | Output |
|---|---|---|---|
I colori nella tabella riportata di seguito eseguono una query sulle proprietà utilizzate per definire il colore: alfa, rosso, verde e blu. Notare che il nodo Color.Components fornisce tutti e quattro come output diversi, il che lo rende il nodo preferito per l'esecuzione di una query sulle proprietà di un colore.
| Icona | Nome (Sintassi) | Input | Output |
|---|---|---|---|
I colori nella tabella riportata di seguito corrispondono allo spazio colore HSB. La divisione del colore in tonalità, saturazione e luminosità è probabilmente più intuitiva per la modalità di interpretazione del colore. Quale colore dovrebbe essere? Quanto dovrebbe essere colorato? E quanto dovrebbe essere chiaro o scuro il colore? Si tratta rispettivamente della suddivisione di tonalità, saturazione e luminosità.
| Icona | Nome (Sintassi) | Input | Output |
|---|---|---|---|
L'intervallo di colori è simile al nodo Remap Range dell'esercizio #part-ii-from-logic-to-geometry: riassocia un elenco di numeri ad un altro dominio. Tuttavia, anziché il mappaggio ad un dominio di numeri, si associa ad una sfumatura di colore in base a numeri di input compresi tra 0 e 1.
L'attuale nodo funziona bene, ma può essere un po' complicato fare in modo che tutto funzioni la prima volta. Il modo migliore per acquisire familiarità con la sfumatura di colore consiste nel verificarla in modo interattivo. Ecco un rapido esercizio per esaminare come impostare una sfumatura con colori di output corrispondenti ai numeri.
Definire tre colori: utilizzando un nodo Code Block, definire rosso, verde e blu collegando le combinazioni appropriate di 0 e 255.
Creare l'elenco: unire i tre colori in un elenco.
Definire gli indici: creare un elenco per definire le posizioni dei grip di ciascun colore (comprese tra 0 e 1). Notare il valore di 0.75 per il verde. In questo modo il colore verde viene posizionato per 3/4 nella sfumatura orizzontale sul dispositivo di scorrimento Color Range.
Code Block: immettere i valori (compresi tra 0 e 1) da convertire in colori.
Il nodo Display.ByGeometry offre la possibilità di colorare la geometria nella finestra di Dynamo. Ciò è utile per separare diversi tipi di geometria, dimostrare un concetto parametrico o definire una legenda di analisi per la simulazione. Gli input sono semplici: geometry e color. Per creare una sfumatura come l'immagine riportata sopra, l'input color è collegato al nodo Color Range.
Il nodo Display.BySurfaceColors consente di associare dati su una superficie con il colore. Questa funzionalità introduce alcune straordinarie possibilità di visualizzazione dei dati ottenuti tramite l'analisi discreta, come quella solare, energetica e di prossimità. L'applicazione di colore ad una superficie in Dynamo è simile all'applicazione di una composizione ad un materiale in altri ambienti CAD. Si dimostrerà come utilizzare questo strumento nel breve esercizio riportato di seguito.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Questo esercizio si concentra sul controllo parametrico del colore in parallelo con la geometria. La geometria è un'elica di base, che è possibile definire di seguito utilizzando Code Block. Si tratta di un metodo rapido e semplice per creare una funzione parametrica; poiché l'attenzione è rivolta al colore (anziché alla geometria), si utilizza il blocco di codice per creare in modo efficiente l'elica senza sovraccaricare l'area di disegno. Il blocco di codice verrà utilizzato più frequentemente man mano che nella guida introduttiva si passa ad un argomento più avanzato.
Code Block: definire i due blocchi di codice con le formule indicate sopra. Si tratta di un metodo parametrico rapido per la creazione di una spirale.
Point.ByCoordinates: collegare i tre output del blocco di codice alle coordinate per il nodo.
Ora è presente una serie di punti che creano un'elica. Il passaggio successivo consiste nel creare una curva attraverso i punti in modo da poter visualizzare l'elica.
PolyCurve.ByPoints: collegare l'output Point.ByCoordinates all'input points per il nodo. Si ottiene una curva elicoidale.
Curve.PointAtParameter: collegare l'output PolyCurve.ByPoints all'input curve. Lo scopo di questo passaggio è creare un punto attrattore parametrico che scorre lungo la curva. Poiché la curva sta valutando un punto in corrispondenza di un parametro, sarà necessario immettere un valore param compreso tra 0 e 1.
Number Slider: dopo l'aggiunta all'area di disegno, modificare il valore min in 0.0, il valore max in 1.0 e il valore step in 0.01. Collegare l'output del dispositivo di scorrimento all'input param per Curve.PointAtParameter. Ora è visibile un punto per la lunghezza dell'elica, rappresentato da una percentuale del dispositivo di scorrimento (0 in corrispondenza del punto iniziale, 1 in corrispondenza del punto finale).
Una volta creato il punto di riferimento, verrà confrontata la distanza dal punto di riferimento ai punti originali che definiscono l'elica. Questo valore della distanza controllerà la geometria e il colore.
Geometry.DistanceTo: collegare l'output Curve.PointAtParameter all'input. Collegare Point.ByCoordinates all'input geometry.
Watch: l'output risultante mostra un elenco di distanze da ogni punto elicoidale al punto di riferimento lungo la curva.
Il passaggio successivo consiste nel controllare i parametri con l'elenco di distanze dai punti elicoidali al punto di riferimento. È possibile utilizzare questi valori della distanza per definire i raggi di una serie di sfere lungo la curva. Per mantenere le sfere ad una dimensione adatta, è necessario riassociare i valori per la distanza.
Math.RemapRange: collegare l'output Geometry.DistanceTo all'input numbers.
Code Block: collegare un blocco di codice con un valore di 0.01 all'input newMin e un blocco di codice con un valore di 1 all'input di newMax.
Watch: collegare l'output Math.RemapRange ad un nodo e l'output Geometry.DistanceTo ad un altro. Confrontare i risultati.
In questo passaggio è stato riassociato l'elenco di distanze in modo che siano un intervallo più piccolo. È possibile modificare i valori newMin e newMax in base alle esigenze specifiche. I valori verranno riassociati e avranno lo stesso rapporto di distribuzione nel dominio.
Sphere.ByCenterPointRadius: collegare l'output Math.RemapRange all'input radius e l'output Point.ByCoordinates originale all'input centerPoint.
Modificare il valore del dispositivo di scorrimento dei numeri e osservare la dimensione delle sfere aggiornate. Si ottiene una maschera di inserimento parametrica.
La dimensione delle sfere dimostra la serie parametrica definita da un punto di riferimento lungo la curva. Per controllare il colore, utilizzare lo stesso concetto per il raggio della sfera.
Color Range: aggiungere all'area di disegno. Quando si posiziona il cursore sull'input value, si noterà che i numeri richiesti sono compresi tra 0 e 1. È necessario riassociare i numeri dell'output Geometry.DistanceTo in modo che siano compatibili con questo dominio.
Sphere.ByCenterPointRadius: per il momento, disattivare l'anteprima in questo nodo (fare clic con il pulsante destro del mouse > Anteprima).
Math.RemapRange: questo processo dovrebbe essere noto. Collegare l'output Geometry.DistanceTo all'input numbers.
Code Block: analogamente ad un passaggio precedente, creare un valore di 0 per l'input newMin e un valore di 1 per l'input newMax. In questo caso, è possibile definire due output da un blocco di codice.
Color Range: collegare l'output Math.RemapRange all'input value.
Color.ByARGB: questa è la procedura che consente di creare due colori. Sebbene questo processo possa sembrare complesso, è identico ai colori RGB di un altro software. Per eseguirlo, occorre semplicemente utilizzare la programmazione visiva.
Code Block: creare due valori di 0 e 255. Collegare i due output ai due input Color.ByARGB come mostra l'immagine riportata sopra (o creare i due colori preferiti).
Color Range: l'input colors richiede un elenco di colori. È necessario creare questo elenco dai due colori creati nel passaggio precedente.
List.Create: unire i due colori in un elenco. Collegare l'output all'input colors per Color Range.
Display.ByGeometryColor: collegare Sphere.ByCenterPointRadius all'input geometry e Color Range all'input color. Si ottiene una sfumatura uniforme nel dominio della curva.
Se si modifica il valore di Number Slider di prima nella definizione, i colori e le dimensioni vengono aggiornati. In questo caso, i colori e la dimensione del raggio sono direttamente correlati: ora si dispone di un collegamento visivo tra due parametri.
Scaricare il file di esempio facendo clic sul collegamento seguente.
Un elenco completo di file di esempio è disponibile nell'Appendice.
Innanzitutto, è necessario creare (o fare riferimento ad) una superficie da utilizzare come input per il nodo Display.BySurfaceColors. In questo esempio si esegue il loft tra una curva seno e una curva coseno.
Questo gruppo di nodi sta creando punti lungo l'asse Z, quindi li disloca in base alle funzioni seno e coseno. Gli elenchi a due punti vengono quindi utilizzati per generare curve NURBS.
Surface.ByLoft: generare una superficie interpolata tra l'elenco di curve NURBS.
File Path: selezionare un file di immagine da campionare per i dati di pixel a valle.
Utilizzare File.FromPath per convertire il percorso del file in un file, quindi passare a Image.ReadFromFile per produrre un'immagine per il campionamento.
Image.Pixels: immettere un'immagine e fornire un valore di esempio da utilizzare lungo le quote X e Y dell'immagine.
Dispositivo di scorrimento: fornire valori di esempio per Image.Pixels.
Display.BySurfaceColors: associare la serie di valori del colore sulla superficie rispettivamente lungo X e Y.
Anteprima ravvicinata della superficie di output con campioni dalla risoluzione di 400 x 300
Colore ARGB (Color.ByARGB)
A,R,G,B
colore
Alfa (Color.Alpha)
colore
A
Rosso (Color.Red)
colore
R
Verde (Color.Green)
colore
G
Blu (Color.Blue)
colore
B
Componenti (Color.Components)
colore
A,R,G,B
Tonalità (Color.Hue)
colore
Tonalità
Saturazione (Color.Saturation)
colore
Saturazione
Luminosità (Color.Brightness)
colore
Luminosità
