Dynamo
Primer for v2.0
Español
Español
  • Acerca de
  • Introducción
    • ¿Qué es Dynamo y cómo funciona?
    • Manual de introducción, comunidad y plataforma de Dynamo
  • Configuración de Dynamo
  • Interfaz de usuario
    • Espacio de trabajo
    • Biblioteca
  • Nodos y cables
  • Nodos y conceptos básicos
    • Índice de nodos
    • Geometría para el diseño computacional
      • Descripción general de la geometría
      • Vector, plano y sistema de coordenadas
      • Puntos
      • Curvas
      • Superficies
      • Sólidos
      • Mallas
    • Los bloques de construcción de los programas
      • Datos
      • Matemáticas
      • Lógica
      • Cadenas
      • Color
    • Diseño con listas
      • ¿Qué es una lista?
      • Trabajo con listas
      • Listas de listas
      • Listas de n dimensiones
    • Diccionarios en Dynamo
      • ¿Qué es un diccionario?
      • Nodos de diccionario
      • Diccionarios en bloques de código
      • Casos de uso de Revit
  • Nodos y paquetes personalizados
    • Nodos personalizados
      • Introducción a los nodos personalizados
      • Creación de un nodo personalizado
      • Publicación en la biblioteca
    • Paquetes
      • Introducción a los paquetes
      • Caso real de paquete: Kit de herramientas de malla
      • Desarrollo de un paquete
      • Publicación de un paquete
      • Importación de Zero-Touch
  • Dynamo para Revit
    • La conexión de Revit
    • Selección
    • Edición
    • Creación
    • Personalización
    • Documentación
  • Dynamo for Civil 3D
    • La conexión con Civil 3D
    • Introducción
    • Biblioteca de nodos
    • Flujos de trabajo de ejemplo
      • Carreteras
        • Colocación de farolas
      • Land
        • Colocación de servicios
      • Servicios
        • Renombrar estructuras
      • Raíl
        • Envolvente libre
      • Topografía
        • Administración de grupos de puntos
    • Temas avanzados
      • Enlace de objetos
      • Python y Civil 3D
    • Dynamo Player
    • Paquetes útiles
    • Recursos
  • Dynamo en Forma (beta)
    • Configurar Dynamo Player en Forma
    • Añadir y compartir gráficos en Dynamo Player
    • Ejecutar gráficos en Dynamo Player
    • Diferencias en el servicio de cálculo de Dynamo con la versión de escritorio de Dynamo
  • Codificación en Dynamo
    • Bloques de código y DesignScript
      • ¿Qué es un bloque de código?
      • Sintaxis de DesignScript
      • Abreviatura
      • Funciones
    • Geometría con DesignScript
      • Conceptos básicos de geometría con DesignScript
      • Primitivas geométricas
      • Matemáticas vectoriales
      • Curvas: puntos interpolados y de control
      • Traslación, rotación y otras transformaciones
      • Superficies: interpoladas, puntos de control, solevación y revolución
      • Parametrización geométrica
      • Intersección y recorte
      • Operaciones booleanas geométricas
      • Generadores de puntos de Python
    • Python
      • Nodos de Python
      • Python y Revit
      • Configurar su propia plantilla de Python
    • Cambios en el lenguaje
  • Prácticas recomendadas
    • Estrategias gráficas
    • Estrategias de creación de secuencias de comandos
    • Referencia de secuencias de comandos
    • Administración del programa
    • Trabajar de forma eficaz con grandes conjuntos de datos en Dynamo
  • Flujos de trabajo de ejemplo
    • Flujos de trabajo para empezar
      • Jarrón paramétrico
      • Puntos de atractor
    • Índice de conceptos
  • Guía de introducción para desarrolladores
    • Compilar Dynamo a partir del código fuente
      • Compilar DynamoRevit a partir del código fuente
      • Administración y actualización de dependencias en Dynamo
    • Desarrollo para Dynamo
      • Introducción
      • Caso real de Zero-Touch (nodo de rejilla)
      • Ejecución de secuencias de comandos de Python en nodos Zero-Touch (C#)
      • Conceptos avanzados de Zero-Touch
      • Personalización avanzada de nodos de Dynamo
      • Uso de tipos COM (interoperabilidad) en paquetes de Dynamo
      • Caso real de NodeModel (interfaz de usuario personalizada)
      • Actualización de paquetes y bibliotecas de Dynamo para Dynamo 2.x
      • Actualización de paquetes y bibliotecas de Dynamo para Dynamo 3.x
      • Extensiones
      • Definición de la organización de paquetes personalizados para Dynamo 2.0+
      • Interfaz de línea de comandos de Dynamo
      • Integración de Dynamo
      • Desarrollo para Dynamo for Revit
      • Publicar un paquete
      • Compilar un paquete desde Visual Studio
      • Extensiones como paquetes
    • Solicitudes de incorporación de cambios
    • Expectativas de las pruebas
    • Ejemplos
  • Apéndice
    • Preguntas frecuentes
    • Programación visual y Dynamo
    • Recursos
    • Notas de la versión
    • Paquetes útiles
    • Archivos de ejemplo
    • Mapa de integración de anfitriones
    • Descargar PDF
    • Métodos abreviados de teclado de Dynamo
Powered by GitBook
On this page
Edit on GitHub
Export as PDF
  1. Guía de introducción para desarrolladores
  2. Desarrollo para Dynamo

Ejecución de secuencias de comandos de Python en nodos Zero-Touch (C#)

PreviousCaso real de Zero-Touch (nodo de rejilla)NextConceptos avanzados de Zero-Touch

Last updated 1 month ago

Ejecución de secuencias de comandos de Python en nodos Zero-Touch (C#)

Si sabe cómo escribir secuencias de comandos en Python y desea obtener más funcionalidad de los nodos estándar de Python de Dynamo, podemos utilizar Zero-Touch para crear nuestros propios nodos. Comencemos con un ejemplo sencillo que nos permite pasar una secuencia de comandos de Python como una cadena a un nodo Zero-Touch donde se ejecuta la secuencia de comandos y se devuelve un resultado. Este caso real se basará en los recorridos y los ejemplos de la sección Introducción. Consulte estos ejemplos si es la primera vez que crea nodos Zero-Touch.

Un nodo Zero-Touch que ejecutará una cadena de secuencia de comandos de Python.

Motor de Python

Este nodo se basa en una instancia del motor de secuencias de comandos de IronPython. Para ello, debemos hacer referencia a algunos montajes adicionales. Siga los pasos que se indican a continuación para configurar una plantilla básica en Visual Studio:

  • Cree un nuevo proyecto de clase de Visual Studio.

  • Añada una referencia al archivo IronPython.dll, que se encuentra en C:\Program Files (x86)\IronPython 2.7\IronPython.dll.

  • Añada una referencia al archivo Microsoft.Scripting.dll, que se encuentra en C:\Program Files (x86)\IronPython 2.7\Platforms\Net40\Microsoft.Scripting.dll.

  • Incluya las instrucciones IronPython.Hosting y Microsoft.Scripting.Hosting using en la clase.

  • Añada un constructor privado vacío para evitar que se agregue un nodo adicional a la biblioteca de Dynamo con nuestro paquete.

  • Cree un nuevo método que utilice una única cadena como parámetro de entrada.

  • En este método, se creará una instancia de un nuevo motor de Python y un ámbito de secuencias de comandos vacío. Puede considerar este ámbito como variables globales de una instancia del intérprete de Python.

  • A continuación, llame a Execute en el motor que transfiere la cadena de entrada y el ámbito como parámetros

  • Por último, recupere y devuelva los resultados de la secuencia de comandos. Para ello, llame a GetVariable en el ámbito y transfiera el nombre de la variable desde la secuencia de comandos de Python que contiene el valor que intenta devolver. (Consulte el siguiente ejemplo para obtener más información).

El siguiente código proporciona un ejemplo del paso mencionado anteriormente. La compilación de la solución creará un nuevo archivo .dll ubicado en la carpeta bin del proyecto. Este archivo .dll ahora se puede importar en Dynamo como parte de un paquete o accediendo a File < Import Library....

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;

namespace PythonLibrary
{
    public class PythonZT
    {
        // Unless a constructor is provided, Dynamo will automatically create one and add it to the library
        // To avoid this, create a private constructor
        private PythonZT() { }

        // The method that executes the Python string
        public static string executePyString(string pyString)
        {
            ScriptEngine engine = Python.CreateEngine();
            ScriptScope scope = engine.CreateScope();
            engine.Execute(pyString, scope);
            // Return the value of the 'output' variable from the Python script below
            var output = scope.GetVariable("output");
            return (output);
        }
    }
}
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

cube = Cuboid.ByLengths(10,10,10);
volume = cube.Volume
output = str(volume)

Varias salidas

Una limitación de los nodos estándar de Python es que solo tienen un único puerto de salida, por lo que si deseamos devolver varios objetos, debemos crear una lista y recuperar cada objeto. Si modificamos el ejemplo anterior para devolver un diccionario, podemos añadir tantos puertos de salida como deseemos. Consulte la sección Devolución de varios valores de Conceptos avanzados de Zero-Touch para obtener información detallada sobre los diccionarios.

Este nodo nos permite devolver tanto el volumen del ortoedro como su centroide.

Vamos a modificar el ejemplo anterior con los siguientes pasos:

  • Añada una referencia a DynamoServices.dll desde el administrador de paquetes NuGet.

  • Además de los montajes anteriores, se incluyen System.Collections.Generic y Autodesk.DesignScript.Runtime.

  • Modifique el tipo de valor devuelto en el método para que se devuelva un diccionario que contendrá las salidas.

  • Cada salida se debe recuperar individualmente desde el ámbito (considere la posibilidad de configurar un bucle sencillo para conjuntos de salidas de mayor tamaño).

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
using System.Collections.Generic;
using Autodesk.DesignScript.Runtime;

namespace PythonLibrary
{
    public class PythonZT
    {
        private PythonZT() { }

        [MultiReturn(new[] { "output1", "output2" })]
        public static Dictionary<string, object> executePyString(string pyString)
        {
            ScriptEngine engine = Python.CreateEngine();
            ScriptScope scope = engine.CreateScope();
            engine.Execute(pyString, scope);
            // Return the value of 'output1' from script
            var output1 = scope.GetVariable("output1");
            // Return the value of 'output2' from script
            var output2 = scope.GetVariable("output2");
            // Define the names of outputs and the objects to return
            return new Dictionary<string, object> {
                { "output1", (output1) },
                { "output2", (output2) }
            };
        }
    }
}

También hemos añadido una variable de salida adicional (output2) a la secuencia de comandos de Python de ejemplo. Tenga en cuenta que estas variables pueden utilizar cualquier convención de nomenclatura legal de Python; la salida se ha utilizado estrictamente para brindar mayor claridad a este ejemplo.

import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *

cube = Cuboid.ByLengths(10,10,10);
centroid = Cuboid.Centroid(cube);
volume = cube.Volume
output1 = str(volume)
output2 = str(centroid)

La secuencia de comandos de Python devuelve la variable output, lo que significa que necesitaremos una variable output en la secuencia de comandos de Python. Utilice esta secuencia de comandos de ejemplo para probar el nodo en Dynamo. Si alguna vez ha utilizado el nodo de Python en Dynamo, debería resultarle familiar lo siguiente. Para obtener más información, consulte la .

sección sobre Python de Dynamo Primer
Un nodo Zero-Touch que ejecutará una cadena de secuencia de comandos de Python.
Este nodo nos permite devolver tanto el volumen del ortoedro como su centroide.