Dynamo
Primer for v2.0
Italiano
Italiano
  • Informazioni
  • Introduzione
    • Che cos'è Dynamo e come funziona?
    • Guida introduttiva, comunità e piattaforma di Dynamo
  • Installazione per Dynamo
  • Interfaccia utente
    • Area di lavoro
    • Libreria
  • Nodi e fili
  • Nodi e concetti essenziali
    • Indice dei nodi
    • Geometria per la progettazione computazionale
      • Panoramica sulla geometria
      • Vettore, piano e sistema di coordinate
      • Punti
      • Curve
      • Superfici
      • Solidi
      • Mesh
    • Elementi di base dei programmi
      • Dati
      • Matematica
      • Logica
      • Stringhe
      • Colore
    • Progettazione con elenchi
      • Che cos'è un elenco?
      • Utilizzo di elenchi
      • Elenchi di elenchi
      • Elenchi n-dimensionali
    • Dizionari in Dynamo
      • Che cos'è un dizionario?
      • Nodi Dictionary
      • Dizionari nei blocchi di codice
      • Casi di utilizzo di Revit
  • Pacchetti e nodi personalizzati
    • Nodi personalizzati
      • Introduzione ai nodi personalizzati
      • Creazione di un nodo personalizzato
      • Pubblicazione nella libreria
    • Pacchetti
      • Introduzione ai pacchetti
      • Case study di un pacchetto - Mesh Toolkit
      • Sviluppo di un pacchetto
      • Pubblicazione di un pacchetto
      • Importazione zero-touch
  • Dynamo per Revit
    • Correlazione con Revit
    • Selezione
    • Modifica
    • Creazione
    • Personalizzazione
    • Documentazione
  • Dynamo for Civil 3D
    • Connessione a Civil 3D
    • Per iniziare
    • Libreria di nodi
    • Esempi di workflow
      • Strade
        • Posizionamento di lampioni
      • Gestione catastale
        • Posizionamento dei servizi
      • Impianti di pubblica utilità
        • Ridenominazione di strutture
      • Ferrovia
        • Sagoma dello spazio libero
      • Rilievi
        • Gestione di gruppi di punti
    • Argomenti avanzati
      • Unione di oggetti
      • Python e Civil 3D
    • Dynamo Player
    • Pacchetti utili
    • Risorse
  • Dynamo in Forma Beta
    • Impostazione di Dynamo Player in Forma
    • Aggiunta e condivisione di grafici in Dynamo Player
    • Esecuzione di grafici in Dynamo Player
    • Differenze tra Dynamo compute service e Desktop Dynamo
  • Codifica in Dynamo
    • Blocchi di codice e DesignScript
      • Cos'è un blocco di codice?
      • Sintassi di DesignScript
      • Sintassi abbreviata
      • Funzioni
    • Geometria con DesignScript
      • Nozioni di base della geometria DesignScript
      • Primitive geometriche
      • Matematica vettoriale
      • Curve: punti interpolati e di controllo
      • Traslazione, rotazione e altre trasformazioni
      • Superfici: punti interpolati e di controllo, loft, rivoluzione
      • Parametrizzazione geometrica
      • Intersezione e taglio
      • Operazioni booleane geometriche
      • Generatori di punti di Python
    • Python
      • Nodi Python
      • Python e Revit
      • Impostazione del modello di Python personalizzato
    • Modifiche al linguaggio
  • Procedure ottimali
    • Strategie sui grafici
    • Strategie di scripting
    • Riferimento per lo scripting
    • Gestione del programma
    • Utilizzo efficiente di set di dati di grandi dimensioni in Dynamo
  • Esempi di workflow
    • Introduzione ai workflow
      • Vaso parametrico
      • Punti attrattore
    • Indice concettuale
  • Guida introduttiva per sviluppatori
    • Compilazione di Dynamo dalla sorgente
      • Compilazione di DynamoRevit dalla sorgente
      • Gestione e aggiornamento delle dipendenze in Dynamo
    • Sviluppo per Dynamo
      • Per iniziare
      • Case study zero-touch - Nodo griglia
      • Esecuzione di script Python in nodi zero-touch (C#)
      • Ulteriori informazioni sul concetto di zero-touch
      • Personalizzazione avanzata dei nodi di Dynamo
      • Utilizzo di tipi COM (interoperabilità) nei pacchetti di Dynamo
      • Case study NodeModel - Interfaccia utente personalizzata
      • Aggiornamento di pacchetti e librerie di Dynamo per Dynamo 2.x
      • Aggiornamento di pacchetti e librerie di Dynamo per Dynamo 3.x
      • Estensioni
      • Definizione dell'organizzazione di pacchetti personalizzati (Dynamo 2.0 e versioni successive)
      • Interfaccia della riga di comando di Dynamo
      • Integrazione per Dynamo
      • Sviluppo per Dynamo for Revit
      • Pubblicazione di un pacchetto
      • Creazione di un pacchetto da Visual Studio
      • Estensioni come pacchetti
    • Richieste pull
    • Aspettative di test
    • Esempi
  • Appendice
    • Domande frequenti
    • Programmazione visiva e Dynamo
    • Risorse
    • Note di rilascio
    • Pacchetti utili
    • File di esempio
    • Mappa di integrazione host
    • Download del file PDF
    • Tasti di scelta rapida di Dynamo
Powered by GitBook
On this page
  • Parent
  • Elementi derivati
  • Esercizio: Sfera per Z
Edit on GitHub
Export as PDF
  1. Codifica in Dynamo
  2. Blocchi di codice e DesignScript

Funzioni

PreviousSintassi abbreviataNextGeometria con DesignScript

Last updated 2 years ago

Le funzioni possono essere create in un blocco di codice e richiamate in un altro punto della definizione di Dynamo. In questo modo viene creato un altro livello di controllo in un file parametrico e può essere visualizzato come versione basata su testo di un nodo personalizzato. In questo caso, il blocco di codice "principale" è facilmente accessibile e può essere posizionato ovunque nel grafico. Non sono necessari i fili.

Parent

La prima riga contiene la parola chiave "def", il nome della funzione e i nomi degli input tra parentesi. Le parentesi graffe definiscono il corpo della funzione. Restituiscono un valore con "return =". I blocchi di codice che definiscono una funzione non presentano porte di input o output, in quanto vengono chiamati da altri blocchi di codice.

/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};

Elementi derivati

Chiamano la funzione con un altro blocco di codice nello stesso file, assegnando lo stesso nome e lo stesso numero di argomenti. Funzionano come i nodi predefiniti nella libreria.

FunctionName(in1,in2);

Esercizio: Sfera per Z

Scaricare il file di esempio facendo clic sul collegamento seguente.

Un elenco completo di file di esempio è disponibile nell'Appendice.

In questo esercizio verrà eseguita una definizione generica che creerà sfere da un elenco di input di punti. Il raggio di queste sfere viene gestito dalla proprietà Z di ogni punto.

Iniziare con un numero di dieci valori compresi tra 0 e 100. Collegarli ai nodi Point.ByCoordinates per creare una linea diagonale.

Creare un Code Block e introdurre la definizione.

  1. Utilizzare queste righe di codice:

    def sphereByZ(inputPt)
    {
    
    };

inputPt è il nome fornito per rappresentare i punti che controlleranno la funzione. Per ora, la funzione non sta eseguendo alcuna operazione, ma si costruirà questa funzione nei prossimi passaggi.

  1. Alla funzione Code Block, si aggiungono un commento e una variabile sphereRadius che esegue una query sulla posizione Z di ogni punto. Tenere presente che inputPt.Z non richiede parentesi come metodo. Si tratta di una query sulle proprietà di un elemento esistente, pertanto non sono necessari input:

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};
  1. Ora, richiamare la funzione che è stata creata in un altro Code Block. Se si fa doppio clic sull'area di disegno per creare un nuovo Code Block e si digita sphereB, si noterà che Dynamo suggerisce la funzione sphereByZ definita. La funzione è stata aggiunta alla libreria di IntelliSense. Ottimo.

  1. Ora richiamare la funzione e creare una variabile denominata Pt per collegare i punti creati nei passaggi precedenti:

    sphereByZ(Pt)
  2. Dall'output si noterà che tutti i valori sono nulli. Perché? Quando è stata definita la funzione, si stava calcolando la variabile sphereRadius, ma non è stato definito che cosa la funzione dovrebbe restituire come output. È possibile risolvere il problema nel passaggio successivo.

  1. Un passaggio importante: è necessario definire l'output della funzione aggiungendo la riga return = sphereRadius; alla funzione sphereByZ.

  2. Ora si può vedere che l'output di Code Block fornisce le coordinate Z di ciascun punto.

Procedere alla creazione di sfere effettive modificando la funzione principale.

  1. Per prima cosa si definisce una sfera con la riga di codice: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);.

  2. Successivamente, si modifica il valore restituito in modo che sia sphere anziché sphereRadius: return = sphere;. In questo modo vengono restituite alcune sfere giganti nell'anteprima di Dynamo.

1. Per ridurre le dimensioni di queste sfere, aggiornare il valore sphereRadius aggiungendo un divisore: sphereRadius = inputPt.Z/20;. Ora è possibile vedere le sfere separate. Inizia ad avere un senso la relazione tra il raggio e il valore Z.

  1. Nel nodo Point.ByCoordinates, modificando il collegamento da Più breve a Globale, verrà creata una griglia di punti. La funzione sphereByZ è ancora attiva, per cui tutti i punti creano sfere con i raggi basati sui valori Z.

  1. E solo per fare delle prove, è necessario collegare l'elenco originale di numeri all'input X per Point.ByCoordinates. Ora si ottiene un cubo di sfere.

  2. Nota: se il calcolo al computer richiede molto tempo, provare a modificare #10 impostandolo su un valore simile a #5.

Tenere presente che la funzione sphereByZ che è stata creata è una funzione generica, pertanto è possibile richiamare l'elica da una lezione precedente e applicare la funzione ad essa.

Un passaggio finale: controllare il rapporto del raggio con un parametro definito dall'utente. A tale scopo, è necessario creare un nuovo input per la funzione e sostituire anche il divisore 20 con un parametro.

  1. Aggiornare la definizione di sphereByZ a:

    def sphereByZ(inputPt,radiusRatio)
    {
    //get Z Value, use it to drive radius of sphere
    sphereRadius=inputPt.Z/radiusRatio;
    //Define Sphere Geometry
    sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
    //Define output for function
    return sphere;
    };
  2. Aggiornare il Code Block degli elementi derivati aggiungendo una variabile ratio all'input: sphereByZ(Pt,ratio);. Collegare un dispositivo di scorrimento all'input Code Block appena creato e modificare la dimensione dei raggi in base al rapporto del raggio.

30KB
Functions_SphereByZ.dyn