Dynamo
Primer for v2.0
Français
Français
  • À propos
  • Introduction
    • Qu’est-ce que Dynamo et comment fonctionne-t-il ?
    • Manuel d’utilisation du guide, communauté et plate-forme Dynamo
  • Configuration de Dynamo
  • Interface utilisateur
    • Espace de travail
    • Bibliothèque
  • Nœuds et fils
  • Nœuds et concepts essentiels
    • Index des nœuds
    • Géométrie pour la conception informatique
      • Présentation de la géométrie
      • Vecteur, plan et système de coordonnées
      • Points
      • Courbes
      • Surfaces
      • Solides
      • Maillages
    • Blocs de construction des programmes
      • Données
      • Math
      • Logique
      • Chaînes
      • Couleur
    • Conception avec des listes
      • Qu’est-ce qu’une liste
      • Utilisation des listes
      • Listes de listes
      • Listes à n dimensions
    • Dictionnaires dans Dynamo
      • Qu’est-ce qu’un dictionnaire ?
      • Nœuds de dictionnaire
      • Dictionnaires dans les blocs de code
      • Cas d’utilisation de Revit
  • Packages et nœuds personnalisés
    • Nœuds personnalisés
      • Présentation des nœuds personnalisés
      • Création d’un nœud personnalisé
      • Publication dans votre bibliothèque
    • Packages
      • Présentation des packages
      • Étude de cas de package – Mesh Toolkit
      • Développement d'un package
      • Publication d’un package
      • Importation Zero-Touch
  • Dynamo pour Revit
    • La connexion Revit
    • Sélection
    • Édition
    • Création
    • Personnalisation
    • Documentation
  • Dynamo for Civil 3D
    • La connexion de Civil 3D
    • Mise en route
    • Bibliothèque de nœuds
    • Exemples de workflows
      • Routes
        • Positionnement des lampadaires
      • Terrain
        • Positionnement des services
      • Réseaux techniques
        • Renommer des structures
      • Rail
        • Zone de dégagement
      • Topographie
        • Gestion des groupes de points
    • Concepts avancés
      • Liaison d’objet
      • Python et Civil 3D
    • Lecteur Dynamo
    • Packages utiles
    • Ressources
  • Version bêta de Dynamo dans Forma
    • Configurer Dynamo Player dans Forma
    • Ajouter et partager des graphes dans Dynamo Player
    • Exécuter des graphes dans Dynamo Player
    • Différences entre les services de calcul Dynamo et Dynamo Desktop
  • Codage dans Dynamo
    • Nœuds Code Block et DesignScript
      • Qu’est-ce qu’un bloc de code ?
      • Syntaxe DesignScript
      • Raccourci
      • Fonctions
    • Géométrie avec DesignScript
      • Concepts de base de la géométrie DesignScript
      • Primitives géométriques
      • Calcul vectoriel
      • Courbes : points de contrôle et interpolés
      • Conversion, rotation et autres transformations
      • Surfaces : interpolation, points de contrôle, lissage, révolution
      • Définition des paramètres géométriques
      • Intersection et ajustement
      • Opérations booléennes géométriques
      • Générateurs de points Python
    • Python
      • Nœuds Python
      • Python et Revit
      • Configuration de votre propre gabarit Python
    • Changements relatifs au langage
  • Conseils d’utilisation
    • Stratégies de graphiques
    • Stratégies de script
    • Références concernant la création et la gestion des scripts
    • Gestion de votre programme
    • Utilisation efficace de jeux de données volumineux dans Dynamo
  • Exemples de workflows
    • Workflows de mise en route
      • Vase paramétrique
      • Points d’attraction
    • Index de concept
  • Guide du développeur
    • Générer Dynamo à partir de la source
      • Générer DynamoRevit à partir de la source
      • Gestion et mise à jour des dépendances dans Dynamo
    • Développer pour Dynamo
      • Mise en route
      • Étude de cas Zero-Touch : nœud grille
      • Exécuter des scripts Python dans des nœuds Zero-Touch (C#)
      • Aller plus loin avec le Zero-Touch
      • Personnalisation avancée des nœuds Dynamo
      • Utilisation de types COM (interopérabilité) dans les packages Dynamo
      • Étude de cas de modèle de nœud : interface utilisateur personnalisée
      • Mise à jour des packages et des bibliothèques Dynamo pour Dynamo 2.x
      • Mise à jour des packages et des bibliothèques Dynamo pour Dynamo 3.x
      • Extensions
      • Définition de l’organisation des packages personnalisés pour Dynamo 2.0+
      • Interface en ligne de commande Dynamo
      • Intégration Dynamo
      • Développement pour Dynamo for Revit
      • Publier un package
      • Générer un package à partir de Visual Studio
      • Extensions en tant que packages
    • Demandes de tirage
    • Test des attentes
    • Exemples
  • Annexe
    • Questions fréquemment posées
    • Programmation visuelle et Dynamo
    • Ressources
    • Informations sur la nouvelle version
    • Packages utiles
    • Fichiers d’exemple
    • Carte d’intégration de l’hôte
    • Télécharger le PDF.
    • Raccourcis clavier de Dynamo
Powered by GitBook
On this page
  • Parent
  • Enfants
  • Exercice : Sphère par Z
Edit on GitHub
Export as PDF
  1. Codage dans Dynamo
  2. Nœuds Code Block et DesignScript

Fonctions

PreviousRaccourciNextGéométrie avec DesignScript

Last updated 2 years ago

Les fonctions peuvent être créées dans un bloc de code et rappelées ailleurs dans une définition Dynamo. Cela permet de créer un autre calque de contrôle dans un fichier paramétrique et de l'afficher en tant que version de texte d'un nœud personnalisé. Dans ce cas, le bloc de code "parent" est facilement accessible et peut être situé n'importe où sur le graphique. Aucun fil n'est nécessaire.

Parent

La première ligne comporte le mot clé "def", puis le nom de la fonction, puis les noms des entrées entre parenthèses. Les contreventements définissent le corps de la fonction et renvoient une valeur avec "return =". Les nœuds Code Block qui définissent une fonction ne disposent pas de ports d’entrée ou de sortie, car ils sont appelés à partir d’autres nœuds Code Block.

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

Enfants

Appelez la fonction avec un autre noeud Code Block dans le même fichier en donnant le nom et le même nombre d'arguments. Cela fonctionne comme les nœuds prêts à l’emploi de votre bibliothèque.

FunctionName(in1,in2);

Exercice : Sphère par Z

Téléchargez le fichier d’exemple en cliquant sur le lien ci-dessous.

Vous trouverez la liste complète des fichiers d'exemple dans l'annexe.

Dans cet exercice, vous allez créer une définition générique permettant d'obtenir des sphères à partir d'une liste de points d'entrée. Le rayon de ces sphères est défini par la propriété Z de chaque point.

Commencez par une plage de dix valeurs allant de 0 à 100. Connectez-les à un nœud Point.ByCoordinates afin de créer une ligne diagonale.

Créez un nœud Code Block et introduisez votre définition.

  1. Utilisez les lignes de code suivantes :

    def sphereByZ(inputPt)
    {
    
    };

Le terme inputPt est le nom donné pour représenter les points qui contrôlent la fonction. Pour l’instant, la fonction ne fait rien, mais vous allez la construire dans les étapes à venir.

  1. L’ajout de la fonction Code Block permet de placer un commentaire et une variable sphereRadius qui interroge la position Z de chaque point. N’oubliez pas que inputPt.Z n’a pas besoin de parenthèses comme méthode. Il s’agit d’une requête des propriétés d’un élément existant, donc aucune entrée n’est nécessaire :

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};
  1. Rappelez-vous la fonction créée dans un autre nœud Code Block. Si vous double-cliquez sur la zone de dessin pour créer un Code Block et que vous tapez sphereB, Dynamo suggère la fonction sphereByZ que vous avez définie. Votre fonction a été ajoutée à la bibliothèque Intellisense. Bien.

  1. Vous allez maintenant appeler la fonction et créer une variable appelée Pt afin de connecter les points créés dans les étapes précédentes :

    sphereByZ(Pt)
  2. La sortie ne contient que des valeurs nulles. Pourquoi ? Lorsque vous avez défini la fonction, vous avez calculé la variable sphereRadius, mais vous n’avez pas défini ce que la fonction doit renvoyer en tant que sortie. Vous pourrez résoudre ce problème à l’étape suivante.

  1. Une étape importante consiste à définir la sortie de la fonction en ajoutant la ligne return = sphereRadius; à la fonction sphereByZ.

  2. La sortie du nœud Code Block indique désormais les coordonnées Z de chaque point.

Modifiez la fonction Parent pour créer des sphères réelles.

  1. Commencez par définir une sphère avec la ligne de code suivante : sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);

  2. Ensuite, modifiez la valeur renvoyée pour la définir comme sphere au lieu de sphereRadius : return = sphere; Vous obtenez ainsi des sphères géantes dans l’aperçu de Dynamo.

1. Pour modifier la taille de ces sphères, mettez à jour la valeur sphereRadius en ajoutant un séparateur : sphereRadius = inputPt.Z/20;Les sphères distinctes sont maintenant visibles et la relation entre le rayon et la valeur Z devient plus claire.

  1. Sur le nœud Point.ByCoordinates, remplacez la liaison Liste la plus courte par Produit cartésien afin de créer une grille de points. La fonction sphereByZ reste pleinement effective, de sorte que tous les points créent des sphères avec des rayons fondés sur des valeurs Z.

  1. Pour tâter le terrain, connectez simplement la liste de nombres d’origine à l’entrée X de Point.ByCoordinates. Vous obtenez ainsi un cube de sphères.

  2. Remarque : si le calcul sur votre ordinateur prend beaucoup de temps, essayez de remplacer nº 10 par un autre élément, nº 5 par exemple.

N’oubliez pas que la fonction sphereByZ créée est générique. Vous pouvez donc rappeler l’hélice d’une leçon précédente et lui appliquer la fonction.

Dernière étape : déterminez le rapport des rayons avec un paramètre défini par l’utilisateur. Pour ce faire, vous devez créer une entrée pour la fonction et remplacer également le séparateur 20 par un paramètre.

  1. Remplacez la définition de sphereByZ par :

    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. Mettez à jour les nœuds Code Block enfant en ajoutant une variable ratio à l’entrée : sphereByZ(Pt,ratio); Connectez un curseur à la nouvelle entrée du nœud Code Block et modifiez la taille des rayons en fonction du rapport des rayons.

30KB
Functions_SphereByZ.dyn