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
  • Elemento principal
  • Elementos secundarios
  • Ejercicio: esfera por Z
Edit on GitHub
Export as PDF
  1. Codificación en Dynamo
  2. Bloques de código y DesignScript

Funciones

PreviousAbreviaturaNextGeometría con DesignScript

Last updated 2 years ago

Las funciones se pueden crear en un bloque de código y recuperar en cualquier parte de una definición de Dynamo. Esto crea otra capa de control en un archivo paramétrico y se puede ver como una versión de texto de un nodo personalizado. En este caso, se puede acceder fácilmente al bloque de código "principal", que se encuentra en cualquier parte del gráfico. No se necesitan cables.

Elemento principal

En la primera línea, aparece la palabra clave "def", después el nombre de la función y, a continuación, los nombres de las entradas entre paréntesis. Las llaves definen el cuerpo de la función. Se devuelve un valor con "return =". Los bloques de código que definen una función no tienen puertos de entrada o salida porque se invocan desde otros bloques de código.

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

Elementos secundarios

Invoque la función con otro bloque de código en el mismo archivo asignando el nombre y la misma cantidad de argumentos. Funciona igual que los nodos predefinidos de la biblioteca.

FunctionName(in1,in2);

Ejercicio: esfera por Z

Descargue el archivo de ejemplo. Para ello, haga clic en el vínculo siguiente.

En el Apéndice, se incluye una lista completa de los archivos de ejemplo.

En este ejercicio, crearemos una definición genérica que creará esferas a partir de una lista de entrada de puntos. El radio de estas esferas depende de la propiedad Z de cada punto.

Comencemos con un intervalo de diez valores que abarca de 0 a 100. Conecte estos nodos a un nodo Point.ByCoordinates para crear una línea diagonal.

Cree un bloque de código e introduzca nuestra definición.

  1. Utilice estas líneas de código:

    def sphereByZ(inputPt)
    {
    
    };

El parámetro inputPt es el nombre que se le ha asignado para representar los puntos que controlarán la función. En este momento, la función no realiza ninguna acción, pero la ampliaremos en los pasos siguientes.

  1. Al añadir la función de bloque de código, se coloca un comentario y una variable sphereRadius que consulta la posición Z de cada punto. Recuerde que inputPt.Z no necesita paréntesis como método. Se trata de una consulta de las propiedades de un elemento existente, por lo que no se necesita ninguna entrada:

def sphereByZ(inputPt,radiusRatio)
{
//get Z Value, ise ot to drive radius of sphere
sphereRadius=inputPt.Z;
};
  1. Ahora, vamos a recuperar la función que hemos creado en otro bloque de código. Si hacemos doble clic en el lienzo para crear un nuevo bloque de código y escribimos sphereB, observaremos que Dynamo sugiere la función sphereByZ que hemos definido. La función se ha añadido a la biblioteca de IntelliSense. ¡Genial!

  1. Ahora llamamos a la función y creamos una variable denominada Pt para conectar los puntos creados en los pasos anteriores:

    sphereByZ(Pt)
  2. En la salida, podemos observar que todos los valores son nulos. ¿Por qué ocurre eso? Al definir la función, calculamos la variable sphereRadius, pero no hemos definido qué debe devolver la función como una salida. Podemos solucionar esto en el siguiente paso.

  1. Un paso importante es definir la salida de la función mediante la adición de la línea return = sphereRadius; a la función sphereByZ.

  2. Ahora vemos que la salida del bloque de código nos proporciona las coordenadas Z de cada punto.

Ahora vamos a crear esferas reales mediante la edición de la función principal.

  1. Definamos primero una esfera con la siguiente línea de código: sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);.

  2. A continuación, cambiamos el valor de retorno para que sea sphere en lugar de sphereRadius: return = sphere;. Esto nos proporciona unas esferas gigantes en la vista preliminar de Dynamo.

1. Para reducir el tamaño de estas esferas, actualicemos el valor de sphereRadius mediante la adición de un divisor: sphereRadius = inputPt.Z/20;. Ahora podemos ver las esferas separadas y empezar a entender la relación entre el radio y el valor Z.

  1. En el nodo Point.ByCoordinates, al cambiar el encaje de Más corto a Producto vectorial, creamos una rejilla de puntos. La función sphereByZ sigue estando totalmente activa, por lo que todos los puntos crean esferas con radios basados en valores Z.

  1. Y, solo para tantear el terreno, conectamos la lista original de números a la entrada X de Point.ByCoordinates. Ahora tenemos un cubo de esferas.

  2. Nota: Si el cálculo tarda mucho en completarse en el equipo, pruebe a cambiar el valor #10 por un valor como #5.

Recuerde que la función sphereByZ que hemos creado es una función genérica, por lo que podemos recuperar la hélice de una lección anterior y aplicarle la función.

Como paso final, vamos a controlar la relación de radio con un parámetro definido por el usuario. Para ello, debemos crear una entrada nueva para la función y reemplazar el divisor 20 por un parámetro.

  1. Actualice la definición de 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. Actualice el bloque de código secundario mediante la adición de una variable "ratio" a la entrada: sphereByZ(Pt,ratio);. Conecte un control deslizante a la entrada de bloque de código recién creada y varíe el tamaño de los radios en función de la relación de radio.

30KB
Functions_SphereByZ.dyn