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
Edit on GitHub
Export as PDF
  1. Annexe

Programmation visuelle et Dynamo

PreviousQuestions fréquemment poséesNextRessources

Last updated 2 years ago

Qu’est-ce que la programmation visuelle ?

L’activité de conception implique souvent l’établissement de relations visuelles, systémiques ou géométriques entre les différentes parties d’une conception. La plupart du temps, ces relations sont développées par des workflows qui permettent de passer du concept au résultat grâce à des règles. Sans le savoir, vous travaillez par le biais d'algorithmes, c'est-à-dire en définissant un ensemble d'actions progressives qui suivent une logique de base d'entrée, de traitement et de sortie. La programmation permet de travailler de cette façon, mais tout en appliquant des algorithmes.

Présentation des algorithmes

Même s’il offre de puissantes opportunités, le terme algorithme peut véhiculer quelques idées fausses. Les algorithmes peuvent générer des éléments inattendus, imprévisibles ou sympas, mais ils ne sont pas magiques. Ils sont en réalité assez simples, tels qu'ils sont. Prenez un exemple concret comme une grue en origami. Tout d’abord, prenez une feuille de papier carrée (entrée), puis suivez une série d’étapes de pliage (actions de traitement) afin d’obtenir une grue (sortie).

Grue en origami

Où est l’algorithme ? Il s’agit de l’ensemble d’étapes abstrait qu’il est possible de représenter de deux façons : textuellement ou graphiquement.

Instructions textuelles :

  1. Tout d’abord, prenez une feuille de papier carrée, la partie colorée vers le haut. Pliez la feuille en deux et ouvrez-la. Ensuite, pliez la feuille en deux de l'autre côté.

  2. Retournez la feuille, côté blanc vers le haut. Pliez la feuille en deux, marquez bien le pli et ouvrez la feuille, puis repliez-la dans l'autre sens.

  3. En utilisant les plis que vous avez faits, placez les 3 coins supérieurs du modèle vers le bas. Aplanissez le modèle.

  4. Pliez les rabats triangulaires supérieurs au centre, puis dépliez-lez.

  5. Pliez la partie supérieure du modèle vers le bas, marquez bien le pli et dépliez.

  6. Ouvrez le rabat supérieur du modèle en le ramenant vers le haut et en appuyant simultanément sur les côtés du modèle vers l'intérieur. Aplanissez et marquez bien le pli.

  7. Retournez le modèle et répétez les étapes 4 à 6 de l'autre côté.

  8. Pliez les rabats supérieurs vers le centre.

  9. Répétez l'opération de l'autre côté.

  10. Pliez les deux "jambes" du modèle vers le haut, marquez bien les plis, puis dépliez.

  11. Ramenez les "jambes" vers l'intérieur le long des plis que vous venez de faire.

  12. Ramenez les pointes à l'intérieur afin de créer une tête, puis pliez les ailes.

  13. Vous obtenez une grue.

Instructions graphiques :

Programmation définie

Ces séries d’instructions permettent toutes les deux de créer une grue, et si vous avez correctement suivi les étapes, vous avez appliqué un algorithme. La seule différence est la façon dont vous lisez l’application de cet ensemble d’instructions qui conduit à la programmation. La programmation, terme couramment employé pour la programmation informatique, consiste à formaliser le traitement d’une série d’actions dans un programme exécutable. Si vous écrivez les instructions susmentionnées (permettant de créer une grue) dans un format que votre ordinateur peut lire et exécuter, vous faites de la programmation.

La clé, mais aussi le premier obstacle de la programmation, est de s'appuyer sur une forme abstraite afin de communiquer efficacement avec son ordinateur. Cela prend la forme de n'importe quel langage de programmation, tel que JavaScript, Python ou C. Si vous pouvez écrire un ensemble d'instructions reproductibles, comme pour la grue en origami, vous n'avez besoin de le traduire que pour l'ordinateur. Vous êtes en passe de configurer l'ordinateur pour que ce dernier puisse créer une grue ou même une multitude de grues différentes où chacune varie légèrement. C’est la puissance de la programmation : l’ordinateur exécute plusieurs fois les tâches, ou ensembles de tâches, que vous lui affectez, sans délai ni erreur humaine.

Programmation visuelle définie

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.

Si vous étiez chargé d'écrire des instructions de pliage afin de créer une grue en origami, comment procéderiez-vous ? Voulez-vous les créer sous forme de graphiques, de texte ou une combinaison des deux ?

Si votre réponse contenait des graphiques, alors la programmation visuelle est certainement pour vous. Le processus est pratiquement le même pour la programmation que pour la programmation visuelle. Elles utilisent le même cadre d'application ; cependant, vous définissez les instructions et les relations de votre programme par le biais d'une interface utilisateur graphique (ou "visuelle"). Au lieu de taper du texte lié par syntaxe, vous connectez des nœuds pré-intégrés ensemble. Voici une comparaison de l’algorithme « dessiner un cercle par point » programmé avec des nœuds ou du code :

Programme visuel :

Programme textuel :

myPoint = Point.ByCoordinates(0.0,0.0,0.0);
x = 5.6;
y = 11.5;
attractorPoint = Point.ByCoordinates(x,y,0.0);
dist = myPoint.DistanceTo(attractorPoint);
myCircle = Circle.ByCenterPointRadius(myPoint,dist);

Résultats de l’algorithme :

La caractéristique visuelle de la programmation permet de réduire les obstacles à l’entrée et de communiquer fréquemment avec les concepteurs. Dynamo est intégré dans le paradigme de la programmation visuelle, mais vous verrez plus tard qu'il est également possible d'utiliser la programmation textuelle dans l'application.

Instructions relatives aux grues en origami
12KB
Visual Programming - Circle Through Point.dyn