Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Dynamo ha evolucionado desde sus orígenes como un complemento para BIM (Building Information Modeling) en Revit para convertirse en algo mucho más diverso. Ante todo, se trata de una plataforma que permite a los diseñadores explorar la programación visual, resolver problemas y crear sus propias herramientas. Comencemos nuestro viaje con Dynamo proporcionando algo de contexto: ¿qué es y cómo puedo utilizarlo?
La interfaz de usuario (IU) de Dynamo se organiza en cinco regiones principales. Aquí se ofrecerá una breve descripción general; analizaremos más detalladamente el espacio de trabajo y la biblioteca en las siguientes secciones.
Menús
Barra de herramientas
Biblioteca
Espacio de trabajo
Barra de ejecución
A continuación, se indican los menús de las funciones básicas de la aplicación Dynamo. Al igual que la mayoría del software de Windows, los dos primeros menús están relacionados con la administración de archivos, las operaciones de selección y la edición de contenido. El resto de los menús son más específicos de Dynamo.
La información general y la configuración se pueden encontrar en el menú desplegable Dynamo.
Acerca de: descubra la versión de Dynamo instalada en el equipo.
Acuerdo para recopilar datos de uso: esta opción le permite elegir compartir sus datos de usuario a fin de mejorar Dynamo.
Preferencias: incluye parámetros como, por ejemplo, la definición de la precisión del separador decimal de la aplicación y la calidad de renderización de la geometría.
Salir de Dynamo
Si no sabe cómo continuar, consulte el menú de Ayuda. Puede acceder a uno de los sitios web de referencia de Dynamo a través del navegador de Internet.
Para empezar: una breve introducción al uso de Dynamo.
Guías interactivas:
Muestras: archivos de ejemplo de referencia.
Diccionario de Dynamo: recurso con documentación sobre todos los nodos.
Sitio web de Dynamo: vea el proyecto de Dynamo en GitHub.
Wiki del proyecto Dynamo: visite la página wiki para obtener información sobre el desarrollo mediante la API de Dynamo con bibliotecas y herramientas.
Mostrar página de inicio: regrese a la página de inicio de Dynamo cuando se encuentre en un documento.
Informar de un error: abra una incidencia en GitHub.
La barra de herramientas de Dynamo contiene una serie de botones para acceder rápidamente a los archivos, así como a los comandos Deshacer (Ctrl + Z) y Rehacer (Ctrl + Y). En el extremo derecho, hay otro botón que exporta una instantánea del espacio de trabajo, lo que resulta muy útil para la documentación y el uso compartido.
La biblioteca de Dynamo es una colección de bibliotecas funcionales; cada una de ellas contiene nodos agrupados por categorías. Consta de bibliotecas básicas que se añaden durante la instalación por defecto de Dynamo. A medida que sigamos describiendo su uso, mostraremos cómo ampliar la funcionalidad básica con nodos personalizados y paquetes adicionales. En la sección Biblioteca, se ofrecerá información más detallada sobre cómo utilizarla.
El espacio de trabajo es el lugar en el que se crean los programas visuales; también puede cambiar su parámetro Vista preliminar para ver las geometrías 3D desde aquí. Para obtener más información, consulte Espacio de trabajo.
Ejecute la secuencia de comandos de Dynamo desde aquí. Haga clic en el icono desplegable del botón de ejecución para cambiar entre los distintos modos.
Automático: ejecuta la secuencia de comandos automáticamente. Los cambios se actualizan en tiempo real.
Manual: la secuencia de comandos solo se ejecuta cuando se hace clic en el botón "Ejecutar". Este modo es útil para realizar cambios en secuencias de comandos complejas y de gran tamaño.
Periódica: esta opción está atenuada por defecto. Solo está disponible cuando se utiliza el nodo DateTime.Now. Puede establecer el gráfico para que se ejecute automáticamente en el intervalo especificado.
Dynamo es una aplicación de que se puede descargar y ejecutar en modo "Sandbox" independiente o como un módulo de extensión para otro software como Revit, FormIt o Civil 3D.
Obtenga más información sobre la
Dynamo nos permite trabajar en un proceso de programación visual en el que conectaremos elementos para definir las relaciones y las secuencias de acciones que componen algoritmos personalizados. Podemos utilizar nuestros algoritmos con diferentes fines, desde el procesamiento de datos hasta la generación de geometría, todo en tiempo real y sin necesidad de escribir un ápice de código o code
.
Desde el uso de la programación visual para flujos de trabajo de proyectos hasta el desarrollo de herramientas personalizadas, Dynamo es un aspecto integral de una amplia variedad de aplicaciones interesantes.
Este manual de introducción incluye capítulos desarrollados con Mode Lab. Estos capítulos se centran en los conceptos básicos que necesita para empezar a trabajar y desarrollar sus propios programas visuales con Dynamo e influyen decisivamente en cómo llevar Dynamo a un nivel superior.
Este manual se ha diseñado para lectores de diferentes orígenes y con distintos niveles de habilidades. En las siguientes secciones, se ofrece información general sobre la configuración de Dynamo, la interfaz de usuario y los conceptos clave. Es recomendable que los nuevos usuarios aborden los siguientes temas:
Para los usuarios que deseen obtener información más exhaustiva de cada elemento, como un nodo específico y el concepto subyacente, abordaremos los conceptos básicos en su propio capítulo.
Si desea ver la demostración de los flujos de trabajo de Dynamo, hemos incluido algunos gráficos en la sección Flujos de trabajo de ejemplo. Siga las instrucciones que se adjuntan para crear sus propios gráficos de Dynamo.
En capítulos posteriores, se pueden encontrar más ejercicios específicos de los temas, ya que abordamos diferentes aspectos de Dynamo. Los ejercicios se suelen encontrar en la última sección de cada página.
Dynamo es una herramienta de programación visual para diseñadores, lo que nos permite crear herramientas que utilicen bibliotecas externas o cualquier producto de Autodesk que tenga una API. Dynamo Sandbox permite desarrollar programas en una aplicación de estilo "Sandbox". Y el ecosistema de Dynamo sigue creciendo.
El código fuente del proyecto es de código abierto, lo que nos permite ampliar su funcionalidad como deseemos. Eche un vistazo al proyecto en GitHub y examine los trabajos en curso de los usuarios que personalizan Dynamo.
Examine, bifurque y empiece a ampliar Dynamo en función de sus necesidades.
En Dynamo, los nodos son los objetos que se conectan para formar un programa visual. Cada nodo realiza una operación: en ocasiones, es algo tan sencillo como almacenar un número, o puede ser una acción más compleja, como crear o consultar geometría.
La mayoría de los nodos de Dynamo están compuestos por cinco partes. Aunque existen excepciones, como los nodos de entrada, la anatomía de cada nodo se puede describir como se indica a continuación:
Nombre: nombre del nodo con la convención de nomenclatura
Category.Name
.Cuerpo principal: el cuerpo principal del nodo. Al hacer clic con el botón derecho, se presentan opciones en el nivel de todo el nodo.
Puertos (entrada y salida): los receptores de los cables que proporcionan los datos de entrada al nodo, así como los resultados de la acción del nodo.
Valor por defecto (haga clic con el botón derecho en un puerto de entrada): algunos nodos tienen valores por defecto que se pueden utilizar o no.
Las entradas y las salidas de los nodos se denominan puertos y actúan como receptores de cables. Los datos entran por la izquierda en el nodo a través de los puertos y salen del nodo por la derecha después de que se haya ejecutado su operación.
Los puertos esperan recibir datos de un tipo determinado. Por ejemplo, al conectar un número como 2.75 a los puertos de un nodo Point.ByCoordinates, se creará correctamente un punto. Sin embargo, si se proporciona Red al mismo puerto, se producirá un error.
Consejo: Coloque el cursor sobre un puerto para ver la información de herramientas que contiene el tipo de datos esperado.
Etiqueta de puerto
Información de herramientas
Tipo de datos
Valor por defecto
Dynamo proporciona una indicación del estado de ejecución del programa visual mediante la renderización de los nodos con diferentes esquemas de color en función del estado de cada nodo. La jerarquía de estados sigue esta secuencia: Error > Advertencia > Información > Vista preliminar.
Al colocar el cursor sobre el nombre o los puertos, o al hacer clic con el botón derecho en ellos, se ofrecen información y opciones adicionales.
Entradas satisfactorias: un nodo con barras verticales azules sobre sus puertos de entrada está bien conectado y todas sus entradas se han conectado correctamente.
Entradas insatisfactorias: un nodo con una barra vertical roja sobre uno o más puertos de entrada debe tener esas entradas conectadas.
Función: un nodo que genera una función y tiene una barra vertical gris sobre un puerto de salida es un nodo de función.
Seleccionados: los nodos seleccionados actualmente se resaltan con un borde de color turquesa.
Inutilizados: un nodo azul translúcido está inutilizado, por lo que se suspende su ejecución.
Advertencia: una barra de estado amarilla debajo de los nodos indica un estado de advertencia, lo que significa que no tienen datos de entrada o que pueden tener tipos de datos incorrectos.
Error: una barra de estado roja debajo del nodo indica que este presenta un estado de error.
Información: la barra de estado azul debajo del nodo indica el estado de información, que ofrece detalles útiles sobre los nodos. Este estado se puede activar al aproximarse a un valor máximo admitido por el nodo, usar un nodo de forma que pueda afectar al rendimiento, etc.
Consejo: Con esta información de herramientas a mano, examine los nodos ascendentes para ver si el tipo de datos o la estructura de datos necesarios presentan errores.
Información de herramientas de advertencia: el valor "null" (nulo) o la falta de datos no se pueden considerar como doble, por ejemplo, un número.
Utilice el nodo Watch para examinar los datos de entrada.
El nodo Number ascendente almacena "Red", no un número.
En algunas situaciones, es posible que desee impedir la ejecución de determinados nodos del programa visual. Para ello, puede "bloquear" el nodo, que es una opción de su menú contextual.
Al bloquear un nodo, también se bloquean los nodos que están en el nivel inferior. En otras palabras, también se bloquearán todos los nodos que dependan de la salida de un nodo bloqueado.
Los cables se conectan entre nodos para crear relaciones y establecer el flujo de nuestro programa visual. Podemos considerarlos literalmente como cables eléctricos que transportan pulsos de datos de un objeto al siguiente.
Los cables conectan el puerto de salida de un nodo al puerto de entrada de otro nodo. Esta dirección establece el flujo de datos en el programa visual.
Los puertos de entrada se encuentran en el lado izquierdo de los nodos y los de salida se encuentran en el lado derecho, por lo que podemos afirmar que el flujo del programa se suele desplazar de izquierda a derecha.
Cree un cable. Para ello, haga clic con el botón izquierdo en un puerto y, a continuación, haga clic con el botón izquierdo en el puerto de otro nodo para crear una conexión. Durante el proceso de creación de una conexión, el cable se mostrará discontinuo y se ajustará para convertirse en líneas continuas cuando se establezca correctamente la conexión.
Los datos siempre fluirán a través de este cable desde la salida hasta la entrada. No obstante, podemos crear el cable en cualquier dirección en cuanto a la secuencia en la que se hace clic en los puertos conectados.
Con frecuencia, desearemos ajustar el flujo de programa de nuestro programa visual mediante la edición de las conexiones representadas por los cables. Para editar un cable, haga clic con el botón izquierdo en el puerto de entrada del nodo que ya está conectado. Ahora tiene dos opciones:
Cambie la conexión a un puerto de entrada; haga clic con el botón izquierdo en otro puerto de entrada.
Para eliminar el cable, retire el cable y haga clic con el botón izquierdo en el espacio de trabajo.
Vuelva a conectar varios cables. Para ello, mantenga pulsada la tecla Mayús mientras hace clic con el botón izquierdo.
Duplique un cable. Para ello, mantenga pulsada la tecla Ctrl mientras hace clic con el botón izquierdo.
Por defecto, nuestros cables se previsualizarán con un trazo gris. Cuando se selecciona un nodo, se renderizará cualquier cable de conexión con el mismo resaltado de color turquesa que el nodo.
Cable resaltado
Cable por defecto
Ocultar cables por defecto
Si prefiere ocultar los cables en el gráfico, vaya a Vista > Conectores > desmarque Mostrar conectores.
Con este parámetro, solo los nodos seleccionados y sus cables de unión se mostrarán resaltados en turquesa claro.
También puede ocultar el conductor seleccionado. Para ello, haga clic con el botón derecho en la salida Nodos > seleccione Ocultar cables.
En esta sección, presentamos los nodos básicos disponibles en la biblioteca de Dynamo que le ayudarán a crear su propio programa visual como un profesional.
: ¿cómo puedo trabajar con elementos geométricos en Dynamo? Explore varias formas de crear geometrías simples o complejas a partir de primitivas.
: ¿qué son los "datos" y qué tipos fundamentales puedo utilizar en mis programas? Además, aprenda a incorporar operaciones matemáticas y lógicas en el flujo de trabajo de diseño.
: ¿cómo administro y coordino las estructuras de datos? Obtenga más información sobre el concepto de lista y utilícelo para administrar de forma eficaz los datos de diseño.
: ¿qué son los diccionarios? Aprenda a utilizar diccionarios para buscar datos y valores específicos de resultados existentes.
Nuevo: cree un nuevo archivo .dyn.
Abrir: abra un archivo .dyn existente (espacio de trabajo) o un archivo .dyf (nodo personalizado).
Guardar/Guardar como: guarde el archivo .dyn o .dyf activo.
Deshacer: deshaga la última acción.
Rehacer: rehaga la siguiente acción.
Exportar espacio de trabajo como imagen: exporte el espacio de trabajo visible como un archivo PNG.
Los nodos y los cables son los componentes clave de Dynamo que impulsan el proceso de . Este ayuda a establecer relaciones visuales y sistémicas sólidas entre las piezas de un diseño. Con un simple clic del ratón, conecte fácilmente los nodos mientras desarrolla y optimiza el flujo de trabajo de diseño.
Dynamo no sería lo que es sin un grupo fiel de fervientes usuarios y colaboradores activos. Participe en la comunidad: siga el , añada su trabajo a la galería o hable de Dynamo en el .
Icono de encaje: indica la especificada para las entradas de lista coincidentes (se explicará detalladamente más adelante).
Vista preliminar desactivada: una barra de estado gris debajo del nodo y un icono de ojo indican que la vista preliminar de geometría del nodo está desactivada.
Si el programa visual contiene advertencias o errores, Dynamo proporcionará información adicional sobre el problema. Todos los nodos en amarillo también presentarán una información de herramientas sobre el nombre. Coloque el cursor sobre el icono de información de herramientas de advertencia o error para expandirlo.
El espacio de trabajo de Dynamo consta de cuatro elementos principales.
Todas las fichas activas
Modo de vista preliminar
Controles de zoom/encuadre
Nodo en el espacio de trabajo
Al abrir un nuevo archivo, se abrirá por defecto un nuevo espacio de trabajo de inicio.
Puede crear un nodo personalizado y abrirlo en un espacio de trabajo de nodos personalizados.
En cada ventana de Dynamo, solo se permite un espacio de trabajo de inicio, pero puede tener abiertos varios espacios de trabajo de nodos personalizados en las fichas.
Estos tres métodos se pueden utilizar para alternar entre distintas vistas preliminares:
a. Usar los iconos ubicados en la parte superior derecha
b. Hacer clic con el botón derecho
Cambiar de la vista preliminar 3D a la vista preliminar de gráfico
Cambiar de la vista preliminar de gráfico a la vista preliminar 3D
c. Usar los métodos abreviados de teclado (Ctrl+B)
Puede utilizar iconos o el ratón para desplazarse por cualquiera de los espacios de trabajo.
a. En el modo Vista preliminar de gráfico
Mediante iconos:
Mediante el ratón:
Hacer clic con el botón izquierdo: seleccionar
Hacer clic con el botón izquierdo y arrastrar: cuadro de selección para elegir varios nodos
Desplazamiento hacia arriba/abajo: ampliar/reducir
Pulsar con el botón central y arrastrar: encuadre
Hacer clic con el botón derecho en cualquier lugar del lienzo: abrir la búsqueda en el lienzo
b. En el modo Vista preliminar 3D
Mediante iconos:
Mediante el ratón:
Desplazamiento hacia arriba/abajo: ampliar/reducir
Pulsar con el botón central y arrastrar: encuadre
Hacer clic con el botón derecho y arrastrar: órbita
Haga clic con el botón izquierdo para seleccionar cualquier nodo.
Para seleccionar varios nodos, haga clic y arrastre para crear un cuadro de selección.
Vista preliminar de gráfico
Vista preliminar 3D
Ajustar en ventana
Ampliar
Reducir
Encuadre
Ajustar en ventana
Ampliar
Reducir
Encuadre
Órbita
Dynamo es un proyecto activo de desarrollo de código abierto. Obtenga la lista de software compatible con Dynamo.
Dynamo viene preinstalado en software como Revit3D, FormIt, Civil3D, etc.
Para obtener más información sobre el uso de Dynamo con un software específico, es recomendable consultar las siguientes secciones:
Si desea utilizar Dynamo como una aplicación independiente, siga leyendo para obtener instrucciones sobre cómo descargar Sandbox.
La aplicación Dynamo está disponible en el sitio web de Dynamo. Tanto las versiones oficiales como las preliminares o las anteriores están disponibles en la página de descarga. Visite la página Get Dynamo y haga clic en Download para obtener la versión oficial publicada.
Si busca versiones anteriores o de desarrollo de "vanguardia", todas las versiones se pueden encontrar en la sección inferior de la misma página.
El desarrollo de "vanguardia" puede incluir algunas funciones nuevas y experimentales que aún no se han probado completamente, por lo que pueden ser inestables. Al utilizar esta opción, puede detectar errores o problemas y ayudarnos a mejorar la aplicación informando de los problemas a nuestro equipo.
Se recomienda a los principiantes que descarguen la versión estable oficial.
Antes de iniciar la versión que haya descargado, deberá descomprimir el contenido en la carpeta que desee.
Descargue e instale 7zip en el equipo para este paso.
Haga clic con el botón derecho en el archivo ZIP y seleccione Extraer todo.
Elija un destino para descomprimir todos los archivos.
En la carpeta de destino, haga doble clic en DynamoSandbox.exe para iniciarlo.
Aparecerá la pantalla de inicio de Dynamo Sandbox, como se muestra a continuación.
Enhorabuena, ya ha finalizado la configuración para utilizar Dynamo Sandbox.
La función Geometría es una característica adicional de Dynamo Sandbox disponible únicamente para los usuarios que tengan una licencia o una suscripción actuales a las siguientes soluciones de software de Autodesk: Revit, Robot Structural Analysis, FormIt y Civil 3D. La función Geometría permite a los usuarios importar, crear, editar y exportar geometría desde Dynamo Sandbox.
La geometría es el idioma del diseño. Cuando un lenguaje o un entorno de programación tienen un núcleo de geometría, podemos descubrir las posibilidades del diseño de modelos precisos y sólidos, la automatización de las rutinas de diseño y la creación de iteraciones de diseño con algoritmos.
Conocer los tipos de geometría y cómo se relacionan nos permitirá desplazarnos por la colección de nodos de geometría disponibles en la biblioteca. Los nodos de geometría se organizan alfabéticamente en lugar de jerárquicamente; aquí se muestran de forma similar a su presentación en la interfaz de Dynamo.
Además, la creación de modelos en Dynamo y la conexión de la vista preliminar de lo que aparece en la vista preliminar en segundo plano al flujo de datos del gráfico deberían ser procesos más intuitivos con el tiempo.
Observe el supuesto sistema de coordenadas renderizado por la rejilla y los ejes coloreados.
Los nodos seleccionados renderizarán la geometría correspondiente (si el nodo crea la geometría) en segundo plano con el color resaltado.
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.
La geometría se define tradicionalmente como el estudio de la forma, el tamaño y la posición relativa de las figuras y las propiedades del espacio. Este campo tiene una historia muy rica que se remonta a miles de años. Con la llegada y la popularización de la informática, disponemos de una poderosa herramienta para definir, explorar y generar geometría. Ahora es muy fácil calcular el resultado de interacciones geométricas complejas y lo hacemos de forma casi transparente.
Si tiene curiosidad por comprobar lo diversa y compleja que puede ser la geometría mediante la potencia de su ordenador, realice una búsqueda rápida en la web del conejito de Stanford (o "Stanford Bunny"), un modelo canónico que se utiliza para probar algoritmos.
Comprender la geometría en el contexto de los algoritmos, la informática y la complejidad puede parecer una tarea abrumadora. Sin embargo, existen algunos principios clave y relativamente sencillos que podemos establecer como base para empezar a crear aplicaciones más avanzadas:
La geometría se compone de datos: para el ordenador y Dynamo, un conejito no se diferencia mucho de un número.
La geometría se basa en la abstracción: sobre todo, los elementos geométricos se describen mediante números, relaciones y fórmulas dentro de un sistema de coordenadas espacial específico.
La geometría tiene una jerarquía: los puntos se combinan para crear líneas, las líneas se unen para crear superficies, etc.
La geometría describe simultáneamente la parte y el todo: cuando tenemos una curva, se tiene en cuenta tanto la forma como todos los posibles puntos a lo largo de ella.
En la práctica, estos principios nos indican que debemos tener en cuenta con qué tipo de geometría estamos trabajando (qué tipo de geometría, cómo se creó, etc.) para poder crear, descomponer y recomponer de forma fluida diferentes geometrías a medida que desarrollamos modelos más complejos.
Dediquemos un momento a observar la relación entre las descripciones abstractas y jerárquicas de la geometría. Como estos dos conceptos están relacionados, pero esto no es siempre evidente al principio, podemos encontrarnos rápidamente con un bloqueo conceptual una vez que empezamos a desarrollar flujos de trabajo o modelos más profundos. Para empezar, vamos a usar la dimensionalidad como un sencillo descriptor del "material" que modelamos. El número de dimensiones necesarias para describir una forma nos muestra cómo organizar la forma en que la geometría se organiza jerárquicamente.
Un punto (definido por coordenadas) no tiene ninguna dimensión asociada; son solo números que describen cada coordenada.
Una línea (definida por dos puntos) tiene ahora una dimensión; podemos "recorrer" la línea hacia delante (dirección positiva) o hacia atrás (dirección negativa).
Un plano (definido por dos líneas) tiene dos dimensiones: es posible desplazarse más a la izquierda o más a la derecha.
Un cubo (definido por dos planos) tiene tres dimensiones: se puede definir una posición hacia arriba o hacia abajo.
La dimensionalidad es un método práctico para empezar a organizar en categorías la geometría, pero no es necesariamente el mejor. Después de todo, no modelamos solo puntos, líneas, planos y cuadros, ¿qué ocurre si deseo utilizar un elemento curvado? Además, existe toda una categoría adicional de tipos geométricos que son totalmente abstractos; por ejemplo, definen propiedades como la orientación, el volumen o las relaciones entre las partes. No podemos realmente agarrar un vector, así que, ¿cómo lo definimos en relación con lo que vemos en el espacio? Una categorización más detallada de la jerarquía geométrica debería incluir la diferencia entre los tipos abstractos o "ayudas", que podemos agrupar por lo que ayudan a hacer, y los tipos que ayudan a describir la forma de los elementos del modelo.
La creación de modelos en Dynamo no se limita a lo que se puede generar con nodos. A continuación, se indican algunas formas clave para llevar el proceso al siguiente nivel con la geometría:
Dynamo permite importar archivos: pruebe a utilizar un archivo CSV para nubes de puntos o SAT para incorporar superficies.
Al trabajar con Revit, podemos hacer referencia a los elementos de Revit que se utilizarán en Dynamo.
Dynamo Package Manager ofrece funciones adicionales para operaciones y tipos de geometría ampliados; consulte el paquete de Kit de herramientas de malla.
Dynamo es una plataforma de programación visual de código abierto para diseñadores.
Acaba de abrir Dynamo Primer, una guía completa de programación visual en Autodesk Dynamo. Este manual de introducción es un proyecto continuo para compartir los conceptos básicos de programación. Entre los temas, se incluyen el trabajo con geometría computacional, los procedimientos recomendados para el diseño basado en reglas, las aplicaciones de programación interdisciplinarias y muchos más aspectos relacionados con la plataforma Dynamo.
La potencia de Dynamo se puede encontrar en una amplia variedad de actividades relacionadas con el diseño. Dynamo ofrece una lista ampliable de métodos accesibles para que dé sus primeros pasos:
Explore la programación visual por primera vez.
Conecte flujos de trabajo en varios programas.
Participe en una comunidad activa de usuarios, colaboradores y desarrolladores.
Desarrolle una plataforma de código abierto para seguir mejorando.
En medio de esta actividad y magnífica oportunidad para trabajar con Dynamo, necesitamos un documento del mismo calibre, Dynamo Primer.
Estamos mejorando continuamente Dynamo, por lo que algunas funciones pueden tener un aspecto diferente al que se representa en este manual de introducción. Sin embargo, todos los cambios de funcionalidades se representarán correctamente.
El proyecto Dynamo Primer es de código abierto. Nos hemos dedicado a proporcionar contenido de calidad y agradeceremos cualquier comentario que pueda tener. Si desea informar de un problema sobre cualquier aspecto, publíquelo en la página de problemas de GitHub: https://github.com/DynamoDS/DynamoPrimer/issues.
Si desea contribuir con una nueva sección, modificaciones o cualquier otra aportación a este proyecto, consulte el repositorio de GitHub para empezar: https://github.com/DynamoDS/DynamoPrimer.
Dynamo Primer es un proyecto de código abierto iniciado por Matt Jezyk y el equipo de desarrollo de Dynamo de Autodesk.
Mode Lab recibió el encargo de escribir la primera edición del manual de introducción. Les agradecemos todos sus esfuerzos para establecer este valioso recurso.
A John Pierson de Parallax Team se le encargó actualizar el manual de introducción para incluir las revisiones de Dynamo 2.0.
A Matterlab se le encargó actualizar el manual de introducción para incluir las revisiones de Dynamo 2.13.
A Archilizer se le encargó actualizar el manual de introducción para incluir las revisiones de Dynamo 2.17.
A Wood Rodgers se le encargó actualizar el manual de introducción con contenido sobre Dynamo for Civil 3D.
Un agradecimiento especial a Ian Keough por iniciar y guiar el proyecto de Dynamo.
Deseamos agradecer a Matt Jezyk, Ian Keough, Zach Kron, Racel Amour y Colin McCrone su colaboración entusiasta y la oportunidad de participar en una amplia gama de proyectos de Dynamo.
Dynamo Consulte los siguientes sitios para obtener la versión estable más reciente de Dynamo.
http://dynamobim.com/download/ o http://dynamobuilds.com
DynamoBIM La mejor fuente de información adicional, contenido de aprendizaje y foros es el sitio web de DynamoBIM.
http://dynamobim.org
Dynamo en GitHub Dynamo es un proyecto de código abierto en GitHub. Para colaborar, consulte DynamoDS.
https://github.com/DynamoDS/Dynamo
Contacto Infórmenos de cualquier problema relacionado con este documento.
Dynamo@autodesk.com
Copyright 2023 Autodesk
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. Puede obtener una copia de la licencia en
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
Las son el primer tipo de datos geométricos abordado que presenta un conjunto más familiar de propiedades descriptivas de forma... ¿Qué grado de curvatura o rectitud? ¿Cómo de larga o corta? Recuerde que los puntos siguen siendo nuestros bloques de construcción para definir cualquier elemento, desde una línea a una spline y todos los tipos de curva intermedios.
Línea
Polilínea
Arco
Círculo
Elipse
Curva NURBS
PolyCurve
NurbsCurve.ByControlPoints utiliza la lista de puntos como puntos de control.
NurbsCurve.ByPoints dibuja una curva a través de la lista de puntos.
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.
El término curva suele ser un comodín para todo tipo de formas curvas (incluso aunque adopten un aspecto recto). La curva en su sentido primordial es la categorización principal de todos estos tipos de forma: líneas, círculos, splines, etc. Desde una perspectiva más técnica, una curva describe cada punto posible que se puede encontrar introduciendo "t" en un conjunto de funciones, que pueden ir desde la sencilla función (x = -1.26*t, y = t
) hasta funciones que implican cálculo. Independientemente del tipo de curva con el que trabajemos, este parámetro denominado "t" es una propiedad que se puede evaluar. Además, independientemente del aspecto de la forma, todas las curvas tienen también un punto inicial y un punto final, que se alinean de forma coincidente con los valores t mínimo y máximo utilizados para crear la curva. Esto también nos ayuda a comprender su direccionalidad.
Es importante tener en cuenta que Dynamo presupone que el dominio de los valores "t" de una curva se entiende como de 0.0 a 1.0.
Todas las curvas también poseen una serie de propiedades o características que se pueden utilizar para describirlas o analizarlas. Cuando la distancia entre los puntos inicial y final es cero, la curva es "cerrada". Además, cada curva tiene varios puntos de control; si todos estos puntos se encuentran en el mismo plano, la curva es "plana". Algunas propiedades se aplican a la curva como un todo, mientras que otras solo se aplican a puntos específicos a lo largo de la curva. Por ejemplo, la planaridad es una propiedad global, mientras que un vector tangente en un valor t especificado es una propiedad local.
Las líneas son la forma más sencilla de las curvas. Puede que no parezcan curvadas, pero en realidad son curvas, solo que no tienen ninguna curvatura. Existen varias formas diferentes de crear líneas; la más intuitiva desde el punto A al punto B. La forma de la línea AB se dibujará entre los puntos, pero matemáticamente se extiende infinitamente en ambas direcciones.
Cuando conectamos dos líneas, tenemos una polilínea. Aquí tenemos una representación directa de lo que es un punto de control. Si se edita cualquiera de estas ubicaciones de punto, cambiará la forma de la polilínea. Si la polilínea está cerrada, se trata de un polígono. Si todas las longitudes de arista del polígono son iguales, se describe como normal.
A medida que se añade más complejidad a las funciones paramétricas que definen una forma, podemos ir un poco más allá de la línea y crear un arco, un círculo, un arco elíptico o una elipse mediante la descripción de uno o dos radios. Las diferencias entre la versión de arco y el círculo o la elipse se encuentran en si la forma está cerrada o no.
NURBS (Non-uniform Rational Basis Splines, splines de base racionales no uniformes) son representaciones matemáticas que pueden modelar con precisión cualquier forma, desde líneas, círculos, arcos o rectángulos bidimensionales sencillos a la curva orgánica tridimensional de forma libre más compleja. Gracias a su flexibilidad (hay relativamente pocos puntos de control, aunque la interpolación suave se basa en parámetros de grado) y su precisión (vinculada a complejas operaciones matemáticas), los modelos NURBS se pueden utilizar en cualquier proceso, desde la ilustración y la animación hasta la fabricación.
Grado: el grado de la curva determina el rango de influencia que los puntos de control tienen en una curva; cuanto mayor sea el grado, mayor será el rango. El grado es un número entero positivo. Este número suele ser 1, 2, 3 o 5, pero puede ser cualquier número entero positivo. Las líneas y las polilíneas NURBS suelen ser de grado 1 y la mayoría de las curvas de forma libre son de grado 3 o 5.
Puntos de control: los puntos de control son una lista de puntos de al menos grado+1. Una de las formas más fáciles de cambiar la forma de una curva NURBS es desplazar sus puntos de control.
Grosor: los puntos de control tienen un número asociado denominado grosor. Los grosores son normalmente números positivos. Cuando todos los puntos de control de una curva tienen el mismo grosor (normalmente, 1), la curva se denomina no racional; de lo contrario, la curva se denomina racional. La mayoría de las curvas NURBS son no racionales.
Nudos: los nudos son una lista de números (grado+N-1), donde N es el número de puntos de control. Los nudos se utilizan junto con los grosores para controlar la influencia de los puntos de control en la curva resultante. Por ejemplo, los nudos se pueden utilizar para crear puntos de torsión en determinados puntos de la curva.
Grado = 1
Grado = 2
Grado = 3
Tenga en cuenta que cuanto mayor sea el valor de grado, más puntos de control se utilizarán para interpolar la curva resultante.
Para empezar a utilizarlo, inícielo desde el panel de la barra de herramientas. Aunque su posición varía en función del software utilizado, el icono de inicio se suele encontrar en el menú > ficha Administrar. Haga clic en el icono de Dynamo para iniciarlo.
Consulte el para obtener información sobre lo que puede aprender en esta guía.
Nota: A partir de Revit 2020, Dynamo se incluye en las versiones de Revit, por lo que no es necesaria la instalación manual. Hay más información disponible en esta .
Una está formada por un conjunto de puntos; cada línea tiene al menos dos puntos. Una de las formas más habituales de crear líneas en Dynamo es utilizar Line.ByStartPointEndPoint
.
es un modelo que se utiliza para representar curvas y superficies con precisión. Una curva de seno en Dynamo mediante dos métodos diferentes para crear curvas NURBS a fin de comparar los resultados.
Este índice proporciona información adicional sobre todos los nodos utilizados en este manual de introducción, así como sobre otros componentes que pueden resultar útiles. Esto es solo una introducción a algunos de los 500 nodos disponibles en Dynamo.
**En otras palabras, si crea una longitud de anchura de ortoedro (eje X) de 10 y la transforma en un CoordinateSystem con dos veces la escala en X, la anchura seguirá siendo 10. ASM no permite extraer los vértices de un cuerpo en ningún orden predecible, por lo que es imposible determinar las cotas después de una transformación.
Dynamo, un entorno de programación visual, le permite diseñar la forma en que se procesan los datos. Los datos son números o texto, pero también lo es la geometría. Tal y como lo entiende el equipo, la geometría (denominada a veces geometría computacional) son los datos que se pueden utilizar para crear modelos atractivos, complejos o basados en el rendimiento. Para ello, debemos conocer los pormenores de los diversos tipos de geometría que podemos utilizar.
El vector es una representación de magnitud y dirección, que se puede mostrar como una flecha que se acelera hacia una dirección concreta a una velocidad determinada. Este es un componente clave de los modelos de Dynamo. Tenga en cuenta que, como se encuentran en la categoría abstracta de "ayudas", cuando creamos un vector, no aparecerá nada en la vista preliminar en segundo plano.
Podemos utilizar una línea como sustituto de una vista preliminar del vector.
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.
Un plano es una superficie bidimensional que puede tener el aspecto de una superficie plana que se extiende de forma indefinida. Cada plano tiene un origen y una dirección X, Y y Z (arriba).
Aunque son abstractos, los planos tienen una posición de origen, por lo que podemos localizarlos en el espacio.
En Dynamo, los planos se renderizan en la vista preliminar en segundo plano.
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.
Un sistema de coordenadas permite determinar la ubicación de puntos u otros elementos geométricos. En la imagen siguiente, se explica el aspecto que tiene en Dynamo y lo que representa cada color.
Aunque son abstractos, los sistemas de coordenadas también tienen una posición de origen para poder localizarlos en el espacio.
En Dynamo, los sistemas de coordenadas se renderizan en la vista preliminar en segundo plano como un punto (origen) y líneas que definen los ejes (X es rojo, Y es verde y Z es azul según la convención).
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.
Los vectores, los planos y los sistemas de coordenadas constituyen el grupo principal de los tipos de geometría abstracta. Nos ayudan a definir la ubicación, la orientación y el contexto espacial de otra geometría que describe formas. Si, por ejemplo, digo que estoy en la ciudad de Nueva York en la calle 42 con Broadway (sistema de coordenadas), de pie en el nivel de la calle (plano), mirando al norte (vector), acabo de usar estas "ayudas" para definir dónde estoy. Lo mismo sucede con la carcasa de un teléfono o un rascacielos; necesitamos este contexto para desarrollar el modelo.
Un vector es una cantidad geométrica que describe la dirección y la magnitud. Los vectores son abstractos, es decir, representan una cantidad, no un elemento geométrico. Los vectores se pueden confundir fácilmente con los puntos porque ambos están compuestos de una lista de valores. Aunque existe una diferencia clave: los puntos describen una posición en un sistema de coordenadas específico, mientras que los vectores describen una diferencia relativa en la posición, lo que equivale a la "dirección".
Si la idea de la diferencia relativa es confusa, piense en el Vector AB como "Estoy de pie en el punto A, mirando hacia el punto B". La dirección, de aquí (A) a allí (B), es el vector.
Este es un desglose de los vectores en sus diferentes partes mediante la misma notación AB:
El punto inicial del vector se denomina base.
El **punto final **del vector se denomina punta o sentido.
El vector AB no es igual al vector BA, que señalaría la dirección opuesta.
Si desea ver un momento cómico en relación con los vectores (y su definición abstracta), eche un vistazo al clásico de la comedia "Aterriza como puedas" y escuche la siguiente línea de diálogo burlona bastante citada:
Bien, bien. ¿Cuál es nuestro vector, Víctor?
Los planos son "ayudas" abstractas bidimensionales. En concreto, los planos son conceptualmente un "llano" que se extiende infinitamente en dos direcciones. Por lo general, se renderizan como un rectángulo más pequeño próximo a su origen.
Es posible que piense: "¡Un momento! ¿Origen? Eso suena a un sistema de coordenadas... como el que utilizo para modelar en el software de CAD".
Y tiene razón. La mayoría del software de modelado aprovecha los planos de construcción o "niveles" para definir un contexto local bidimensional en el que dibujar. Es posible que XY, XZ, YZ, o Norte, Sudeste o Nivel le resulten términos más familiares. Todos son planos que definen un contexto "llano" infinito. Los planos no tienen profundidad, pero nos ayudan también a describir la dirección:
Si estamos familiarizados con los planos, estamos a un paso de comprender los sistemas de coordenadas. Un plano tiene las mismas partes que un sistema de coordenadas, siempre que se trate de un sistema de coordenadas euclidiano o XYZ estándar.
Sin embargo, hay otros sistemas de coordenadas alternativos como, por ejemplo, cilíndricos o esféricos. Como veremos en las secciones posteriores, los sistemas de coordenadas también se pueden aplicar a otros tipos de geometría para definir una posición en esa geometría.
Añadir sistemas de coordenadas alternativos: cilíndricos y esféricos.
En el campo del modelado computacional, las mallas son una de las formas más generalizadas de representación de la geometría 3D. Por lo general, la geometría de malla se compone de una colección de cuadriláteros o triángulos; puede ser una alternativa ligera y flexible al trabajo con NURBS. Las mallas se utilizan en todo, desde la renderización y las visualizaciones hasta la fabricación digital y la impresión en 3D.
Dynamo define mallas mediante una estructura de datos de cara-vértice. En su nivel más básico, esta estructura es simplemente un conjunto de puntos que se agrupan en polígonos. Los puntos de una malla se denominan vértices, mientras que los polígonos similares a superficies se denominan caras.
Para crear una malla, se necesita una lista de vértices y un sistema de agrupación de esos vértices en caras denominado grupo de índice.
Lista de vértices
Lista de grupos de índice para definir caras
Las funciones de malla de Dynamo se pueden ampliar mediante la instalación del paquete de Kit de herramientas de malla. El Kit de herramientas de malla de Dynamo proporciona herramientas para importar mallas desde formatos de archivo externos, crear una malla a partir de objetos de geometría de Dynamo y generar manualmente mallas mediante sus vértices e índices.
La biblioteca también proporciona herramientas para modificar y reparar mallas, o extraer cortes horizontales para su uso en la fabricación.
Consulte los casos reales del Kit de herramientas de malla para obtener un ejemplo de cómo utilizar este paquete.
Una malla es un conjunto de cuadriláteros y triángulos que representa una superficie o una geometría sólida. Al igual que los sólidos, la estructura de un objeto de malla incluye vértices, aristas y caras. Existen propiedades adicionales que hacen que las mallas sean únicas como, por ejemplo, las normales.
Vértices de malla.
Aristas de malla. * Las aristas con una única cara adyacente se denominan "desnudas". El resto de aristas están "vestidas".
Caras de malla.
Los vértices de una malla son simplemente una lista de puntos. El índice de los vértices es muy importante al crear una malla u obtener información sobre la estructura de una malla. Para cada vértice, también existe una normal de vértice (vector) correspondiente que describe la dirección media de las caras enlazadas y ayuda a comprender la orientación de "entrada" y "salida" de la malla.
Vértices
Normales de vértice
Una cara es una lista ordenada de tres o cuatro vértices. Por lo tanto, la representación de la "superficie" de una cara de malla se deduce en función de la posición de los vértices que se están indexando. Ya tenemos la lista de vértices que componen la malla, por lo que, en lugar de proporcionar puntos individuales para definir la malla, solo tenemos que usar el índice de los vértices. Esto también nos permite utilizar el mismo vértice en más de una cara.
Una cara cuadrática compuesta por los índices 0, 1, 2 y 3.
Una cara triangular creada con los índices 1, 4 y 2. Tenga en cuenta que se puede cambiar el orden de los grupos de índice; siempre que la secuencia se ordene en el sentido contrario a las agujas del reloj, la cara se definirá correctamente.
¿En qué se diferencia la geometría de malla de la geometría NURBS? ¿Cuándo es recomendable utilizar una en lugar de la otra?
En un capítulo anterior, vimos que las superficies NURBS se definen mediante una serie de curvas NURBS que se dirigen en dos direcciones. Estas direcciones se etiquetan como U
y V
, y permiten que una superficie NURB se parametrice de acuerdo con un dominio de superficie bidimensional. Las curvas propiamente dichas se almacenan como ecuaciones en el ordenador, lo que permite calcular las superficies resultantes con un grado de precisión arbitrariamente pequeño. Sin embargo, puede ser difícil combinar varias superficies NURBS. La unión de dos superficies NURBS genera una PolySurface, donde las distintas secciones de la geometría tendrán diferentes parámetros UV y definiciones de curva.
Superficie
Curva isoparamétrica (línea isoparamétrica)
Punto de control de superficie
Polígono de control de superficie
Punto isométrico
Marco de superficie
Malla
Arista desnuda
Red de malla
Aristas de malla
Normal de vértice
Cara de malla/normal de cara de malla
Por otra parte, las mallas están formadas por un número específico de caras y vértices definidos exactamente. La red de vértices no se puede definir normalmente mediante coordenadas UV
sencillas, y como las caras son independientes, la cantidad de precisión se incorpora en la malla y solo se puede cambiar mediante el ajuste preciso de la malla y la adición de más caras. La falta de descripciones matemáticas permite que las mallas gestionen con mayor flexibilidad geometrías complejas dentro de una única malla.
Otra diferencia importante es la extensión en la que un cambio local en la geometría de malla o NURBS afecta a toda la forma. El desplazamiento de un vértice de una malla solo afecta a las caras adyacentes a ese vértice. En las superficies NURBS, la extensión de la influencia es más complicada y depende del grado de la superficie, así como de los grosores y los nudos de los puntos de control. Sin embargo, por lo general, al desplazar un único punto de control en una superficie NURBS, se produce un cambio más suave y extensivo en la geometría.
Superficie NURBS: el desplazamiento de un punto de control tiene una influencia que se extiende a lo largo de la forma.
Geometría de malla: el desplazamiento de un vértice solo influye en los elementos adyacentes.
Una analogía que puede resultar útil es comparar una imagen vectorial (compuesta de líneas y curvas) con una imagen ráster (compuesta de píxeles individuales). Si amplía la vista de una imagen vectorial, las curvas permanecen nítidas y claras, mientras que si se amplía la vista de una imagen ráster, los píxeles individuales aumentan de tamaño. En esta analogía, las superficies NURBS se pueden comparar con una imagen vectorial porque existe una relación matemática fluida, mientras que una malla se comporta de forma similar a una imagen ráster con una resolución establecida.
Un punto se define por uno o más valores denominados coordenadas. El número de valores de coordenadas necesarios para definir el punto depende del sistema de coordenadas o del contexto en el que se encuentra.
El tipo de punto más común en Dynamo se encuentra en el sistema de coordenadas universales tridimensional y tiene tres coordenadas [X,Y,Z] (punto 3D en Dynamo).
Un punto 2D de Dynamo tiene dos coordenadas [X,Y].
Los parámetros de las curvas y las superficies son continuos y se extienden más allá del borde de la geometría especificada. Como las formas que definen el espacio paramétrico se encuentran en un sistema de coordenadas universales tridimensional, siempre se puede convertir una coordenada paramétrica en una coordenada "universal". Por ejemplo, el punto [0,2, 0,5] de la superficie es el mismo que el punto [1,8, 2,0, 4,1] de las coordenadas universales.
Punto en presuntas coordenadas XYZ globales
Punto relativo a un sistema de coordenadas especificado (cilíndrico)
Punto como coordenada UV en una superficie
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.
Si la geometría es el idioma de un modelo, los puntos son el alfabeto. Los puntos son la base sobre la que se crea el resto de la geometría; se necesitan al menos dos puntos para crear una curva. tres puntos para crear un polígono o una cara de malla, etc. La definición de la posición, el orden y la relación entre los puntos (pruebe con una función de seno) nos permite definir geometrías de orden superior, como elementos que reconocemos como círculos o curvas.
Un círculo que utiliza las funciones
x=r*cos(t)
yy=r*sin(t)
Una curva seno que utiliza las funciones
x=(t)
yy=r*sin(t)
Los puntos también pueden existir en un sistema de coordenadas bidimensional. La convención tiene diferentes notaciones de letras en función del tipo de espacio con el que se trabaje: es posible que se utilice [X,Y] en un plano o [U,V] en una superficie.
Un punto en el sistema de coordenadas euclidiano: [X,Y,Z]
Un punto en un sistema de coordenadas de parámetro de curva: [t]
Un punto en un sistema de coordenadas de parámetro de superficie: [U,V]
La biblioteca contiene todos los nodos cargados, incluidos los 10 nodos de categorías por defecto que se suministran con la instalación, así como los paquetes o los nodos personalizados cargados de forma adicional. Los nodos de la biblioteca se organizan jerárquicamente en bibliotecas, categorías y, si procede, subcategorías.
Nodos básicos: se incluye con la instalación por defecto.
Nodos personalizados: almacene las rutinas o los gráficos especiales utilizados con frecuencia como nodos personalizados. También puede compartir los nodos personalizados con la comunidad.
Nodos de Package Manager: colección de nodos personalizados publicados.
Repasaremos las categorías de jerarquía de nodos, mostraremos cómo realizar rápidamente búsquedas en la biblioteca y conoceremos algunos de los nodos utilizados con frecuencia.
La exploración a través de estas categorías es la manera más rápida de conocer la jerarquía de lo que podemos añadir a nuestro espacio de trabajo y la mejor forma de descubrir nuevos nodos que no ha utilizado antes.
Examine la biblioteca. Para ello, haga clic en los menús para expandir cada categoría y su subcategoría.
Núcleo y Geometría son excelentes menús para empezar a explorar, ya que contienen la mayor cantidad de nodos.
Biblioteca
Categoría
Subcategoría
Nodo
Estos clasifican aún más los nodos en la misma subcategoría en función si los nodos crean datos, ejecutan una acción o consultan datos.
Coloque el puntero en un nodo para visualizar información más detallada, además de su nombre e icono. Esto nos permite conocer rápidamente lo que realiza el nodo, lo que necesitará para las entradas y lo que proporcionará como salida.
Descripción: descripción del nodo en lenguaje normal.
Icono: versión más grande del icono en el menú Biblioteca.
Entrada(s): el nombre, y el tipo y la estructura de datos.
Salida(s): el tipo y la estructura de datos.
Si sabe con precisión relativa qué nodo desea añadir al espacio de trabajo, especifíquelo en el campo Buscar para buscar todos los nodos coincidentes.
Haga clic en el nodo que desea añadir o pulse Intro para añadir los nodos resaltados al centro del espacio de trabajo.
Además de utilizar palabras clave para intentar encontrar nodos, podemos escribir la jerarquía separada por un punto en el campo de búsqueda o con bloques de código (que utilizan el lenguaje textual de Dynamo).
La jerarquía de cada biblioteca se refleja en el nombre de los nodos añadidos al espacio de trabajo.
Al escribir distintas partes de la ubicación del nodo en la jerarquía de biblioteca con el formato library.category.nodeName
, se obtienen resultados diferentes.
library.category.nodeName
category.nodeName
nodeName
o keyword
Por lo general, el nombre del nodo en el espacio de trabajo se renderizará con el formato category.nodeName
, con algunas excepciones destacadas, sobre todo, en las categorías de entrada y vista.
Tenga en cuenta la diferencia de categoría en nodos con nombres similares:
Los nodos de la mayoría de las bibliotecas incluirán el formato de categoría.
Point.ByCoordinates
y UV.ByCoordinates
tienen el mismo nombre, pero proceden de diferentes categorías.
Entre las excepciones destacables, se incluyen las funciones integradas, Core.Input, Core.View y los operadores.
Con cientos de nodos incluidos en la instalación básica de Dynamo, ¿cuáles son fundamentales para desarrollar nuestros programas visuales? Veamos los parámetros de nuestro programa (Input), consultemos los resultados de la acción de un nodo (Watch) y definamos entradas o funciones mediante un acceso directo (Code Block).
Los nodos de entrada son el principal medio para que el usuario de nuestro programa visual (ya sea usted mismo u otro usuario) interactúe con los parámetros clave. A continuación, se muestran algunos de la biblioteca principal:
Los nodos de visualización, Watch, son esenciales para administrar los datos que se ejecutan a través del programa visual. Puede ver el resultado de un nodo a través de la vista preliminar de datos del nodo. Para ello, coloque el cursor sobre el nodo.
Será útil mantenerlo visible en un nodo Watch.
O bien, consulte los resultados de la geometría a través de un nodo Watch3D.
Ambos se encuentran en la categoría de vista de la biblioteca principal.
Consejo: En ocasiones, la vista preliminar 3D puede ser molesta cuando el programa visual contiene muchos nodos. Considere la posibilidad de desactivar la opción Mostrando vista preliminar 3D en segundo plano en el menú Configuración y utilizar un nodo Watch3D para obtener una vista preliminar de la geometría.
Los nodos de bloque de código, Code Block, se pueden utilizar para definir un bloque de código con líneas separadas por signos de punto y coma. Esto puede ser tan sencillo como X/Y
.
También podemos utilizar bloques de código como un acceso directo para definir una entrada de número o una llamada a la función de otro nodo. La sintaxis para esta acción sigue la convención de nomenclatura del lenguaje textual de Dynamo, DesignScript.
A continuación, se muestra una sencilla demostración (con instrucciones) de uso del bloque de código en la secuencia de comandos.
Haga doble clic para crear un nodo de bloque de código.
Circle.ByCenterPointRadius(x,y);
Tipo
Haga clic en el espacio de trabajo para borrar la selección; se añadirán automáticamente las entradas x
y y
.
Cree un nodo Point.ByCoordinates y un control deslizante de número; a continuación, conecte las entradas al bloque de código.
El resultado de la ejecución del programa visual se muestra como un círculo en la vista preliminar 3D.
Una vez que estemos listos para profundizar en el desarrollo de programas visuales, necesitaremos una mejor comprensión de los componentes de construcción que utilizaremos. En este capítulo, se presentan conceptos fundamentales sobre los datos: el contenido que recorre los cables de nuestro programa de Dynamo.
Los datos son el contenido de nuestros programas. Viajan a través de cables proporcionando entradas a los nodos, donde se procesan y se transforman en una nueva forma de datos de salida. Revisemos la definición de los datos, cómo se estructuran y cómo utilizarlos en Dynamo.
Los datos son un conjunto de valores de variables cualitativas o cuantitativas. La forma de datos más sencilla son números como, por ejemplo, 0
, 3.14
o 17
. Sin embargo, los datos también puede ser de diferentes tipos: una variable que representa números cambiantes (height
); caracteres (myName
); geometría (Circle
), o una lista de elementos de datos (1,2,3,5,8,13,...
).
En Dynamo, añadimos o introducimos datos en los puertos de entrada de los nodos; podemos tener datos sin acciones, pero nos hacen falta datos para procesar las acciones que representan nuestros nodos. Cuando se añade un nodo al espacio de trabajo, si no se le proporciona ninguna entrada, el resultado será una función y no el resultado de la acción en sí.
Datos simples.
Datos y una acción (un nodo); se ejecuta correctamente.
Una acción (un nodo) sin entradas de datos; devuelve una función genérica.
Cuidado con los valores nulos. El tipo 'null'
representa la ausencia de datos. Aunque se trata de un concepto abstracto, es probable que esto ocurra mientras trabaja con programación visual. Si una acción no crea un resultado válido, el nodo devolverá un valor "null".
Comprobar si existen valores "null" y eliminarlos de la estructura de datos es una parte crucial para crear programas sólidos.
Cuando somos programadores visuales, podemos generar una gran cantidad de datos rápidamente y requerir un medio de administración de su jerarquía. Esta es la función de las estructuras de datos, los esquemas organizativos en los que almacenamos los datos. Las características específicas de las estructuras de datos y su uso varían de un lenguaje de programación a otro.
En Dynamo, se añade jerarquía a los datos a través de las listas. Exploraremos esto en profundidad en capítulos posteriores, pero empecemos con algo sencillo.
Una lista representa una colección de elementos colocados en una estructura de datos:
Tengo cinco dedos (elementos) en la mano (lista).
Hay diez casas (elementos) en mi calle (lista).
Un nodo Number Sequence define una lista de números mediante entradas start, amount y step. Con estos nodos, hemos creado dos listas independientes de diez números, una que abarca de 100 a 109 y otra de 0 a 9.
El nodo List.GetItemAtIndex selecciona un elemento de una lista en un índice determinado. Al seleccionar 0, se obtiene el primer elemento de la lista (100 en este caso).
Al aplicar el mismo proceso a la segunda lista, obtenemos un valor de 0, el primer elemento de la lista.
Ahora combinamos las dos listas en una mediante el nodo List.Create. Observe que el nodo crea una lista de listas. Esto cambia la estructura de los datos.
Al volver a utilizar List.GetItemAtIndex, con el índice establecido en 0, se obtiene la primera lista de la lista de listas. Esto es lo que significa tratar una lista como un elemento, lo cual es ligeramente diferente de otros lenguajes de secuencias de comandos. En capítulos posteriores, nos adentraremos más en la manipulación de listas y la estructura de datos.
El concepto clave para comprender la jerarquía de datos en Dynamo es que en relación con la estructura de datos, las listas se consideran elementos. En otras palabras, Dynamo funciona con un proceso descendente para comprender las estructuras de datos. Implicaciones Veámoslo con un ejemplo.
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 primer ejemplo, vamos a ensamblar un cilindro vaciado que recorre la jerarquía de geometría tratada en esta sección.
1. Añada Point.ByCoordinates: después de añadir el nodo al lienzo, se muestra un punto en el origen de la rejilla de vista preliminar de Dynamo. Los valores por defecto de las entradas x, y y z son 0,0, lo que nos da un punto en esta ubicación.
2. Plane.ByOriginNormal: el siguiente paso en la jerarquía de geometría es un plano. Existen varias formas de construir un plano; utilizaremos un origen y una normal para la entrada. El origen es el nodo de punto creado en el paso anterior.
Vector.ZAxis: es un vector unificado en la dirección Z. Observe que no hay entradas, solo un vector con un valor [0,0,1]. Se utiliza como la entrada normal para el nodo Plane.ByOriginNormal. Esto nos proporciona un plano rectangular en la vista preliminar de Dynamo.
3. Circle.ByPlaneRadius: ascendiendo en la jerarquía, ahora creamos una curva a partir del plano del paso anterior. Después de conectar el nodo, se obtiene un círculo en el origen. El radio por defecto del nodo es el valor de 1.
4. Curve.Extrude: ahora vamos a hacer que este elemento crezca dándole profundidad y añadiendo la tercera dimensión. Este nodo crea una superficie a partir de una curva mediante su extrusión. La distancia por defecto en el nodo es 1 y debería aparecer un cilindro en la ventana gráfica.
5. Surface.Thicken: este nodo nos proporciona un sólido cerrado mediante el desfase de la superficie con la distancia especificada y el cierre de la forma. El valor de grosor por defecto es 1 y vemos un cilindro vaciado en la ventana gráfica en línea con estos valores.
6. Number Slider: en lugar de utilizar los valores por defecto para todas estas entradas, vamos a añadir algún control paramétrico al modelo.
Edición del dominio: después de añadir el control deslizante de número al lienzo, haga clic en el signo de intercalación situado en la parte superior izquierda para ver las opciones de dominio.
Min/Max/Step: cambie los valores min, max y step a 0, 2 y 0,01 respectivamente. Esto lo hacemos para controlar el tamaño de la geometría global.
7. Nodos Number Slider: en todas las entradas por defecto, copiemos y peguemos este control deslizante de número (seleccione el control deslizante, pulse Ctrl+C y, a continuación, Ctrl+V) varias veces hasta que todas las entradas con valores por defecto tengan un control deslizante. Algunos de los valores del control deslizante tendrán que ser mayores que cero para que la definición funcione (es decir, para que una superficie se engrose, se necesita una profundidad de extrusión).
8. Hemos creado un cilindro paramétrico vaciado con estos controles deslizantes. Pruebe a modificar algunos de estos parámetros y ver cómo la geometría se actualiza de forma dinámica en la ventana gráfica de Dynamo.
Nodos Number Slider: al avanzar en este ejemplo, hemos añadido muchos controles deslizantes al lienzo y debemos limpiar la interfaz de la herramienta que acabamos de crear. Haga clic con el botón derecho en un control deslizante, seleccione "Cambiar nombre" y cambie cada control deslizante al nombre apropiado para su parámetro (Grosor, Radio, Altura, etc.).
9. En este punto, hemos creado un fantástico elemento de cilindro engrosado. Se trata de un objeto actualmente; veamos cómo crear una matriz de cilindros que permanezca enlazada de forma dinámica. Para ello, vamos a crear una lista de cilindros en lugar de trabajar con un único elemento.
Adición (+): nuestro objetivo es añadir una fila de cilindros junto al cilindro que hemos creado. Si se desea añadir un cilindro adyacente al actual, se deben tener en cuenta el radio del cilindro y el grosor del vaciado. Para obtener este número, se añaden los dos valores de los controles deslizantes.
10. Este paso es más complejo, por lo que pasaremos por él más lentamente. El objetivo es crear una lista de números que defina las ubicaciones de cada cilindro en una fila.
a. Multiplicación: deseamos multiplicar primero el valor del paso anterior por 2. El valor del paso anterior representa un radio y queremos mover el cilindro por el diámetro completo.
b. Number Sequence: creamos una matriz de números con este nodo. La primera entrada es el nodo de multiplicación del paso anterior en el valor step. El valor start se puede establecer en 0,0 mediante un nodo Number.
c. Control deslizante de enteros: para el valor amount, conectamos un control deslizante de entero. Esto definirá cuántos cilindros se crean.
d. Salida: esta lista muestra la distancia desplazada para cada cilindro de la matriz y la manejan paramétricamente los controles deslizantes originales.
11. Este paso es bastante sencillo: conecte la secuencia definida en el paso anterior a la entrada x del Point.ByCoordinates original. De este modo, se sustituye el control deslizante pointX, que se puede suprimir Ahora vemos una matriz de cilindros en la ventana gráfica (asegúrese de que el control deslizante de enteros sea mayor que 0).
12. La cadena de cilindros sigue enlazada dinámicamente a todos los controles deslizantes. Mueva cada uno de los controles deslizantes para ver cómo se actualiza la definición.
Si la forma más sencilla de datos es el número, la forma más sencilla de relacionarlos es mediante las matemáticas. Desde operadores sencillos como la división a funciones trigonométricas y fórmulas más complejas, las matemáticas son un método excelente para empezar a explorar relaciones y patrones numéricos.
Los operadores son un conjunto de componentes que utilizan funciones algebraicas con dos valores numéricos de entrada que dan como resultado un valor de salida (suma, resta, multiplicación, división, etc.). Estos se pueden encontrar en Operators > Actions.
Icono | Nombre (sintaxis) | Entradas | Salidas |
---|
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.
Combine operadores y variables para formar una relación más compleja mediante fórmulas. Utilice los controles deslizantes para crear una fórmula que se pueda manejar con parámetros de entrada.
1. Cree la secuencia numérica que representa la "t" de la ecuación paramétrica, por lo que debemos utilizar una lista lo suficientemente grande como para definir una espiral.
Number Sequence: defina una secuencia de números basada en tres entradas: start, amount y step.
2. En el paso anterior, hemos creado una lista de números para definir el dominio paramétrico. A continuación, cree un grupo de nodos que representen la ecuación de la espiral dorada.
La espiral dorada se define como la siguiente ecuación:
La imagen siguiente representa la espiral dorada en forma de programación visual. Al desplazarse por el grupo de nodos, intente prestar atención al paralelismo entre el programa visual y la ecuación por escrito.
a. Number Slider: añada dos controles deslizantes de número al lienzo. Estos controles deslizantes representarán las variables a y b de la ecuación paramétrica. Estas representan una constante que es flexible o parámetros que podemos ajustar hacia el resultado deseado.
b. Multiplication (*): el nodo de multiplicación se representa mediante un asterisco. Lo usaremos con frecuencia para conectar variables de multiplicación.
c. Math.RadiansToDegrees: los valores de "t" se deben convertir a grados para que se evalúen en las funciones trigonométricas. Recuerde que Dynamo utiliza por defecto los grados para evaluar estas funciones.
d. Math.Pow: como función de "t" y del número "e", crea la secuencia Fibonacci.
e. Math.Cos y Math.Sin: estas dos funciones trigonométricas distinguirán la coordenada X y la coordenada Y, respectivamente, de cada punto paramétrico.
f. Watch: ahora vemos que las salidas son dos listas, que serán las coordenadas x e y de los puntos utilizados para generar la espiral.
Point.ByCoordinates: conecte el nodo de multiplicación superior a la entrada "x" y el inferior a la entrada "y". Ahora se muestra una espiral paramétrica de puntos en la pantalla.
Polycurve.ByPoints: conecte Point.ByCoordinates del paso anterior a points. Podemos dejar connectLastToFirst sin entrada porque no estamos creando una curva cerrada. Se crea una espiral que pasa a través de cada punto definido en el paso anterior.
Ya hemos completado la espiral Fibonacci. Vamos a profundizar en estos conceptos con dos ejercicios separados a partir de aquí; a uno lo llamaremos caracol y al otro girasol. Se trata de abstracciones de sistemas naturales, pero las dos aplicaciones diferentes de la espiral Fibonacci estarán bien representadas.
Circle.ByCenterPointRadius: utilizaremos aquí un nodo de círculo con las mismas entradas que en el paso anterior. El valor por defecto del radio es 1,0, por lo que vemos una salida de círculos inmediata. Se hace inmediatamente evidente cómo los puntos divergen más respecto al origen.
Number Sequence: es la matriz original de "t". Al conectarlo con el valor del radio de Circle.ByCenterPointRadius, los centros de círculo siguen divergiendo más respecto del origen, pero el radio de los círculos aumenta, lo que crea un gráfico de círculos Fibonacci con mucho estilo.
Un premio para quién consiga convertirlo a 3D.
Como punto de partida, vamos a realizar el mismo paso del ejercicio anterior: crear una matriz de puntos de espiral con el nodo Point.ByCoordinates.
![](../images/5-3/2/math-part IV-01.jpg)
A continuación, siga estos pequeños pasos para generar una serie de espirales en varias rotaciones.
a. Geometry.Rotate: existen varias opciones de Geometry.Rotate; asegúrese de que ha elegido el nodo que contiene las entradas geometry, basePlane y degrees. Conecte Point.ByCoordinates en la entrada geometry. Haga clic con el botón derecho en este nodo y asegúrese de que el encaje se haya establecido en "Producto vectorial".
b. Plano.XY: conéctelo a la entrada basePlane. Rotaremos alrededor del origen, que es la misma ubicación que la base de la espiral.
c. Number Range: para la entrada de grados, vamos a crear varias rotaciones. Esto se puede realizar rápidamente con un componente Number Range. Conéctelo a la entrada degrees.
d. Number: para definir el rango de números, añada tres nodos numéricos al lienzo en orden vertical. De arriba a abajo, asigne valores de 0,0; 360,0 y 120,0 respectivamente. Estos valores controlan la rotación de la espiral. Observe los resultados de las salidas del nodo Number Range después de conectar los tres nodos numéricos al mismo.
Nuestro resultado empieza a parecerse a un remolino. Ajustemos algunos de los parámetros de Number Range y veamos cómo cambian los resultados.
Cambie el tamaño de paso del nodo Number Range de 120,0 a 36,0. Observe que esto crea más rotaciones y que, por tanto, nos proporciona una rejilla más densa.
Cambie el tamaño de paso del nodo Number Range de 36,0 a 3,6. Esto nos da una rejilla mucho más densa y la dirección de la espiral no está clara. Damas y caballeros, hemos creado un girasol.
Utilizamos una en el modelo para representar los objetos que vemos en nuestro mundo tridimensional. Aunque las curvas no siempre son planas, es decir, tridimensionales, el espacio que definen siempre está vinculado a una dimensión. Las superficies nos ofrecen otra dimensión y un conjunto de propiedades adicionales que se pueden utilizar en otras operaciones de modelado.
Importe y evalúe una superficie en un parámetro de Dynamo para ver qué tipo de información se puede extraer.
Surface.PointAtParameter devuelve el punto en una coordenada UV especificada.
Surface.NormalAtParameter devuelve el vector normal en una coordenada UV especificada.
Surface.GetIsoline devuelve la curva isoparamétrica en una coordenada U o V; observe la entrada de isoDirection.
Descargue los archivos 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.
Una superficie es una forma matemática definida por una función y dos parámetros; en lugar de t
para las curvas, utilizamos U
y V
para describir el espacio de parámetros correspondiente. Esto significa que hay más datos geométricos que dibujar cuando se trabaja con este tipo de geometría. Por ejemplo, las curvas tienen vectores y planos normales (que se pueden rotar o girar a lo largo de la longitud de la curva), mientras que las superficies tienen vectores normales y planos tangentes que serán coherentes en su orientación.
Superficie
Isocurva U
Isocurva V
Coordenada UV
Plano perpendicular
Vector normal
Dominio de superficie: un dominio de superficie se define como el rango de parámetros (U,V) que se evalúan en un punto tridimensional de esa superficie. El dominio de cada dimensión (U o V) se describe normalmente como dos números, de U mín. a U máx. y de V mín. a V máx.
Aunque la forma de la superficie puede no parecer "rectangular" y es posible que tenga un conjunto de isocurvas más ajustadas o sueltas, el "espacio" definido por su dominio siempre es bidimensional. En Dynamo, se entiende que las superficies tienen un dominio definido por un mínimo de 0.0 y un máximo de 1.0 en las direcciones U y V. Las superficies planas o recortadas pueden tener dominios diferentes.
Isocurva (o curva isoparamétrica): curva definida por un valor U o V constante en la superficie y un dominio de valores para la otra dirección U o V correspondiente.
Coordenada UV: el punto del espacio del parámetro UV definido por U, V y, a veces, W.
Plano perpendicular: un plano perpendicular a las isocurvas U y V en una coordenada UV especificada.
Vector normal: un vector que define la dirección de "arriba" en relación con el plano perpendicular.
Las superficies NURBS son muy similares a las curvas NURBS. Las superficies NURBS se pueden considerar como una rejilla de curvas NURBS que van en dos direcciones. La forma de una superficie NURBS se define mediante un número de puntos de control y el grado de esa superficie en las direcciones U y V. Se utilizan los mismos algoritmos para calcular la forma, las normales, las tangentes, las curvaturas y otras propiedades mediante puntos de control, grosores y grados.
En el caso de las superficies NURBS, la geometría indica dos direcciones, ya que las superficies NURBS son, independientemente de la forma que veamos, rejillas rectangulares de puntos de control. Y, aunque estas direcciones son a menudo arbitrarias en relación con el sistema de coordenadas universal, las utilizaremos frecuentemente para analizar los modelos o generar otra geometría en función de la superficie.
Grado (U,V) = (3,3)
Grado (U,V) = (3,1)
Grado (U,V) = (1,2)
Grado (U,V) = (1,1)
Las PolySurfaces se componen de superficies unidas a lo largo de una arista. Las PolySurfaces ofrecen más de una definición de UV bidimensional, por lo que ahora podemos desplazarnos por las formas conectadas a través de su topología.
Aunque la "topología" describe normalmente un concepto sobre el modo en que las piezas están conectadas o relacionadas, la topología en Dynamo es también un tipo de geometría. En concreto, es una categoría principal de superficies, PolySurfaces y sólidos.
En ocasiones denominadas parches, este modo de unión de superficies nos permite crear formas más complejas y definir detalles a lo largo de la unión. De forma oportuna, podemos aplicar una operación de empalme o chaflán a las aristas de una PolySurface.
Crear: cree o construya una geometría desde cero. Por ejemplo, un círculo.
Acción: realice una acción en un objeto. Por ejemplo, ajuste la escala de un círculo.
Consulta: obtenga una propiedad de un objeto existente. Por ejemplo, obtenga el radio de un círculo.
Nodo | Nodo | ||
---|---|---|---|
Icono | Nombre/sintaxis | Entradas | Salidas |
---|
El cúmulo de nodos del paso anterior funcionará correctamente, pero conlleva mucho trabajo. Para crear un flujo de trabajo más eficiente, consulte a fin de definir una cadena de expresiones de Dynamo en un nodo. En la siguiente serie de pasos, veremos cómo utilizar la ecuación paramétrica para dibujar la espiral Fibonacci.
Ahora que hemos hecho una concha de caracol circular, vamos a pasar a las rejillas paramétricas. Vamos a usar una rotación básica en la espiral Fibonacci para crear una rejilla Fibonacci y modelar el resultado según el .
CREAR
Color.ByARGB Genera un color mediante componentes alfa, rojo, verde y azul.
Color Range Obtiene un color de un degradado de color entre un color inicial y un color final.
ACCIONES
Color.Brightness Obtiene el valor de brillo de este color.
Color.Components Enumera los componentes del color en el orden siguiente: alfa, rojo, verde y azul.
Color.Saturation Obtiene el valor de saturación de este color.
Color.Hue Obtiene el valor de matiz de este color.
CONSULTA
Color.Alpha Busca el componente alfa del color, de 0 a 255.
Color.Blue Busca el componente azul del color, de 0 a 255.
Color.Green Busca el componente verde del color, de 0 a 255.
Color.Red Busca el componente rojo del color, de 0 a 255.
CREAR
GeometryColor.ByGeometryColor Muestra geometría mediante un color.
ACCIONES
View.Watch Permite visualizar la salida del nodo.
View.Watch 3D Muestra una vista preliminar dinámica de la geometría.
ACCIONES
Boolean Selección entre un valor "true" (verdadero) y "false" (falso).
Code Block Permite la creación directa de código de DesignScript.
Directory Path Permite seleccionar un directorio del sistema para obtener su ruta.
File Path Permite seleccionar un archivo del sistema para obtener su nombre de archivo.
Integer Slider Un control deslizante que genera valores enteros.
hab. Crea un número.
Number Slider Un control deslizante que genera valores numéricos.
Cadena Crea una cadena.
Object.IsNull Determina si el objeto especificado es nulo.
CREAR
List.Create Crea una nueva lista a partir de las entradas especificadas.
List.Combine Aplica un combinador a cada elemento en dos secuencias
Number Range Crea una secuencia de números o letras en el intervalo especificado.
Number Sequence Crea una secuencia de números.
ACCIONES
List.Chop Divide una lista en un conjunto de listas en el que cada una contiene la cantidad especificada de elementos.
List.Count Obtiene el número de elementos almacenados en la lista especificada.
List.Flatten Aplana una lista anidada de listas en función de una determinada cantidad.
List.FilterByBoolMask Filtra una secuencia mediante la búsqueda de los índices correspondientes en una lista independiente de valores booleanos.
List.GetItemAtIndex Devuelve un elemento de la lista especificada que se encuentra en el índice indicado.
List.Map Aplica una función a todos los elementos de una lista y genera una lista nueva a partir de los resultados.
List.Reverse Crea una lista con los elementos de la lista especificada, pero en el orden inverso.
List.ReplaceItemAtIndex Sustituye un elemento de la lista especificada que se encuentra en el índice indicado.
List.ShiftIndices Desplaza a la derecha los índices de la lista en función de la cantidad especificada.
List.TakeEveryNthItem Recupera elementos de la lista especificada en los índices que son múltiplos del valor especificado y después del desfase indicado.
List.Transpose Intercambia filas y columnas en una lista de listas. Si hay algunas filas más cortas que otras, los valores nulos se insertan como marcadores de posición en la matriz resultante de forma que siempre sean rectangulares.
ACCIONES
If Sentencia condicional. Comprueba el valor booleano de la entrada de prueba. Si la entrada de prueba es "true" (verdadera), el resultado genera la entrada "true"; de lo contrario, el resultado genera la entrada "false" (falsa).
ACCIONES
Math.Cos Devuelve el coseno de un ángulo.
Math.DegreesToRadians Convierte un ángulo expresado en grados en un ángulo expresado en radianes.
Math.Pow Eleva un número a la potencia especificada.
Math.RadiansToDegrees Convierte un ángulo expresado en radianes en un ángulo expresado en grados.
Math.RemapRange Ajusta el intervalo de una lista de números conservando la relación de distribución.
Math.Sin Calcula el seno de un ángulo.
Fórmula Evalúa fórmulas matemáticas. Utiliza NCalc para la evaluación. Consulte http://ncalc.codeplex.com.
Map Asigna un valor a un rango de entrada.
ACCIONES
String.Concat Concatena varias cadenas y crea una sola cadena.
String.Contains Determina si la cadena indicada contiene la subcadena especificada.
String.Join Concatena varias cadenas en una sola e inserta el separador especificado entre cada una de las cadenas unidas.
String.Split Divide una cadena en una lista de cadenas. Las cadenas de separación especificadas determinan las divisiones.
String.ToNumber Convierte una cadena en un número entero o doble.
CREAR
Circle.ByCenterPointRadius Crea un círculo con punto central y radio en el plano XY universal, con el plano Z universal como normal.
Circle.ByPlaneRadius Crea un círculo centrado en el origen de plano de entrada (raíz), que se encuentra en el plano de entrada, con el radio especificado.
CREAR
CoordinateSystem.ByOrigin Crea un CoordinateSystem con origen en el punto de entrada con los ejes X e Y establecidos como los ejes X e Y de SCU.
CoordinateSystem.ByCyclindricalCoordinates Crea un CoordinateSystem en los parámetros de coordenadas cilíndricas especificados respecto al sistema de coordenadas especificado.
CREAR
Cuboid.ByLengths Crea un ortoedro centrado en el origen de SCU con anchura, longitud y altura.
Cuboid.ByLengths (origin)
Crea un ortoedro centrado en el punto de entrada con la anchura, la longitud y la altura especificadas.
Cuboid.ByLengths (coordinateSystem)
Crea un ortoedro centrado en el origen de SCU con anchura, longitud y altura.
Cuboid.ByCorners
Crea un ortoedro que abarca del punto inferior al punto superior.
Cuboid.Length
Devuelve las cotas de entrada del cubo, NO las cotas reales del espacio universal. **
Cuboid.Width
Devuelve las cotas de entrada del cubo, NO las cotas reales del espacio universal. **
Cuboid.Height
Devuelve las cotas de entrada del cubo, NO las cotas reales del espacio universal. **
BoundingBox.ToCuboid
Obtiene el cuadro delimitador como un ortoedro sólido.
ACCIONES
Curve.Extrude (distance) Extruye una curva en la dirección del vector normal.
Curve.PointAtParameter Obtiene un punto en la curva en el parámetro especificado entre StartParameter() y EndParameter().
ACCIONES
Geometry.DistanceTo Obtiene la distancia entre esta geometría y otra.
Geometry.Explode Separa elementos compuestos o no separados en sus componentes.
Geometry.ImportFromSAT Lista de geometrías importadas
Geometry.Rotate (basePlane) Rota un objeto sobre la normal y el origen del plano el número de grados especificado.
Geometry.Translate Traslada cualquier tipo de geometría según la distancia especificada en la dirección indicada.
CREAR
Line.ByBestFitThroughPoints Crea una línea que aproxima al máximo un diagrama de dispersión de puntos.
Line.ByStartPointDirectionLength Crea una línea recta desde el punto inicial y la extiende la longitud especificada en la dirección del vector.
Line.ByStartPointEndPoint Crea una línea recta entre dos puntos de entrada.
Line.ByTangency Crea una línea tangente a la curva de entrada, que se coloca en el parámetro de punto de la curva de entrada.
CONSULTA
Line.Direction La dirección de la curva.
Crear
NurbsCurve.ByControlPoints Crea una BSplineCurve mediante puntos de control explícitos.
NurbsCurve.ByPoints Crea una BSplineCurve mediante la interpolación entre puntos.
Crear
NurbsSurface.ByControlPoints Crea una NurbsSurface mediante el uso de puntos de control explícitos y los grados especificados para U y V.
NurbsSurface.ByPoints Crea una NurbsSurface con los puntos interpolados y los grados especificados para U y V. La superficie resultante atravesará todos los puntos.
CREAR
Plane.ByOriginNormal Crea un plano centrado en el punto raíz con el vector normal de entrada.
Plane.XY Crea un plano en el plano XY universal.
CREAR
Point.ByCartesianCoordinates Genera un punto en el sistema de coordenadas especificado con tres coordenadas cartesianas.
Point.ByCoordinates (2D) Genera un punto en el plano XY con las dos coordenadas cartesianas especificadas. El componente Z es 0.
Point.ByCoordinates (3D) Genera un punto con las tres coordenadas cartesianas especificadas.
Point.Origin Obtiene el punto de origen (0,0,0).
ACCIONES
Point.Add Añade un vector a un punto. Equivale a Translate (Vector).
CONSULTA
Point.X Obtiene el componente X de un punto.
Point.Y Obtiene el componente Y de un punto.
Point.Z Obtiene el componente Z de un punto.
CREAR
Polycurve.ByPoints Crea una PolyCurve a partir de una secuencia de líneas que conectan puntos. En una curva cerrada, el último punto debe estar en la misma ubicación que el punto inicial.
CREAR
Rectangle.ByWidthLength (plane) Crea un rectángulo centrado en la raíz del plano de entrada con la anchura (longitud del eje X del plano) y la longitud de entrada (longitud del eje Y del plano).
CREAR
Sphere.ByCenterPointRadius Crea una esfera sólida centrada en el punto de entrada con el radio especificado.
CREAR
Surface.ByLoft Crea una superficie mediante la solevación entre curvas de sección transversal de entrada.
Surface.ByPatch Crea una superficie mediante el relleno del interior de un contorno cerrado definido por curvas de entrada.
ACCIONES
Surface.Offset Desfasa la superficie en la dirección de la normal de superficie en función de la distancia especificada.
Surface.PointAtParameter Devuelve el punto en los parámetros U y V especificados.
Surface.Thicken Engrosa la superficie hasta convertirla en un sólido y realiza la extrusión en la dirección de las normales de superficie en ambos lados de la superficie.
CREAR
UV.ByCoordinates Crea un UV a partir de dos dobles.
CREAR
Vector.ByCoordinates Genera un vector mediante tres coordenadas euclidianas.
Vector.XAxis Obtiene el vector del eje X canónico (1,0,0).
Vector.YAxis Obtiene el vector del eje Y canónico (0,1,0).
Vector.ZAxis Obtiene el vector del eje Z canónico (0,0,1).
ACCIONES
Vector.Normalized Obtiene la versión normalizada de un vector.
CREAR
CoordinateSystem.ByOrigin Crea un CoordinateSystem con origen en el punto de entrada con los ejes X e Y establecidos como los ejes X e Y de SCU.
CoordinateSystem.ByCyclindricalCoordinates Crea un CoordinateSystem en los parámetros de coordenadas cilíndricas especificados respecto al sistema de coordenadas especificado.
+ Suma
- Resta
* Multiplicación
/ División
% La división modular busca el resto de la primera entrada después la división por la segunda entrada
< Menor que
> Mayor que
== Este operador comprueba la igualdad entre dos valores.
Booleano
Número
Cadena
Control deslizante de número
Ruta de directorio
Control deslizante de entero
Ruta de archivo
Object.IsNull | obj | bool |
Sumar (+) | var[]...[], var[]...[] | var[]...[] |
Restar (-) | var[]...[], var[]...[] | var[]...[] |
Multiplicar (*) | var[]...[], var[]...[] | var[]...[] |
Dividir (/) | var[]...[], var[]...[] | var[]...[] |
Si deseamos crear modelos más complejos que no se puedan crear a partir de una única superficie o si queremos definir un volumen explícito, debemos aventurarnos en el terreno de los sólidos (y las PolySurfaces). Incluso un cubo sencillo es lo suficientemente complejo como para necesitar seis superficies, una por cara. Los sólidos proporcionan acceso a dos conceptos clave que las superficies no ofrecen: una descripción topológica más refinada (caras, aristas y vértices) y operaciones booleanas.
Puede utilizar operaciones booleanas para modificar sólidos. Vamos a utilizar algunas operaciones booleanas para crear una bola llena de puntas.
Sphere.ByCenterPointRadius: cree el sólido base.
Topology.Faces, Face.SurfaceGeometry: consulte las caras del sólido y conviértalas en geometría de superficie; en este caso, la esfera solo tiene una cara.
Cone.ByPointsRadii: cree conos mediante puntos en la superficie.
Solid.UnionAll: una los conos y la esfera.
Topology.Edges: consulte las aristas del nuevo sólido.
Solid.Fillet: empalme las aristas de la bola llena de puntas.
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.
Las operaciones booleanas son complejas y pueden resultar lentas de calcular. Puede utilizar la función "Bloquear" para suspender la ejecución de nodos seleccionados y nodos descendentes afectados.
1. Utilice el menú contextual para bloquear la operación de unión de sólidos.
2. El nodo seleccionado y todos los nodos descendentes se previsualizan en modo atenuado con un color gris claro y los cables afectados se muestran como líneas continuas. La vista preliminar de la geometría afectada también se mostrará atenuada. Ahora puede cambiar los valores ascendentes sin calcular la unión booleana.
3. Para desbloquear los nodos, haga clic con el botón derecho y desactive la opción Bloquear.
4. Todos los nodos afectados y las vistas preliminares de la geometría asociada se actualizarán y se restablecerán al modo de vista preliminar estándar.
Puede obtener más información sobre cómo bloquear nodos en la sección Nodos y cables.
Los sólidos constan de una o varias superficies que contienen volumen a partir de un contorno cerrado que define lo que está "dentro" o "fuera". Independientemente de cuántas superficies haya, estas deben formar un volumen "hermético" para que se considere un sólido. Los sólidos se pueden crear mediante la unión de superficies o PolySurfaces, o mediante operaciones como, por ejemplo, solevación, barrido y revolución. Las primitivas de esfera, cubo, cono y cilindro también son sólidos. Un cubo con al menos una cara eliminada se considera una PolySurface, que tiene algunas propiedades similares, pero no es un sólido.
Un plano está compuesto por una única superficie y no es un sólido.
Una esfera está formada por una única superficie, pero es un sólido.
Un cono está formado por dos superficies unidas para crear un sólido.
Un cilindro está formado por tres superficies unidas para crear un sólido.
Un cubo está formado por seis superficies unidas para crear un sólido.
Los sólidos se componen de tres tipos de elementos: vértices, aristas y caras. Las caras son las superficies que conforman el sólido. Las aristas son las curvas que definen la conexión entre las caras adyacentes y los vértices son los puntos inicial y final de esas curvas. Estos elementos se pueden consultar mediante los nodos de topología.
Caras
Aristas
Vértices
Los sólidos se pueden modificar mediante empalmes o achaflanados de sus aristas para eliminar esquinas y ángulos agudos. La operación de chaflán crea una superficie reglada entre dos caras, mientras que un empalme se fusiona entre las caras para mantener la tangencia.
Cubo sólido
Cubo achaflanado
Cubo empalmado
Las operaciones booleanas de sólidos son métodos para combinar dos o más sólidos. Una única operación booleana implica realmente la realización de cuatro operaciones:
Interseque dos o más objetos.
Divídalos en las intersecciones.
Suprima las partes no deseadas de la geometría.
Una todo de nuevo.
Unión: elimine las partes que se solapan de los sólidos y únalas en un único sólido.
Diferencia: reste un sólido a otro. El sólido que se va a restar se conoce como herramienta. Tenga en cuenta que puede cambiar el sólido que será la herramienta para conservar el volumen inverso.
Intersección: conserve solo el volumen de intersección de los dos sólidos.
UnionAll: operación de unión con esfera y conos orientados hacia fuera.
DifferenceAll: operación de diferencia con esfera y conos orientados hacia dentro.
El color es un excelente tipo de datos para crear imágenes convincentes, así como para renderizar la diferencia en la salida del programa visual. Cuando se trabaja con datos abstractos y números variables, a veces es difícil ver qué se está cambiando y en qué grado. Esta es una aplicación excelente para los colores.
Los colores de Dynamo se crean con entradas de ARGB. Estas corresponden a los canales alfa, rojo, verde y azul. El canal alfa representa la transparencia del color, mientras que los otros tres se utilizan como colores principales para generar todo el espectro de color sincronizado.
Icono | Nombre (sintaxis) | Entradas | Salidas |
---|---|---|---|
Los colores de la tabla siguiente consultan las propiedades utilizadas para definir el color: alfa, rojo, verde y azul. Observe que el nodo Color.Components nos proporciona las cuatro salidas diferentes, lo que hace que este nodo sea preferible para consultar las propiedades de un color.
Icono | Nombre (sintaxis) | Entradas | Salidas |
---|---|---|---|
Los colores de la tabla siguiente corresponden al espacio de color HSB. La división del color en el matiz, la saturación y el brillo es, probablemente, más intuitiva en la forma en que se interpreta el color: ¿Qué color debería ser? ¿Debería ser más o menos colorido? ¿Y debería ser más o menos claro u oscuro? Este es el desglose del matiz, la saturación y el brillo respectivamente.
Icono | Nombre (sintaxis) | Entradas | Salidas |
---|---|---|---|
El rango de color es similar al nodo Remap Range del ejercicio #part-ii-from-logic-to-geometry; asigna de nuevo una lista de números a otro dominio. Sin embargo, en lugar de asignarla a un dominio de número, la asigna a un degradado de color basado en números de entrada que van del 0 al 1.
El nodo actual funciona bien, pero puede resultar un poco incómodo para que todo funcione la primera vez. La mejor forma de familiarizarse con el degradado de color es probarlo de forma interactiva. Hagamos un ejercicio rápido para revisar cómo configurar un degradado con colores de salida que corresponden a números.
Definir tres colores: con un nodo Code Block, defina rojo, verde y azul mediante la conexión de las combinaciones adecuadas de 0 y 255.
Crear lista:fusione los tres colores en una lista.
Definir índices: cree una lista para definir las posiciones de pinzamiento de cada color (de 0 a 1). Observe el valor de 0,75 para el verde. De este modo, se coloca el color verde a tres cuartos de camino en el degradado horizontal del control deslizante de rango de colores.
Code Block: valores de entrada (entre 0 y 1) para convertir en colores.
El nodo Display.ByGeometry nos permite colorear la geometría en la ventana gráfica de Dynamo. Esto resulta útil para separar diferentes tipos de geometría, demostrar un concepto paramétrico o definir una leyenda de análisis para la simulación. Las entradas son sencillas, geometría y color. Para crear un degradado como el de la imagen anterior, la entrada de color se conecta al nodo Color Range.
El nodo Display.BySurfaceColors nos permite asignar datos en una superficie mediante los colores. Esta función ofrece posibilidades interesantes para visualizar los datos obtenidos a través de análisis independientes como análisis solares, de energía o de proximidad. La aplicación de color a una superficie en Dynamo es similar a la aplicación de una textura a un material en otros entornos de CAD. Vamos a demostrar cómo utilizar esta herramienta en el siguiente ejercicio breve.
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.
Este ejercicio se centra en el control paramétrico del color en paralelo a la geometría. La geometría es una hélice básica que se define a continuación mediante el bloque de código. Esta es una forma rápida y sencilla de crear una función paramétrica y, como nuestro enfoque está en el color (en lugar de en la geometría), utilizamos el bloque de código para crear la hélice de forma eficaz sin sobrecargar el lienzo. Utilizaremos el bloque de código con más frecuencia a medida que el manual de introducción se adentre en materiales más avanzados.
Code Block: defina los dos bloques de código con las fórmulas mostradas anteriormente. Este es un método paramétrico rápido para crear una espiral.
Point.ByCoordinates: conecte las tres salidas del bloque de código a las coordenadas del nodo.
Ahora se muestra una matriz de puntos que crean una hélice. El siguiente paso consiste en crear una curva que atraviese los puntos para que podamos visualizar la hélice.
PolyCurve.ByPoints: conecte la salida Point.ByCoordinates en la entrada points del nodo. Se obtiene una curva helicoidal.
Curve.PointAtParameter: conecte la salida de PolyCurve.ByPoints a la entrada curve. La finalidad de este paso es crear un punto atractor paramétrico que se deslice a lo largo de la curva. Dado que la curva está evaluando un punto en el parámetro, necesitaremos introducir un valor en param entre 0 y 1.
Number Slider: después de añadirlo al lienzo, cambie el valor mínimo a 0,0, el valor máximo a 1,0 y el valor de paso a 0,01. Conecte la salida del control deslizante a la entrada param de Curve.PointAtParameter. Ahora se muestra un punto a lo largo de la longitud de la hélice representado por un porcentaje del control deslizante (0 en el punto inicial, 1 en el punto final).
Con el punto de referencia creado, ahora comparamos la distancia desde el punto de referencia a los puntos originales que definen la hélice. Este valor de distancia controlará la geometría y el color.
Geometry.DistanceTo: conecte la salida de Curve.PointAtParameter a la entrada. Conecte Point.ByCoordinates en la entrada geometry.
Watch: la salida resultante muestra una lista de las distancias desde cada punto helicoidal hasta el punto de referencia a lo largo de la curva.
El siguiente paso consiste en controlar los parámetros con la lista de distancias entre los puntos helicoidales y el punto de referencia. Utilizamos estos valores de distancia para definir los radios de una serie de esferas a lo largo de la curva. Para mantener las esferas en un tamaño adecuado, es necesario reasignar los valores de la distancia.
Math.RemapRange: conecte la salida de Geometry.DistanceTo a la entrada "numbers".
Code Block: conecte un bloque de código con un valor de 0,01 a la entrada newMin y un bloque de código con un valor de 1 a la entrada newMax.
Watch: conecte la salida de Math.RemapRange a un nodo y la salida de Geometry.DistanceTo a otro. Compare los resultados.
Este paso ha reasignado la lista de distancias para que tenga un rango más pequeño. Podemos editar los valores de newMin y newMax según consideremos adecuado. Los valores se reasignarán y tendrán la misma relación de distribución en todo el dominio.
Sphere.ByCenterPointRadius: conecte la salida de Math.RemapRange a la entrada radius y la salida de Point.ByCoordinates original a la entrada centerPoint.
Cambie el valor del control deslizante de número y observe cómo se actualiza el tamaño de las esferas. Ahora tenemos una guía paramétrica.
El tamaño de las esferas muestra la matriz paramétrica definida por un punto de referencia a lo largo de la curva. Usaremos el mismo concepto para que el radio de la esfera controle su color.
Color Range: añádalo al lienzo. Al pasar el cursor sobre la entrada value, observamos que los números solicitados se encuentran entre 0 y 1. Es necesario volver a asignar los números de la salida de Geometry.DistanceTo para que sean compatibles con este dominio.
Sphere.ByCenterPointRadius: por el momento, desactivemos la vista preliminar en este nodo (Haga clic con el botón derecho > Vista preliminar).
Math.RemapRange: este proceso debería resultarle familiar. Conecte la salida de Geometry.DistanceTo a la entrada "numbers".
Code Block: como hicimos en un paso anterior, cree el valor 0 para la entrada newMin y el valor 1 para la entrada newMax. Observe que, en este caso, podemos definir dos salidas de un bloque de código.
Color Range: conecte la salida de Math.RemapRange a la entrada value.
Color.ByARGB: esto es lo que haremos para crear dos colores. Aunque este proceso puede parecer incómodo, es el mismo que el utilizado con los colores RGB en otro software, solo que usamos programación visual para ello.
Code Block: cree dos valores de 0 y 255. Conecte las dos salidas a las dos entradas de Color.ByARGB de acuerdo con la imagen anterior (o cree sus dos colores favoritos).
Color Range: la entrada colors requiere una lista de colores. Se debe crear esta lista a partir de los dos colores creados en el paso anterior.
List.Create: combine los dos colores en una lista. Conecte la salida a la entrada colors de Color Range.
Display.ByGeometryColor: conecte Sphere.ByCenterPointRadius a la entrada geometry y Color Range a la entrada color. Ahora tenemos un degradado suave en el dominio de la curva.
Si se cambia el valor del control deslizante de número mostrado anteriormente, se actualizan los colores y los tamaños. Los colores y el tamaño del radio están directamente relacionados en este caso; ahora tenemos un vínculo visual entre dos parámetros.
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.
Es necesario crear primero una superficie o hacer referencia a ella para utilizarla como entrada en el nodo Display.BySurfaceColors. En este ejemplo, se realiza la solevación entre una curva seno y coseno.
Este grupo de nodos crea puntos a lo largo del eje Z y los desplaza según las funciones de seno y coseno. Las dos listas de puntos se utilizan a continuación para generar curvas NURBS.
Surface.ByLoft: genere una superficie interpolada entre las curvas NURBS de la lista.
File Path: seleccione un archivo de imagen para muestrear datos de píxeles.
Utilice File.FromPath para convertir la ruta de archivo en un archivo y, a continuación, páselo a Image.ReadFromFile para obtener una imagen para el muestreo.
Image.Pixels: introduzca una imagen y proporcione un valor de muestra para utilizarlo en las cotas X e Y de la imagen.
Control deslizante: proporcione valores de muestra para Image.Pixels.
Display.BySurfaceColors: asigne los valores de matriz de color de la superficie a lo largo de X e Y respectivamente.
Vista preliminar ampliada de la superficie de salida con resolución de 400 x 300 muestras
Ahora que hemos establecido lo que es una lista, hablemos de las operaciones que podemos realizar en ella. Imagine una lista como un mazo de cartas. El mazo es la lista y cada carta representa un elemento.
Fotografía de Christian Gidlöf
¿Qué consultas se pueden realizar a partir de la lista? Esto permite acceder a las propiedades existentes.
¿Número de cartas del mazo? 52.
¿Número de palos? 4.
¿Material? Papel.
¿Longitud? 3,5" u 89 mm.
¿Anchura? 2,5" o 64 mm.
¿Qué acciones se pueden realizar en la lista? Estas acciones cambian la lista en función de una operación especificada.
Podemos barajar el mazo de cartas.
Podemos ordenar el mazo por valor.
Podemos ordenar el mazo por palo.
Podemos dividir el mazo.
Podemos dividir el mazo repartiendo manos individuales.
Podemos seleccionar una carta específica del mazo.
Todas las operaciones mencionadas anteriormente tienen nodos análogos de Dynamo para trabajar con listas de datos genéricos. En las lecciones siguientes, se muestran algunas de las operaciones fundamentales que podemos realizar en las listas.
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.
La imagen siguiente es el gráfico base en el que se dibujan líneas entre dos círculos para representar operaciones de lista básicas. Exploraremos cómo administrar los datos de una lista y mostraremos los resultados visuales a través de las acciones de lista que aparecen a continuación.
Comience con un bloque de código con un valor de
500;
.Conéctelo a la entrada x de un nodo Point.ByCoordinates.
Conecte el nodo del paso anterior a la entrada origin de un nodo Plane.ByOriginNormal.
Con un nodo Circle.ByPlaneRadius, conecte el nodo del paso anterior en la entrada plane.
Mediante el bloque de código, designe un valor de
50;
para el radio. Este es el primer círculo que crearemos.Con un nodo Geometry.Translate, desplace el círculo hacia arriba 100 unidades en la dirección Z.
Con un nodo Code Block, defina un rango de diez números entre 0 y 1 con esta línea de código:
0..1..#10;
.Conecte el bloque de código del paso anterior a la entrada param de dos nodos Curve.PointAtParameter. Conecte Circle.ByPlaneRadius a la entrada "curve" del nodo superior y Geometry.Translate a la entrada curve del nodo situado debajo del mismo.
Con un nodo Line.ByStartPointEndPoint, conecte los dos nodos Curve.PointAtParameter.
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.
El nodo List.Count es sencillo: cuenta el número de valores de una lista y devuelve ese número. Este nodo presenta más detalles cuando se trabaja con listas de listas, pero eso lo veremos en las secciones siguientes.
El nodo **List.Count ****** devuelve el número de líneas del nodo Line.ByStartPointEndPoint. En este caso, el valor es 10, lo que coincide con el número de puntos creados a partir del nodo Code Block original.
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.
List.GetItemAtIndex es una forma fundamental de consultar un elemento de la lista.
En primer lugar, haga clic con el botón derecho en el nodo Line.ByStartPointEndPoint para desactivar su vista preliminar.
Con el nodo List.GetItemAtIndex, seleccionamos el índice "0" o el primer elemento de la lista de líneas.
Cambie el valor del control deslizante entre 0 y 9 para seleccionar un elemento diferente mediante List.GetItemAtIndex.
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.
List.Reverse invierte el orden de todos los elementos de una lista.
Para visualizar correctamente la lista de líneas invertida, cree más líneas. Para ello, cambie el nodo Code Block a
0..1..#50;
.Duplique el nodo Line.ByStartPointEndPoint, inserte un nodo List.Reverse entre Curve.PointAtParameter y el segundo nodo Line.ByStartPointEndPoint.
Utilice los nodos Watch3D para obtener una vista preliminar de dos resultados diferentes. El primero muestra el resultado sin una lista invertida. Las líneas se conectan verticalmente con los puntos adyacentes. Sin embargo, la lista invertida conectará todos los puntos con la otra lista en el orden opuesto.
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.
List.ShiftIndices es una buena herramienta para crear torsiones o patrones helicoidales, así como cualquier otra manipulación de datos similar. Este nodo desplaza los elementos de una lista un determinado número de índices.
En el mismo proceso que la lista inversa, inserte un nodo List.ShiftIndices en Curve.PointAtParameter y Line.ByStartPointEndPointPoint.
Mediante un bloque de código, designe un valor de "1" para desplazar la lista un índice.
Observe que el cambio es sutil, pero todas las líneas del nodo Watch3D inferior se han desplazado un índice al conectarlas al otro conjunto de puntos.
Al cambiar el bloque de código a un valor superior, por ejemplo "30", observamos una diferencia significativa en las líneas diagonales. El desplazamiento funciona como el iris de una cámara en este caso, creando una torsión en la forma cilíndrica original.
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.
List.FilterByBooleanMask eliminará determinados elementos en función de una lista de operaciones booleanos o valores de "verdadero" o "falso".
Para crear una lista de valores de "verdadero" o "falso", necesitamos realizar un poco más de trabajo...
Mediante un bloque de código, defina una expresión con la sintaxis:
0..List.Count(list);
. Conecte el nodo Curve.PointAtParameter a la entrada list. Veremos más detalles sobre esta configuración en el capítulo del bloque de código, pero la línea de código en este caso nos proporciona una lista que representa cada índice del nodo Curve.PointAtParameter.Mediante un nodo %** (módulo)**, conecte la salida del bloque de código en la entrada x y un valor de 4 en la salida y. Esto nos dará el resto al dividir la lista de índices entre 4. El módulo es un nodo muy útil para la creación de patrones. Todos los valores serán los restos posibles de 4: 0, 1, 2, 3.
En el nodo %** (módulo)**, sabemos que el valor 0 significa que el índice es divisible por 4 (0, 4, 8, etc.). Mediante un nodo ==, podemos probar la divisibilidad frente a un valor de "0".
El nodo Watch muestra solo esto; disponemos de un patrón verdadero/falso que dice: verdadero,falso,falso,falso,falso....
Mediante este patrón verdadero/falso, conéctelo a la entrada "mask" de dos nodos List.FilterByBooleanMask.
Conecte el nodo Curve.PointAtParameter en cada una de las entradas "list" de los nodos List.FilterByBooleanMask.
Las salidas de Filter.ByBooleanMask son "in" y "out". "In" representa los valores que tenían un valor de máscara de "Verdadero (True)" mientras que "out" representa los valores que tenían un valor de "Falso (False)". Al conectar las salidas "in" a las entradas startPoint y endPoint de un nodo Line.ByStartPointEndPoint, hemos creado una lista filtrada de líneas.
El nodo Watch3D indica que hay menos líneas que puntos. Hemos seleccionado solo el 25 % de los nodos filtrando solo los valores verdaderos.
Añadamos un nivel más a la jerarquía. Si utilizamos la baraja de cartas del ejemplo original y creamos un cuadro que contiene varias barajas, este representa ahora una lista de barajas y cada baraja representa una lista de cartas. Esta es una lista de listas. En esta sección, usaremos la siguiente analogía: el cuadro rojo mostrado a continuación contiene un rollo de monedas y cada rollo contiene una lista de peniques.
Fotografía de Dori.
¿Qué consultas se pueden realizar a partir de la lista de listas? Esto permite acceder a las propiedades existentes.
¿Número de tipos de moneda? 2.
¿Valores de tipo de moneda? 0,01 y 0,25 USD.
¿Material de los cuartos de dólar? 75 % de cobre y 25 % de níquel.
¿Material de los peniques? 97,5 % de zinc y 2,5% de cobre.
¿Qué acciones se pueden realizar en la lista de listas? Esta acción cambia la lista de listas en función de la operación especificada.
Seleccione un montón específico de cuartos de dólar o peniques.
Seleccione un cuarto de dólar o un penique específicos.
Reorganice los montones de cuartos de dólar y peniques.
Junte los montones.
De nuevo, Dynamo tiene un nodo análogo para cada una de las operaciones anteriores. Como trabajamos con datos abstractos y no con objetos físicos, necesitamos un conjunto de reglas para controlar el desplazamiento hacia arriba y hacia abajo por la jerarquía de datos.
Al trabajar con listas de listas, los datos son complejos y se dividen en capas, pero esto ofrece la oportunidad de realizar operaciones paramétricas impresionantes. Vamos a desglosar los conceptos básicos y abordar algunas operaciones más en las lecciones mostradas a continuación.
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.
El concepto fundamental que se debe aprender en esta sección: Dynamo trata las listas como objetos en sí mismos. Esta jerarquía descendente se desarrolla teniendo en cuenta la programación orientada a objetos. En lugar de seleccionar subelementos con un comando como List.GetItemAtIndex, Dynamo seleccionará ese índice de la lista principal en la estructura de datos. Y ese elemento puede ser otra lista. Vamos a desglosar esto con una imagen de ejemplo:
Con el bloque de código, hemos definido dos intervalos:
0..2; 0..3;
.Estos intervalos están conectados a un nodo Point.ByCoordinates con el encaje establecido en "Producto vectorial". De este modo, se crea una rejilla de puntos y también se devuelve una lista de listas como salida.
Observe que el nodo Watch proporciona tres listas con cuatro elementos en cada lista.
Cuando se utiliza List.GetItemAtIndex con un índice 0, Dynamo selecciona la primera lista y todo su contenido. Es posible que otros programas seleccionen el primer elemento de cada lista de la estructura de datos, pero Dynamo utiliza una jerarquía descendente al trabajar con los datos.
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.
Flatten elimina todos los niveles de datos de una estructura de datos. Esto resulta útil cuando las jerarquías de datos no son necesarias para la operación, pero puede resultar peligroso porque elimina información. En el siguiente ejemplo, se muestra el resultado de aplanar una lista de datos.
Inserte una línea de código para definir un intervalo en el bloque de código:
-250..-150..#4;
.Al conectar el bloque de código a la entrada x e y de un nodo Point.ByCoordinates, se establece el encaje como "Producto vectorial" para obtener una rejilla de puntos.
En el nodo Watch, se muestra que tenemos una lista de listas.
Un nodo PolyCurve.ByPoints hará referencia a cada lista y creará la PolyCurve respectiva. En la vista preliminar de Dynamo, observe que tenemos cuatro PolyCurves que representan cada fila de la rejilla.
Al insertar un elemento Flatten antes del nodo de PolyCurve, hemos creado una única lista para todos los puntos. El nodo PolyCurve.ByPoints hace referencia a una lista para crear una curva y, como todos los puntos están en una lista, se obtiene una PolyCurve en zigzag que se ejecuta en toda la lista de puntos.
También existen opciones para aplanar niveles aislados de datos. Mediante el nodo List.Flatten, puede definir un número establecido de niveles de datos que aplanar desde la parte superior de la jerarquía. Esta es una herramienta muy útil si tiene problemas con estructuras de datos complejas que no son necesariamente pertinentes para el flujo de trabajo. Otra opción consiste en utilizar el nodo de aplanado como una función en List.Map. A continuación, examinaremos más detalladamente List.Map.
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 el modelado paramétrico, también hay ocasiones en las que se desea modificar la estructura de datos en una lista existente. Hay muchos nodos disponibles para ello y el elemento "Chop" es la versión más básica. Con "Chop", se puede dividir una lista en sublistas con un número establecido de elementos.
El comando "Chop" divide listas en función de una longitud de lista determinada. De alguna manera, el efecto de "Chop" es contrario al efecto de "Flatten": en lugar de eliminar una estructura de datos, se añaden nuevos niveles a ella. Es una herramienta útil para operaciones geométricas, como el ejemplo siguiente.
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.
List.Map/Combine aplica una función establecida a una lista de entradas, pero un nivel hacia abajo en la jerarquía. Las combinaciones son iguales a las asignaciones, excepto que las combinaciones pueden tener varias entradas correspondientes a la entrada de una determinada función.
Nota: Este ejercicio se ha creado con una versión anterior de Dynamo. Gran parte de la funcionalidad de List.Map se ha resuelto con la adición de la función List@Level . Para obtener más información, consulte List@Level a continuación.
Como introducción rápida, examinemos el nodo List.Count de una sección anterior.
El nodo List.Count realiza un recuento de todos los elementos de una lista. Utilizaremos esta opción para mostrar cómo funciona List.Map.
Inserte dos líneas de código en el bloque de código:
-50..50..#Nx; -50..50..#Ny;
.Después de escribir este código, el bloque de código creará dos entradas para Nx y Ny.
Con dos controles deslizantes de enteros, defina los valores de Nx y Ny conectándolos al bloque de código.
Conecte cada línea del bloque de código a las entradas X e Y respectivas de un nodo Point.ByCoordinates. Haga clic con el botón derecho en el nodo, seleccione "Encaje" y, a continuación, elija "Producto vectorial". Esta acción crea una rejilla de puntos. Como hemos definido el intervalo de -50 a 50, se extiende la rejilla de Dynamo por defecto.
En el nodo Watch, se muestran los puntos creados. Observe la estructura de datos. Hemos creado una lista de listas. Cada lista representa una fila de puntos de la rejilla.
Enlace un nodo List.Count a la salida del nodo de visualización del paso anterior.
Conecte un nodo Watch a la salida de List.Count.
Observe que el nodo List.Count ofrece el valor 5. Este es igual a la variable "Nx", tal y como se ha definido en el bloque de código. ¿Por qué ocurre eso?
En primer lugar, el nodo Point.ByCoordinates utiliza la entrada "x" como entrada principal para crear listas. Si Nx es 5 y Ny es 3, se obtiene una lista de cinco listas, cada una con tres elementos.
Como Dynamo trata las listas como objetos en sí mismos, se aplica un nodo List.Count a la lista principal de la jerarquía. El resultado es el valor 5 o el número de listas de la lista principal.
Mediante un nodo List.Map, nos desplazaremos un nivel hacia abajo en la jerarquía y ejecutaremos una "función" en este nivel.
Observe que el nodo List.Count no tiene ninguna entrada. Se utiliza como una función, por lo que el nodo List.Count se aplicará a cada lista individual un nivel hacia abajo en la jerarquía. La entrada en blanco de List.Count corresponde a la entrada de lista de List.Map.
Los resultados de List.Count ahora proporcionan una lista de cinco elementos, cada uno con el valor 3. Esto representa la longitud de cada sublista.
Nota: Este ejercicio se ha creado con una versión anterior de Dynamo. Gran parte de la funcionalidad de List.Combine se ha resuelto con la adición de la función List@Level. Para obtener más información, consulte List@Level a continuación.
En este ejercicio, utilizaremos List.Combine para mostrar cómo se puede utilizar para aplicar una función en listas de objetos independientes.
Configure primero dos listas de puntos.
Utilice el nodo Sequence para generar 10 valores, cada uno con un incremento de 10 pasos.
Conecte el resultado a la entrada x de un nodo Point.ByCoordinates. De este modo, se creará una lista de puntos en Dynamo.
Añada un segundo nodo Point.ByCoordinates al espacio de trabajo; utilice la misma salida de Sequence como entrada x, pero utilice un control deslizante de entero como entrada y, y establezca su valor en 31 (puede ser cualquier valor siempre que no se solape con el primer conjunto de puntos) para que los dos conjuntos de puntos no se solapen entre sí.
A continuación, utilizaremos List.Combine para aplicar una función a los objetos de dos listas independientes. En este caso, será una función de línea de dibujo sencilla.
Añada List.Combine al espacio de trabajo y conecte los dos conjuntos de puntos como entrada list0 y list1.
Utilice Line.ByStartPointEndPoint como función de entrada para List.Combine.
Una vez completado, los dos conjuntos de puntos se comprimen o se emparejan mediante una función Line.ByStartPointEndPoint y se devuelven 10 líneas en Dynamo.
Consulte el ejercicio de listas de n dimensiones para ver otro ejemplo de uso de List.Combine.
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.
Como alternativa a List.Map, la función List@Level permite seleccionar directamente el nivel de lista con el que se desea trabajar justo en el puerto de entrada del nodo. Esta función se puede aplicar a cualquier entrada de un nodo y le permitirá acceder a los niveles de las listas de forma más rápida y sencilla que con otros métodos. Solo tiene que indicar al nodo el nivel de la lista que desea utilizar como entrada y permitir que el nodo realice el resto.
En este ejercicio, utilizaremos la función List@Level para aislar un nivel específico de datos.
Comenzaremos con una rejilla 3D de puntos sencilla.
Como la rejilla se ha creado con un intervalo para X, Y y Z, sabemos que los datos están estructurados con tres capas: una lista X, una lista Y y una lista Z.
Estas capas existen en niveles diferentes. Los niveles se indican en la parte inferior de la burbuja de vista preliminar. Las columnas de niveles de la lista corresponden a los datos de la lista anterior para ayudar a identificar el nivel en el que se va a trabajar.
Los niveles de la lista se organizan en orden inverso, por lo que los datos de nivel inferior siempre se encuentran en "L1". Esto ayudará a garantizar que los gráficos funcionen según lo planeado, incluso aunque se realicen cambios en niveles superiores.
Para utilizar la función List@Level, haga clic en ">". En este menú, verá dos casillas de verificación.
Utilizar niveles: permite utilizar la función List@Level. Después de hacer clic en esta opción, podrá hacer clic por los niveles de lista de entrada que desee que utilice el nodo, además de seleccionarlos. Con este menú, puede probar rápidamente diferentes opciones de nivel haciendo clic arriba o abajo.
Mantener la estructura de listas: si se ha activado, dispondrá de la opción para mantener la estructura de niveles de esa entrada. En ocasiones, es posible que haya organizado deliberadamente los datos en sublistas. Al seleccionar esta opción, puede mantener la organización de listas intacta sin perder información.
Con nuestra sencilla rejilla 3D, podemos acceder a la estructura de listas y visualizarla mediante la activación o la desactivación de los niveles de la lista. Cada combinación de nivel de lista e índice devolverá un conjunto de puntos diferente de nuestro conjunto 3D original.
"@L2" en DesignScript nos permite seleccionar únicamente la lista en el nivel 2. La lista del nivel 2 con el índice 0 incluye solo el primer conjunto de puntos Y y devuelve solo la rejilla XZ.
Si cambiamos el filtro Nivel a "L1", podremos ver todos los elementos del primer nivel de lista. La lista del nivel 1 con el índice 0 incluye todos los puntos 3D en una lista plana.
Si intentamos realizar lo mismo para "L3", solo veremos los puntos del tercer nivel de lista. La lista del nivel 3 con el índice 0 incluye solo el primer conjunto de puntos Z y devuelve solo la rejilla XY.
Si intentamos realizar lo mismo para "L4", solo veremos los puntos del tercer nivel de lista. La lista del nivel 4 con el índice 0 incluye solo el primer conjunto de puntos X y devuelve solo la rejilla YZ.
Aunque este ejemplo específico también se puede crear con List.Map, List@Level simplifica considerablemente la interacción, lo que facilita el acceso a los datos del nodo. Consulte la siguiente comparación entre los métodos List.Map y List@Level:
Aunque ambos métodos nos brindarán acceso a los mismos puntos, el método List@Level permite alternar fácilmente entre capas de datos dentro de un único nodo
Para acceder a una rejilla de puntos con List.Map, necesitaremos un nodo List.GetItemAtIndex, junto con List.Map. Para cada nivel de lista que descendamos, necesitaremos utilizar un nodo List.Map adicional. Según la complejidad de las listas, esto podría requerir la adición de una gran cantidad de nodos List.Map al gráfico para acceder al nivel de información adecuado.
En este ejemplo, un nodo List.GetItemAtIndex con un nodo List.Map devuelve el mismo conjunto de puntos con la misma estructura de listas que List.GetItemAtIndex con "@L3" seleccionado.
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.
Transpose es una función fundamental al utilizar listas de listas. Al igual que en los programas de hojas de cálculo, una transposición intercambia las columnas y las filas de una estructura de datos. Mostraremos esto con una matriz básica a continuación y, en la siguiente sección, demostraremos cómo se puede utilizar una transposición para crear relaciones geométricas.
Suprimiremos los nodos List.Count del ejercicio anterior y pasaremos a alguna geometría para ver cómo se estructuraron los datos.
Conecte PolyCurve.ByPoints a la salida del nodo de inspección desde Point.ByCoordinates.
En la salida, se muestran cinco PolyCurves. Podemos ver las curvas en la vista preliminar de Dynamo. El nodo de Dynamo busca una lista de puntos (o, en este caso, una lista de listas de puntos) y crea una única PolyCurve a partir de ellas. Básicamente, cada lista se ha convertido en una curva en la estructura de datos.
Un nodo List.Transpose intercambiará todos los elementos con todas las listas de una lista de listas. Esto suena complicado, pero es la misma lógica que la transposición en Microsoft Excel: intercambiar las columnas y las filas en una estructura de datos.
Observe el resultado abstracto: la transposición ha cambiado la estructura de listas de cinco listas con tres elementos cada una a tres listas con cinco elementos cada una.
Observe el resultado geométrico: al utilizar PolyCurve.ByPoints, se obtienen tres PolyCurves en la dirección perpendicular a las curvas originales.
El modo de bloque de código abreviado utiliza "[]" para definir una lista. Esta es una forma mucho más rápida y fluida de crear una lista que con el nodo List.Create. El bloque de código se aborda con más detalle en Bloques de código y DesignScript. Consulte la imagen mostrada a continuación para observar cómo se puede definir una lista con varias expresiones mediante el bloque de código.
La abreviatura de bloque de código utiliza "[]" como método rápido y sencillo para seleccionar elementos específicos deseados en una estructura de datos compleja. Los bloques de código se describen con más detalle en el capítulo Bloques de código y DesignScript. Consulte la imagen mostrada a continuación para observar cómo se puede consultar una lista con varios tipos de datos con un bloque de código.
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, se utiliza parte de la lógica establecida en el ejercicio anterior para editar una superficie. Nuestro objetivo es intuitivo, pero la navegación por la estructura de datos es más participativa. Deseamos articular una superficie mediante el desplazamiento de un punto de control.
Comience con la cadena de nodos anterior. Vamos a crear una superficie básica que abarque la rejilla de Dynamo por defecto.
Mediante el bloque de código, inserte estas dos líneas de código y conéctelas a las entradas u y v de Surface.PointAtParameter respectivamente:
-50..50..#3;
-50..50..#5;
.Asegúrese de establecer el encaje de Surface.PointAtParameter en "Producto vectorial".
En el nodo Watch, se muestra que tenemos una lista de tres listas con cinco elementos cada una.
En este paso, deseamos consultar el punto central de la rejilla que hemos creado. Para ello, seleccionaremos el punto medio de la lista central. Tiene sentido, ¿verdad?
Para confirmar que este es el punto adecuado, también podemos hacer clic por los elementos del nodo de visualización para confirmar que se trata del objetivo correcto.
Mediante el bloque de código, escribiremos una línea de código básica para consultar una lista de listas, como se indica a continuación:
points[1][2];
.Con Geometry.Translate, desplazaremos el punto seleccionado hacia arriba en la dirección Z en 20 unidades.
Vamos a seleccionar la fila central de puntos con un nodo List.GetItemAtIndex. Nota: Al igual que en un paso anterior, también podemos consultar la lista con un bloque de código mediante una línea de
points[1];
.
Hasta ahora, hemos consultado correctamente el punto central y lo hemos desplazado hacia arriba. Ahora deseamos insertar de nuevo este punto desplazado en la estructura de datos original.
Deseamos reemplazar primero el elemento de la lista que hemos aislado en un paso anterior.
Con List.ReplaceItemAtIndex, sustituiremos el elemento central mediante el uso de un índice "2" con el elemento de reemplazo conectado al punto desplazado (Geometry.Translate).
En la salida, se muestra que hemos introducido el punto desplazado en el elemento central de la lista.
Ahora que hemos modificado la lista, debemos volver a insertarla en la estructura de datos original: la lista de listas.
Siguiendo la misma lógica, utilice List.ReplaceItemAtIndex para reemplazar la lista central por la lista modificada.
Observe que los bloques de código que definen el índice de estos dos nodos son 1 y 2, que coinciden con la consulta original del bloque de código (points[1][2]).
Al seleccionar la lista en el índice 1, veremos la estructura de datos resaltada en la vista preliminar de Dynamo. Hemos fusionado correctamente el punto desplazado con la estructura de datos original.
Hay muchas formas de crear una superficie a partir de este conjunto de puntos. En este caso, vamos a crear una superficie mediante la solevación conjunta de curvas.
Cree un nodo NurbsCurve.ByPoints y conecte la nueva estructura de datos para crear tres curvas NURBS.
Conecte Surface.ByLoft a la salida desde NurbsCurve.ByPoints. Ahora tenemos una superficie modificada. Podemos cambiar el valor Z original de la geometría. Realice el traslado y vea cómo se actualiza la geometría.
Formalmente, una cadena es una secuencia de caracteres que representa una constante literal o algún tipo de variable. Informalmente, una cadena es texto en la jerga de la programación. Hemos trabajado con números, enteros y decimales, para controlar los parámetros y podemos hacer lo mismo con el texto.
Las cadenas se pueden utilizar para una amplia gama de aplicaciones, como la definición de parámetros personalizados, la anotación de conjuntos de documentación y el análisis mediante conjuntos de datos basados en texto. El nodo string se encuentra en la categoría Core > Input.
Los nodos de ejemplo anteriores son cadenas. Un número puede representarse como una cadena, al igual que una letra o una matriz completa de texto.
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.
Puede analizar rápidamente grandes cantidades de datos consultando cadenas. Hablaremos de algunas operaciones básicas que pueden acelerar un flujo de trabajo y ayudar a mejorar la interoperabilidad de software.
La imagen siguiente se basa en una cadena de datos procedentes de una hoja de cálculo externa. La cadena representa los vértices de un rectángulo en el plano XY. Vamos a desglosar algunas operaciones de división de cadenas en un ejercicio de miniaturas:
El separador ";" divide cada vértice del rectángulo. De este modo, se crea una lista con tres elementos para cada vértice.
Al pulsar "+" en el centro del nodo, se crea un nuevo separador.
Añada una cadena "," al lienzo y conéctela a la nueva entrada de separador.
Nuestro resultado es ahora una lista de diez artículos. El nodo realiza la división primero en función de separator0 y, a continuación, en función de separator1.
Aunque los elementos de la lista anterior pueden tener el aspecto de números, se siguen considerando cadenas individuales en Dynamo. Para crear puntos, su tipo de datos debe convertirse de una cadena a un número. Esto se realiza con el nodo String.ToNumber.
Este nodo es sencillo. Conecte los resultados de String.Split a la entrada. La salida no tiene un aspecto diferente, pero el tipo de datos es ahora un número en lugar de una cadena.
Con algunas operaciones básicas adicionales, ahora se ha dibujado un triángulo en el origen en función de la entrada de cadena original.
Dado que una cadena es un objeto de texto genérico, alberga una amplia gama de aplicaciones. Echemos un vistazo a algunas de las acciones principales de la categoría Core > String de Dynamo:
Este es un método para fusionar dos cadenas en orden. Toma cada cadena literal de una lista y crea una cadena combinada.
A continuación, se representa la concatenación de tres cadenas:
Añada o sustraiga cadenas a la concatenación haciendo clic en los botones +/- del centro del nodo.
La salida es una cadena concatenada, incluidos espacios y signos de puntuación.
El método de unión es muy similar a la concatenación, excepto que tiene una capa añadida de signos de puntuación.
Si ha trabajado en Excel, es posible que haya encontrado un archivo CSV. Se trata de un archivo de valores separados por comas. Se puede utilizar una coma (o, en este caso, dos guiones) como separador con el nodo String.Join para crear una estructura de datos similar.
La imagen anterior representa la unión de dos cadenas:
La entrada "separator" permite crear una cadena que divide las cadenas unidas.
En este ejercicio, vamos a usar métodos de consulta y manipulación de cadenas para deconstruir la última estrofa del poema Alto en el bosque en una noche de invierno de Robert Frost. No es la aplicación más práctica, pero nos ayudará a comprender las acciones de cadenas conceptuales a medida que las aplicamos a líneas legibles de ritmo y rima.
Comencemos con una división de cadenas básica de la estrofa. Primero, observamos que el formato de la escritura se basa en comas. Utilizaremos este formato para separar cada línea en elementos individuales.
La cadena base se pega en un nodo String.
Se utiliza otro nodo String para indicar el separador. En este caso, usamos una coma.
Se añade un nodo String.Split al lienzo y se conecta a las dos cadenas.
La salida muestra ahora que hemos separado las líneas en elementos individuales.
Ahora, vamos a la parte buena del poema: las dos últimas líneas. La estrofa original era un elemento de datos. En el primer paso, separamos estos datos en elementos individuales. Ahora debemos buscar el texto que deseamos encontrar. Y, aunque podemos hacerlo seleccionando los dos últimos elementos de la lista, si se tratara de un libro completo, no sería un método eficaz leerlo todo y aislar manualmente los elementos.
En lugar de realizar una búsqueda manual, se utiliza un nodo String.Contains para realizar una búsqueda de un conjunto de caracteres. Esto es similar a utilizar el comando "Buscar" en un procesador de texto. En este caso, obtenemos un valor de "verdadero" o "falso" si se encuentra esa subcadena en el elemento.
En la entrada searchFor, definimos la subcadena que buscamos dentro de la estrofa. Vamos a usar un nodo String con el texto "And miles".
La salida nos proporciona una lista de resultados de verdadero y falso. Utilizaremos esta lógica booleana para filtrar los elementos en el siguiente paso.
List.FilterByBoolMask es el nodo que debemos utilizar para seleccionar los resultados con valor "false" (falso) y "true" (verdadero). La salida "in" devuelve las instrucciones con una entrada "mask" de "verdadero", mientras que la salida "out" devuelve las que tienen un valor de "falso".
Nuestra salida de "in" es como se esperaba, ya que devuelve las dos frases finales de la estrofa.
Ahora, vamos a dejar clara la repetición de la estrofa fusionando las dos líneas. Al visualizar el resultado del paso anterior, observamos que hay dos elementos en la lista:
Mediante dos nodos List.GetItemAtIndex, se pueden aislar los elementos con los valores 0 y 1 como entrada del índice.
La salida de cada nodo nos proporciona, por orden, las dos líneas finales.
Para fusionar estos dos elementos en uno, se utiliza el nodo String.Join:
Después de añadir el nodo String.Join, observamos que necesitamos un separador.
Para crear el separador, se añade un nodo String al lienzo y se escribe una coma.
La última salida ha fusionado los dos últimos elementos en uno.
Puede parecer muy laborioso aislar las dos últimas líneas y es cierto que, a menudo, las operaciones de cadena requieren trabajo inicial. Pero son escalables y se pueden aplicar a grandes conjuntos de datos con relativa facilidad. Si trabaja paramétricamente con hojas de cálculo e interoperabilidad, asegúrese de mantener en mente las operaciones de cadena.
La lógica o, más específicamente, la lógica condicional nos permite especificar una acción o un conjunto de acciones basadas en una prueba. Tras evaluar la prueba, dispondremos de un valor booleano que representa True
o False
que podemos utilizar para controlar el flujo del programa.
Las variables numéricas pueden almacenar una gran variedad de números diferentes. Las variables booleanas solo pueden almacenar dos valores denominados Verdadero o Falso, Sí o No, 1 o 0. Rara vez utilizamos booleanos para realizar cálculos debido a su rango limitado.
La instrucción "If" ("si") es un concepto clave en la programación: "Si esto es cierto, eso ocurre; de lo contrario, otra cosa ocurre. La acción resultante de la instrucción se rige por un valor booleano. Hay varias formas de definir una instrucción "If" en Dynamo:
Icono | Nombre (sintaxis) | Entradas | Salidas |
---|---|---|---|
Veamos un breve ejemplo de cada uno de estos tres nodos en acción mediante la instrucción condicional "If".
En esta imagen, el nodo Boolean se ha establecido en Verdadero (True), lo que significa que el resultado es una cadena que dice: "este es el resultado si es verdadero". Los tres nodos que crean la instrucción If funcionan de la misma forma aquí.
De nuevo, los nodos funcionan de la misma forma. Si el nodo Boolean se cambia a Falso (False), el resultado es el número Pi, tal y como se define en la instrucción If original.
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.
Usemos la lógica para separar una lista de números en una lista de números pares y una lista de números impares.
a. Number Range: añada un rango de números al lienzo.
b. Nodos Number: añada tres nodos numéricos al lienzo. El valor de cada nodo numérico debe ser 0,0 para start, 10,0 para end y 1,0 para step.
c. Salida: nuestra salida es una lista de 11 números que van del 0 al 10.
d. Módulo (%): Number Range se conecta a x y 2,0 a y. De este modo, se calcula el resto de cada número de la lista dividido por 2. La salida de esta lista nos proporciona una lista de valores alternantes entre 0 y 1.
e. Prueba de igualdad (==): añada una prueba de igualdad al lienzo. Conecte la salida de módulo a la entrada x y 0,0 en la entrada y.
f. Watch: la salida de la prueba de igualdad es una lista de valores que alterna entre verdadero y falso. Estos son los valores utilizados para separar los elementos de la lista. 0 (o true) representa números pares y 1 (o false) representa números impares.
g. List.FilterByBoolMask: este nodo filtrará los valores en dos listas diferentes en función del valor booleano de entrada. Conecte el nodo Number Range original a la entrada list y la salida de la prueba de igualdad en la entrada mask. La salida in representa los valores verdaderos, mientras que la salida out representa los valores falsos.
h. Watch: como resultado, ahora tenemos una lista de números pares y una de impares. Hemos utilizado operadores lógicos para separar las listas en patrones.
Basándonos en la lógica establecida en el primer ejercicio, vamos a aplicar esta configuración en una operación de modelado.
2. Comenzaremos por donde dejamos el ejercicio anterior, con los mismos nodos. Las únicas excepciones (además de cambiar el formato) son las siguientes:
a. Utilice un nodo Sequence con estos valores de entrada.
b. Se ha desconectado la entrada list en List.FilterByBoolMask. Dejaremos estos nodos a un lado por ahora, pero en fases posteriores del ejercicio serán muy útiles.
3. Creemos primero un grupo independiente de gráficos, como se muestra en la imagen anterior. Este grupo de nodos representa una ecuación paramétrica para definir una curva de línea. Información que debemos tener en cuenta:
a. El primer control deslizante de número representa la frecuencia de la onda; debe tener un mínimo de 1, un máximo de 4 y un paso de 0,01.
b. El segundo control deslizante de número representa la amplitud de la onda; debe tener un mínimo de 0, un máximo de 1 y un paso de 0,01.
c. PolyCurve.ByPoints: si se copia el diagrama de nodos anterior, el resultado es una curva de seno en la ventana de vista preliminar de Dynamo.
El método que se sigue para las entradas es utilizar nodos numéricos para las propiedades más estáticas y controles deslizantes de número para las más flexibles. Vamos a mantener el rango de números original que definimos al principio de este paso. Sin embargo, la curva de seno que se crea aquí debe tener cierta flexibilidad. Se pueden mover estos controles deslizantes para ver cómo se actualiza la frecuencia y la amplitud de la curva.
4. Vamos a saltar un poco en la definición, así que veamos el resultado final para que podamos tener como referencia lo que vamos a conseguir. Los dos primeros pasos se realizan por separado; ahora queremos conectar los dos. Utilizaremos la curva de seno base para controlar la ubicación de los componentes de cremallera y utilizaremos la lógica de verdadero/falso para alternar entre cuadros pequeños y cuadros más grandes.
a. Math.RemapRange: con la secuencia de números creada en el paso 02, vamos a crear una nueva serie de números reasignando el rango. Los números originales del paso 01 van del 0 al 100. Estos números oscilan entre 0 y 1 en las entradas newMin y newMax respectivamente.
5. Cree un nodo Curve.PointAtParameter y, a continuación, conecte la salida Math.RemapRange del paso 04 como su entrada param.
Este paso crea puntos a lo largo de la curva. Hemos reasignado los números a entre 0 y 1 porque la entrada param busca valores en este rango. El valor 0 representa el punto inicial; el valor 1 representa los puntos finales. Todos los números que se encuentran en medio se evalúan dentro del rango de [0,1].
6. Conecte la salida de Curve.PointAtParameter a List.FilterByBoolMask para separar la lista de índices pares e impares.
a. List.FilterByBoolMask: conecte el nodo Curve.PointAtParameter del paso anterior a la entrada list.
b. Watch: un nodo de visualización para in y otro para out indican que hay dos listas que representan índices pares e impares. Estos puntos se ordenan de la misma forma en la curva, que se muestra en el siguiente paso.
7. A continuación, vamos a utilizar el resultado de salida de List.FilterByBoolMask en el paso 05 para generar geometrías con tamaños según sus índices.
Cuboid.ByLengths: reproduzca las conexiones representadas en la imagen anterior para obtener una cremallera a lo largo de la curva de seno. Un cubo es solo un cuadro, y estamos definiendo su tamaño basándonos en el punto de curva del centro del cuadro. La lógica de la división par/impar debería ser clara ahora en el modelo.
a. Lista de ortoedros en índices uniformes.
b. Lista de ortoedros en índices impares.
Y eso es todo. Acaba de programar un proceso para definir las cotas de geometría de acuerdo con la operación lógica que se muestra en este ejercicio.
Las listas son la forma en que organizamos los datos. En el sistema operativo del equipo, tiene archivos y carpetas. En Dynamo, podemos considerarlos como elementos y listas respectivamente. Al igual que su sistema operativo, existen muchas formas de crear, modificar y consultar datos. En este capítulo, vamos a desglosar el modo en que se gestionan las listas en Dynamo.
Una lista es un conjunto de elementos o ítems. Pensemos en un racimo de plátanos, por ejemplo. Cada plátano es un elemento de la lista (o racimo). Es más fácil coger un racimo de plátanos que cada plátano individualmente y lo mismo se aplica a la agrupación de elementos por relaciones paramétricas en una estructura de datos.
Fotografía de Augustus Binu.
Cuando hacemos la compra, ponemos todos los artículos comprados en una bolsa. Esta bolsa también es una lista. Si vamos a hacer pan de plátano, necesitamos tres racimos de plátanos (vamos a hacer mucho pan de plátano). La bolsa representa una lista de racimos de plátanos y cada racimo representa una lista de plátanos. La bolsa es una lista de listas (bidimensional) y el racimo de plátanos es una lista (unidimensional).
En Dynamo, los datos de las listas se ponen en orden y el primer elemento de cada lista tiene un índice "0". A continuación, vamos a ver cómo se definen las listas en Dynamo y cómo se relacionan varias listas entre sí.
Algo que podría parecer extraño al principio es que el primer índice de una lista es siempre 0 en lugar de 1. Por lo tanto, cuando hablamos del primer elemento de una lista, en realidad nos referimos al elemento que corresponde al índice 0.
Por ejemplo, si tuviéramos que contar el número de dedos que tenemos en la mano derecha, es probable que contáramos del 1 al 5. Sin embargo, si tuviéramos que poner los dedos en una lista, Dynamo les asignaría los índices del 0 al 4. Aunque esto puede parecer un poco extraño para programadores principiantes, el índice de base cero es una práctica estándar en la mayoría de los sistemas de cálculo.
Tenga en cuenta que sigue habiendo cinco elementos en la lista; solo que la lista utiliza un sistema de recuento basado en cero. Y los elementos que se almacenan en la lista no solo pueden ser números. Pueden ser cualquier tipo de datos compatible con Dynamo, como puntos, curvas, superficies, familias, etc.
a. Índice
b. Punto
c. Elemento
A menudo, la forma más sencilla de echar un vistazo al tipo de datos almacenados en una lista es conectar un nodo Watch con la salida de otro nodo. Por defecto, el nodo Watch muestra automáticamente todos los índices en el lado izquierdo de la lista y los elementos de datos en el lado derecho.
Estos índices son elementos decisivos cuando se trabaja con listas.
Las entradas y las salidas, que pertenecen a las listas, varían en función del nodo de Dynamo que se utilice. Como ejemplo, vamos a utilizar una lista de cinco puntos y a conectar esta salida a dos nodos de Dynamo diferentes: PolyCurve.ByPoints y Circle.ByCenterPointRadius:
La entrada points de PolyCurve.ByPoints busca "Point[]". Esto representa una lista de puntos.
La salida de PolyCurve.ByPoints es una PolyCurve única creada a partir de una lista de cinco puntos.
La entrada centerPoint de Circle.ByCenterPointRadius solicita "Point".
La salida de Circle.ByCenterPointRadius es una lista de cinco círculos cuyos centros corresponden a la lista original de puntos.
Los datos de entrada de PolyCurve.ByPoints y Circle.ByCenterPointRadius son los mismos. Sin embargo, el nodo Polycurve.ByPoints nos proporciona una PolyCurve, mientras que el nodo Circle.ByCenterPointRadius nos proporciona cinco círculos con centros en cada punto. Esto resulta intuitivo: la PolyCurve se dibuja como una curva que conecta los cinco puntos, mientras que los círculos crean un círculo distinto en cada punto. Entonces, ¿qué ocurre con los datos?
Al colocar el cursor sobre la entrada points de Polycurve.ByPoints, vemos que la entrada busca "Point[]". Observe los corchetes que aparecen al final. Este elemento representa una lista de puntos y, para crear una PolyCurve, la entrada debe ser una lista para cada PolyCurve. Por lo tanto, este nodo condensará cada lista en una PolyCurve.
Por otra parte, la entrada centerPoint de Circle.ByCenterPointRadius solicita "Point". Este nodo busca un punto, como elemento, para definir el centro del círculo. Por este motivo, se obtienen cinco círculos a partir de los datos de entrada. Reconocer esta diferencia en las entradas de Dynamo ayuda a comprender mejor cómo funcionan los nodos al administrar los datos.
La correspondencia de datos es un problema sin una solución definitiva. Se produce cuando un nodo tiene acceso a entradas de distinto tamaño. El cambio del algoritmo de correspondencia de datos puede dar lugar a resultados muy diferentes.
Imagine un nodo que crea segmentos de línea entre puntos (Line.ByStartPointEndPoint). Tendrá dos parámetros de entrada y ambos proporcionarán coordenadas de punto:
La forma más sencilla es conectar las entradas una a una hasta que uno de los flujos se acabe. Esto se denomina algoritmo "Lista más corta". Este es el comportamiento por defecto de los nodos de Dynamo:
El algoritmo "Lista más larga" sigue conectando entradas, reutilizando elementos, hasta que todos los flujos se acaben:
Por último, el método "Producto vectorial" hace todas las conexiones posibles:
Como puede ver, existen diferentes métodos para dibujar líneas entre estos conjuntos de puntos. Las opciones de encaje se encuentran haciendo clic con el botón derecho en el centro de un nodo y eligiendo el menú "Encaje".
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.
Para realizar una demostración de las operaciones de encaje desarrolladas a continuación, utilizaremos este archivo base para definir la lista más corta, la más larga y el producto vectorial.
Cambiaremos el encaje en Point.ByCoordinates, pero no cambiaremos nada más en el gráfico anterior.
Si se selecciona Lista más corta como opción de encaje (también la opción por defecto), se obtiene una línea diagonal básica compuesta por cinco puntos. Cinco puntos es la longitud de la lista menor, de modo que el encaje de la lista más corta se detiene cuando alcanza el final de una lista.
Al cambiar el encaje a la lista más larga, obtenemos una línea diagonal que se extiende verticalmente. Con el mismo método que el diagrama conceptual, el último elemento de la lista de cinco elementos se repetirá para alcanzar la longitud de la lista más larga.
Al cambiar el encaje a Producto vectorial, obtenemos todas las combinaciones entre cada lista, lo que nos proporciona una rejilla de puntos de 5 x 10. Esta es una estructura de datos equivalente al producto vectorial que se muestra en el diagrama de conceptos anterior, excepto que nuestros datos son ahora una lista de listas. Al conectar una PolyCurve, podemos ver que cada lista se ha definido por su valor X, lo que nos da una fila de líneas verticales.
Dynamo 2.0 no solo presenta los nodos indicados anteriormente para los diccionarios, sino que también hay nuevas funciones en los bloques de código para ello.
Puede utilizar una sintaxis como la siguiente o representaciones basadas en DesignScript de los nodos.
Dado que un diccionario es un tipo de objeto de Dynamo, podemos realizar las siguientes acciones con él.
Mantener este tipo de interacciones resulta especialmente útil al relacionar datos de Revit con cadenas. A continuación, veremos algunos casos de uso de Revit.
¿Alguna vez ha deseado buscar algo en Revit mediante un segmento de datos incluido en la solución?
Si la respuesta es afirmativa, es probable que haya hecho algo similar a lo que aparece en el ejemplo siguiente.
En la imagen mostrada a continuación, recopilamos todas las habitaciones del modelo de Revit, obtenemos el índice de la habitación que deseamos (por número de habitación) y, por último, obtenemos la habitación en el índice.
Recopile todas las habitaciones del modelo.
Especifique el número de habitación que se va a buscar.
Obtenga el número de habitación y busque el índice en el que se encuentra.
Obtenga la habitación en el índice.
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.
Ahora vamos a recrear esta idea mediante diccionarios. Debemos recopilar primero todas las habitaciones de nuestro modelo de Revit.
Seleccionamos la categoría de Revit con la que deseamos trabajar (en este caso, trabajaremos con habitaciones).
Le indicamos a Dynamo que recopile todos esos elementos.
Los datos que usaremos son el número de habitación.
Ahora crearemos el diccionario con las claves y los elementos especificados.
El nodo Dictionary.ByKeysValues creará un diccionario con las entradas correspondientes especificadas.
Keys
debe ser una cadena, mientras quevalues
puede ser diversos tipos de objeto.
Por último, ahora podemos recuperar una habitación del diccionario con su número de habitación.
String
será la clave que utilizaremos para buscar un objeto en el diccionario.Dictionary.ValueAtKey obtendrá ahora el objeto del diccionario.
Con esta misma lógica de diccionario, también podemos crear diccionarios con objetos agrupados. Si deseamos buscar todas las habitaciones en un nivel determinado, podemos modificar el gráfico anterior de la siguiente manera.
En lugar de utilizar el número de habitación como clave, ahora podemos utilizar un valor de parámetro (en este caso, utilizaremos nivel).
Ahora podemos agrupar las habitaciones por el nivel en el que residen.
Con los elementos agrupados por el nivel, ahora podemos utilizar las claves compartidas (claves exclusivas) como nuestra clave para el diccionario y las listas de habitaciones como elementos.
Por último, mediante los niveles del modelo de Revit, podemos buscar en el diccionario las habitaciones que se encuentran en ese nivel.
Dictionary.ValueAtKey
utilizará el nombre de nivel y devolverá los objetos de habitación presentes en ese nivel.
Las oportunidades de uso del diccionario son realmente infinitas. La capacidad de relacionar los datos de BIM de Revit con el propio elemento plantea diversos casos de uso.
Los diccionarios representan una recopilación de datos relacionados con otro elemento de datos conocido como clave. Los diccionarios muestran la capacidad de buscar, suprimir e insertar datos en una colección.
Básicamente, podemos considerar un diccionario como una manera realmente inteligente de buscar algo.
Aunque la función de diccionario lleva disponible en Dynamo durante algún tiempo, Dynamo 2.0 presenta una nueva forma de administrar este tipo de datos.
Adentrándonos aún más en el laberinto, vamos a agregar más niveles a la jerarquía. La estructura de datos puede ampliarse mucho más allá de una lista de listas bidimensional. Dado que las listas son elementos en sí mismos en Dynamo, podemos crear datos con tantas dimensiones como sea posible.
La analogía con la que trabajaremos aquí son las muñecas rusas. Cada lista se puede considerar como un contenedor que contiene varios elementos. Cada lista tiene sus propias propiedades y también se considera su propio objeto.
Un conjunto de muñecas rusas (fotografía de ) es una analogía de las listas de n dimensiones. Cada capa representa una lista y cada lista contiene elementos. En el caso de Dynamo, cada contenedor puede tener varios contenedores dentro (que representan los elementos de cada lista).
Las listas de n dimensiones son difíciles de explicar visualmente, pero hemos configurado algunos ejercicios en este capítulo que se centran en trabajar con listas que van más allá de las dos dimensiones.
La asignación es, probablemente, la parte más compleja de la administración de datos en Dynamo y es especialmente relevante al trabajar con jerarquías de listas complejas. Con la serie de ejercicios incluidos a continuación, mostraremos cuándo utilizar la asignación y las combinaciones a medida que los datos se convierten en datos multidimensionales.
Las introducciones preliminares a List.Map y List.Combine se pueden encontrar en la sección anterior. En el último ejercicio de los que se incluyen a continuación, usaremos estos nodos en una estructura de datos compleja.
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.
Este es el primero de una serie de tres ejercicios que se centra en la articulación de la geometría importada. Cada parte de esta serie de ejercicios aumentará en la complejidad de la estructura de datos.
Comencemos con el archivo .sat de la carpeta de archivos del ejercicio. Se puede acceder a este archivo mediante el nodo File Path.
Con Geometry.ImportFromSAT, la geometría se importa a nuestra vista preliminar de Dynamo como dos superficies.
En este sencillo ejercicio, vamos a trabajar con una de las superficies.
Seleccionaremos el índice de 1 para capturar la superficie superior. Esta acción se realiza con el nodo List.GetItemAtIndex.
Desactive la vista preliminar de geometría de la vista preliminar de Geometry.ImportFromSAT.
El siguiente paso es dividir la superficie en una rejilla de puntos.
1. Mediante el bloque de código, inserte estas dos líneas de código:
0..1..#10;
0..1..#5;
.2. Con Surface.PointAtParameter, conecte los dos valores del bloque de código a u y v. Cambie el encaje de este nodo a "Producto vectorial".
3. La salida muestra la estructura de datos, que también está visible en la vista preliminar de Dynamo.
A continuación, utilice los puntos del último paso para generar 10 curvas a lo largo de la superficie.
Para obtener información sobre cómo se organiza la estructura de datos, conectemos un nodo NurbsCurve.ByPoints a la salida de Surface.PointAtParameter.
Por ahora, puede desactivar la vista preliminar del nodo List.GetItemAtIndex para obtener un resultado más claro.
Un nodo List.Transpose básico cambiará las columnas y las filas de una lista de listas.
Al conectar la salida de List.Transpose a NurbsCurve.ByPoints, se obtienen cinco curvas que discurren horizontalmente a través de la superficie.
Puede desactivar la vista preliminar del nodo NurbsCurve.ByPoints en el paso anterior para obtener el mismo resultado en la imagen.
Aumentemos la complejidad. Supongamos que deseamos realizar una operación en las curvas creadas en el ejercicio anterior. Tal vez nos gustaría relacionar estas curvas con otra superficie y solevar entre ellas. Esto requiere más atención en la estructura de datos, pero la lógica subyacente es la misma.
Comience con un paso del ejercicio anterior, aislando la superficie superior de la geometría importada con el nodo List.GetItemAtIndex.
Con Surface.Offset, desfase la superficie con un valor de 10.
Del mismo modo que en el ejercicio anterior, defina un bloque de código con estas dos líneas de código:
0..1..#10;
0..1..#5;
.Conecte estas salidas a dos nodos Surface.PointAtParameter, cada uno con el encaje establecido en "Producto vectorial". Uno de estos nodos está conectado a la superficie original, mientras que el otro está conectado a la superficie desfasada.
Desactive la vista preliminar de estas superficies.
Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints. En el resultado, se muestran las curvas correspondientes a dos superficies.
Con List.Create, podemos combinar los dos conjuntos de curvas en una lista de listas.
Observe en la salida que tenemos dos listas con 10 elementos cada una que representan cada conjunto de conexiones de curvas NURBS.
Al ejecutar Surface.ByLoft, podemos visualizar con claridad esta estructura de datos. El nodo soleva todas las curvas de cada sublista.
Desactive la vista preliminar del nodo Surface.ByLoft en el paso anterior.
Al utilizar List.Transpose, recuerde que estamos volteando todas las columnas y filas. Este nodo transferirá dos listas de diez curvas a diez listas de dos curvas. Ahora cada curva NURBS está relacionada con la curva contigua de la otra superficie.
Con Surface.ByLoft, llegamos a una estructura con nervios.
A continuación, mostraremos un proceso alternativo para lograr este resultado.
Antes de empezar, desactive la vista preliminar de Surface.ByLoft en el paso anterior para evitar confusiones.
Una alternativa a List.Transpose es utilizar List.Combine. Esta acción pondrá en funcionamiento un "combinador" en cada sublista.
En este caso, utilizaremos List.Create como "combinador", que creará una lista de cada elemento de las sublistas.
Con el nodo Surface.ByLoft, se obtienen las mismas superficies que en el paso anterior. La transposición es más fácil de utilizar en este caso, pero cuando la estructura de datos se vuelve más compleja, List.Combine es más fiable.
Retrocediendo unos pasos, si deseamos cambiar la orientación de las curvas en la estructura con nervios, debemos utilizar un nodo List.Transpose antes de conectar con NurbsCurve.ByPoints. Esto invertirá las columnas y las filas, lo que nos dará cinco nervios horizontales.
Ahora, vamos a ir un paso más allá. En este ejercicio, trabajaremos con ambas superficies importadas y crearemos una jerarquía de datos compleja. Aun así, nuestro objetivo es completar la misma operación con la misma lógica subyacente.
Comience con el archivo importado del ejercicio anterior.
Como en el ejercicio anterior, utilice el nodo Surface.Offset para desfasar por un valor de 10.
Observe en la salida que hemos creado dos superficies con el nodo de desfase.
Del mismo modo que en el ejercicio anterior, defina un bloque de código con estas dos líneas de código:
0..1..#20;
0..1..#20;
.Conecte estas salidas a dos nodos Surface.PointAtParameter, cada uno con el encaje establecido en "Producto vectorial". Uno de estos nodos está conectado a las superficies originales, mientras que el otro está conectado a las superficies desfasadas.
Como en el ejercicio anterior, conecte la salida a dos nodos NurbsCurve.ByPoints.
En la salida de NurbsCurve.ByPoints, observe que se trata de una lista de dos listas, que es más compleja que la del ejercicio anterior. Los datos se clasifican según la superficie subyacente, por lo que hemos añadido otro nivel a los datos estructurados.
Observe que los datos se vuelven más complejos en el nodo Surface.PointAtParameter. En este caso, tenemos una lista compuesta por listas de listas.
Antes de continuar, desactive la vista preliminar de las superficies existentes.
Con el nodo List.Create, se fusionan las curvas NURBS en una estructura de datos, lo que crea una lista de listas de listas.
Al conectar un nodo Surface.ByLoft, se obtiene una versión de las superficies originales, ya que cada una de ellas permanece en su propia lista tal como se crearon a partir de la estructura de datos original.
En el ejercicio anterior, pudimos utilizar List.Transpose para crear una estructura con nervios. Esto no funcionaría aquí. La transposición se debe utilizar en una lista bidimensional y, puesto que tenemos una lista tridimensional, una operación de "voltear columnas y filas" no funcionaría de manera tan sencilla. Recuerde que las listas son objetos, de modo que List.Transpose voltearía las listas sin sublistas, pero no voltearía las curvas NURBS ubicadas una lista más abajo en la jerarquía.
List.Combine funcionará mejor aquí. Debemos usar los nodos List.Map y List.Combine cuando trabajamos con estructuras de datos más complejas.
Al utilizar List.Create como "combinador", creamos una estructura de datos que funcionará mejor para nosotros.
La estructura de datos aún debe transponerse un paso hacia abajo en la jerarquía. Para ello, utilizaremos List.Map. Funciona como List.Combine, salvo que utiliza solo una lista de entrada, en lugar de dos o más.
La función que aplicaremos a List.Map es List.Transpose, que volteará las columnas y las filas de las sublistas de nuestra lista principal.
Por último, podemos solevar las curvas NURBS junto con una jerarquía de datos adecuada, lo que nos proporciona una estructura con nervios.
Añadamos profundidad a la geometría mediante un nodo Surface.Thicken con los parámetros de entrada, como se muestra.
Será recomendable una superficie que respalde también esta estructura, por lo que añada otro nodo Surface.ByLoft y utilice la primera salida de NurbsCurve.ByPoints de un paso anterior como entrada.
A medida que se sobrecargue la vista preliminar, desactive la vista preliminar de estos nodos. Para ello, haga clic con el botón derecho en cada uno de ellos y desactive la opción "vista preliminar" para ver mejor el resultado.
Y si engrosamos las superficies seleccionadas, la articulación está completa.
No es la mecedora más cómoda del mercado, pero hay muchos datos en ella.
En el último paso, vamos a invertir la dirección de los miembros estriados. Como ya usamos la transposición en el ejercicio anterior, haremos algo similar aquí.
Tenemos un nivel más en la jerarquía, por lo que debemos utilizar List.Map con la función List.Tranpose para cambiar la dirección de las curvas NURBS.
Es posible que deseemos aumentar el número de huellas. Para ello, podemos cambiar el bloque de código al siguiente:
0..1..#20;
0..1..#30;
.
La primera versión de la mecedora era elegante, así que nuestro segundo modelo ofrece una versión todoterreno del asiento reclinable.
Dynamo 2.0 presenta una gran variedad de nodos de diccionario para nuestro uso. Esto incluye los nodos de creación, acción y consulta.
Dictionary.ByKeysValues
creará un diccionario con las claves y los valores proporcionados. (El número de entradas será el de la entrada de lista más corta).
Dictionary.Components
generará los componentes del diccionario de entrada. (Es el proceso inverso al nodo creado).
Dictionary.RemoveKeys
generará un nuevo objeto de diccionario con las claves de entrada eliminadas.
Dictionary.SetValueAtKeys
creará un nuevo diccionario basado en las claves de entrada y los valores para reemplazar el valor actual en las claves correspondientes.
Dictionary.ValueAtKey
devolverá el valor en la clave de entrada.
Dictionary.Count
le indicará cuántos pares de clave-valor hay en el diccionario.
Dictionary.Keys
devolverá las claves almacenadas actualmente en el diccionario.
Dictionary.Values
devolverá los valores almacenados actualmente en el diccionario.
Relacionar de forma general datos con diccionarios es una magnífica alternativa al antiguo método de trabajo con índices y listas.
Dynamo 2.0 introduce el concepto de separación del tipo de datos del diccionario del tipo de datos de lista. Esta novedad puede conllevar algunos cambios importantes en la forma de crear y trabajar con datos en los flujos de trabajo. Antes de la versión 2.0, los diccionarios y las listas se combinaban como un tipo de datos. En resumen, las listas eran en realidad diccionarios con claves de enteros.
Un diccionario es un tipo de datos compuesto por una colección de pares de clave-valor en los que cada clave es exclusiva para cada colección. Un diccionario no tiene orden y, básicamente, se pueden "buscar elementos" mediante una clave en lugar de un valor de índice como en una lista. En Dynamo 2.0, las claves solo pueden ser cadenas.
Una lista es un tipo de datos compuesto por un conjunto de valores ordenados. En Dynamo, las listas utilizan enteros como valores de índice.
La separación de los diccionarios y las listas convierte a los diccionarios en componentes de primera clase que se pueden utilizar para almacenar y buscar valores de forma rápida y sencilla sin necesidad de recordar un valor de índice o mantener una estructura de listas estricta a lo largo del flujo de trabajo. Durante las pruebas realizadas por los usuarios, hemos detectado una reducción considerable del tamaño del gráfico cuando se utilizaron los diccionarios en lugar de varios nodos GetItemAtIndex
.
Se han producido cambios en la sintaxis que modifican el modo en que se inicializarán y se utilizarán los diccionarios y las listas en los bloques de código.
Los diccionarios utilizan la siguiente sintaxis: {key:value}
.
Las listas utilizan la siguiente sintaxis: [value,value,value]
.
Se han introducido nuevos nodos en la biblioteca para ayudarle a crear, modificar y consultar diccionarios.
Las listas creadas con bloques de código v1.x se migrarán automáticamente al cargar la secuencia de comandos a la nueva sintaxis de lista que utiliza corchetes [ ]
en lugar de llaves { }
.
En las ciencias informáticas, los diccionarios, al igual que las listas, son colecciones de objetos. Mientras que las listas se encuentran en un orden específico, los diccionarios son colecciones sin ordenar. No dependen de números secuenciales (índices), sino de claves.
En la imagen siguiente, se muestra un posible caso de uso de un diccionario. A menudo, los diccionarios se utilizan para relacionar dos segmentos de datos que podrían no tener una correlación directa. En este caso, conectamos la versión en español de una palabra a la versión en inglés para su posterior búsqueda.
Cree un diccionario para relacionar los dos datos.
Obtenga el valor con la clave especificada.
De este modo, las operaciones booleanas de sólidos permiten ahorrar mucho tiempo. Existen tres operaciones booleanas de sólidos que distinguen las partes de la geometría que se conservan.
Además de estas tres operaciones, Dynamo incluye los nodos Solid.DifferenceAll y Solid.UnionAll para realizar operaciones de diferencia y unión con varios sólidos.
A continuación, debemos decidir las claves que vamos a utilizar para buscar estos datos. (La información sobre las claves se encuentra en la sección ).
Imagen original por cortesía de:
Color ARGB (Color.ByARGB)
A,R,G,B
color
Alfa (Color.Alpha)
color
A
Rojo (Color.Red)
color
R
Verde (Color.Green)
color
G
Azul (Color.Blue)
color
B
Componentes (Color.Components)
color
A, R, G, B
Matiz (Color.Hue)
color
Matiz
Saturación (Color.Saturation)
color
Saturación
Brillo (Color.Brightness)
color
Brillo
If (If)
test, true, false
resultado
Formula (IF(x,y,z))
x, y, z
resultado
Code Block ((x?y:z);)
x? y, z
resultado
Los nodos personalizados se crean mediante la anidación de otros nodos y nodos personalizados dentro de un "nodo personalizado de Dynamo", que podemos considerar conceptualmente como un contenedor. Cuando se ejecuta este nodo contenedor en el gráfico, se ejecutará todo lo que contiene para permitirle reutilizar y compartir una combinación útil de nodos.
Cuando existen varias copias de un nodo personalizado en el gráfico, puede actualizarlas todas mediante la edición del nodo personalizado base. Esto permite actualizar el gráfico sin problemas adaptándolo a los cambios que puedan producirse en el flujo de trabajo o el diseño.
Podría decirse que la mejor función de los nodos personalizados es su capacidad para compartir el trabajo. Si un "usuario avanzado" crea un gráfico complejo de Dynamo y se lo entrega a un diseñador que no esté familiarizado con esta herramienta, este puede condensar el gráfico a sus aspectos básicos para interactuar con el diseño. El nodo personalizado se puede abrir para editar el gráfico interno, pero manteniendo la simplicidad del "contenedor". Con este proceso, los nodos personalizados permiten a los usuarios de Dynamo diseñar un gráfico limpio e intuitivo.
Hay una gran variedad de métodos para crear nodos personalizados en Dynamo. En los ejemplos de este capítulo, crearemos nodos personalizados directamente desde la interfaz de usuario de Dynamo. Si es un programador y está interesado en el formato C# o Zero-Touch, puede consultar esta página en la página wiki de Dynamo para obtener una revisión más detallada.
Pasemos al entorno de nodos personalizados y creemos un nodo sencillo para calcular un porcentaje. El entorno de nodos personalizados es diferente al entorno de gráficos de Dynamo, pero la interacción es básicamente la misma. Una vez señalado esto, crearemos nuestro primer nodo personalizado.
Para crear un nodo personalizado desde cero, inicie Dynamo y seleccione Nodo personalizado o pulse Ctrl + Mayús + N en el lienzo.
Asigne un nombre, una descripción y una categoría en el cuadro de diálogo Propiedades de nodo personalizado.
Nombre: porcentaje.
Descripción: calcule el porcentaje de un valor en relación con otro.
Categoría: Math.Functions.
Se abre un lienzo con un fondo de color amarillo, lo que indica que está trabajando en un nodo personalizado. En este lienzo, tiene acceso a todos los nodos principales de Dynamo, así como a los nodos Input y Output, que etiquetan los datos que entran en el nodo personalizado y salen de él. Se pueden encontrar en Entrada > Básico.
Entradas: los nodos de entrada crean puertos de entrada en el nodo personalizado. La sintaxis de un nodo de entrada es nombre_entrada : tipo de datos = valor_por defecto(opcional).
Salidas: son similares a las entradas; estas crearán puertos en el nodo personalizado y les asignarán un nombre. Considere la posibilidad de añadir un comentario personalizado a los puertos de entrada y salida para que se muestren como sugerencia en los tipos de entrada y salida. Esto se explica con más detalle en la sección Creación de nodos personalizados.
Puede guardar este nodo personalizado como un archivo .dyf (en lugar de como un archivo .dyn estándar); este se añadirá automáticamente a la sesión actual y futuras. Encontrará el nodo personalizado en la sección Complementos de la biblioteca.
Ahora que hemos creado nuestro primer nodo personalizado, las secciones siguientes profundizarán en las funciones de los nodos personalizados y en la publicación de flujos de trabajo genéricos. En la siguiente sección, estudiaremos el desarrollo de un nodo personalizado que transfiere geometría de una superficie a otra.
Dynamo ofrece varios métodos diferentes para crear nodos personalizados. Puede crear nodos personalizados desde cero, a partir de un gráfico existente o de forma explícita en C#. En esta sección, vamos a cubrir la generación de un nodo personalizado en la interfaz de usuario de Dynamo a partir de un gráfico existente. Este método es ideal para limpiar el espacio de trabajo, así como para empaquetar una secuencia de nodos con el fin de reutilizarlos en otros entornos.
En la imagen siguiente, se asigna un punto de una superficie a otra mediante coordenadas UV. Utilizaremos este concepto para crear una superficie panelizada que haga referencia a curvas en el plano XY. Crearemos paneles de cuadrados para esta panelización pero, con esta misma lógica, podemos crear una amplia variedad de paneles con asignación de UV. Esta es una gran oportunidad para el desarrollo de nodos personalizados, ya que vamos a poder repetir un proceso similar más fácilmente en este gráfico o en otros flujos de trabajo de Dynamo.
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.
Comenzaremos con la creación de un gráfico que deseamos anidar en un nodo personalizado. En este ejemplo, crearemos un gráfico que asigna polígonos de una superficie base a una superficie de destino mediante coordenadas UV. Este proceso de asignación de UV es algo que se utiliza con frecuencia, lo que lo convierte en un buen candidato para un nodo personalizado. Para obtener más información sobre superficies y el espacio UV, consulte la página Superficie. El gráfico completo es _UVmapping\Custom-Node.dyn del archivo .zip descargado anteriormente.
Code Block: utilice esta línea para crear un intervalo de 10 números entre -45 y 45
45..45..#10;
.Point.ByCoordinates: conecte la salida del bloque de código a las entradas "x" e "y", y establezca el encaje como producto vectorial. Ahora debería ver una rejilla de puntos.
Plane.ByOriginNormal: conecte la salida "Point" a la entrada "origin" para crear un plano en cada uno de los puntos. Se utilizará el vector normal por defecto (0,0,1).
Rectangle.ByWidthLength: conecte los planos del paso anterior a la entrada "plane" y utilice un bloque de código con un valor de 10 para especificar la anchura y la longitud.
Ahora debería ver una rejilla de rectángulos. Asignemos ahora estos rectángulos a una superficie de destino mediante coordenadas UV.
Polygon.Points: conecte la salida Rectangle.ByWidthLength del paso anterior a la entrada "polygon" para extraer los puntos de esquina de cada rectángulo. Estos son los puntos que asignaremos a la superficie de destino.
Rectangle.ByWidthLength: utilice un bloque de código con un valor de 100 para especificar la anchura y la longitud del rectángulo. Este será el contorno de la superficie base.
Surface.ByPatch: conecte la salida Rectangle.ByWidthLength del paso anterior a la entrada "closedCurve" para crear una superficie base.
Surface.UVParameterAtPoint: conecte la salida "Point" del nodo Polygon.Points y la salida "Surface" del nodo Surface.ByPatch para devolver el parámetro UV de cada punto.
Ahora que tenemos una superficie base y un conjunto de coordenadas UV, podemos importar una superficie de destino y asignar los puntos entre las superficies.
File Path: seleccione la ruta de archivo de la superficie que desea importar. El tipo de archivo debe ser .SAT. Haga clic en el botón "Examinar" y desplácese hasta el archivo UVmapping_srf.sat del archivo .zip que hemos descargado anteriormente.
Geometry.ImportFromSAT: conecte la ruta de archivo para importar la superficie. La superficie importada se muestra en la vista preliminar de la geometría.
UV: conecte la salida del parámetro UV a un nodo UV.U y un nodo UV.V.
Surface.PointAtParameter: conecte la superficie importada, así como las coordenadas u y v. Ahora debería ver una rejilla de puntos 3D en la superficie de destino.
El último paso consiste en utilizar los puntos 3D para crear parches de superficie rectangulares.
PolyCurve.ByPoints: conecte los puntos de la superficie para construir una PolyCurve a través de los puntos.
Boolean: añada un nodo Boolean al espacio de trabajo y conéctelo a la entrada "connectLastToFirst" y, a continuación, cambie el valor a "True" (verdadero) para cerrar las PolyCurves. Ahora debería ver los rectángulos asignados a la superficie.
Surface.ByPatch: conecte las PolyCurves a la entrada "closedCurve" para construir parches de superficie.
Ahora vamos a seleccionar los nodos que queremos anidar en un nodo personalizado teniendo en cuenta las entradas y salidas que este debe tener. Queremos que nuestro nodo personalizado sea lo más flexible posible, de modo que debería poder asignar cualquier polígono, no solo rectángulos.
Seleccione los siguientes nodos (comenzando por Polygon.Points), haga clic con el botón derecho en el espacio de trabajo y seleccione "Crear nodo personalizado".
En el cuadro de diálogo Propiedades de nodo personalizado, asigne un nombre, una descripción y una categoría al nodo personalizado.
Nombre: MapPolygonsToSurface.
Descripción: asigne polígonos de una base a una superficie de destino.
Categoría de complementos: Geometry.Curve.
El nodo personalizado ha limpiado considerablemente el espacio de trabajo. Observe que las entradas y salidas se han nombrado en función de los nodos originales. Editaremos el nodo personalizado para que los nombres sean más descriptivos.
Haga doble clic en el nodo personalizado para editarlo. Se abrirá un espacio de trabajo con un fondo amarillo que representa el interior del nodo.
Entradas: cambie los nombres de entrada a baseSurface y targetSurface.
Salidas: añada una salida adicional para los polígonos asignados.
Guarde el nodo personalizado y vuelva al espacio de trabajo de inicio. Observe que el nodo MapPolygonsToSurface refleja los cambios que acabamos de realizar.
También podemos reforzar la solidez del nodo personalizado añadiendo comentarios personalizados. Los comentarios pueden servir como ayuda en las entradas y salidas o explicar el funcionamiento del nodo. Los comentarios aparecerán cuando el usuario coloque el cursor sobre una entrada o una salida de un nodo personalizado.
Haga doble clic en el nodo personalizado para editarlo. De este modo, se volverá a abrir el espacio de trabajo con fondo amarillo.
Edite primero el bloque de código de entrada. Para iniciar un comentario, escriba "//" seguido del texto del comentario. Escriba cualquier información que pueda ayudar a entender mejor el nodo; aquí describiremos targetSurface.
Vamos a definir también el valor por defecto de inputSurface estableciendo el valor a que equivale un tipo de entrada. Aquí, vamos a definir el valor por defecto en el conjunto Surface.ByPatch original.
También se pueden aplicar comentarios a las salidas.
Edite el texto en el bloque de código Output. Escriba "//" seguido del texto del comentario. Aquí vamos a aclarar las salidas Polygons y surfacePatches añadiendo una descripción más detallada.
Coloque el cursor sobre las entradas del nodo personalizado para ver los comentarios.
Con el valor por defecto establecido en inputSurface, también podemos ejecutar la definición sin una entrada de superficie.
Acabamos de crear un nodo personalizado y lo hemos aplicado a un proceso específico en el gráfico de Dynamo. Y nos gusta tanto este nodo que deseamos conservarlo en nuestra biblioteca de Dynamo para hacer referencia a él en otros gráficos. Para ello, publicaremos el nodo localmente. Este es un proceso similar al de la publicación de un paquete, que se explicará con más detalle en el siguiente capítulo.
Al publicar un nodo localmente, se podrá acceder a este en la biblioteca de Dynamo cuando se abra una nueva sesión. Si no se publica un nodo, un gráfico de Dynamo que haga referencia a un nodo personalizado deberá incluir este en su carpeta (o este deberá importarse a Dynamo mediante Archivo > Importar biblioteca).
Puede publicar nodos y paquetes personalizados desde Dynamo Sandbox en la versión 2.17 y posteriores, siempre que no presenten dependencias de la API del anfitrión. En versiones anteriores, la publicación de nodos y paquetes personalizados solo estaba activada en Dynamo for Revit y Dynamo para Civil 3D.
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.
Avancemos con el nodo personalizado que hemos creado en la sección anterior. Una vez abierto el nodo personalizado PointsToSurface, se muestra el gráfico en el editor de nodos personalizados de Dynamo. También puede abrir un nodo personalizado haciendo doble clic en él en el editor de gráficos de Dynamo.
Para publicar localmente un nodo personalizado, haga clic con el botón derecho en el lienzo y seleccione "Publicar este nodo personalizado".
Rellene la información pertinente similar a la imagen anterior y seleccione "Publicar localmente". Observe que el campo Grupo define el elemento principal al que se puede acceder desde el menú de Dynamo.
Seleccione una carpeta para alojar todos los nodos personalizados que tiene previsto publicar localmente. Dynamo comprobará esta carpeta cada vez que se cargue, por lo que debe asegurarse de que esta se encuentre en una ubicación permanente. Vaya a esta carpeta y elija "Seleccionar carpeta". El nodo de Dynamo se publica ahora localmente y permanecerá en la biblioteca de Dynamo cada vez que cargue el programa.
Para comprobar la ubicación de la carpeta de nodos personalizados, vaya a Dynamo > Preferencias > Configuración de paquetes > Rutas de nodos y paquetes.
En esta ventana, se muestra una lista de rutas.
Documents\DynamoCustomNodes... hace referencia a la ubicación de los nodos personalizados que se han publicado localmente.
AppData\Roaming\Dynamo... hace referencia a la ubicación por defecto de los paquetes de Dynamo instalados en línea.
Es posible que desee desplazar la ruta de carpeta local hacia abajo en el orden de la lista anterior. (Para ello, haga clic en la flecha hacia abajo situada a la izquierda de los nombres de ruta). La carpeta superior es la ruta por defecto para las instalaciones de paquetes. Por lo tanto, al mantener la ruta de instalación por defecto de paquetes de Dynamo como la carpeta por defecto, los paquetes en línea se separarán de los nodos publicados localmente.
Cambiamos el orden de los nombres de ruta para que la ruta por defecto de Dynamo sea la ubicación de instalación de paquetes.
Al acceder a esta carpeta local, podemos encontrar el nodo personalizado original en la carpeta ".dyf", que es la extensión de un archivo de nodo personalizado de Dynamo. Podemos editar el archivo en esta carpeta; el nodo se actualizará en la interfaz de usuario. También podemos añadir más nodos a la carpeta principal de DynamoCustomNode; Dynamo los añadirá a la biblioteca al reiniciar.
Dynamo ahora se cargará cada vez con PointsToSurface en el grupo DynamoPrimer de la biblioteca de Dynamo.
Una vez que haya creado algunos nodos personalizados, el siguiente paso es comenzar a organizarlos y publicarlos mediante paquetes, una forma cómoda de almacenar y compartir sus nodos con la comunidad de Dynamo.
De forma predefinida, Dynamo tiene muchas funciones almacenadas en su biblioteca de nodos. Para las rutinas de uso frecuente o ese gráfico especial que desea compartir con la comunidad, los nodos y los paquetes personalizados son un método excelente para ampliar Dynamo aún más.
Dynamo ofrece muchos nodos principales para una amplia gama de tareas de programación visual. En ocasiones, una solución más rápida, elegante o fácil de compartir consiste en crear sus propios nodos. Estos se pueden reutilizar en distintos proyectos, lo que permite que los gráficos sean más claros y limpios, y se puedan transferir a Package Manager y compartir con la comunidad global de Dynamo.
Dynamo ofrece un gran número de funciones listas para usar y también mantiene una extensa biblioteca de paquetes que puede ampliar considerablemente la capacidad de Dynamo. Un paquete es una colección de nodos personalizados o funciones adicionales. Dynamo Package Manager es un portal para que la comunidad descargue cualquier paquete que se haya publicado en línea. Estos conjuntos de herramientas los desarrollan terceros para ampliar la funcionalidad principal de Dynamo. Están disponibles para todos los usuarios y listos para descargar con solo hacer clic.
Un proyecto de código abierto como Dynamo crece con este tipo de participación de la comunidad. Con desarrolladores independientes dedicados, Dynamo puede ampliar su alcance a los flujos de trabajo de una amplia gama de sectores. Por este motivo, el equipo de Dynamo ha realizado esfuerzos coordinados para optimizar el desarrollo y la publicación de paquetes (lo cual se trata en mayor detalle en las siguientes secciones).
La forma más sencilla de instalar un paquete es mediante la opción de menú Paquetes de la interfaz de Dynamo. Pongámonos manos a la obra e instalemos ahora un paquete. En este ejemplo rápido, instalaremos un paquete popular para la creación de paneles de cuadrados en una rejilla.
En Dynamo, vaya a Paquetes > Package Manager.
En la barra de búsqueda, buscamos "Quads from Rectangular Grid". Tras unos segundos, deberían aparecer todos los paquetes que coincidan con esta consulta de búsqueda. Vamos a seleccionar el primer paquete cuyo nombre coincida.
Haga clic en Instalar para añadir este paquete a la biblioteca y acepte la confirmación. Listo.
Observe que ahora tenemos otro grupo en la biblioteca de Dynamo denominado "buildz". Este nombre hace referencia al desarrollador del paquete y el nodo personalizado se encuentra en este grupo. Podemos empezar a utilizarlo al instante.
Utilice Code Block para definir rápidamente una rejilla rectangular, generar el resultado en un nodo Polygon.ByPoints y, posteriormente, en un nodo Surface.ByPatch a fin de ver la lista de paneles rectangulares que acaba de crear.
El ejemplo anterior se centra en un paquete con un nodo personalizado, pero se utiliza el mismo proceso para descargar paquetes con varios nodos personalizados y archivos de datos complementarios. Vamos a demostrar esto a continuación con un paquete más completo: Dynamo Unfold.
Como en el ejemplo anterior, seleccione primero Paquetes > Package Manager.
Esta vez, buscaremos "DynamoUnfold", todo en una sola palabra. Cuando aparezcan los paquetes, descárguelos. Para ello, haga clic en Instalar a fin de añadir Dynamo Unfold a la biblioteca de Dynamo.
En la biblioteca de Dynamo, tenemos un grupo de DynamoUnfold con varias categorías y nodos personalizados.
Ahora, veamos la estructura de archivos del paquete.
Vaya primero a Paquetes > Package Manager > Paquetes instalados.
A continuación, haga clic en Mostrar directorio raíz para abrir la carpeta raíz de este paquete.
Esto nos llevará al directorio raíz del paquete. Observe que hay tres carpetas y un archivo.
La carpeta bin contiene archivos .dll. Este paquete de Dynamo se desarrolló mediante el uso de Zero-Touch, por lo que los nodos personalizados se guardan en esta carpeta.
La carpeta dyf contiene los nodos personalizados. Este paquete no se desarrolló mediante nodos personalizados de Dynamo, por lo que esta carpeta está vacía para este paquete.
La carpeta extra contiene todos los archivos adicionales, incluidos los archivos de ejemplo.
El archivo pkg es un archivo de texto básico que define los parámetros del paquete. Podemos pasarlo por alto por ahora.
Al abrir la carpeta "extra", vemos un conjunto de archivos de ejemplo que se han descargado con la instalación. No todos los paquetes tienen archivos de ejemplo, pero aquí es donde se pueden encontrar si forman parte de un paquete.
Abriremos "SphereUnfold".
Después de abrir el archivo y pulsar "Ejecutar" en el solucionador, tenemos una esfera desplegada. Estos archivos de ejemplo son útiles para aprender a trabajar con un nuevo paquete de Dynamo.
En Package Manager, puede buscar paquetes mediante las opciones de orden y filtrado de la ficha Buscar paquetes. Hay varios filtros disponibles para el programa anfitrión, el estado (nuevo, obsoleto o no obsoleto) y si el paquete tiene o no dependencias.
Al ordenar los paquetes, puede identificar los más valorados o los más descargados, o aquellos con actualizaciones recientes.
También puede acceder a más información sobre cada paquete. Para ello, haga clic en Ver detalles. Se abrirá un panel lateral en Package Manager, donde podrá encontrar información como las versiones y las dependencias, la URL del sitio web o del repositorio, información sobre la licencia, etc.
Si desea ver dónde se guardan los archivos de los paquetes, en el panel de navegación superior haga clic en Dynamo > Preferencias > Configuración de paquetes > Ubicaciones de archivo de nodos y paquetes, donde podrá encontrar el directorio de la carpeta raíz actual.
Por defecto, los paquetes se instalan en una ubicación similar a esta ruta de carpeta: C:/Usuarios/[nombre de usuario]/AppData/Roaming/Dynamo/[Versión de Dynamo].
La comunidad de Dynamo está en constante crecimiento y evolución. Si explora Dynamo Package Manager de vez en cuando, descubrirá algunos avances excelentes. En las secciones siguientes, analizaremos en profundidad los paquetes, desde la perspectiva del usuario final hasta la autoría de un paquete de Dynamo propio.
Junto a DynamoUnfold, seleccione el menú de opciones .
Otra forma de descubrir los paquetes de Dynamo es explorar el sitio web de . Aquí puede encontrar estadísticas sobre paquetes y tablas de clasificación de autores. También puede descargar los archivos de paquete desde Dynamo Package Manager, pero este proceso es más directo si se realiza desde Dynamo.
Dynamo es un entorno flexible diseñado para su uso en una amplia gama de programas y creado originalmente para su uso con Revit. Un programa visual crea opciones eficaces para BIM (Building Information Modeling). Dynamo ofrece un conjunto completo de nodos diseñados específicamente para Revit, así como bibliotecas de terceros de una creciente comunidad de AEC. Este capítulo se centra en los conceptos básicos de uso de Dynamo en Revit.
Revit es un entorno con gran cantidad de datos. Esto nos proporciona una gama de posibilidades de selección que se expande mucho más allá de "señalar y hacer clic". Podemos consultar la base de datos de Revit y vincular dinámicamente elementos de Revit a la geometría de Dynamo mientras realizamos operaciones paramétricas.
La biblioteca de Revit de la interfaz de usuario ofrece la categoría "Selection" (selección) que permite elegir varias formas de seleccionar la geometría.
Para seleccionar elementos de Revit correctamente, es importante comprender totalmente la jerarquía de elementos de Revit. ¿Desea seleccionar todos los muros de un proyecto? Seleccione por categoría. ¿Desea seleccionar todas las sillas Eames en su lobby moderno de mediados de siglo? Seleccione por familia.
Vamos a revisar rápidamente la jerarquía de Revit.
¿Recuerda la taxonomía de la biología? Reino, phylum, clase, orden, familia, género y especie. Los elementos de Revit se clasifican de forma similar. En un nivel básico, la jerarquía de Revit se puede dividir en categorías, familias, tipos* y ejemplares. Un ejemplar es un elemento de modelo individual (con un ID exclusivo), mientras que una categoría define un grupo genérico (como "muros" o "suelos"). Con la base de datos de Revit organizada de este modo, podemos seleccionar un elemento y elegir todos los elementos similares en función de un nivel especificado en la jerarquía.
Los tipos en Revit se definen de forma distinta a los tipos en programación. En Revit, un tipo hace referencia a una ramificación de la jerarquía, en lugar de a un "tipo de datos".
Las tres imágenes siguientes dividen las categorías principales para la selección de elementos de Revit en Dynamo. Son herramientas excelentes para usarlas en combinación y exploraremos algunas de ellas en los ejercicios siguientes.
Señalar y hacer clic es el método más sencillo para seleccionar directamente un elemento de Revit. Puede seleccionar un elemento de modelo completo o partes de su topología (como una cara o un borde). Este elemento permanece vinculado dinámicamente a ese objeto de Revit, por lo que, cuando el archivo de Revit actualiza su ubicación o parámetros, el elemento de Dynamo al que se hace referencia se actualiza en el gráfico.
Los menús desplegables crean una lista de todos los elementos a los que se puede acceder en un proyecto de Revit. Puede utilizar esta opción para hacer referencia a elementos de Revit que no están necesariamente visibles en una vista. Esta es una herramienta excelente para consultar elementos existentes o crear nuevos elementos en un editor de proyectos o familias de Revit.
![](../.gitbook/assets/selecting _database_navigation_with_dynamo_nodes_02.png)
También puede seleccionar elementos de Revit por niveles específicos en la jerarquía de Revit. Esta es una opción eficaz para personalizar grandes matrices de datos para preparar la documentación o la creación de ejemplares y personalización generativas.
Teniendo en cuenta las tres imágenes anteriores, vamos a profundizar en un ejercicio que selecciona elementos de un proyecto básico de Revit para preparar las aplicaciones paramétricas que crearemos en las secciones restantes de este capítulo.
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 archivo de Revit de ejemplo, tenemos tres tipos de elementos de un edificio sencillo. Vamos a usar este archivo como ejemplo para seleccionar elementos de Revit en el contexto de la jerarquía de Revit.
Masa de construcción
Vigas (armazón estructural)
Vigas de celosía (componentes adaptativos)
¿Qué conclusiones podemos sacar de los elementos que hay en la vista de proyecto de Revit? Y, ¿cuánto debemos descender en la jerarquía para seleccionar los elementos adecuados? Por supuesto, esta tarea se volverá más compleja al trabajar en un proyecto de gran tamaño. Hay una gran cantidad de opciones disponibles; se pueden seleccionar elementos por categorías, niveles, familias, ejemplares, etc.
Como estamos trabajando con una configuración básica, seleccionaremos la masa de construcción eligiendo "Mass" en el nodo desplegable Categories. Puede encontrarlo en la ficha Revit > Selection.
La salida de la categoría Mass es solo la categoría en sí. Debemos seleccionar los elementos. Para ello, se utiliza el nodo "All Elements of Category".
En este punto, observe que no se ve ninguna geometría en Dynamo. Hemos seleccionado un elemento de Revit, pero no lo hemos convertido en geometría de Dynamo. Se trata de una distinción importante. Si tuviéramos que seleccionar un gran número de elementos, no es deseable obtener una vista preliminar de todos ellos en Dynamo porque esto ralentizaría todo el proceso. Dynamo es una herramienta para gestionar un proyecto de Revit sin realizar necesariamente operaciones de geometría, y lo veremos en la siguiente sección de este capítulo.
En este caso trabajamos con geometría sencilla, por lo que vamos a incorporar la geometría a la vista preliminar de Dynamo. Junto al elemento "BldgMass" del nodo Watch anterior aparece un número verde. Esto representa el ID del elemento e indica que estamos trabajando con un elemento de Revit, no con una geometría de Dynamo. El siguiente paso es convertir este elemento de Revit en geometría en Dynamo.
Mediante el nodo Element.Faces, se obtiene una lista de las superficies que representan cada cara de la masa de Revit. Ahora podemos ver la geometría en la ventana gráfica de Dynamo y comenzar a hacer referencia a la cara para realizar operaciones paramétricas.
A continuación se incluye un método alternativo. En este caso, no vamos a realizar la selección mediante la jerarquía de Revit ("All Elements of Category"), sino que vamos a seleccionar de forma explícita la geometría en Revit.
Mediante el nodo "Select Model Element", haga clic en el botón *"select" *(o "change"). En la ventana gráfica de Revit, seleccione el elemento que desee. En este caso, seleccionamos la masa de construcción.
En lugar de Element.Faces, se puede seleccionar la masa completa como una geometría sólida mediante Element.Geometry. De este modo, se selecciona toda la geometría contenida en la masa.
Mediante Geometry.Explode, podemos obtener la lista de superficies de nuevo. Estos dos nodos funcionan de la misma forma que Element.Faces, pero ofrecen opciones alternativas para profundizar en la geometría de un elemento de Revit.
Mediante algunas operaciones de lista básicas, podemos consultar una cara de interés.
En primer lugar, genere los elementos seleccionados anteriormente en el nodo Element.Faces.
A continuación, el nodo List.Count indica que estamos trabajando con 23 superficies en la masa.
Al hacer referencia a este número, se cambia el valor máximo de un *control deslizante de enteros *a "22".
Con List.GetItemAtIndex, se introducen las listas y el *control deslizante de enteros *para el índice. Deslizamos la selección y nos detenemos cuando lleguemos al índice 9 y hayamos aislado la fachada principal que contiene las vigas de celosía.
El paso anterior era un poco engorroso. Esto se puede hacer mucho más deprisa con el nodo "Select Face". Este nos permite aislar una cara que no es un elemento en el proyecto de Revit. Se aplica la misma interacción que con "Select Model Element", excepto que seleccionamos la superficie en lugar del elemento completo.
Supongamos que deseamos aislar los muros de las fachadas principales del edificio. Para ello, se puede utilizar el nodo "Select Faces". Haga clic en el botón "Select" y, a continuación, seleccione las cuatro fachadas principales en Revit.
Después de seleccionar los cuatro muros, asegúrese de hacer clic en el botón "Finalizar" en Revit.
Las caras se importan en Dynamo como superficies.
Ahora, veamos las vigas situadas sobre el atrio.
Con el nodo "Select Model Element", seleccione una de las vigas.
Conecte el elemento de viga al nodo Element.Geometry; la viga aparecerá en la ventana gráfica de Dynamo.
Podemos ampliar la geometría con un nodo Watch3D (si no ve la viga en Watch 3D, haga clic con el botón derecho y pulse "Ajustar en ventana").
Una duda que puede aparecer con frecuencia en los flujos de trabajo de Revit o Dynamo es la siguiente: ¿cómo selecciono un elemento y obtengo todos los elementos similares? Como el elemento de Revit seleccionado contiene toda su información jerárquica, podemos consultar su tipo de familia y seleccionar todos los elementos de ese tipo.
Conecte el elemento de viga a un nodo Element.ElementType.
El nodo Watch indica que la salida es ahora un símbolo de familia en lugar de un elemento de Revit.
Element.ElementType es una consulta sencilla, por lo que podemos realizarla en el bloque de código de la misma forma con
x.ElementType;
y obtener los mismos resultados.
Para seleccionar las vigas restantes, utilizaremos el nodo "All Elements of Family Type".
El nodo Watch muestra que se han seleccionado cinco elementos de Revit.
También podemos convertir estos cinco elementos en geometría de Dynamo.
¿Y si tuviéramos 500 vigas? Convertir todos estos elementos en geometría de Dynamo sería muy lento. Si Dynamo tarda mucho tiempo en calcular los nodos, puede usar la función "Bloquear" para poner en pausa la ejecución de operaciones de Revit mientras desarrolla el gráfico. Para obtener más información sobre el bloqueo de nodos, consulte la sección "Bloqueo" del capítulo sobre sólidos.
En cualquier caso, si importamos 500 vigas, ¿necesitamos que todas las superficies realicen la operación paramétrica deseada? ¿O podemos extraer información básica de las vigas y realizar tareas generativas con geometría fundamental? Esta es una pregunta que tendremos en cuenta a medida que avanzamos en este capítulo. Por ejemplo, veamos a continuación el sistema de vigas de celosía:
Con el mismo gráfico de nodos, seleccione el elemento de viga de celosía en lugar del elemento de viga. Antes de hacerlo, suprima el nodo Element.Geometry del paso anterior.
A continuación, ya estamos listos para extraer información básica del tipo de familia de vigas de celosía.
En el nodo Watch, podemos ver que tenemos una lista de componentes adaptativos seleccionados en Revit. Vamos a extraer la información básica, por lo que comenzaremos con los puntos adaptativos.
Conecte el nodo "All Elements of Family Type" al nodo "AdaptiveComponent.Location". Esto nos proporciona una lista de listas, cada una con tres puntos que representan las ubicaciones de los puntos adaptativos.
Al conectar un nodo "Polygon.ByPoints", se obtiene una PolyCurve. Se puede ver en la ventana gráfica de Dynamo. Con este método, hemos visualizado la geometría de un elemento y hemos abstraído la geometría de la matriz de elementos restantes (que podría ser mayor en número que este ejemplo).
Consejo: Si hace clic en el número verde de un elemento de Revit en Dynamo, la ventana gráfica de Revit ampliará ese elemento.
Una característica útil de Dynamo es la posibilidad de editar parámetros en un nivel paramétrico. Por ejemplo, se puede utilizar un algoritmo generativo o los resultados de una simulación para controlar los parámetros de una matriz de elementos. De este modo, un conjunto de ejemplares de la misma familia puede tener propiedades personalizadas en el proyecto de Revit.
Los parámetros de ejemplar definen la apertura de los paneles en la superficie de la cubierta, desde una proporción de apertura de 0,1 a 0,4.
Los parámetros basados en tipo se aplican a todos los elementos de la superficie porque son del mismo tipo de familia. El material de cada panel, por ejemplo, puede controlarse mediante un parámetro basado en tipo.
Si ha configurado una familia de Revit con anterioridad, recuerde que debe asignar un tipo de parámetro (cadena, número, cota, etc.). Asegúrese de utilizar el tipo de datos correcto al asignar parámetros de Dynamo.
También puede utilizar Dynamo en combinación con restricciones paramétricas definidas en las propiedades de una familia de Revit.
Como revisión rápida de los parámetros en Revit, recordemos que existen parámetros de tipo y parámetros de ejemplar. Ambos se pueden editar en Dynamo, pero trabajaremos con parámetros de ejemplar en el ejercicio siguiente.
A partir de la versión 0.8, Dynamo prácticamente no trabaja con unidades. Esto permite que Dynamo siga siendo un entorno de programación visual abstracto. Los nodos de Dynamo que interactúan con las cotas de Revit harán referencia a las unidades del proyecto de Revit. Por ejemplo, si configura un parámetro de longitud en Revit desde Dynamo, el número del valor en Dynamo se corresponderá con las unidades por defecto del proyecto de Revit. El siguiente ejercicio utiliza metros.
Para obtener una conversión rápida de unidades, utilice el nodo "Convert Between Units". Esta es una herramienta práctica para convertir unidades de longitud, área y volumen sobre la marcha.
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 el siguiente ejercicio, se utilizan metros.
Este ejercicio se centra en la edición de elementos de Revit sin realizar operaciones geométricas en Dynamo. No vamos a importar la geometría de Dynamo aquí, solo vamos a editar los parámetros de un proyecto de Revit. Este ejercicio es básico; para los usuarios más avanzados de Revit, observe que se trata de parámetros de ejemplar de una masa, pero la misma lógica se puede aplicar a una matriz de elementos para personalizarlos a gran escala. Esto se realiza con el nodo "Element.SetParameterByName".
Empiece con el archivo de ejemplo de Revit para esta sección. Hemos eliminado los elementos estructurales y las vigas de celosía adaptativas de la sección anterior. En este ejercicio, nos centraremos en una manipulación paramétrica en Revit y en la manipulación en Dynamo.
Al seleccionar el edificio dentro de Masa en Revit, vemos una matriz de parámetros de ejemplar en el panel Propiedades.
En Dynamo, podemos recuperar los parámetros mediante la selección del elemento de destino.
Seleccione la masa de construcción con el nodo "Select Model Element".
Se pueden consultar todos los parámetros de esta masa mediante el nodo "Element.Parameters". Esto incluye los parámetros de tipo y ejemplar.
Consulte el nodo Element. Parameters para buscar los parámetros de destino. También podemos ver el panel Propiedades del paso anterior para elegir los nombres de parámetro que deseamos editar. En este caso, buscamos los parámetros que afectan a los grandes movimientos geométricos en la masa de construcción.
Realizaremos cambios en el elemento de Revit mediante el nodo Element.SetParameterByName.
Utilice un bloque de código para definir una lista de parámetros con cada elemento entre comillas para indicar una cadena. También podemos utilizar el nodo List.Create con una serie de nodos "string" conectados a varias entradas, pero el uso de un bloque de código es más rápido y sencillo. Asegúrese de que la cadena coincida con el nombre exacto de Revit teniendo en cuenta mayúsculas y minúsculas:
{"BldgWidth","BldgLength","BldgHeight", "AtriumOffset", "InsideOffset","LiftUp"};
.
También vamos a designar valores para cada parámetro. Añada seis "controles deslizantes de enteros" al lienzo y cambie el nombre de estos al parámetro correspondiente de la lista. Asimismo, defina los valores de cada control deslizante a los que se pueden ver en la imagen anterior. Por orden de arriba a abajo: 62,92,25,22,8,12.
Defina otro bloque de código con una lista de la misma longitud que los nombres de parámetro. En este caso, se asignan nombres a las variables (sin comillas) que crean entradas para el bloque de código. Conecte los controles deslizantes a cada entrada respectiva:
{bw,bl,bh,ao,io,lu};
Conecte el bloque de código a la entrada de valor "Element.SetParameterByName"*. Con la opción Ejecutar automáticamente seleccionada, veremos los resultados automáticamente.
Esta demostración funciona con parámetros de ejemplar, pero no con parámetros de tipo.
Al igual que en Revit, muchos de estos parámetros dependen unos de otros. Por supuesto, existen combinaciones en las que la geometría se puede partir. Podemos solucionar este problema con las fórmulas definidas en las propiedades de los parámetros, o bien podemos configurar una lógica similar con operaciones matemáticas en Dynamo (este es un reto adicional si desea ampliar el ejercicio).
Esta combinación proporciona un nuevo diseño con estilo a la masa de construcción: 100, 92, 100, 25, 13, 51.
A continuación, veamos cómo podemos editar la fachada mediante un proceso similar.
Copie el gráfico y céntrese en la cristalera de la fachada que alojará el sistema de vigas de celosía. En este caso, se aíslan cuatro parámetros:
{"DblSkin_SouthOffset","DblSkin_MidOffset","DblSkin_NorthOffset","Facade Bend Location"};
.Además, creamos controles deslizantes de número y les cambiamos el nombre por los parámetros adecuados. Los tres primeros controles deslizantes empezando por arriba deben asignarse de nuevo a un dominio de [0,10], mientras que el control deslizante final, "Facade Bend Location", se debe asignar de nuevo a un dominio de [0,1]. Estos elementos, de arriba a abajo, deben empezar con los valores siguientes: 2,68, 2,64, 2,29, 0,5.
Defina un nuevo bloque de código y conecte los controles deslizantes:
{so,mo,no,fbl};
.
Al cambiar los controles deslizantes en esta parte del gráfico, podemos hacer que la cristalera de la fachada sea mucho más sustancial: 9,98, 10,0, 9,71, 0,31.
Puede crear una matriz de elementos de Revit en Dynamo con control paramétrico completo. Los nodos de Revit en Dynamo permiten importar elementos de geometrías genéricas a tipos de categorías específicos (como muros y suelos). En esta sección, nos centraremos en la importación paramétrica de elementos flexibles con componentes adaptativos.
Un componente adaptativo es una categoría de familia flexible que se presta bien a las aplicaciones generativas. Una vez creada la instancia, puede crear un elemento geométrico complejo controlado por la ubicación fundamental de los puntos adaptativos.
A continuación, se muestra un ejemplo de un componente adaptativo de tres puntos en el Editor de familias. Esto genera una viga de celosía definida por la posición de cada punto adaptativo. En el ejercicio siguiente, utilizaremos este componente para generar una serie de vigas de celosía en una fachada.
El componente adaptativo es un buen ejemplo de los procedimientos recomendados de interoperabilidad. Podemos crear una matriz de componentes adaptativos mediante la definición de los puntos adaptativos fundamentales. Y, al transferir estos datos a otros programas, tenemos la posibilidad de reducir la geometría a datos simples. La importación y la exportación con un programa como Excel siguen una lógica similar.
Supongamos que un consultor de fachada desea conocer la ubicación de los elementos de la viga de celosía sin necesidad de realizar un análisis mediante geometría totalmente articulada. Para preparar la fabricación, el consultor puede examinar la ubicación de los puntos adaptativos a fin de regenerar la geometría en un programa como Inventor.
El flujo de trabajo que configuraremos en el siguiente ejercicio nos permite acceder a todos estos datos mientras creamos la definición para la creación de elementos de Revit. Mediante este proceso, podemos combinar la conceptualización, la documentación y la fabricación en un flujo de trabajo perfecto. Esto permite generar un proceso más inteligente y eficaz para la interoperabilidad.
Otro método para importar geometría paramétrica de Dynamo a Revit es DirectShape. En resumen, el elemento DirectShape y las clases relacionadas permiten almacenar formas geométricas creadas externamente en un documento de Revit. La geometría puede incluir mallas o sólidos cerrados. DirectShape se ha diseñado principalmente para la importación de formas de otros formatos de datos, como IFC o STEP, donde no hay suficiente información disponible para crear un elemento de Revit "real". Al igual que en el flujo de trabajo de IFC y STEP, la función DirectShape permite importar sin problemas geometrías creadas en Dynamo a proyectos de Revit como elementos reales.
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.
Comenzando con el archivo de ejemplo de esta sección (o continuando con el archivo de Revit de la sesión anterior), veremos la misma masa de Revit.
Este es el archivo, tal y como se ha abierto.
Este es el sistema de vigas de celosía que hemos creado con Dynamo, vinculado de forma inteligente a la masa de Revit.
Hemos utilizado los nodos "Select Model Element" y "Select Face", bajamos un nivel más en la jerarquía y utilizamos "Select Edge". Con el solucionador de Dynamo establecido en "Automático", el gráfico se actualizará continuamente con los cambios realizados en el archivo de Revit. El borde que seleccionamos se asocia dinámicamente a la topología del elemento de Revit. Mientras la topología* no cambie, la conexión permanecerá vinculada entre Revit y Dynamo.
Seleccione la curva superior de la fachada de la cristalera. Esto abarca toda la longitud del edificio. Si tiene problemas para seleccionar el borde, recuerde realizar la selección en Revit. Para ello, coloque el cursor sobre el borde y pulse "Tab" hasta que se resalte el borde seleccionado.
Mediante dos nodos "Select Edge", seleccione cada borde que represente la inclinación en el centro de la fachada.
Realice lo mismo para los bordes inferiores de la fachada en Revit.
En los nodos Watch, se muestra que ahora tenemos líneas en Dynamo. Esto se convierte automáticamente en geometría de Dynamo, ya que los bordes en sí no son elementos de Revit. Estas curvas son las referencias que utilizaremos para crear instancias de vigas de celosía adaptativas a lo largo de la fachada.
Para mantener la coherencia de la topología, consultaremos un modelo sin caras o bordes adicionales añadidos. Aunque los parámetros pueden cambiar su forma, el modo en que se crea sigue siendo coherente.
Debemos unir primero las curvas y fusionarlas en una lista. De esta forma, podemos "agrupar" las curvas para realizar operaciones geométricas.
Cree una lista para las dos curvas del centro de la fachada.
Una las dos curvas en una PolyCurve. Para ello, conecte el componente List.Create a un nodo Polycurve.ByJoinedCurves.
Cree una lista para las dos curvas de la parte inferior de la fachada.
Una las dos curvas en una PolyCurve. Para ello, conecte el componente List.Create a un nodo Polycurve.ByJoinedCurves.
Por último, una las tres curvas principales (una línea y dos PolyCurves) en una lista.
Deseamos aprovechar la curva superior, que es una línea, y representa toda la extensión de la fachada. Crearemos planos a lo largo de esta línea para que se intersequen con el conjunto de curvas que hemos agrupado en una lista.
Con un bloque de código, defina un intervalo mediante la sintaxis:
0..1..#numberOfTrusses;
.Conecte un *control deslizante de enteros *a la entrada del bloque de código. Como podrá haber adivinado, esto representará el número de vigas de celosía. Observe que el control deslizante determina el número de elementos del intervalo definido de *0 *a 1.
Conecte el bloque de código a la entrada param de un nodo "Curve.PlaneAtParameter" y conecte el borde superior a la entrada curve. Esto nos dará diez planos, distribuidos de forma uniforme a lo largo de la extensión de la fachada.
Un plano es una unidad abstracta de geometría que representa un espacio bidimensional infinito. Los planos son ideales para la creación de contornos y la intersección, tal y como los vamos a configurar en este paso.
Con el nodo Geometry.Intersect (establezca el encaje en producto vectorial), conecte Curve.PlaneAtParameter a la entrada entity del nodo Geometry.Intersect. Conecte el nodo List.Create principal a la entrada geometry. Ahora aparecen puntos en la ventana gráfica de Dynamo que representan la intersección de cada curva con los planos definidos.
Observe que la salida es una lista de listas de listas. Hay demasiadas listas para nuestros fines. Vamos a realizar un aplanamiento parcial aquí. Debemos bajar un nivel en la lista y aplanar el resultado. Para ello, utilizaremos la operación List.Map, tal y como se explica en el capítulo sobre las listas del manual de introducción.
Conecte el nodo Geometry.Intersect a la entrada de lista de List.Map.
Conecte un nodo Flatten a la entrada f(x) de List.Map. Los resultados proporcionan tres listas, cada una con un número igual a la cantidad de vigas de celosía.
Debemos cambiar estos datos. Si desea crear una instancia de la viga de celosía, debemos utilizar el mismo número de puntos adaptativos que se ha definido en la familia. Se trata de un componente adaptativo de tres puntos, por lo que, en lugar de tres listas con 10 elementos cada una (numberOfTrusses), deseamos obtener 10 listas con tres elementos cada una. De este modo, podemos crear 10 componentes adaptativos.
Conecte List.Map a un nodo List.Transpose. Ahora tenemos la salida de datos deseada.
Para confirmar que los datos sean correctos, añada un nodo Polygon.ByPoints al lienzo y realice una comprobación con la vista preliminar de Dynamo.
Del mismo modo que hemos creado los polígonos, disponemos en una matriz los componentes adaptativos.
Añada un nodo AdaptiveComponent.ByPoints al lienzo y conecte el nodo List.Transpose a la entrada points.
Mediante un nodo Family Types, seleccione la familia "AdaptiveTruss" y conecte esta a la entrada FamilyType del nodo AdaptiveComponent.ByPoints.
En Revit, ahora las 10 vigas de celosía se han espaciado uniformemente a lo largo de la fachada.
Al ajustar el gráfico, hemos aumentado el valor de numberOfTrusses a 30 cambiando el control deslizante. Muchas vigas de celosía no son muy realistas, pero el vínculo paramétrico funciona. Una vez verificado, establezca el número de vigas de celosía en 15.
Y, como prueba final, al seleccionar la masa en Revit y editar los parámetros de ejemplar, podemos cambiar la forma del edificio y comprobar cómo cambia también la viga de celosía. Recuerde que este gráfico de Dynamo debe estar abierto para ver esta actualización y que el vínculo se romperá en cuanto se cierre.
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.
Abra primero el archivo de ejemplo para esta lección: ARCH-DirectShape-BaseFile.rvt.
En la vista 3D, vemos la masa de construcción de la lección anterior.
A lo largo del borde del atrio se encuentra una curva de referencia, la utilizaremos como una curva a la que haremos referencia en Dynamo.
A lo largo del borde opuesto del atrio se encuentra otra curva de referencia a la que también haremos referencia en Dynamo.
Para hacer referencia a la geometría en Dynamo, utilizaremos Select Model Element para cada miembro en Revit. Seleccione la masa en Revit e importe la geometría en Dynamo mediante Element.Faces: la masa debería estar visible en la vista preliminar de Dynamo.
Importe una curva de referencia en Dynamo mediante Select Model Element y CurveElement.Curve.
Importe la otra curva de referencia en Dynamo mediante Select Model Element y CurveElement.Curve.
La estructura se rige por tres parámetros principales: Desplazamiento diagonal, Contraflecha y Radio.
Al aplicar zoom, se obtiene una vista en primer plano de los parámetros de este gráfico. Podemos ajustarlos para obtener diferentes salidas de geometría.
Al soltar el nodo DirectShape.ByGeometry en el lienzo, vemos que tiene cuatro entradas: geometría, categoría, material y nombre.
La geometría será el sólido creado a partir de la parte de creación de geometría del gráfico
La entrada de categoría se elige mediante el nodo desplegable Categories. En este caso, utilizaremos "Armazón estructural".
La entrada de material se selecciona a través de la matriz de nodos anterior, aunque puede definirse más simplemente como "Por defecto" en este caso.
Después de ejecutar Dynamo, al volver a Revit, tenemos la geometría importada en la cubierta del proyecto. Se trata de un elemento de armazón estructural en lugar de un modelo genérico. El vínculo paramétrico a Dynamo permanece intacto.
A medida que descubra la amplia aplicación de la edición de parámetros, puede que desee editar una gran cantidad de elementos en Revit con Dynamo. Esta puede ser una operación computacionalmente exigente, lo que significa que puede ser lenta. Si va a editar un gran número de elementos, puede usar la función de nodo "Bloquear" para poner en pausa la ejecución de operaciones de Revit mientras desarrolla el gráfico. Para obtener más información sobre el bloqueo de nodos, consulte la sección "" del capítulo sobre sólidos.
En el , se describe cómo Dynamo consulta los datos para la creación de elementos de Revit. Para generar varios componentes adaptativos, definimos una lista de listas en la que cada lista tiene tres puntos que representan cada punto del componente adaptativo. Tendremos esto en cuenta a medida que gestionamos las estructuras de datos en Dynamo.
Repasemos el para importar geometría de Dynamo como DirectShape en el proyecto de Revit. Mediante este método, podemos asignar la categoría, el material y el nombre de una geometría importada, mientras se mantiene un vínculo paramétrico con nuestro gráfico de Dynamo.
Al alejar la vista y encuadrar a la derecha en el gráfico de ejemplo, vemos un gran grupo de nodos, que son operaciones geométricas que generan la estructura de cubierta de enrejado visible en la vista preliminar de Dynamo. Estos nodos se generan mediante la función de nodo a código, tal como se describe en la del manual de introducción.
Aunque Dynamo se creó originalmente con Revit en mente, su versatilidad como herramienta de programación visual se extiende más allá de esta solución. Dynamo también está integrado en Civil 3D, lo que permite a los usuarios crear eficaces rutinas de automatización para proyectos de infraestructuras civiles. Se trata de una herramienta extremadamente útil para procesar desde tareas habituales hasta los flujos de trabajo de diseño más complejos, lo que le ayudará en última instancia a ahorrar tiempo, optimizar sus diseños y tomar mejores decisiones al respecto. Dynamo ofrece todo un conjunto de nodos diseñados específicamente para Civil 3D, así como bibliotecas de terceros procedentes de una floreciente comunidad de usuarios.
Este capítulo del manual de introducción, se centrará en Dynamo for Civil 3D, desde lo más básico hasta temas más avanzados.
Aunque ya hemos visto cómo editar una masa de construcción básica, queremos profundizar en el vínculo entre Dynamo y Revit mediante la edición de un gran número de elementos de una sola vez. La personalización a gran escala se vuelve más compleja ya que las estructuras de datos requieren operaciones de lista más avanzadas. Sin embargo, los principios subyacentes de su ejecución son esencialmente los mismos. Vamos a estudiar algunas oportunidades de análisis a partir de un conjunto de componentes adaptativos.
Supongamos que hemos creado un rango de componentes adaptativos y queremos editar parámetros en función de sus ubicaciones de puntos. Los puntos podrían, por ejemplo, controlar un parámetro de grosor relacionado con el área del elemento. O bien, podrían controlar un parámetro de opacidad relacionado con la exposición solar a lo largo del año. Dynamo permite la conexión de análisis a parámetros en unos sencillos pasos; exploraremos una versión básica en el ejercicio siguiente.
Consulte los puntos adaptativos de un componente adaptativo seleccionado mediante el nodo AdaptiveComponent.Locations. Esto nos permite trabajar con una versión resumida de un elemento de Revit para el análisis.
Al extraer la ubicación de los puntos de los componentes adaptativos, se pueden ejecutar distintos análisis para ese elemento. Un componente adaptativo de cuatro puntos le permitirá estudiar la desviación desde el plano en un panel determinado, por ejemplo.
Utilice la reasignación para asignar un conjunto de datos a un rango de parámetros. Esta es una herramienta fundamental que se utiliza en un modelo paramétrico. Haremos una demostración en el siguiente ejercicio.
Dynamo permite usar las ubicaciones de los puntos de los componentes adaptativos para crear un plano de ajuste óptimo para cada elemento. También podemos consultar la posición del sol en el archivo de Revit y estudiar la orientación relativa del plano con respecto al sol en comparación con otros componentes adaptativos. Configuremos esta acción en el siguiente ejercicio mediante la creación de una cubierta algorítmica.
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 se amplían las técnicas mostradas en la sección anterior. En este caso, vamos a definir una superficie paramétrica a partir de elementos de Revit; para ello, crearemos ejemplares de los componentes adaptativos de cuatro puntos y, a continuación, los editaremos según la orientación del sol.
Comience por seleccionar dos bordes con el nodo "Select Edge". Los dos bordes son los tramos largos del atrio.
Combine los dos bordes en una lista con el nodo List.Create.
Cree una superficie entre los dos bordes con un nodo Surface.ByLoft.
Mediante el bloque de código, defina un rango de 0 a 1 con 10 valores espaciados uniformemente:
0..1..#10;
.Conecte el bloque de código a las entradas u y v de un nodo Surface.PointAtParameter y conecte el nodo Surface.ByLoft a la entrada surface. Haga clic con el botón derecho en el nodo y cambie el encaje a Producto vectorial. Esto proporcionará una rejilla de puntos en la superficie.
Esta rejilla de puntos sirve como puntos de control para una superficie definida paramétricamente. Queremos extraer las posiciones u y v de cada uno de estos puntos para poder conectarlos a una fórmula paramétrica y mantener la misma estructura de datos. Para ello, podemos consultar las ubicaciones de parámetros de los puntos que acabamos de crear.
Añada un nodo Surface.ParameterAtPoint al lienzo y conecte las entradas como se muestra más arriba.
Consulte los valores u de estos parámetros con el nodo UV.U.
Consulte los valores v de estos parámetros con el nodo UV.V.
Las salidas muestran los valores u y v correspondientes a cada punto de la superficie. Ahora tenemos un rango de 0 a 1 para cada valor en la estructura de datos adecuada, por lo que estamos listos para aplicar un algoritmo paramétrico.
Añada un bloque de código al lienzo e introduzca el siguiente código:
Math.Sin(u*180)*Math.Sin(v*180)*w;
. Esta es una función paramétrica que crea un relieve de seno a partir de una superficie plana.Conecta UV.U a la entrada u y UV.V a la entrada v.
La entrada w representa la amplitud de la forma, por lo que le conectamos un control deslizante de número.
Ahora tenemos una lista de valores tal y como los define el algoritmo. Usaremos esta lista de valores para mover los puntos hacia arriba en la dirección +Z. Con Geometry.Translate, conecte el *bloque de código *a zTranslation y el nodo Surface.PointAtParameter a la entrada geometry. Deben aparecer los nuevos puntos en la vista preliminar de Dynamo.
Por último, creamos una superficie con el nodo NurbsSurface.ByPoints y conectamos el nodo del paso anterior a la entrada points. Ya tenemos una superficie paramétrica. Puede arrastrar el control deslizante para reducir o aumentar el relieve.
Con la superficie paramétrica, vamos a definir un método para dividirla en paneles y crear la matriz de componentes adaptativos de cuatro puntos. Dynamo no dispone de funciones predefinidas para la división en paneles de las superficies, por lo que podemos buscar en la comunidad paquetes de Dynamo útiles.
Vaya a Paquetes > Buscar un paquete.
Busque "LunchBox" e instale "LunchBox for Dynamo". Se trata de un conjunto de herramientas muy útil para operaciones de geometría como esta.
Tras la descarga, tendrá acceso completo a la suite de LunchBox. Busque "Quad Grid" y seleccione "LunchBox Quad Grid By Face". Conecte la superficie paramétrica a la entrada surface y establezca las divisiones U y V en 15. Debe aparecer una superficie con cuatro paneles en la vista preliminar de Dynamo.
Si tiene curiosidad sobre su configuración, puede hacer doble clic en el nodo Lunch Box y ver cómo se ha realizado.
Volvamos a Revit para comprobar rápidamente el componente adaptativo que estamos utilizando aquí. No hace falta seguirlo, pero este es el panel de cubierta del que vamos a crear un ejemplar. Se trata de un componente adaptativo de cuatro puntos que es una representación en bruto de un sistema ETFE. La apertura del vacío central se encuentra en un parámetro denominado "ApertureRatio".
Vamos a crear una gran cantidad de ejemplares de geometría en Revit, por lo que debe asegurarse de que el solucionador de Dynamo se encuentre en el modo "Manual".
Añada un nodo Family Types al lienzo y seleccione "ROOF-PANEL-4PT".
Añada un nodo AdaptiveComponent.ByPoints al lienzo, conecte Panel Pts de la salida de "LunchBox Quad Grid by Face" a la entrada points. Conecte el nodo Family Types a la entrada familySymbol.
Pulse Ejecutar. Revit tendrá que pensar un poco mientras se crea la geometría. Si tarda demasiado, reduzca el valor de 15 del bloque de código a un número inferior. De este modo, se reduce el número de paneles de la cubierta.
Nota: Si Dynamo tarda mucho tiempo en calcular los nodos, puede usar la función "Bloquear" para poner en pausa la ejecución de operaciones de Revit mientras desarrolla el gráfico. Para obtener más información sobre el bloqueo de nodos, consulte la sección "Bloqueo" del capítulo sobre sólidos.
Al volver a Revit, disponemos de la matriz de paneles en la cubierta.
Al ampliar, podemos observar mejor las cualidades de la superficie.
Continuando con el ejemplo anterior, vamos a ir un paso más allá y vamos a definir la apertura de cada panel en función de su exposición al sol. Al ampliar en Revit y seleccionar un panel, vemos que hay un parámetro denominado "Coeficiente de apertura" en la barra de propiedades. La familia se configura para que los rangos de apertura estén comprendidos aproximadamente entre 0,05 y 0,45.
Si se activa el camino solar, se puede ver la ubicación actual del sol en Revit.
Podemos hacer referencia a esta ubicación del sol mediante el nodo SunSettings.Current.
Conecte la configuración del sol a Sunsetting.SunDirection para obtener el vector solar.
En el elemento Panel Pts utilizado para crear los componentes adaptativos, utilice Plane.ByBestFitThroughPoints para aproximar un plano para el componente.
Consulte la normal de este plano.
Use el producto escalar para calcular la orientación solar. El producto escalar es una fórmula que determina el grado de paralelismo o antiparalelismo de dos vectores. Por tanto, tomamos la normal del plano de cada componente adaptativo y lo comparamos con el vector solar para simular aproximadamente la orientación solar.
Tome el valor absoluto del resultado. De esta forma, se garantiza que el producto escalar sea preciso si la normal del plano está orientada hacia la dirección inversa.
Pulse Ejecutar.
En el producto escalar, tenemos una amplia gama de números. Queremos usar su distribución relativa, pero debemos condensar los números en el rango apropiado del parámetro "Coeficiente de apertura" que tenemos previsto editar.
Math.RemapRange es una herramienta ideal para ello. Toma una lista de entrada y reasigna sus límites a dos valores objetivo.
Defina los valores objetivo en 0,15 y 0,45 en un bloque de código.
Pulse Ejecutar.
Conecte los valores reasignados a un nodo Element.SetParameterByName.
Conecte la cadena "Coeficiente de apertura" a la entrada parameterName.
Conecte los componentes adaptativos a la entrada element.
Pulse Ejecutar.
De vuelta en Revit, visualizamos a una distancia que nos permita determinar el efecto de la orientación solar en la apertura de los paneles ETFE.
Al ampliar, vemos que los paneles ETFE están más cerrados cuando miran hacia el sol. Nuestro objetivo es reducir el sobrecalentamiento por la exposición solar. Si quisiéramos dejar pasar más luz en función de la exposición solar, solo tendríamos que cambiar el dominio en Math.RemapRange.
El Kit de herramientas de malla de Dynamo proporciona herramientas para importar mallas desde formatos de archivo externos, crear una malla a partir de objetos de geometría de Dynamo y generar manualmente mallas mediante sus vértices e índices. La biblioteca también proporciona herramientas para modificar y reparar mallas, o extraer cortes horizontales para su uso en la fabricación.
El Kit de herramientas de malla de Dynamo forma parte de la investigación de mallas en curso de Autodesk y, como tal, seguirá creciendo a lo largo de los próximos años. Esperamos que aparezcan con frecuencia nuevos métodos en este kit y no dude en ponerse en contacto con el equipo de Dynamo para ofrecer comentarios, indicar errores y enviar sugerencias sobre las nuevas funciones.
En el siguiente ejercicio, se muestran algunas operaciones básicas de malla que utiliza el Kit de herramientas de malla. En el ejercicio, intersecamos una malla con una serie de planos, lo que puede ser muy costoso desde una perspectiva computacional si se utilizan sólidos. A diferencia de los sólidos, las mallas tienen una "resolución" establecida y no se definen matemáticamente, sino topológicamente, y podemos definir esta resolución en función de la tarea que se está llevando a cabo. Para obtener más información sobre las relaciones entre mallas y sólidos, puede consultar el capítulo Geometría para el diseño computacional de este manual de introducción. Para examinar de forma más exhaustiva el Kit de herramientas de malla, consulte la página wiki de Dynamo. Pasemos al paquete en el ejercicio siguiente.
En Dynamo, vaya a Paquetes > Package Manager en la barra de menús superior. En el campo de búsqueda, escriba "MeshToolkit", todo en una sola palabra. Haga clic en Instalar y acepte las confirmaciones para iniciar la descarga. Así de fácil.
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 ejemplo, examinaremos el nodo Intersect del Kit de herramientas de malla. Importaremos una malla y la intersecaremos con una serie de planos de entrada para crear cortes. Este es el punto inicial de la preparación del modelo para la fabricación en una herramienta de corte láser o por chorro de agua, o un dispositivo de fresado CNC.
Abra primero Mesh-Toolkit_Intersect-Mesh.dyn in Dynamo.
File Path: busque el archivo de malla que desea importar (stanford_bunny_tri.obj). Los tipos de archivo admitidos son .mix y .obj.
Mesh.ImportFile: conecte la ruta de archivo para importar la malla.
Point.ByCoordinates: cree un punto; este será el centro de un arco.
Arc.ByCenterPointRadiusAngle: cree un arco alrededor del punto. Esta curva se utilizará para colocar una serie de planos. __ La configuración es la siguiente: __
radius: 40, startAngle: -90, endAngle:0
.
Cree una serie de planos orientados a lo largo del arco.
Code Block: cree 25 números entre 0 y 1.
Curve.PointAtParameter: conecte el arco a la entrada "curve" y la salida de bloque de código a la entrada "param" para extraer una serie de puntos a lo largo de la curva.
Curve.TangentAtParameter: conecte las mismas entradas que en el nodo anterior.
Plane.ByOriginNormal: conecte los puntos a la entrada "origin" y los vectores a la entrada "normal" para crear una serie de planos en cada punto.
A continuación, utilizaremos estos planos para intersecar la malla.
Mesh.Intersect: interseque los planos con la malla importada, creando una serie de contornos de PolyCurve. Haga clic con el botón derecho en el nodo y defina el encaje como el más largo.
PolyCurve.Curves: divida las PolyCurves en fragmentos de curva.
Curve.EndPoint: extraiga los puntos finales de cada curva.
NurbsCurve.ByPoints: utilice los puntos para crear una NurbsCurve. Utilice un nodo booleano establecido en True (verdadero) para cerrar las curvas.
Antes de continuar, desactive la vista preliminar de algunos de los nodos, como Mesh.ImportFile, Curve.EndPoint, Plane.ByOriginNormal y Arc.ByCenterPointRadiusAngle para ver mejor el resultado.
Surface.ByPatch: cree parches de superficie para cada contorno con el fin de crear "cortes" de la malla.
Añada un segundo conjunto de cortes para obtener un efecto de gofre/cartón de huevos.
Es posible que se haya dado cuenta de que las operaciones de intersección se calculan de forma más rápida con una malla que con un sólido comparable. Los flujos de trabajo como el que se muestra en este ejercicio son excelentes para trabajar con mallas.
Dynamo ofrece una gran variedad de métodos para crear un paquete para uso personal o para compartir con la comunidad de Dynamo. En el caso real incluido a continuación, veremos cómo se configura un paquete mediante la desconstrucción de uno existente. Este caso real se basa en las lecciones del capítulo anterior y proporciona un conjunto de nodos personalizados para la asignación de geometría, mediante coordenadas UV, de una superficie de Dynamo a otra.
Vamos a trabajar con un paquete de ejemplo que demuestra la asignación de UV de puntos de una superficie a otra. Ya hemos aprendido los conceptos básicos de la herramienta en la sección Creación de un nodo personalizado de este manual de introducción. Los archivos siguientes muestran cómo podemos utilizar el concepto de asignación de UV y desarrollar un conjunto de herramientas para una biblioteca publicable.
En esta imagen, se asigna un punto de una superficie a otra mediante coordenadas UV. El paquete se basa en este concepto, pero con una geometría más compleja.
En el capítulo anterior, exploramos métodos para panelizar una superficie en Dynamo según las curvas definidas en el plano XY. Este caso real amplía estos conceptos a más dimensiones de la geometría. Vamos a instalar este paquete como se creó para mostrar cómo se ha desarrollado. En la siguiente sección, mostraremos cómo se ha publicado este paquete.
En Dynamo, haga clic en Paquetes > Package Manager y busque el paquete "MapToSurface" (todo en una sola palabra). Haga clic en Instalar para iniciar la descarga y añada el paquete a la biblioteca.
Después de la instalación, los nodos personalizados deben estar disponibles en la sección Complementos > DynamoPrimer.
Con el paquete instalado, veamos cómo se configura.
El paquete que estamos creando utiliza cinco nodos personalizados que hemos creado como referencia. Veamos qué hace cada nodo a continuación. Algunos nodos personalizados se basan en otros nodos personalizados y los gráficos tienen un diseño que los demás usuarios pueden comprender con total claridad.
Este es un paquete sencillo con cinco nodos personalizados. En los pasos siguientes, hablaremos brevemente de la configuración de cada nodo personalizado.
Se trata de un nodo personalizado básico en el que se basan los demás nodos de asignación. En pocas palabras, el nodo asigna un punto desde una coordenada UV de la superficie de origen a la ubicación de la coordenada UV de la superficie de destino. Como los puntos son la geometría más primitiva, a partir de la cual se genera geometría más compleja, podemos utilizar esta lógica para asignar geometría 2D e incluso geometría 3D de una superficie a otra.
La lógica de ampliar puntos asignados de geometría 1D a geometría 2D se muestra aquí de forma sencilla con polígonos. Observe que se ha anidado el nodo "PointsToSurface" en este nodo personalizado. De esta forma, podemos asignar los puntos de cada polígono a la superficie y, a continuación, volver a generar el polígono a partir de los puntos asignados. Si se mantiene la estructura de datos correcta (una lista de listas de puntos), se pueden mantener los polígonos separados después de reducirlos a un conjunto de puntos.
Aquí se aplica la misma lógica que en el nodo "PolygonsToSurface". En lugar de asignar puntos poligonales, asignamos puntos de control de una curva NURBS.
OffsetPointsToSurface
Este nodo es un poco más complejo, pero el concepto es simple. Como el nodo "PointsToSurface", este nodo asigna puntos de una superficie a otra. Sin embargo, también considera los puntos que no se encuentran en la superficie de origen inicial, obtiene su distancia al parámetro UV más cercano y asigna esta distancia a la normal de la superficie de destino en la coordenada UV correspondiente. Esto se ve con mayor claridad al examinar los archivos de ejemplo.
Se trata de un nodo simple que crea una superficie paramétrica para asignar de la rejilla de origen a una superficie ondulada en los archivos de ejemplo.
Los archivos de ejemplo se pueden encontrar en la carpeta raíz del paquete. Haga clic en Package Manager > ficha Paquetes instalados.
Junto a MapToSurface, haga clic en el menú de puntos verticales > Mostrar directorio raíz.
A continuación, abra la carpeta "extra", que aloja todos los archivos del paquete que no son nodos personalizados. Aquí es donde se almacenan los archivos de ejemplo (si existen) de los paquetes de Dynamo. Las capturas de pantalla que se muestran a continuación explican los conceptos demostrados en cada archivo de ejemplo.
Este archivo de ejemplo muestra cómo se puede utilizar "PointsToSurface" para panelizar una superficie en función de una rejilla de rectángulos. Esto debería resultarle familiar, ya que hicimos una demostración de un flujo de trabajo similar en el capítulo anterior.
Mediante un flujo de trabajo similar, este archivo de ejercicio muestra una configuración para la asignación de círculos (o polígonos que representan círculos) de una superficie a otra. Utiliza el nodo "PolygonsToSurface".
Este archivo de ejemplo añade cierta complejidad al trabajar con el nodo "NurbsCrvToSurface". La superficie de destino se desfasa una distancia dada y la curva NURBS se asigna a la superficie de destino original y a la superficie de desfase. A partir de ahí, las dos curvas asignadas se solevan para crear una superficie que, a continuación, se engrosa. Este sólido resultante tiene una ondulación que es representativa de las normales de la superficie de destino.
Este archivo de ejemplo muestra cómo asignar una PolySurface plegada de una superficie de origen a una superficie de destino. Las superficies de origen y de destino son superficies rectangulares que abarcan la rejilla y una superficie de revolución, respectivamente.
La PolySurface de origen asignada desde la superficie de origen a la superficie de destino.
Dado que los nodos personalizados pueden asignar diferentes tipos de curvas, este último archivo hace referencia a un archivo SVG exportado de Illustrator y asigna las curvas importadas a una superficie de destino.
Mediante el análisis de la sintaxis de un archivo .svg, las curvas se trasladan del formato .xml a PolyCurves de Dynamo.
Las curvas importadas se asignan a una superficie de destino. Esto nos permite diseñar de forma explícita (señalar y hacer clic) una panelización en Illustrator, importarla en Dynamo y aplicarla a una superficie de destino.
En las secciones anteriores, examinamos cómo se configura el paquete de MapToSurface con nodos personalizados y archivos de ejemplo. Pero, ¿cómo publicamos un paquete que se ha desarrollado localmente? En este caso real, se muestra cómo publicar un paquete a partir de un conjunto de archivos en una carpeta local.
Hay muchas formas de publicar un paquete. A continuación, se indica el proceso recomendado: publique localmente, desarrolle localmente y, a continuación, publique en línea. Comenzaremos con una carpeta que contiene todos los archivos del paquete.
Antes de pasar a la publicación del paquete MapToSurface, si ha instalado el paquete en una lección anterior, desinstálelo para que no trabaje con paquetes idénticos.
Vaya primero a Paquetes > Package Manager > ficha Paquetes instalados > junto a MapToSurface, haga clic en el menú de puntos verticales > Suprimir.
A continuación, reinicie Dynamo. Al volver a abrirlo, cuando active la ventana "Gestionar paquetes", MapToSurface ya no debería aparecer. Ya estamos listos para empezar desde el principio.
Puede publicar nodos y paquetes personalizados desde Dynamo Sandbox en la versión 2.17 y posteriores, siempre que no presenten dependencias de la API del anfitrión. En versiones anteriores, la publicación de nodos y paquetes personalizados solo estaba activada en Dynamo for Revit y Dynamo para Civil 3D.
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.
Este es el primer envío del paquete y se han incluido todos los nodos personalizados y los archivos de ejemplo en una única carpeta. Con esta carpeta preparada, ya podemos realizar la carga en Dynamo Package Manager.
Esta carpeta contiene cinco nodos personalizados (.dyf).
Esta carpeta también contiene cinco archivos de ejemplo (.dyn) y un archivo de vectores importado (.svg). Estos archivos se utilizarán como ejercicios de introducción para mostrar al usuario cómo trabajar con los nodos personalizados.
En Dynamo, haga clic primero en Paquetes > Package Manager > ficha Publicar paquete nuevo.
En la ficha Publicar un paquete, rellene los campos correspondientes en el lado izquierdo de la ventana.
A continuación, añadiremos archivos del paquete. Puede añadir archivos individualmente o carpetas enteras si selecciona Añadir directorio (1). Para añadir archivos que no sean .dyf, asegúrese de cambiar el tipo de archivo en la ventana del navegador a "Todos los archivos (.)". Observe que añadiremos sin distinción todos los archivos, los nodos personalizados (.dyf) o los archivos de ejemplo (.dyn). Dynamo organizará estos elementos en categorías cuando publiquemos el paquete.
Una vez que haya seleccionado la carpeta MapToSurface, Package Manager le mostrará su contenido. Si va a cargar su propio paquete con una estructura de carpetas compleja y no desea que Dynamo realice cambios en ella, puede activar el conmutador "Conservar estructura de carpetas". Esta opción es para usuarios avanzados y, si el paquete no se ha configurado deliberadamente de una manera específica, lo mejor es dejar este conmutador desactivado y permitir que Dynamo organice los archivos según sea necesario. Pulse Siguiente para continuar.
Aquí tiene la oportunidad de previsualizar cómo organizará Dynamo los archivos del paquete antes de publicarlo. Haga clic en Finalizar para continuar.
Para la publicación, haga clic en "Publicar localmente" (1). Si sigue este proceso, asegúrese de hacer clic en "Publicar localmente" y no en "Publicar en línea". No deseamos un conjunto de paquetes duplicados en Package Manager.
Tras la publicación, los nodos personalizados deberían estar disponibles en el grupo "DynamoPrimer" o en la biblioteca de Dynamo.
Ahora veamos el directorio raíz para comprobar cómo Dynamo ha aplicado formato al paquete que acabamos de crear. Para ello, vaya a la ficha Paquetes instalados > junto a MapToSurface, haga clic en el menú de puntos verticales > seleccione Mostrar directorio raíz.
Observe que el directorio raíz se encuentra en la ubicación local del paquete (recuerde que hemos publicado el paquete "localmente"). Dynamo hace referencia a esta carpeta para leer nodos personalizados. Por lo tanto, es importante publicar localmente el directorio en una ubicación de carpeta permanente (es decir, no en el escritorio). A continuación, se desglosan las carpetas del paquete de Dynamo.
La carpeta bin contiene archivos .dll creados con bibliotecas de C# o Zero-Touch. No hay ninguna para este paquete, por lo que esta carpeta aparece vacía en este ejemplo.
La carpeta dyf contiene los nodos personalizados. Al abrir esta, se mostrarán todos los nodos personalizados (archivos .dyf) de este paquete.
La carpeta "extra" contiene todos los archivos adicionales. Es probable que estos archivos sean archivos de Dynamo (.dyn) o archivos adicionales necesarios (.svg, .xls, .jpeg, .sat, etc.).
El archivo pkg es un archivo de texto básico que define los parámetros del paquete. Esta función está automatizada en Dynamo, pero se puede modificar si desea acceder a los detalles.
Nota: No siga este paso a menos que publique realmente un paquete suyo.
Cuando desee publicarlo, en Paquetes > Package Manager > ventana Paquetes instalados, seleccione el botón situado a la derecha del paquete que desee publicar y elija Publicar.
Si va a actualizar un paquete que ya se ha publicado, seleccione Publicar versión; Dynamo actualizará el paquete en línea en función de los nuevos archivos del directorio raíz del paquete. Así de fácil.
Al actualizar los archivos de la carpeta raíz del paquete publicado, puede publicar también una nueva versión del paquete. Para ello, seleccione "Publicar versión" en la ventana Mis paquetes. Esta es una forma perfecta de realizar las actualizaciones necesarias del contenido y compartirlas con la comunidad. Publicar versión solo funcionará si es la persona encargada del mantenimiento del paquete.
Dynamo para Revit amplía el modelado de información de construcción mediante el entorno de datos y lógica de un editor gráfico de algoritmos. Su flexibilidad, junto con una base de datos de Revit robusta, ofrece una nueva perspectiva para BIM.
Este capítulo se centra en los flujos de trabajo de Dynamo para BIM. Las secciones se basan principalmente en ejercicios, ya que la mejor forma de familiarizarse con un editor gráfico de algoritmos para BIM es pasar directamente a un proyecto. No obstante, veamos primero los inicios del programa.
A medida que Revit y Dynamo continúan evolucionando, es posible que observe que la versión de Revit con la que está trabajando no es compatible con la versión de Dynamo para Revit que ha instalado en su equipo. A continuación, se describen las versiones de Dynamo para Revit que son compatibles con Revit.
Con un equipo dedicado de desarrolladores y una ferviente comunidad, el proyecto ha avanzado mucho desde sus humildes inicios.
Dynamo se creó originalmente para agilizar los flujos de trabajo de AEC en Revit. Aunque Revit crea una robusta base de datos para cada proyecto, puede resultar difícil para un usuario medio acceder a esta información fuera de las restricciones de la interfaz. Revit incluye una API (interfaz de programación de aplicaciones) completa que permite a desarrolladores de terceros crear herramientas personalizadas. Y los programadores han estado utilizado esta API durante años, pero la creación de secuencias de comandos basadas en texto no está accesible para todos. Dynamo busca democratizar los datos de Revit a través de un editor gráfico de algoritmos de fácil manejo.
Mediante el uso de los nodos principales de Dynamo, junto con los nodos personalizados de Revit, un usuario puede ampliar sustancialmente los flujos de trabajo paramétricos en cuanto a interoperabilidad, documentación, análisis y generación. Con Dynamo, los flujos de trabajo tediosos pueden automatizarse, mientras que pueden impulsarse las exploraciones de diseño.
En un editor de proyectos o familias de Revit, vaya a Complementos y haga clic en Dynamo.*
Tenga en cuenta que Dynamo solo se ejecutará en el archivo en el que se abrió.
Al abrir Dynamo en Revit, hay una nueva categoría denominada "Revit". Se trata de una adición completa a la interfaz de usuario que ofrece nodos que se adaptan específicamente a los flujos de trabajo de Revit.*
El gráfico de Dynamo solo funcionará al abrirse en Dynamo para Revit mediante la familia de nodos específica de Revit. Si se abre un gráfico de Dynamo para Revit en Dynamo Sandbox, por ejemplo, no aparecerán los nodos de Revit.
Como Revit es una plataforma que proporciona una sólida gestión de proyectos, las operaciones paramétricas de Dynamo pueden ser complejas y lentas de calcular. Si Dynamo tarda mucho tiempo en calcular los nodos, puede usar la función "Bloquear" para poner en pausa la ejecución de operaciones de Revit mientras desarrolla el gráfico.
Puede obtener más información sobre cómo bloquear nodos en la sección Nodos y cables.
Como Dynamo se creó originalmente para AEC, su comunidad grande y creciente es un recurso excelente para aprender del sector y ponerse en contacto con expertos de la industria. La comunidad de Dynamo la integran arquitectos, ingenieros, programadores y diseñadores a los que les apasiona compartir y crear.
Dynamo es un proyecto de código abierto que evoluciona constantemente y gran parte del desarrollo está relacionado con Revit. Si es un nuevo usuario, diríjase al foro de debate y comience a publicar preguntas. Si es un programador y desea participar en el desarrollo de Dynamo, consulte el repositorio de GitHub. Además, un recurso excelente para las bibliotecas de terceros es Dynamo Package Manager. Muchos de estos paquetes se crean teniendo en mente AEC y echaremos un vistazo a los paquetes de terceros para la panelización en este capítulo.
Dynamo también mantiene un blog activo. Lea las últimas publicaciones para obtener información sobre los avances más recientes.
Ahora que ya sabe un poco más sobre el panorama general, vamos a empezar a crear el primer gráfico de Dynamo en Civil 3D.
Este es un ejemplo sencillo que pretende demostrar la funcionalidad básica de Dynamo. Es recomendable seguir los pasos descritos en un nuevo documento vacío de Civil 3D.
Lo primero que debe hacer es abrir un documento vacío en Civil 3D. Una vez allí, vaya a la ficha Administrar de la cinta de opciones de Civil 3D y busque el grupo Programación visual.
Haga clic en el botón Dynamo, que iniciará Dynamo en una ventana independiente.
¿Cuál es la diferencia entre Dynamo y el Reproductor de Dynamo?
Dynamo es la herramienta que se utiliza para crear y ejecutar gráficos. El Reproductor de Dynamo permite ejecutar fácilmente gráficos sin tener que abrirlos en Dynamo.
Vaya a la sección Reproductor de Dynamo cuando desee probarlo.
Una vez que Dynamo esté abierto, aparecerá la pantalla de inicio. Haga clic en Nuevo para abrir un espacio de trabajo en blanco.
¿Y los ejemplos?
Dynamo for Civil 3D incluye algunos gráficos prediseñados que pueden servirle de inspiración para otras ideas sobre cómo usar Dynamo. Es recomendable que les eche un vistazo en algún momento, así como a los Flujos de trabajo de ejemplo aquí en el manual de introducción.
Ahora debería aparecer un espacio de trabajo vacío. Vamos a ver Dynamo en acción. Este es nuestro objetivo:
Muy sencillo, ¿verdad? Sin embargo, antes de empezar, debemos abordar algunos aspectos fundamentales.
Los componentes básicos de un gráfico de Dynamo se denominan nodos. Un nodo es como una pequeña máquina; se le introducen datos, realiza algún trabajo con ellos y genera un resultado. Dynamo for Civil 3D cuenta con una biblioteca de nodos que se pueden conectar mediante cables para formar un gráfico que realiza tareas más eficaces y de mayor tamaño que las que puede realizar un nodo por sí solo.
Espere... ¿Y si nunca he utilizado Dynamo?
Puede que algunos de estos conceptos le resulten bastante nuevos, pero no se preocupe. Estas secciones le ayudarán a ponerse al día.
Interfaz de usuario Nodos y cables Nodos y conceptos básicos
Ahora, vamos a crear el gráfico. Aquí hay una lista de todos los nodos que necesitaremos.
Para encontrar estos nodos, escriba sus nombres en la barra de búsqueda de la biblioteca o haga clic con el botón derecho en cualquier lugar del lienzo y realice allí la búsqueda.
¿Cómo puedo saber qué nodos utilizar y dónde encontrarlos?
Los nodos de la biblioteca se agrupan en categorías lógicas según su finalidad. Consulte la sección Biblioteca de nodos para realizar un recorrido más detallado.
El gráfico final debería presentar el siguiente aspecto.
Resumamos todo lo que hemos hecho aquí:
Hemos elegido el documento en el que se va a trabajar. En este caso (y en la mayoría), deseamos trabajar en el documento activo de Civil 3D.
Hemos definido el bloque de destino en el que se debe crear el objeto de texto (en este caso, el espacio modelo).
Se ha utilizado un nodo String para especificar la capa en la que se debe colocar el texto.
Se ha creado un punto mediante el nodo Point.ByCoordinates para definir la posición en la que se debe colocar el texto.
Se han definido las coordenadas X e Y del punto de inserción de texto mediante dos nodos Number Slider.
Se ha utilizado otro nodo String para definir el contenido del objeto de texto.
Y, por último, hemos creado el objeto de texto.
Veamos los resultados de nuestro nuevo y reluciente gráfico.
De nuevo en Civil 3D, asegúrese de que la ficha Modelo esté seleccionada. Debería ver el nuevo objeto de texto que ha creado Dynamo.
Si no aparece el texto, es posible que deba ejecutar el comando ZOOM -> EXTENSIÓN para ampliar la vista del espacio correcto.
¡Fantástico! Ahora vamos a realizar algunas mejoras en el texto.
De vuelta en el gráfico de Dynamo, cambie algunos de los valores de entrada, como la cadena de texto, las coordenadas del punto de inserción, etc. Debería observar cómo se actualiza automáticamente el texto en Civil 3D. Observe también que si desconecta uno de los puertos de entrada, se elimina el texto. Si vuelve a conectar todo, el texto se crea de nuevo.
¿Por qué Dynamo no inserta un nuevo objeto de texto cada vez que se ejecuta el gráfico?
Por defecto, Dynamo "recordará" los objetos que crea. Si cambia los valores de entrada del nodo, los objetos de Civil 3D se actualizan en lugar de crear objetos nuevos. Obtenga más información sobre este comportamiento en la sección Enlace de objetos.
Este ejemplo es apenas una pequeña muestra de lo que puede hacer con Dynamo for Civil 3D. Siga leyendo para obtener más información.
Uno de los muchos y excelentes casos de uso de Dynamo es la colocación dinámica de objetos discretos a lo largo de un modelo de obra lineal. A menudo, es necesario colocar objetos en ubicaciones independientes de los ensamblajes insertados a lo largo de la obra lineal, lo que resulta una tarea muy tediosa de realizar manualmente. Y, cuando la geometría horizontal o vertical de la obra lineal cambia, esto suele ir acompañado de un importante trabajo de rectificación.
Lectura de datos de un archivo externo (en este caso, Excel)
Organización de datos en diccionarios
Uso de sistemas de coordenadas para controlar la posición/escala/rotación
Colocación de referencias a bloque
Visualización de geometría en Dynamo
Este gráfico se ejecutará en Civil 3D 2020 y versiones posteriores.
Descargue primero los archivos de ejemplo que aparecen a continuación y abra el archivo DWG y el gráfico de Dynamo.
Es preferible que el archivo de Excel se guarde en el mismo directorio que el gráfico de Dynamo.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Leer el archivo de Excel e importar los datos en Dynamo
Obtener líneas características de la línea base de obra lineal especificada
Generar sistemas de coordenadas a lo largo de la línea característica de obra lineal en los P.K. deseados
Utilizar los sistemas de coordenadas para colocar referencias a bloque en el espacio modelo
¡Empecemos!
En este gráfico de ejemplo, vamos a utilizar un archivo de Excel a fin de almacenar los datos que utilizará Dynamo para colocar las referencias a bloque de farolas. La tabla presenta el siguiente aspecto.
El uso de Dynamo para leer datos de un archivo externo (como un archivo de Excel) es una excelente estrategia, sobre todo, cuando los datos deben compartirse con otros miembros del equipo.
Los datos de Excel se importan en Dynamo de este modo.
Ahora que tenemos los datos, debemos dividirlos por columna (Corridor, Baseline, PointCode, etc.) para poder utilizarlos en el resto del gráfico. Para ello, lo habitual es utilizar el nodo List.GetItemAtIndex y especificar el número de índice de cada columna que deseemos. Por ejemplo, la columna Corridor se encuentra en el índice 0, la columna Baseline en el índice 1, etc.
Parece lógico, ¿verdad? Sin embargo, este planteamiento puede plantear un problema. ¿Qué ocurre si el orden de las columnas del archivo de Excel cambia en el futuro? ¿O se añade una nueva columna entre otras dos? En ese caso, el gráfico no funcionará correctamente y deberá actualizarse. Podemos preparar el gráfico para el futuro incluyendo los datos en un diccionario, con los encabezados de las columnas de Excel como claves y el resto de los datos como valores.
Esto permite que el gráfico sea más flexible a la hora de cambiar el orden de las columnas en Excel. Mientras los encabezados de las columnas sigan siendo los mismos, los datos podrán recuperarse simplemente del diccionario mediante su clave (es decir, el encabezado de columna), que es lo que haremos a continuación.
Ahora que ya tenemos los datos de Excel importados y listos, empecemos a utilizarlos para obtener información de Civil 3D sobre los modelos de obra lineal.
Seleccione el modelo de obra lineal por su nombre.
Obtenga una línea base específica en la obra lineal.
Obtenga una línea característica dentro de la línea base mediante su código de punto.
Ahora vamos a generar sistemas de coordenadas a lo largo de las líneas características de obra lineal en los valores de P.K. especificados del archivo de Excel. Estos sistemas de coordenadas se utilizarán para definir la posición, la rotación y la escala de las referencias a bloque de las farolas.
Observe aquí el uso de un bloque de código para rotar los sistemas de coordenadas en función del lado de la línea base en el que se encuentren. Esto podría lograrse mediante una secuencia de varios nodos, pero este es un buen ejemplo de una situación en la que es más fácil simplemente escribirlo.
Ya casi hemos terminado. Disponemos de toda la información necesaria para poder colocar realmente las referencias a bloque. Lo primero que hay que hacer es obtener las definiciones de bloque que deseamos mediante la columna BlockName del archivo de Excel.
A continuación, el último paso es crear las referencias a bloque.
Al ejecutar el gráfico, deberían aparecer nuevas referencias a bloque en el espacio modelo a lo largo de la obra lineal. Y esta es la mejor parte: si el modo de ejecución del gráfico se ha establecido en Automático y edita el archivo de Excel, las referencias de bloque se actualizan automáticamente.
A continuación, se muestra un ejemplo de cómo ejecutar el gráfico con el Reproductor de Dynamo.
Puede resultar útil visualizar la geometría de obra lineal en Dynamo para ofrecer algo de contexto. Este modelo concreto incluye sólidos de obra lineal extraídos en el espacio modelo, por lo que vamos a incorporarlos en Dynamo.
Sin embargo, hay algo más que debemos tener en cuenta. Los sólidos son un tipo de geometría relativamente "pesado", lo que significa que esta operación ralentizará el gráfico. Se agradecería que hubiera una forma sencilla de elegir si deseamos ver los sólidos o no. La respuesta obvia es simplemente desconectar el nodo Corridor.GetSolids, pero eso generará advertencias para todos los nodos posteriores, lo que resulta algo lioso. Esta es una situación en la que el nodo ScopeIf realmente es de gran utilidad.
Observe que el nodo Object.Geometry presenta una barra gris en la parte inferior. Esto significa que la vista preliminar del nodo está desactivada (para acceder a ella, haga clic con el botón derecho en el nodo), lo que permite que GeometryColor.ByGeometryColor evite entrar en conflicto con otra geometría para obtener prioridad de visualización en la vista preliminar en segundo plano.
El nodo ScopeIf permite básicamente ejecutar de forma selectiva una ramificación completa de nodos. Si la entrada test se ha establecido en "falso", no se ejecutará ningún nodo conectado al nodo ScopeIf.
Este es el resultado de la vista preliminar en segundo plano de Dynamo.
A continuación, se ofrecen algunas ideas sobre cómo podría ampliar las posibilidades de este gráfico.
Añada una columna de rotación al archivo de Excel y utilícela para controlar la rotación de los sistemas de coordenadas.
Añada desfases horizontales o verticales al archivo de Excel para que las farolas puedan desviarse de la línea característica de obra lineal si es necesario.
En lugar de utilizar un archivo de Excel con valores de P.K., genere estos valores directamente en Dynamo mediante un P.K. inicial y una separación típica.
La importación Zero-Touch hace referencia a un método sencillo para importar bibliotecas C# con solo apuntar y hacer clic. Dynamo leerá los métodos públicos de un archivo .dll y los convertirá en nodos de Dynamo. Puede utilizar Zero-Touch para desarrollar paquetes y nodos personalizados y para importar bibliotecas externas en el entorno de Dynamo.
Archivos .dll
Nodos de Dynamo
Con Zero-Touch, puede importar una biblioteca que no se haya desarrollado necesariamente para Dynamo y crear un conjunto de nodos nuevos. La función Zero-Touch muestra la mentalidad multiplataforma del proyecto Dynamo.
En Dynamo, cree un archivo nuevo y seleccione Archivo > Importar biblioteca.
A continuación, localice el archivo dll.
En la ventana emergente, vaya a la carpeta de la versión contenida en la ubicación de instalación de AForge. Probablemente se encuentre en una carpeta similar a esta: C:\Program Files (x86)\AForge.NET\Framework\Release.
AForge.Imaging.dll: solo vamos a utilizar este archivo de la biblioteca AForge para este caso real. Seleccione este archivo .dll y pulse "Abrir".
Al regresar a Dynamo, debería mostrarse el grupo de nodos AForge añadidos a la biblioteca. Ahora tenemos acceso a la biblioteca de imágenes AForge desde nuestro programa visual.
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.
Ahora que se ha importado la biblioteca, empezaremos con un sencillo ejercicio (01-EdgeDetection.dyn). Vamos a llevar a cabo un procesamiento de imagen básico en una imagen de muestra para comprobar cómo se filtra la imagen AForge. Utilizaremos el nodo "Watch Image" para visualizar los resultados y aplicar filtros en Dynamo similares a los de Photoshop
El nodo File Path simplemente proporciona una cadena de la ruta a la imagen que hemos seleccionado. A continuación, se debe convertir en un archivo de imagen que se pueda utilizar en Dynamo.
Utilice File From Path para convertir el elemento de ruta de archivo en una imagen en el entorno de Dynamo.
Conecte el nodo File Path al nodo File.FromPath.
Para convertir este archivo en una imagen, utilizaremos el nodo Image.ReadFromFile.
Por último, veamos el resultado. Suelte un nodo Watch Image en el lienzo y conéctelo a Image.ReadFromFile. Aún no hemos utilizado AForge, pero hemos importado correctamente una imagen en Dynamo.
En AForge.Imaging.AForge.Imaging.Filters (en el menú de navegación), verá que hay una amplia gama de filtros disponibles. Vamos a utilizar uno de estos filtros para reducir la saturación de una imagen mediante los valores de umbral.
Coloque tres controles deslizantes en el lienzo, cambie los rangos a entre 0 a 1 y los valores de paso a 0,01.
Añada el nodo Grayscale.Grayscale al lienzo. Este es un filtro de AForge que aplica un filtro de escala de grises a una imagen. Conecte los tres controles deslizantes del paso 1 a cr, cg y cb. Cambie los controles deslizantes superior e inferior para que tengan un valor de 1 y el control deslizante central para que tenga un valor de 0.
Para aplicar el filtro Grayscale, necesitamos una acción que llevar a cabo en nuestra imagen. Para ello, utilizaremos BaseFilter.Apply. Conecte la imagen a la entrada de imagen y Grayscale.Grayscale a la entrada de baseFilter.
Al conectar un nodo Watch Image, se obtiene una imagen con reducción de saturación.
Podemos controlar cómo se reduce la saturación de esta imagen mediante los valores de umbral de rojo, verde y azul. Estos se definen mediante los datos introducidos en el nodo Grayscale.Grayscale. Observe que la imagen se ve bastante atenuada; esto se debe a que el valor de verde se ha establecido en 0 en el control deslizante.
Cambie los controles deslizantes superior e inferior para que tengan un valor de 0 y el control deslizante central para que tenga un valor de 1. De este modo, obtenemos una imagen con reducción de saturación más legible.
Vamos a utilizar la imagen con reducción de saturación y aplicar otro filtro encima. La imagen con reducción de saturación tiene cierto contraste, por lo que vamos a probar una detección de borde.
Añada un nodo SobelEdgeDetector.SobelEdgeDetector al lienzo.
Conecte esta opción a BaseUsingCopyPartialFilter.Apply y conecte la imagen con reducción de saturación a la entrada de imagen de este nodo.
El detector de borde Sobel ha resaltado los bordes en una nueva imagen.
Al ampliar, el detector de bordes ha representado los contornos de las burbujas con píxeles. La biblioteca AForge dispone de herramientas para tomar resultados como este y crear geometría de Dynamo. Lo exploraremos en el siguiente ejercicio.
Ahora que hemos presentado un procesamiento de imagen básico, vamos a usar una imagen para aplicar la geometría de Dynamo. En un nivel elemental, en este ejercicio pretendemos realizar un "trazado directo" de una imagen mediante AForge y Dynamo. Vamos a realizar una tarea sencilla como es extraer rectángulos de una imagen de referencia, pero hay herramientas disponibles en AForge para operaciones más complejas. Trabajaremos con 02-RectangleCreation.dyn, uno de los archivos del ejercicio que hemos descargado.
Con el nodo File Path, desplácese hasta grid.jpg en la carpeta del ejercicio.
Conecte la serie de nodos restantes anterior para que se muestre una rejilla paramétrica de rumbo.
Añada un BlobCounter al lienzo; a continuación, necesitamos un método para procesar la imagen (similar a la herramienta BaseFilter.Apply del ejercicio anterior).
Desafortunadamente, el nodo "Process Image" no aparece de inmediato en la biblioteca de Dynamo. Esto se debe a que la función puede no ser visible en el código fuente AForge. Necesitaremos encontrar una solución para esta situación.
Añada un nodo de Python al lienzo y agregue el código siguiente al nodo de Python. Este código importa la biblioteca AForge y, a continuación, procesa la imagen importada.
Al conectar la salida de imagen a la entrada del nodo de Python, se obtiene un resultado AForge.Imaging.BlobCounter del nodo de Python.
Conecte la salida de la secuencia de comandos de Python a BlobCounterBase.GetObjectRectangles. Este elemento lee objetos de una imagen basándose en un valor de umbral y extrae rectángulos cuantificados del espacio de píxeles.
Añada otro nodo de Python al lienzo, conéctelo a GetObjectRectangles e introduzca el código siguiente. De este modo, se creará una lista organizada de objetos de Dynamo.
Transponga la salida del nodo de Python desde el paso anterior. Se crean cuatro listas, cada una de las cuales representa los valores X, Y, anchura y altura para cada rectángulo.
Mediante el nodo Code Block, se organizan los datos en una estructura que acompaña al nodo Rectangle.ByCornerPoints (el código siguiente).
Disponemos de una matriz de rectángulos que representan los cuadrados blancos de la imagen. A través de la programación, hemos realizado una acción a grandes rasgos similar a un trazado directo en Illustrator.
Sin embargo, aún necesitamos realizar una limpieza. Al ampliar, podemos ver que hay un puñado de pequeños rectángulos no deseados.
A continuación, vamos a escribir códigos para eliminar los rectángulos no deseados.
Inserte un nodo de Python entre el nodo GetObjectRectangles y otro nodo de Python. El código del nodo es el siguiente y elimina todos los rectángulos que están por debajo de un tamaño determinado.
Con los rectángulos superfluos eliminados, solo por probar, vamos a crear una superficie a partir de estos rectángulos y extruirlos una distancia basada en sus áreas.
Por último, cambie el valor de both_sides a falso (false) y se obtendrá una extrusión en una dirección. Bañe este objeto en resina y obtendrá una mesa muy peculiar.
Carreteras, ferrocarriles, terrenos, servicios públicos, topografía, GIS...
La infraestructura civil es todo esto y más. Esta sección contiene varios gráficos de ejemplo útiles y prácticos que le ayudarán a alcanzar pleno dominio de Dynamo y a descubrir todo el potencial de Dynamo for Civil 3D. Cada gráfico se completa con descripciones detalladas de la lógica que se empleó para crearlo, de modo que no solo pueda utilizarlo, sino también comprenderlo.
Además, estos ejemplos encarnan prácticas recomendadas de eficacia probada para crear gráficos útiles. A medida que trabaje con los ejemplos, le animamos a familiarizarse con la sección de para obtener más ideas sobre cómo crear gráficos eficaces, flexibles y manejables.
Anteriormente, hemos mencionado que los nodos son los componentes básicos de un gráfico de Dynamo y que se organizan en grupos lógicos en la biblioteca. En Dynamo for Civil 3D, hay dos categorías (o estantes) de la biblioteca que contienen nodos específicos para trabajar con objetos de AutoCAD y Civil 3D, como alineaciones, perfiles, obras lineales, referencias a bloque, etc. El resto de la biblioteca contiene nodos de naturaleza más genérica y coherentes entre todas las "versiones" de Dynamo (por ejemplo, Dynamo para Revit, Dynamo Sandbox, etc.).
Consulte la sección para obtener más información sobre la organización de los nodos de la biblioteca principal de Dynamo.
Nodos específicos para trabajar con objetos de AutoCAD y Civil 3D
Nodos de uso general
Nodos de paquetes de terceros que se pueden instalar por separado
Al utilizar los nodos que se encuentran en los estantes de AutoCAD y Civil 3D, el gráfico de Dynamo solo funcionará en Dynamo for Civil 3D. Si se abre un gráfico de Dynamo for Civil 3D en otra ubicación (por ejemplo, en Dynamo para Revit), estos nodos se marcarán con una advertencia y no se ejecutarán.
¿Por qué hay dos estantes independientes para AutoCAD y Civil 3D?
Esta organización distingue los nodos de los objetos nativos de AutoCAD (líneas, polilíneas, referencias a bloque, etc.) de los nodos de los objetos de Civil 3D (alineaciones, obras lineales, superficies, etc.). Desde el punto de vista técnico, AutoCAD y Civil 3D son dos componentes independientes; AutoCAD es la aplicación principal y Civil 3D se basa en ella.
Para trabajar con los nodos de AutoCAD y Civil 3D, es importante conocer a fondo la jerarquía de objetos dentro de cada estante. ¿Recuerda la taxonomía de la biología? Reino, phylum, clase, orden, familia, género y especie. Los objetos de AutoCAD y Civil 3D se organizan de forma similar. Veamos algunos ejemplos para explicarlo.
Vamos a utilizar una alineación como ejemplo.
Supongamos que su objetivo es cambiar el nombre de la alineación. A partir de aquí, el siguiente nodo que añadiría es CivilObject.SetName.
Al principio, es posible que esto parezca algo lioso. ¿Qué es un CivilObject y por qué la biblioteca no tiene un nodo Alignment.SetName? La respuesta está relacionada con la reutilización y la simplicidad. Si lo piensa, el proceso de cambio de nombre de un objeto de Civil 3D es el mismo tanto si se trata de una alineación, una obra lineal, un perfil o cualquier otro elemento. Por lo tanto, en lugar de tener nodos repetitivos que básicamente hacen lo mismo (por ejemplo, Alignment.SetName, Corridor.SetName, Profile.SetName, etc.), sería conveniente asignar esa funcionalidad a un solo nodo. Eso es exactamente lo que hace CivilObject.SetName.
Otra forma de enfocar esto es en términos de relaciones. Una alineación y una obra lineal son tipos de objetos de Civil, del mismo modo que una manzana y una pera son tipos de fruta. Al igual que usa un único pelador para pelar tanto una manzana como una pera, los nodos de objetos de Civil se aplican a cualquier objeto de este tipo. ¡Lo desordenada que estaría su cocina si tuviera un pelador distinto para cada tipo de fruta! En ese sentido, la biblioteca de nodos de Dynamo es igual que su cocina.
Ahora, vamos a dar un paso más allá. Supongamos que desea cambiar la capa de la alineación. Se utilizará el nodo Object.SetLayer.
¿Por qué no hay un nodo denominado CivilObject.SetLayer? Aquí se aplican los mismos principios de reutilización y simplicidad que hemos analizado anteriormente. La propiedad layer es común a cualquier objeto de AutoCAD que se pueda dibujar o insertar, como una línea, una polilínea, texto, una referencia a bloque, etc. Los objetos de Civil 3D como alineaciones y obras lineales se encuentran en la misma categoría, por lo que cualquier nodo que se aplique a un objeto también se puede utilizar con cualquier objeto de Civil.
La edición de parámetros para la documentación sigue la misma dinámica que las lecciones aprendidas en las secciones anteriores. En esta sección, vamos a ver cómo editar parámetros que no afectan a las propiedades geométricas de un elemento, sino que preparan un archivo de Revit para la documentación.
En el siguiente ejercicio, utilizaremos una desviación básica del nodo del plano para crear una hoja de Revit para la documentación. Cada panel de nuestra estructura de cubierta definida paramétricamente tiene un valor diferente para la desviación, y queremos invocar el rango de valores mediante el color y la planificación de los puntos adaptativos para entregarlos a un consultor, ingeniero o contratista de fachadas.
La desviación desde el nodo del plano calcula la distancia en que el conjunto de cuatro puntos varía con respecto al plano de ajuste óptimo entre ellos. Esta es una forma rápida y sencilla de estudiar la viabilidad de la construcción.
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.
Empiece con el archivo de Revit para esta sección (o continúe desde la sección anterior). Este archivo tiene una matriz de paneles ETFE en la cubierta. Haremos referencia a estos paneles en este ejercicio.
Añada un nodo Family Types al lienzo y seleccione "ROOF-PANEL-4PT".
Conecte este nodo a un nodo Select All Elements of Family Type para obtener todos los elementos de Revit en Dynamo.
Consulte la ubicación de los puntos adaptativos de cada elemento con el nodo AdaptiveComponent.Locations.
Cree un polígono a partir de estos cuatro puntos con el nodo Polygon.ByPoints. Observe que ahora tenemos una versión abstracta del sistema de paneles en Dynamo sin tener que importar la geometría completa del elemento de Revit.
Calcule la desviación plana con el nodo Polygon.PlaneDeviation.
Solo por probar, como en el ejercicio anterior, vamos a configurar el coeficiente de apertura de cada panel en función de su desviación plana.
Añada un nodo Element.SetParameterByName al lienzo y conecte los componentes adaptativos a la entrada element. Conecte un bloque de código con el texto "Aperture Ratio" a la entrada parameterName.
No se pueden conectar directamente los resultados de la desviación a la entrada "value" porque es necesario volver a asignar los valores al rango de parámetros.
Con Math.RemapRange, vuelva a asignar los valores de desviación a un dominio entre 0,15 y 0,45. Para ello, introduzca
0.15; 0.45;
en el bloque de código.Conecte estos resultados a la entrada "value" de Element.SetParameterByName.
De vuelta en Revit, podemos ver aproximadamente el cambio en la apertura a través de la superficie.
Al ampliar, resulta más evidente que los paneles cerrados están ponderados hacia las esquinas de la superficie. Las esquinas abiertas se orientan hacia la parte superior. Las esquinas representan áreas de mayor desviación, mientras que la curvatura es mínima, lo cual tiene sentido.
La configuración de la relación de apertura no demuestra claramente la desviación de los paneles de la cubierta; además, se cambia la geometría del elemento real. Supongamos que solo queremos estudiar la desviación desde el punto de vista de la viabilidad de fabricación. Sería útil colorear los paneles según el rango de desviación para la documentación. Esto se puede realizar con la serie de pasos que se indican a continuación y en un proceso muy similar a los pasos anteriores.
Elimine Element.SetParameterByName y sus nodos de entrada, y añada Element.OverrideColorInView.
Añada un nodo Color Range al lienzo y conéctelo a la entrada color de Element.OverrideColorInView. Aún tenemos que conectar los valores de desviación con el rango de color para crear el degradado.
Al pasar el ratón sobre la entrada value, podemos ver que los valores de la entrada deben estar entre 0 y 1 para asignar un color a cada valor. Es necesario reasignar los valores de desviación a este rango.
Mediante Math.RemapRange, vuelva a asignar los valores de desviación plana a un rango entre* 0* y 1 (también puede utilizar el nodo "MapTo" para definir un dominio de origen).
Conecte los resultados en un nodo Color Range.
Observe que nuestra salida es un rango de colores en lugar de un rango de números.
Si se ha establecido la opción Manual, pulse Ejecutar. A partir de este momento, todo debería funcionar según lo esperado estableciendo la opción Automático.
Al regresar a Revit, vemos un degradado mucho más legible que es representativo de la desviación plana basada en nuestro rango de colores. Pero, ¿qué pasa si queremos personalizar los colores? Observe que los valores de desviación mínima se representan en rojo, que parece ser lo opuesto a lo que se esperaría. Queremos que la desviación máxima sea roja y que la desviación mínima esté representada por un color más suave. Volvamos a Dynamo y solucionemos esto.
Mediante un bloque de código, añada dos números en dos líneas diferentes:
0;
y255;
.Cree los colores rojo y azul mediante la conexión de los valores adecuados a dos nodos Color.ByARGB.
Cree una lista a partir de estos dos colores.
Conecte esta lista a la entrada colors del nodo Color Range y observe cómo se actualiza el rango de colores personalizado.
De vuelta en Revit, ahora podemos entender mejor las áreas de máxima desviación en las esquinas. Recuerde que este nodo se utiliza para modificar un color en una vista, por lo que puede resultar muy útil si tenemos una hoja concreta en el conjunto de dibujos que se centra en un tipo de análisis concreto.
Al seleccionar un panel ETFE en Revit, vemos que hay cuatro parámetros de ejemplar: XYZ1, XYZ2, XYZ3 y XYZ4. Todos están en blanco después de crearlos. Se trata de parámetros basados en texto y necesitan valores. Utilizaremos Dynamo para escribir las ubicaciones de puntos adaptativos en cada parámetro. Esto aumenta la interoperabilidad si es necesario enviar la geometría a un ingeniero o consultor de fachadas.
En un plano de ejemplo, tenemos una tabla de planificación grande y vacía. Los parámetros XYZ son parámetros compartidos en el archivo de Revit, lo que nos permite añadirlos a la tabla de planificación.
Al ampliar, vemos que los parámetros XYZ aún no se han rellenado. Revit se ocupa de los dos primeros parámetros.
Para escribir estos valores, realizaremos una operación de lista compleja. El gráfico en sí es sencillo, pero los conceptos se hacen más complejos a partir de la asignación de lista, como se explica en el capítulo sobre las listas.
Seleccione todos los componentes adaptativos con dos nodos.
Extraiga la ubicación de cada punto con AdaptiveComponent.Locations.
Convierta estos puntos en cadenas. Recuerde que el parámetro se basa en texto, por lo que es necesario introducir el tipo de datos correcto.
Cree una lista de las cuatro cadenas que definen los parámetros que se van a cambiar: XYZ1, XYZ2, XYZ3 y XYZ4.
Conecte esta lista a la entrada parameterName de Element.SetParameterByName.
Conecte Element.SetParameterByName en la entrada combinator de List.Combine. Conecte los componentes adaptativos en list1. Conecte String from Object a list2.
Estamos asignando listas porque vamos a escribir cuatro valores para cada elemento, lo que crea una estructura de datos compleja. El nodo List.Combine define una operación un escalón más abajo en la jerarquía de datos. Por este motivo, las entradas "element" y "value" de Element.SetParameterByName se dejan en blanco. List.Combine conecta las sublistas de sus entradas a las entradas vacías de Element.SetParameterByName en función del orden en el que están conectadas.
Al seleccionar un panel en Revit, ahora vemos que hay valores de cadena para cada parámetro. En términos realistas, crearíamos un formato más sencillo para escribir un punto (X,Y,Z). Esto se puede realizar con operaciones de cadena en Dynamo, pero vamos a omitir este paso para mantenernos dentro del ámbito de este capítulo.
Vista de la tabla de planificación de muestra con los parámetros completados.
Cada panel ETFE tiene ahora las coordenadas XYZ escritas para cada punto adaptativo, con lo que se representan las esquinas de cada panel para la fabricación.
Versión de Revit | Primera versión de Dynamo estable | Última versión de Dynamo para Revit compatible |
---|---|---|
Cree un gráfico de Dynamo que inserte texto en el espacio modelo.
¡Misión cumplida!
Coloque referencias a bloque de farolas a lo largo de una obra lineal en los valores de P.K. especificados de un archivo de Excel.
Si es la primera vez que utiliza estos diccionarios, consulte la sección .
Si es la primera vez que utiliza los sistemas de coordenadas, consulte la sección .
Si es la primera vez que utiliza bloques de código, consulte la sección .
Puede obtener más información sobre los modos de ejecución de gráficos en la sección .
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección .
¡Misión cumplida!
En esta sección se muestra cómo utilizar Zero-Touch para importar una biblioteca de terceros. Para obtener información sobre el desarrollo de su propia biblioteca Zero-Touch, consulte la .
Los paquetes de Zero-Touch son un buen complemento para los nodos personalizados definidos por el usuario. En la tabla siguiente se muestran algunos paquetes que utilizan bibliotecas C#. Para obtener información más detallada sobre los paquetes, visite la sección del Apéndice.
En este caso real, mostraremos cómo importar la biblioteca externa .dll . AForge es una biblioteca sólida que ofrece una gama de funciones que van desde el procesamiento de imágenes hasta la inteligencia artificial. Haremos referencia a la clase de imágenes en AForge para realizar algunos ejercicios de procesamiento de imágenes a continuación.
Descarguemos primero AForge. En la , seleccione [Download Installer] (Descargar instalador) y realice la instalación una vez que haya finalizado la descarga.
Añada un nodo File Path al lienzo y seleccione "soapbubbles.jpg" en la carpeta del ejercicio que hemos descargado (crédito de la fotografía: ).
En este paso, vamos a hacer referencia a los cuadrados blancos de la imagen y convertirlos a la geometría real de Dynamo. AForge tiene muchas herramientas eficaces de visión por ordenador y aquí vamos a usar una de las más importantes para la biblioteca llamada .
Los siguientes pasos contienen ciertos procedimientos que permiten familiarizarse con la . No es necesario aprender todo esto para trabajar con Dynamo. Esta es más bien una demostración de cómo trabajar con bibliotecas externas dentro de la flexibilidad del entorno de Dynamo.
Estos son ejemplos básicos, pero los conceptos descritos aquí son transferibles a aplicaciones apasionantes en el mundo real. La visión por ordenador se puede utilizar para multitud de procesos. Por nombrar algunos: lectores de código de barras, coincidencia de perspectivas, y . Para consultar temas más avanzados de AForge relacionados con este ejercicio, consulte .
2013
2014
2015
2016
2017
2018
2019
2020
2.1.0: Revit 2020 o superior ahora incluye Dynamo y recibe actualizaciones al igual que Revit.
N/A
Con el tiempo, puede que necesite ir más allá de los conceptos básicos y profundizar en el funcionamiento interno de Dynamo. Las páginas de esta sección le proporcionarán un esquema para descubrir las funciones avanzadas de Dynamo for Civil 3D a fin de que pueda llevar sus gráficos al siguiente nivel.
Logotipo/imagen | Nombre |
Al añadir tuberías y estructuras a una red de tuberías, Civil 3D utiliza una plantilla para asignar nombres automáticamente. Por lo general, esto es suficiente durante la colocación inicial, pero inevitablemente los nombres tendrán que cambiar en el futuro a medida que evolucione el diseño. Además, hay muchos patrones de nomenclatura diferentes que podrían ser necesarios, por ejemplo, denominar las estructuras de forma secuencial dentro de un tramo de tuberías empezando por la estructura más alejada aguas abajo o seguir un patrón de nomenclatura que se ajuste al esquema de datos de un organismo local. En este ejemplo, se muestra cómo se puede utilizar Dynamo para definir cualquier tipo de estrategia de nomenclatura y aplicarla de forma coherente.
Trabajo con cuadros delimitadores
Filtrado de datos mediante el nodo List.FilterByBoolMask
Ordenación de los datos mediante el nodo List.SortByKey
Generación y modificación de cadenas de texto
Este gráfico se ejecutará en Civil 3D 2020 y versiones posteriores.
Descargue primero los archivos de ejemplo que aparecen a continuación y abra el archivo DWG y el gráfico de Dynamo.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Seleccionar las estructuras por capa
Obtener las ubicaciones de estructuras
Filtrar las estructuras por desfase y, a continuación, ordenarlas por P.K.
Generar los nuevos nombres
Renombrar las estructuras
¡Empecemos!
Lo primero que debemos hacer es seleccionar todas las estructuras con las que tenemos previsto trabajar. Para ello, basta con seleccionar todos los objetos de una capa determinada, lo que significa que podemos seleccionar estructuras de diferentes redes de tuberías (siempre que compartan la misma capa).
Este nodo garantiza que no se recuperarán accidentalmente los tipos de objeto no deseados que puedan compartir la misma capa que las estructuras.
Ahora que disponemos de las estructuras, tenemos que averiguar su posición en el espacio para poder ordenarlas según su ubicación. Para ello, utilizaremos el cuadro delimitador de cada objeto. El cuadro delimitador de un objeto es el cuadro de tamaño mínimo que contiene por completo la extensión geométrica del objeto. Al calcular el centro del cuadro delimitador, obtenemos una aproximación bastante precisa del punto de inserción de la estructura.
Utilizaremos estos puntos para obtener el P.K. y el desfase de las estructuras con respecto a una alineación seleccionada.
Aquí es donde las cosas empiezan a ponerse un poco complicadas. En esta fase, tenemos una gran lista de todas las estructuras de la capa que hemos especificado y elegimos una alineación por la que deseamos ordenarlas. El problema es que puede haber estructuras en la lista que no deseamos cambiar de nombre. Por ejemplo, es posible que no formen parte del tramo concreto que nos interesa.
La alineación seleccionada
Las estructuras que deseamos renombrar
Las estructuras que se deben ignorar
Por lo tanto, debemos filtrar la lista de estructuras para que no se tengan en cuenta las que superen un determinado desfase con respecto a la alineación. La mejor forma de conseguirlo es mediante el nodo List.FilterByBoolMask. Después de filtrar la lista de estructuras, utilizamos el nodo List.SortByKey para ordenarlas por sus valores de P.K.
Si es la primera vez que trabaja con listas, consulte la sección Trabajo con listas.
Compruebe si el desfase de la estructura es menor que el valor del umbral.
Sustituya cualquier valor nulo por false (falso).
Filtre la lista de estructuras y P.K.
Ordene las estructuras por P.K.
La última parte del trabajo consiste en crear los nuevos nombres de las estructuras. El formato que usaremos es <alignment name>-STRC-<number>
. Aquí hay algunos nodos más para rellenar los números con ceros adicionales si se desea (por ejemplo, "01" en lugar de "1").
Y, por último, pero no por ello menos importante, cambiamos el nombre de las estructuras.
A continuación, se muestra un ejemplo de cómo ejecutar el gráfico con el Reproductor de Dynamo.
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección Reproductor de Dynamo.
Puede ser útil aprovechar la vista preliminar 3D en segundo plano de Dynamo para visualizar las salidas intermedias del gráfico en lugar de solo el resultado final. Algo fácil que podemos hacer es visualizar los cuadros delimitadores de las estructuras. Además, este conjunto de datos concreto tiene una obra lineal en el documento, por lo que podemos incorporar la geometría de línea característica de obra lineal en Dynamo para proporcionar contexto en relación con la ubicación de las estructuras en el espacio. Si el gráfico se utiliza en un conjunto de datos sin obras lineales, estos nodos no harán nada.
Ahora podemos entender mejor cómo funciona el proceso de filtrado de las estructuras por desfase.
A continuación, se ofrecen algunas ideas sobre cómo podría ampliar las posibilidades de este gráfico.
Cambie el nombre de las estructuras en función de su alineación más cercana en lugar de seleccionar una alineación específica.
Cambie el nombre de las tuberías, además del de las estructuras.
Establezca las capas de las estructuras en función del tramo.
Dynamo for Civil 3D lleva el paradigma de la programación visual a los ingenieros y los diseñadores que trabajan en proyectos de infraestructuras civiles. Puede pensar en Dynamo como una especie de "navaja suiza" digital para los usuarios de Civil 3D; sea cual sea la tarea, dispone de la herramienta adecuada para el trabajo. Su intuitiva interfaz le permite crear rutinas eficaces y personalizables sin necesidad de escribir una sola línea de código. No necesita ser programador para utilizar Dynamo, pero sí debe ser capaz de pensar con la lógica de un programador. Junto con los demás capítulos del manual de introducción, este le ayudará a desarrollar sus habilidades lógicas para que pueda abordar cualquier tarea con una mentalidad de diseño computacional.
Dynamo se introdujo por primera vez en Civil 3D 2020 y ha seguido evolucionando desde entonces. En un principio, se instalaba por separado mediante una actualización de software, pero ahora viene incluido con todas las versiones de Civil 3D. En función de la versión de Civil 3D que esté utilizando, es posible que observe que la interfaz de Dynamo presenta un aspecto ligeramente distinto al de los ejemplos que aparecen en este capítulo. Esto se debe a que se ha realizado una revisión significativa de la interfaz en Civil 3D 2023.
Es recomendable que consulte el blog de Dynamo para obtener la información más actualizada sobre el desarrollo de esta herramienta. En la tabla siguiente, se resumen los principales hitos en la trayectoria de Dynamo for Civil 3D.
El diseño de ingeniería de una construcción de viviendas típica implica trabajar con varios servicios subterráneos, como el alcantarillado sanitario, el desagüe pluvial, el agua potable u otros. En este ejemplo se mostrará cómo puede utilizarse Dynamo para trazar las conexiones de servicios desde una red de distribución hasta una parcela (es decir, un terreno) especificada. Es habitual que cada parcela requiera una conexión de servicios, lo que supone un trabajo considerablemente tedioso para colocar todos ellos. Dynamo puede agilizar el proceso al dibujar automáticamente la geometría necesaria con precisión, además de proporcionar entradas flexibles que pueden ajustarse para adaptarse a las normas de los organismos locales.
Uso del nodo Select Object para la entrada de usuario
Trabajo con sistemas de coordenadas
Uso de operaciones geométricas como Geometry.DistanceTo y Geometry.ClosestPointTo
Creación de referencias a bloque
Control de la configuración de enlace de objetos
Este gráfico se ejecutará en Civil 3D 2020 y versiones posteriores.
Descargue primero los archivos de ejemplo que aparecen a continuación y abra el archivo DWG y el gráfico de Dynamo.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Obtener la geometría de curva para la red de distribución
Obtener la geometría de curva para una línea de parcela seleccionada por el usuario, invirtiéndola si es necesario
Generar los puntos de inserción para los contadores de servicio
Obtener los puntos de la red de distribución más cercanos a las ubicaciones de los contadores de servicio
Crear referencias a bloque y líneas en el espacio modelo
¡Empecemos!
Nuestro primer paso es introducir en Dynamo la geometría de la red de distribución. En lugar de seleccionar líneas o polilíneas individuales, utilizaremos todos los objetos de una determinada capa y los uniremos como una PolyCurve de Dynamo.
Si es la primera vez que utiliza la geometría de curvas de Dynamo, consulte la sección Curvas.
A continuación, debemos obtener la geometría de una línea de parcela seleccionada en Dynamo para poder trabajar con ella. La herramienta adecuada para la tarea es el nodo Select Object, que permite al usuario del gráfico seleccionar un objeto específico en Civil 3D.
También debemos ocuparnos de los posibles problemas que puedan surgir. La línea de parcela tiene un punto inicial y uno final, lo que significa que tiene una dirección. Para que el gráfico genere resultados coherentes, necesitamos que todas las líneas de parcela tengan una dirección coherente. Podemos dar cuenta de esta condición directamente en la lógica del gráfico, lo que hace que este sea más flexible.
Obtenga los puntos inicial y final de la línea de parcela.
Mida la distancia de cada punto a la red de distribución y, a continuación, calcule la distancia que sea mayor.
El resultado deseado es que el punto inicial de la línea sea el más cercano a la red de distribución. Si no es así, invertiremos la dirección de la línea de parcela. En caso contrario, simplemente restableceremos la línea de parcela original.
Es hora de decidir dónde se van a colocar los contadores de servicio. Por lo general, la colocación viene determinada por los requisitos de los organismos locales, por lo que nos limitaremos a proporcionar valores de entrada que puedan modificarse para adaptarlos a las distintas situaciones. Vamos a utilizar un sistema de coordenadas a lo largo de la línea de parcela como referencia para crear los puntos. Esto facilita la definición de desfases en relación con la línea de parcela, independientemente de su orientación.
Si es la primera vez que utiliza los sistemas de coordenadas, consulte la sección Vector, plano y sistema de coordenadas.
Ahora debemos obtener los puntos de la red de distribución más cercanos a las ubicaciones de los contadores de servicio. Esto nos permitirá dibujar las conexiones de servicios en el espacio modelo de forma que sean siempre perpendiculares a la red de distribución. El nodo Geometry.ClosestPointTo es la solución perfecta.
Esta es la PolyCurve de la red de distribución.
Estos son los puntos de inserción del contador de servicio.
El último paso consiste en crear objetos en el espacio modelo. Utilizaremos los puntos de inserción que hemos generado anteriormente para crear referencias a bloque y, a continuación, usaremos los puntos de la red de distribución para dibujar líneas en las conexiones de servicios.
Al ejecutar el gráfico, debe ver las nuevas referencias a bloque y las líneas de conexión de servicios en el espacio modelo. Pruebe a cambiar algunas de las entradas y observe cómo todo se actualiza automáticamente.
Tras colocar los objetos para una línea de parcela, puede que observe que los objetos se "desplazan" al seleccionar una línea diferente.
Este es el comportamiento por defecto de Dynamo y es muy útil en muchos casos. Sin embargo, puede que desee colocar varias conexiones de servicios de forma secuencial y que Dynamo cree nuevos objetos con cada ejecución en lugar de modificar los originales. Cambie la configuración de enlace de objetos para controlar este comportamiento.
Para obtener más información, consulte la sección Enlace de objetos.
Al cambiar esta configuración, se obligará a Dynamo a "olvidar" los objetos que crea con cada ejecución. A continuación, se muestra un ejemplo de ejecución del gráfico con el enlace de objetos desactivado mediante el Reproductor de Dynamo.
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección Reproductor de Dynamo.
A continuación, se ofrecen algunas ideas sobre cómo podría ampliar las posibilidades de este gráfico.
Coloque varias conexiones de servicios simultáneamente en lugar de seleccionar cada línea de parcela.
Ajuste las entradas para colocar bocas de alcantarilla en lugar de contadores de servicio de agua.
Añada un conmutador para permitir la colocación de una única conexión de servicio en un lado concreto de la línea de parcela en lugar de en ambos lados.
Trabajar con puntos COGO y grupos de puntos en Civil 3D es un elemento central de muchos procesos de campo al dibujo terminado. Dynamo destaca realmente cuando se trata de la gestión de datos y, en este ejemplo, le mostraremos un posible caso de uso.
Trabajo con listas
Agrupación de objetos similares con el nodo List.GroupByKey
Visualización de la salida personalizada en el Reproductor de Dynamo
Este gráfico se ejecutará en Civil 3D 2020 y versiones posteriores.
Descargue primero los archivos de ejemplo que aparecen a continuación y abra el archivo DWG y el gráfico de Dynamo.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Obtener todos los puntos COGO del documento
Agrupar puntos COGO por descripción
Crear grupos de puntos
Generar un resumen en el Reproductor de Dynamo
¡Empecemos!
El primer paso consiste en obtener todos los grupos de puntos del documento y, a continuación, todos los puntos COGO dentro de cada grupo. Esto nos proporcionará una lista anidada o una "lista de listas", con las que será más fácil trabajar más adelante si aplanamos todo hasta una sola lista con el nodo List.Flatten.
Si es la primera vez que trabaja con listas, consulte la sección Trabajo con listas.
Ahora que tenemos todos los puntos COGO, debemos separarlos en grupos en función de sus descripciones. Esto es exactamente lo que hace el nodo List.GroupByKey. Básicamente, agrupa todos los elementos que comparten la misma clave.
Ya se ha completado la parte más complicada. El último paso consiste en crear nuevos grupos de puntos de Civil 3D a partir de los puntos COGO agrupados.
Al ejecutar el gráfico, no hay nada que ver en la vista preliminar en segundo plano de Dynamo porque no estamos trabajando con ninguna geometría. Por lo tanto, la única forma de ver si el gráfico se ha ejecutado correctamente es comprobar el espacio de herramientas o echar un vistazo a las vistas preliminares de salida de los nodos. Sin embargo, si ejecutamos el gráfico con el Reproductor de Dynamo, podemos proporcionar más información sobre los resultados del gráfico mediante un resumen de los grupos de puntos que se han creado. Solo hay que hacer clic con el botón derecho en un nodo y establecerlo en Se genera. En este caso, se utiliza un nodo Watch renombrado para ver los resultados.
A continuación, se muestra un ejemplo de cómo ejecutar el gráfico con el Reproductor de Dynamo.
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección Reproductor de Dynamo.
A continuación, se ofrecen algunas ideas sobre cómo podría ampliar las posibilidades de este gráfico.
Modifique la agrupación de puntos para que se base en la descripción completa en lugar del código original.
Agrupe los puntos por otras categorías predefinidas que elija (por ejemplo, "instantáneas del terreno", "monumentos", etc.)
Cree automáticamente superficies TIN para puntos de determinados grupos.
El desarrollo de envolventes cinemáticos para la validación de la separación es una parte importante del diseño de ferrocarriles. Dynamo se puede utilizar para generar sólidos para el envolvente en lugar de crear y administrar subensamblajes de obra lineal complejos para realizar el trabajo.
Trabajo con líneas características de obra lineal
Transformación de la geometría entre sistemas de coordenadas
Creación de sólidos mediante solevación
Control del comportamiento de los nodos con parámetros de encaje
Este gráfico se ejecutará en Civil 3D 2020 y versiones posteriores.
Descargue primero los archivos de ejemplo que aparecen a continuación y abra el archivo DWG y el gráfico de Dynamo.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Obtener líneas características de la línea base de obra lineal especificada
Generar sistemas de coordenadas a lo largo de la línea característica de obra lineal con la separación deseada
Transformar la geometría de bloque de perfil en sistemas de coordenadas
Solevar un sólido entre los perfiles
Crear los sólidos en Civil 3D
¡Empecemos!
El primer paso es obtener datos de obra lineal. Seleccionaremos el modelo de obra lineal por su nombre, obtendremos una línea base específica dentro de la obra lineal y, a continuación, conseguiremos una línea característica dentro de la línea base por su código de punto.
Ahora vamos a generar sistemas de coordenadas a lo largo de las líneas características de obra lineal entre un P.K. inicial y uno final especificados. Estos sistemas de coordenadas se utilizarán para alinear la geometría de bloque del perfil del vehículo con la obra lineal.
Si es la primera vez que utiliza los sistemas de coordenadas, consulte la sección Vector, plano y sistema de coordenadas.
Observe el pequeño XXX en la esquina inferior derecha del nodo. Esto significa que los parámetros de encaje del nodo se han definido como Producto vectorial, lo que es necesario para generar los sistemas de coordenadas con los mismos valores de P.K. para ambas líneas características.
Si es la primera vez que utiliza el encaje de nodos, consulte la sección ¿Qué es una lista?.
Ahora tenemos que crear de alguna manera una matriz de los perfiles de los vehículos a lo largo de las líneas características. Lo que vamos a hacer es transformar la geometría desde la definición de bloque del perfil del vehículo mediante el nodo Geometry.Transform. Se trata de un concepto difícil de visualizar, así que antes de ver los nodos, he aquí un gráfico que muestra lo que va a ocurrir.
En definitiva, lo que hacemos es utilizar la geometría de Dynamo de una única definición de bloque y desplazarla o rotarla, a la vez que creamos una matriz a lo largo de la línea característica. ¡Increíble! A continuación, se muestra el aspecto de la secuencia de nodos.
De esta forma, se obtiene la definición de bloque del documento.
Estos nodos obtienen la geometría de Dynamo de los objetos del bloque.
Estos nodos definen básicamente el sistema de coordenadas desde el que se está transformando la geometría.
Y, por último, este nodo realiza el trabajo real de transformar la geometría.
Observe el encaje más largo en este nodo.
Y esto es lo que obtenemos en Dynamo.
¡Buenas noticias! Ya se ha completado la parte más complicada. Ahora solo tenemos que generar sólidos entre los perfiles. Esto se consigue fácilmente con el nodo Solid.ByLoft.
Este es el resultado. Recuerde que estos son sólidos de Dynamo; aún debemos crearlos en Civil 3D.
El último paso es generar los sólidos en el espacio modelo. También les asignaremos un color para que sean fáciles de ver.
A continuación, se muestra un ejemplo de cómo ejecutar el gráfico con el Reproductor de Dynamo.
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección Reproductor de Dynamo.
A continuación, se ofrecen algunas ideas sobre cómo podría ampliar las posibilidades de este gráfico.
Añada la capacidad de utilizar diferentes intervalos de P.K. por separado para cada vía.
Divida los sólidos en segmentos más pequeños que se puedan analizar individualmente para detectar conflictos.
Compruebe si los sólidos de envolvente se intersecan con elementos y coloree aquellos que entren en conflicto.
Dynamo for Civil 3D contiene un mecanismo muy eficaz para "recordar" los objetos que crea cada nodo. Este mecanismo se denomina Enlace de objetos y permite que un gráfico de Dynamo genere resultados coherentes cada vez que se ejecuta en el mismo documento. Aunque esto es muy deseable en muchas situaciones, hay otras en las que es posible que desee tener más control sobre el comportamiento de Dynamo. Esta sección le ayudará a comprender cómo funciona el enlace de objetos y cómo puede aprovecharlo.
Observe este gráfico que crea un círculo en el espacio modelo de la capa actual.
Observe lo que sucede cuando se cambia el radio.
Esto es un enlace de objetos en acción. El comportamiento por defecto de Dynamo es modificar el radio del círculo en lugar de crear un nuevo círculo cada vez que se modifica la entrada del radio. Esto se debe a que el nodo Object.ByGeometry "recuerda" que crea este círculo específico cada vez que se ejecuta el gráfico. Además, Dynamo guardará esta información para que la próxima vez que abra el documento de Civil 3D y ejecute el gráfico, este presente exactamente el mismo comportamiento.
Veamos un ejemplo en el que puede que desee cambiar el comportamiento por defecto de enlace de objetos de Dynamo. Supongamos que desea crear un gráfico que coloque texto en el centro de un círculo. Sin embargo, lo que pretende con este gráfico es que pueda ejecutarse una y otra vez, y colocar cada vez un nuevo texto para cualquier Círculo que se seleccione. Este es el aspecto que presentaría el gráfico.
Sin embargo, esto es lo que sucede realmente cuando se selecciona un círculo diferente.
Tras realizar ese cambio, obtenemos el comportamiento que buscamos.
Dynamo for Civil 3D permite modificar el comportamiento por defecto de enlace de objetos a través de los parámetros de Almacenamiento de datos de enlace en el menú de Dynamo.
Tenga en cuenta que las opciones de almacenamiento de datos de enlace están disponibles en Civil 3D 2022.1 y versiones posteriores.
Todas las opciones están activadas por defecto. A continuación, se resumen las acciones de cada opción.
Si esta opción está activada, Dynamo "olvidará" los objetos que creó la última vez que se ejecutó el gráfico. De este modo, el gráfico puede ejecutarse en cualquier dibujo y situación, y creará nuevos objetos cada vez.
Cuándo utilizar esta opción
Utilice esta opción cuando desee que Dynamo "olvide" todo lo que ha realizado en ejecuciones anteriores y cree nuevos objetos cada vez.
Esta opción permite serializar los metadatos de enlace de objetos en el gráfico (archivo .dyn) al guardarlo. Si cierra o vuelve a abrir el gráfico y lo ejecuta en el mismo dibujo, todo debería funcionar igual que lo dejó. Si ejecuta el gráfico en un dibujo diferente, los datos de enlace se eliminarán del gráfico y se crearán nuevos objetos. Esto significa que, si abre el dibujo original y vuelve a ejecutar el gráfico, se crearán nuevos objetos, además de los antiguos.
Cuándo utilizar esta opción
Utilice esta opción cuando desee que Dynamo "recuerde" los objetos que creó la última vez que se ejecutó en un dibujo específico.
Esta opción es la más adecuada para situaciones en las que es posible mantener una relación de 1:1 entre un dibujo específico y un gráfico de Dynamo. Las opciones 1 y 3 son más idóneas para gráficos diseñados para ejecutarse en varios dibujos.
Es similar a la opción 2, salvo que los datos de enlace de objetos se serializan en el dibujo en lugar de en el gráfico (archivo .dyn). Si cierra o vuelve a abrir el gráfico y lo ejecuta en el mismo dibujo, todo debería funcionar igual que lo dejó. Si ejecuta el gráfico en un dibujo diferente, los datos de enlace se conservan en el dibujo original, ya que se guardan en el dibujo y no en el gráfico.
Cuándo utilizar esta opción
Utilice esta opción cuando desee utilizar el mismo gráfico en varios dibujos y conseguir que Dynamo "recuerde" lo que realizó en cada uno de ellos.
Lo primero que hay que tener en cuenta con esta opción es que no afecta al modo en que el gráfico interactúa con el dibujo cuando se ejecuta el gráfico a través de la interfaz principal de Dynamo. Esta opción solo se aplica cuando el gráfico se ejecuta con el Reproductor de Dynamo.
Si ejecuta el gráfico mediante la interfaz principal de Dynamo y, a continuación, cierra y ejecuta el mismo gráfico mediante el Reproductor de Dynamo, este creará nuevos objetos sobre los que creó anteriormente. Sin embargo, una vez que el Reproductor de Dynamo haya ejecutado el gráfico una vez, serializará los datos de enlace de objetos en el dibujo. Por lo tanto, si ejecuta el gráfico varias veces a través del Reproductor de Dynamo, este actualizará los objetos en lugar de crear otros nuevos. Si ejecuta el gráfico a través del Reproductor de Dynamo en un dibujo diferente, los datos de enlace seguirán conservándose en el dibujo original, ya que se guardan en el dibujo y no en el gráfico.
Cuándo utilizar esta opción
Utilice esta opción cuando desee ejecutar un gráfico con el Reproductor de Dynamo en varios dibujos y que este "recuerde" lo que realizó en cada uno de ellos.
Los paquetes de Dynamo son conjuntos de herramientas desarrollados por terceros para ampliar las principales funciones de Dynamo. Todos los usuarios pueden acceder a ellos y descargarlos con un solo clic.
Consulte la sección para obtener más información sobre cómo empezar a trabajar con paquetes.
A continuación, se muestra una lista de algunos de los paquetes más populares que pueden llevar los gráficos de Dynamo for Civil 3D al siguiente nivel.
El kit de herramientas de Civil 3D es un paquete de Dynamo for Civil 3D que aporta importantes mejoras a las funciones de Dynamo mediante un gran número de nodos adicionales.
Camber es un paquete de Dynamo for Civil 3D de código abierto que incluye cientos de nodos para trabajar con etiquetas, refX, accesos directos a datos, estilos y mucho más.
CivilConnection es un paquete de Dynamo para Revit de código abierto que permite el intercambio de información entre Civil 3D, Dynamo y Revit.
Los nodos de Arkance Systems son un paquete de Dynamo for Civil 3D con una amplia variedad de nodos útiles para trabajar con cotas, tablas, vistas, control de taladros y mucho más.
Este manual de introducción es solo el comienzo de su andadura con Dynamo for Civil 3D. Hay una gran cantidad de conocimientos disponibles en la floreciente comunidad de usuarios de Dynamo. Eche un vistazo a algunos de estos recursos mientras continúa con su aprendizaje.
El Reproductor de Dynamo proporciona un método simplificado para ejecutar gráficos de Dynamo en Civil 3D. Una vez que se haya creado un gráfico, no es necesario tener conocimientos de Dynamo para utilizar el Reproductor y ejecutar los gráficos. Esto facilita el intercambio de gráficos con otros usuarios que podrían no estar interesados en explorar los detalles de nodos y cables.
Para obtener más información sobre el Reproductor de Dynamo en Civil 3D, consulte la documentación proporcionada en el sitio de la .
Dynamo es un excelente punto de partida para empezar a codificar en el mundo AEC. Puede que le interesen algunas de estas secciones para iniciar su recorrido por la codificación:
Aunque Dynamo es extremadamente eficaz como herramienta de , también es posible ir más allá de los nodos y los cables, y escribir código en forma de texto. Existen dos formas de hacerlo:
Escribir DesignScript mediante un bloque de código
Escribir Python mediante un nodo de Python
Esta sección se centrará en cómo aprovechar Python en el entorno de Civil 3D para sacar partido de las API de .NET de AutoCAD y Civil 3D.
Consulte la sección para obtener información sobre cómo usar Python en Dynamo.
Tanto AutoCAD como Civil 3D disponen de varias API que permiten a desarrolladores como usted ampliar el producto principal con funciones personalizadas. En el contexto de Dynamo, lo pertinente son las API de .NET administrado. Los siguientes vínculos son esenciales para conocer la estructura de las API y su funcionamiento.
A medida que avance por esta sección, es posible que haya algunos conceptos con los que no esté familiarizado, como bases de datos, transacciones, métodos, propiedades, etc. Muchos de estos conceptos son fundamentales para trabajar con las API de .NET y no son específicos de Dynamo o Python. Está fuera del alcance de esta sección del manual abordar estos temas en detalle, por lo que se recomienda consultar con frecuencia los vínculos anteriores para obtener más información.
Al editar por primera vez un nuevo nodo de Python, este se rellenará previamente con el código de la plantilla para que pueda empezar. A continuación, se muestra un desglose de la plantilla con explicaciones sobre cada bloque.
Importa los módulos
sys
yclr
, que son necesarios para que el intérprete de Python funcione correctamente. En concreto, el móduloclr
permite que los espacios de nombres de .NET se traten básicamente como paquetes de Python.Carga los ensamblajes estándar (es decir, los archivos DLL) para trabajar con las API de .NET administrado para AutoCAD y Civil 3D.
Añade referencias a espacios de nombres estándar de AutoCAD y Civil 3D. Equivalen a las directivas
using
oImports
de C# o VB.NET (respectivamente).Se puede acceder a los puertos de entrada del nodo mediante una lista predefinida denominada
IN
. Puede acceder a los datos de un puerto específico mediante su número de índice como, por ejemplo,dataInFirstPort = IN[0]
.Obtiene el documento y el editor activos.
Bloquea el documento e inicia una transacción de base de datos.
Aquí debe colocar la mayor parte de la lógica de la secuencia de comandos.
Anule los comentarios de esta línea para confirmar la transacción una vez que haya terminado el trabajo principal.
Si desea generar datos del nodo, asígnelo a la variable
OUT
al final de la secuencia de comandos.
¿Desea personalizar la plantilla?
Puede modificar la plantilla de Python por defecto. Para ello, edite el archivo PythonTemplate.py
ubicado en C:\ProgramData\Autodesk\C3D <version>\Dynamo
.
Veamos un ejemplo para mostrar algunos de los conceptos básicos de la escritura de secuencias de comandos de Python en Dynamo for Civil 3D.
A continuación, encontrará archivos de ejemplo que puede consultar para este ejercicio.
A continuación, se ofrece una descripción general de la lógica de este gráfico.
Consultar la documentación de la API de Civil 3D
Seleccionar todas las cuencas vertientes del documento por nombre de capa
"Desenvolver" los objetos de Dynamo para acceder a los miembros internos de la API de Civil 3D
Crear puntos de Dynamo a partir de puntos de AutoCAD
Crear PolyCurves a partir de los puntos
¡Empecemos!
Ahora podemos empezar a crear la lógica del gráfico. Lo primero que hay que hacer es obtener una lista de todas las cuencas vertientes del documento. Hay nodos disponibles para ello, por lo que no necesitamos incluirla en la secuencia de comandos de Python. El uso de nodos proporciona una mejor visibilidad para otra persona que pueda leer el gráfico (en lugar de incluir mucho código en una secuencia de comandos de Python), y, además, mantiene la secuencia de comandos de Python centrada en un único objetivo, devolver los puntos límite de las cuencas vertientes.
Observe que la salida del nodo All Objects on Layer es una lista de CivilObjects. Esto se debe a que Dynamo for Civil 3D no dispone actualmente de ningún nodo que permita trabajar con cuencas vertientes, que es el motivo por el que necesitamos acceder a la API a través de Python.
Por regla general, es más seguro obtener el ID de objeto mediante la propiedad InternalObjectId
y, a continuación, acceder al objeto envuelto en una transacción. Esto se debe a que la propiedad InternalDBObject
devolverá un DBObject de AutoCAD que no se encuentra en estado de escritura.
A continuación, se muestra la secuencia de comandos completa de Python que realiza el trabajo de acceder a los objetos de cuenca vertiente internos para obtener sus puntos de contorno. Las líneas resaltadas representan las que se han modificado o añadido a partir del código de plantilla por defecto.
Haga clic en el texto subrayado en la secuencia de comandos para obtener una explicación de cada línea.
Como regla general, es recomendable incluir la mayor parte de la lógica de la secuencia de comandos en una transacción. De este modo, se garantiza un acceso seguro a los objetos que la secuencia de comandos está leyendo o escribiendo. En muchos casos, omitir una transacción puede provocar un error grave.
En esta fase, la secuencia de comandos de Python debería generar una lista de puntos de Dynamo que se pueden ver en la vista preliminar en segundo plano. El último paso consiste en crear simplemente PolyCurves a partir de los puntos. Tenga en cuenta que esto también podría hacerse directamente en la secuencia de comandos de Python, pero lo hemos puesto intencionadamente fuera de ella en un nodo para que resulte más visible. Este es el aspecto del gráfico final.
Y esta es la geometría final de Dynamo.
Apenas una nota rápida aquí antes de terminar. En función de la versión de Civil 3D que esté utilizando, es posible que el nodo de Python se haya configurado de forma diferente. En Civil 3D 2020 y 2021, Dynamo utilizaba una herramienta denominada IronPython para desplazar datos entre objetos .NET y secuencias de comandos de Python. Sin embargo, en Civil 3D 2022, Dynamo realizó la transición al intérprete nativo de Python estándar (también conocido como CPython) que utiliza Python 3. Las ventajas de esta transición incluyen el acceso a las bibliotecas modernas más conocidas y a las nuevas funciones de la plataforma, el mantenimiento esencial y los parches de seguridad.
Esta línea obtiene la clase específica que necesitamos de la biblioteca de geometría de Dynamo. Tenga en cuenta que aquí se especifica import Point as DynPoint
en lugar de import *
, ya que este último elemento provocaría conflictos de nombres.
Aquí especificamos exactamente el puerto de entrada que contiene los datos que deseamos en lugar del elemento IN
por defecto, que hace referencia a la lista completa de todas las entradas.
Cambie el nombre de las estructuras de red de tuberías en orden según el etiquetado en formato P.K. de una alineación.
¡Misión cumplida!
Versión de Civil 3D | Versión de Dynamo | Notas |
---|---|---|
Coloque las referencias a bloque de contadores de servicios de agua a una distancia determinada de la línea de parcela y trace una línea para cada conexión de servicios perpendicular a la red de distribución.
¡Misión cumplida!
Cree un grupo de puntos para cada descripción de punto COGO exclusiva.
¡Misión cumplida!
Utilice un bloque de perfil de vehículo para generar sólidos 3D de envolvente libre a lo largo de una obra lineal.
¡Misión cumplida!
Parece que el texto se suprime y se vuelve a crear con cada ejecución del gráfico. En realidad, la posición del texto se modifica en función del círculo seleccionado. Por lo tanto, es el mismo texto, solo que en un lugar diferente. Para crear un nuevo texto cada vez, debemos modificar la configuración de enlace de objetos de Dynamo para que no se conserve ningún dato de enlace (consulte a continuación).
Si es la primera vez que utiliza el Reproductor de Dynamo, consulte la sección .
Obtenga la geometría de contorno de todas las cuencas vertientes de un dibujo.
Antes de empezar a crear el gráfico y escribir el código, conviene echar un vistazo a la documentación de la API de Civil 3D y hacerse una idea de lo que esta pone a nuestra disposición. En este caso, hay una que devolverá los puntos de contorno de la cuenca vertiente. Tenga en cuenta que esta propiedad devuelve un objeto Point3dCollection
, que Dynamo desconoce cómo utilizar. En otras palabras, no podremos crear una PolyCurve a partir de un objeto Point3dCollection
, por lo que al final tendremos que convertirlo todo en puntos de Dynamo. Ya abordaremos este tema más adelante.
Antes de continuar, debemos abordar brevemente un concepto importante. En la sección , se ha explicado cómo se relacionan los objetos y CivilObjects. Para añadir algo más de detalle, un objeto de Dynamo es una envoltura alrededor de una entidad de AutoCAD. De forma similar, un CivilObject de Dynamo es una envoltura alrededor de una entidad de Civil 3D. Puede "desenvolver" un objeto. Para ello, acceda a sus propiedades InternalDBObject
o InternalObjectId
.
Tipo de Dynamo | Envolturas |
---|
¡Misión cumplida!
Puede obtener más información sobre esta transición y sobre cómo actualizar las secuencias de comandos existentes en el . Si desea seguir utilizando IronPython, solo tendrá que instalar el paquete de DynamoIronPython2.7 mediante Dynamo Package Manager.
2024.1
2.18
2024
2.17
Actualización de la interfaz de usuario del Reproductor de Dynamo
2023.2
2.15
2023
2.13
Actualización de la interfaz de usuario de Dynamo
2022.1
2.12
Adición de la configuración de almacenamiento de datos de enlace de objetos
Nuevos nodos para controlar el enlace de objetos
2022
2.10
Incorporación en la instalación principal de Civil 3D
Transición de IronPython a Python.NET
2021
2.5
2020.2
2.4
2020 Update 2
2.4
Nuevos nodos añadidos
2020.1
2.2
2020
2.1
Lanzamiento inicial
Objeto Autodesk.AutoCAD.DynamoNodes.Object | Entidad Autodesk.AutoCAD.DatabaseServices.Entity |
CivilObject Autodesk.Civil.DynamoNodes.CivilObject | Entidad Autodesk.Civil.DatabaseServices.Entity |
En esta sección, encontrará una serie de lecciones sobre la creación de geometría con DesignScript. Para continuar, copie el contenido de DesignScript de ejemplo en bloques de código de Dynamo.
El bloque de código es una función exclusiva de Dynamo que vincula dinámicamente un entorno de programación visual con uno basado en texto. El bloque de código tiene acceso a todos los nodos de Dynamo y puede definir un gráfico completo en un nodo. Lea este capítulo detenidamente, ya que el bloque de código es un elemento fundamental de Dynamo.
Los bloques de código son una ventana a DesignScript, el lenguaje de programación que es la base de Dynamo. Creado desde cero para admitir flujos de trabajo de diseño exploratorios, DesignScript es un lenguaje legible y conciso que ofrece información inmediata a pequeños fragmentos de código y también se adapta a interacciones grandes y complejas. DesignScript también forma la columna vertebral del motor que impulsa la mayoría de los aspectos subyacentes de Dynamo. Como casi todas las funciones de los nodos y las interacciones de Dynamo tienen una relación de uno a uno con el lenguaje de creación de secuencias de comandos, se ofrecen oportunidades únicas de desplazarse entre secuencias de comandos e interacciones basadas en nodos de forma fluida.
Para los principiantes, los nodos se pueden convertir automáticamente en sintaxis de texto para facilitar el aprendizaje de DesignScript o para reducir el tamaño de secciones de gráficos de mayor tamaño. Esto se realiza mediante un proceso denominado "de nodo a código", que se describe con más detalle en la sección Sintaxis de DesignScript. Los usuarios con más experiencia pueden utilizar bloques de código para crear combinaciones personalizadas de funciones existentes y relaciones creadas por el usuario mediante una gran cantidad de paradigmas de codificación estándar. En un nivel intermedio entre los principiantes y los usuarios avanzados, hay disponibles un gran número de accesos directos y fragmentos de código que agilizarán los diseños. Si bien el término "bloque de código" puede intimidar un poco a los que no son programadores, es una herramienta eficaz y fácil de usar. Un principiante puede utilizar de forma eficaz el bloque de código con una mínima creación de código y un usuario avanzado puede establecer definiciones de secuencias de comandos que se pueden recuperar en cualquier parte de una definición de Dynamo.
En resumen, los bloques de código son una interfaz de creación de secuencias de comandos de texto dentro de un entorno de creación de secuencias de comandos visuales. Se pueden utilizar como números, cadenas, fórmulas y otros tipos de datos. El bloque de código se ha diseñado para Dynamo, por lo que se pueden definir variables arbitrarias en el bloque de código y esas variables se añaden automáticamente a las entradas del nodo:
Con los bloques de código, un usuario dispone de flexibilidad para decidir cómo especificar entradas. A continuación, se indican varias formas de crear un punto básico con coordenadas (10, 5, 0):
A medida que aprende más sobre las funciones disponibles en la biblioteca, es posible que le sea más rápido escribir "Point.ByCoordinates" que buscar en la biblioteca y encontrar el nodo adecuado. Por ejemplo, al escribir "Point.", Dynamo mostrará una lista de posibles funciones que aplicar a un punto. Esto hace que la creación de secuencias de comandos sea más intuitiva y le ayudará a aprender a aplicar funciones en Dynamo.
El bloque de código se encuentra en Core > Entrada > Acciones > Bloque de código. O, simplemente, de forma más rápida, haga doble clic en el lienzo para que aparezca el bloque de código. Este nodo se utiliza con tanta frecuencia que se le han proporcionado privilegios completos de doble clic.
Los bloques de código también son flexibles en relación con los tipos de datos. El usuario puede definir rápidamente números, cadenas y fórmulas, y el bloque de código generará la salida deseada.
En la imagen siguiente, puede comprobar que la forma tradicional de trabajo es algo prolija: el usuario busca el nodo previsto en la interfaz, lo añade al lienzo y, a continuación, introduce los datos. Con el bloque de código, el usuario puede hacer doble clic en el lienzo para desplegar el nodo y escribir el tipo de datos correcto con la sintaxis básica.
Los nodos "number", "string" y "formula" son tres ejemplos de nodos de Dynamo que posiblemente estén obsoletos en comparación con el bloque de código.
"Forma tradicional"
Bloques de código
Existen varios métodos básicos de abreviatura en el bloque de código que, sencillamente, facilitan mucho la administración de datos. A continuación, vamos a desglosar los conceptos básicos y analizar cómo se puede utilizar la abreviatura para crear y consultar datos.
El método para definir rangos y secuencias se puede reducir a un método básico de abreviatura. Utilice la imagen siguiente como guía de la sintaxis "..." para definir una lista de datos numéricos con un bloque de código. Una vez que aprendemos a utilizar esta notación, crear datos numéricos es un proceso realmente eficaz:
En este ejemplo, un rango de números se sustituye por una sintaxis de bloque de código que define
beginning..end..step-size;
. Representados numéricamente, obtenemos lo siguiente:0..10..1;
.Observe que la sintaxis
0..10..1;
es equivalente a0..10;
. Un tamaño de paso de 1 es el valor por defecto de la notación de abreviatura. Por lo tanto,0..10;
proporciona una secuencia de 0 a 10 con un tamaño de paso de 1.El ejemplo de secuencia es similar, excepto que se utiliza un símbolo "#" para indicar que deseamos que haya 15 valores en la lista en lugar de una lista que llegue hasta 15. En este caso, se define lo siguiente:
beginning..#ofSteps..step-size:
. La sintaxis real de la secuencia es0..#15..2
.Ahora vamos a introducir el símbolo "#" del paso anterior en la sección "tamaño-de-paso" de la sintaxis. Ahora, tenemos un rango de números que abarca de "inicio" a "fin" y la notación de "tamaño de paso" distribuye uniformemente un número de valores entre los dos elementos:
beginning..end..#ofSteps
.
La creación de rangos avanzados nos permite trabajar con listas de listas de una forma sencilla. En los ejemplos siguientes, se aísla una variable de la notación de rango principal y se crea otro rango de dicha lista.
1. Mediante la creación de rangos anidados, compare la notación con el símbolo "#" frente a la notación sin este símbolo. Se aplica la misma lógica que en los rangos básicos, pero se vuelve un poco más compleja.
2. Podemos definir un subrango en cualquier lugar dentro del rango principal; observe que también podemos tener dos subrangos.
3. Al controlar el valor "fin" de un rango, se crean más rangos de longitudes diferentes.
Como ejercicio lógico, compare las dos abreviaturas anteriores e intente analizar el modo en que los subrangos y la notación # controlan la salida.
Además de crear listas con la función de abreviatura, también podemos crear listas sobre la marcha. Estas listas pueden contener una amplia gama de tipos de elementos y también se pueden consultar (recuerde que las listas son objetos en sí mismas). En resumen, con el bloque de código se crean listas y se consultan los elementos de una lista con corchetes.
1. Cree listas rápidamente con cadenas y consulte las listas mediante el índice de elementos.
2. Cree listas con variables y realice consultas mediante la notación de abreviatura de rango.
Además, el proceso de gestión con listas anidadas es similar. Tenga en cuenta el orden de la lista y recuerde utilizar varios conjuntos de corchetes:
1. Defina una lista de listas.
2. Consulte una lista con notación de un solo corchete.
3. Consulte un elemento con notación de doble corchete.
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, vamos a poner en práctica nuestras nuevas habilidades de abreviación para crear una superficie de cáscaras de huevo con mucho estilo y definida por rangos y fórmulas. A lo largo de este ejercicio, observe cómo utilizamos el bloque de código y los nodos existentes en Dynamo en tándem: se utiliza el bloque de código para la elevación de datos pesados mientras que los nodos de Dynamo se disponen visualmente para determinar la legibilidad de la definición.
Comience por crear una superficie conectando los nodos anteriores. En lugar de utilizar un nodo numérico para definir la anchura y la longitud, haga doble clic en el lienzo y escriba 100;
en un bloque de código.
Defina un rango entre 0 y 1 con 50 divisiones. Para ello, escriba
0..1..#50
en un bloque de código.Conecte el rango en Surface.PointAtParameter, que toma los valores u y v entre 0 y 1 a lo largo de la superficie. No olvide cambiar el encaje a Producto vectorial. Para ello, haga clic con el botón derecho en el nodo Surface.PointAtParameter.
En este paso, utilizamos nuestra primera función para mover la rejilla de puntos hacia arriba en el eje Z. Esta rejilla controlará una superficie generada a partir de la función subyacente. Añada nuevos nodos, como se muestra en la imagen siguiente.
En lugar de utilizar un nodo de fórmula, utilizamos un bloque de código con la siguiente línea:
(0..Math.Sin(x*360)..#50)*5;
. Para descomponerlo rápidamente, vamos a definir un rango con una fórmula dentro de él. Esta fórmula es la función de seno. La función de seno recibe entradas de grado en Dynamo, por lo que, para obtener una onda sinusoidal completa, multiplicamos los valores x (es decir, la entrada de rango de 0 a 1) por 360. A continuación, queremos que haya el mismo número de divisiones que de puntos de rejilla de control para cada fila, por lo que definimos cincuenta subdivisiones con #50. Por último, el multiplicador de 5 simplemente aumenta la amplitud de la traslación para que podamos ver el efecto en la vista preliminar de Dynamo.
Aunque el bloque de código anterior, no era totalmente paramétrico. Deseamos controlar sus parámetros de forma dinámica, por lo que reemplazaremos la línea del paso anterior por
(0..Math.Sin(x*360*cycles)..#List.Count(x))*amp;
. Esto nos permite definir estos valores en función de las entradas.
Al cambiar los controles deslizantes (de 0 a 10), obtenemos resultados interesantes.
Al realizar una transposición en el rango de números, se invierte la dirección de la onda cortina:
transposeList = List.Transpose(sineList);
.
Se obtiene una superficie de cáscara de huevo distorsionada al añadir los elementos sineList y tranposeList:
eggShellList = sineList+transposeList;
.
Cambiemos los valores de los controles deslizantes especificados a continuación para "calmar las aguas" de este algoritmo.
Por último, vamos a consultar las partes aisladas de los datos con el bloque de código. Para regenerar la superficie con un rango específico de puntos, añada el bloque de código anterior entre los nodos Geometry.Translate y NurbsSurface.ByPoints. Tiene la siguiente línea de texto: sineStrips[0..15..1];
. De este modo, se seleccionarán las primeras 16 filas de puntos (de 50). Al volver a crear la superficie, podemos ver que hemos generado una parte aislada de la rejilla de puntos.
En el paso final, para que este bloque de código sea más paramétrico, la consulta se controla mediante un control deslizante que va de 0 a 1. Para ello, utilizaremos esta línea de código:
sineStrips[0..((List.Count(sineStrips)-1)*u)];
. Esto puede resultar confuso, pero la línea de código nos proporciona una forma rápida de modificar la longitud de la lista con un multiplicador entre 0 y 1.
Un valor de 0.53
en el control deslizante crea una superficie justo después del punto medio de la rejilla.
Como se puede esperar, un control deslizante de 1
crea una superficie a partir de la rejilla completa de puntos.
En el gráfico visual, podemos resaltar los bloques de código y ver cada una de sus funciones.
1. El primer bloque de código sustituye al nodo Number.
2. El segundo bloque de código sustituye al nodo Number Range.
3. El tercer bloque de código sustituye al nodo Formula (así como aList.Transpose, List.Count y Number Range).
4. El cuatro bloque de código consulta una lista de listas y sustituye al nodo List.GetItemAtIndex.
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.
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.
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.
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.
Utilice estas líneas de código:
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.
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:
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!
Ahora llamamos a la función y creamos una variable denominada Pt para conectar los puntos creados en los pasos anteriores:
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.
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.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.
Definamos primero una esfera con la siguiente línea de código:
sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius);
.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.
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.
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.
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.
Actualice la definición de sphereByZ a:
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.
Es posible que haya observado que en los nombres de los nodos de Dynamo se da un elemento común: cada nodo utiliza una sintaxis ".". Esto se debe a que el texto de la parte inicial de cada nodo representa la sintaxis real para las secuencias de comandos y "." (o notación de puntos) separa un elemento de los posibles métodos a los que es posible invocar. Esto permite traducir fácilmente las secuencias de comandos visuales a secuencias de comandos basadas en texto.
Como analogía general para la notación de puntos, ¿cómo podemos tratar una manzana paramétrica en Dynamo? A continuación se indican algunos métodos que ejecutaremos en la manzana antes de decidir consumirla. (Nota: estos no son métodos reales de Dynamo):
Legible para el ser humano | Notación de puntos | Salida |
---|---|---|
A juzgar por las salidas de la tabla de arriba, esta parece una manzana sabrosa. Creo que voy a Manzana.comer.
Con la analogía de manzana en mente, fijémonos en Point.ByCoordinates y veamos cómo podemos crear un punto mediante el bloque de código.
La sintaxis del bloque de código Point.ByCoordinates(0,10);
proporciona el mismo resultado que el nodo Point.ByCoordinates en Dynamo, excepto que permite crear un punto mediante un nodo. Esto es más eficaz que conectar un nodo independiente a "X" e "Y".
Al utilizar Point.ByCoordinates en el bloque de código, se especifican las entradas en el mismo orden que en el nodo (X,Y) predefinido.
Puede invocar cualquier nodo normal de la biblioteca a través de un bloque de código siempre que el nodo no sea un nodo de "IU" especial, los que tienen una función de interfaz de usuario especial. Por ejemplo, puede invocar a Circle.ByCenterPointRadius, pero no tendría mucho sentido invocar a un nodo Watch 3D.
Los nodos normales (la mayoría de los incluidos en la biblioteca) suelen ser de tres tipos. Descubrirá que la biblioteca se organiza teniendo en cuenta estas categorías. Los métodos o nodos de estos tres tipos se tratan de forma diferente cuando se invocan desde un bloque de código.
Crear: crea (o construye) algo.
Acción: realiza una acción sobre algún elemento.
Consulta: obtiene una propiedad de algún elemento que ya existe.
La categoría "Crear" genera geometría desde cero. En el bloque de código, los valores se introducen de izquierda a derecha. Estas entradas están en el mismo orden que las entradas del nodo de arriba abajo.
Si comparamos el nodo Line.ByStartPointEndPoint y la sintaxis correspondiente en el bloque de código, vemos que se obtienen los mismos resultados.
Una acción es algo que se hace a un objeto de un tipo concreto. Dynamo utiliza la notación de puntos, común a muchos idiomas de codificación, para aplicar una acción a un elemento. Una vez que tenga el elemento, escriba un punto y, a continuación, el nombre de la acción. La entrada del método de acción se coloca entre paréntesis, del mismo modo que con los métodos de creación, solo que no es necesario especificar la primera entrada que se ve en el nodo correspondiente. En su lugar, especificamos el elemento en el que realizamos la acción:
El nodo Point.Add es un nodo de acción, por lo que la sintaxis funciona de forma algo distinta.
Las entradas son (1) el punto y (2) el vector que añadir. En un bloque de código, hemos designado al punto (el elemento) "pt". Para añadir un vector denominado *"vec" *a "pt", escribimos pt.Add(vec), o elemento, punto, acción. La acción Add (añadir) solo tiene una entrada o todas las entradas del nodo Point.Add menos la primera. La primera entrada del nodo Point.Add es el punto en sí.
Los métodos de consulta obtienen una propiedad de un objeto. Dado que el objeto en sí es la entrada, no es necesario especificar ninguna entrada. No se requieren paréntesis.
El encaje con nodos es algo diferente al encaje con el bloque de código. Con los nodos, el usuario hace clic con el botón derecho en el nodo y selecciona la opción de encaje que se va a utilizar. Con el bloque de código, el usuario tiene mucho más control sobre la estructura de los datos. El método de abreviatura del bloque de código utiliza guías de replicación para definir cómo se deben emparejar varias listas unidimensionales. Los números entre corchetes angulares "<>" definen la jerarquía de la lista anidada: <1>,<2>,<3>, etc.
En este ejemplo, se utiliza un método abreviado para definir dos rangos (la siguiente sección de este capítulo contiene más información sobre el método abreviado). En resumen,
0..1;
es equivalente a{0,1}
y-3..-7
es equivalente a{-3,-4,-5,-6,-7}
. El resultado nos proporciona listas de 2 valores X y 5 valores Y. Si no utilizamos guías de replicación con estas listas no coincidentes, obtenemos una lista de dos puntos, que es la longitud de la lista más corta. Con las guías de replicación, podemos encontrar todas las combinaciones posibles de 2 y 5 coordenadas (o un producto vectorial).Mediante la sintaxis Point.ByCoordinates
(x_vals<1>,y_vals<2>);
, se obtienen dos listas con cinco elementos en cada lista.Mediante la sintaxis Point.ByCoordinates
(x_vals<2>,y_vals<1>);
, se obtienen cinco listas con dos elementos en cada lista.
Con esta notación, también podemos especificar cuál será la lista dominante: dos listas de cinco elementos o cinco listas de dos elementos. En el ejemplo, al cambiar el orden de las guías de replicación, el resultado es una lista de filas de puntos o una lista de columnas de puntos en una rejilla.
Aunque pueda hacer falta algo de tiempo para acostumbrarse a los métodos de bloqueo anteriores, en Dynamo existe una función denominada "nodo para código" que facilita el proceso. Para utilizar esta función, seleccione una matriz de nodos en el gráfico de Dynamo, haga clic con el botón derecho en el lienzo y seleccione "Nodo para código". Dynamo comprime estos nodos en un bloque de código con todas las entradas y salidas. No solo es una excelente herramienta para aprender a utilizar bloques de código, sino que también permite trabajar con un gráfico Dynamo más eficaz y paramétrico. Concluiremos el siguiente ejercicio utilizando "Nodo para código", así que no se lo pierda.
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.
Para mostrar la eficacia del bloque de código, vamos a convertir una definición de campo atractor existente al lenguaje del bloque de código. Al trabajar con una definición existente, se muestra cómo se relaciona el bloque de código con las secuencias de comandos visuales y es útil para aprender a utilizar la sintaxis de DesignScript.
Comience volviendo a crear la definición de la imagen anterior (o abriendo el archivo de muestra).
Observe que el encaje en Point.ByCoordinates se ha establecido en Producto vectorial.
Cada punto de una rejilla se desplaza hacia arriba en la dirección Z en función de su distancia con respecto al punto de referencia.
Se vuelve a crear una superficie y se engrosa, lo que genera una curvatura en la geometría relativa a la distancia con respecto al punto de referencia.
Para empezar, definamos primero el punto de referencia: Point.ByCoordinates
(x,y,0);
. Utilizaremos la misma sintaxis de Point.ByCoordinates que se especifica en la parte superior del nodo de punto de referencia.Las variables x e y se insertan en el bloque de código para que podamos actualizarlas dinámicamente con los controles deslizantes.
Añada algunos controles deslizantes a las entradas del bloque de código que vayan del -50 al 50. De este modo, podemos abarcar la rejilla por defecto de Dynamo.
En la segunda línea del bloque de código, definimos una abreviatura para reemplazar el nodo de secuencia numérica:
coordsXY = (-50..50..#11);
. Abordaremos más detalladamente este tema en la siguiente sección. Por ahora, observe que este método abreviado es equivalente al nodo Number Sequence de la secuencia de comandos visual.
Ahora vamos a crear una rejilla de puntos a partir de la secuencia coordsXY. Para ello, vamos a utilizar la sintaxis Point.ByCoordinates, pero también debemos iniciar un producto vectorial de la lista de la misma forma que lo hicimos en la secuencia de comandos visual. Para ello, escribimos la siguiente línea:
gridPts = Point.ByCoordinates(coordsXY<1>,coordsXY<2>,0);
. Los corchetes angulares indican la referencia de producto vectorial.Observe en el nodo Watch3D que tenemos una rejilla de puntos en la rejilla de Dynamo.
Ahora llega la parte compleja: mover la rejilla de puntos hacia arriba según su distancia con respecto al punto de referencia. Llamaremos primero a este nuevo conjunto de puntos transPts. Como la traslación es una acción que se lleva a cabo en un elemento existente, en lugar de utilizar
Geometry.Translate...
, utilizamosgridPts.Translate
.Al leer el nodo real en el lienzo, vemos que hay tres entradas. La geometría que se va a trasladar ya se ha definido porque llevamos a cabo la acción en ese elemento (con gridPts.Translate). Las dos entradas restantes se insertarán en los paréntesis de las funciones: dirección y distancia.
Definir la dirección es sencillo; utilizamos
Vector.ZAxis()
para realizar un movimiento vertical.La distancia entre el punto de referencia y cada punto de rejilla aún debe calcularse. Por lo tanto, lo hacemos como una acción al punto de referencia del mismo modo:
refPt.DistanceTo(gridPts)
.La última línea de código nos proporciona los puntos convertidos:
transPts=gridPts.Translate(Vector.ZAxis(),refPt.DistanceTo(gridPts));
.
Ahora tenemos una rejilla de puntos con la estructura de datos adecuada para crear una superficie NURBS. Creamos la superficie mediante
srf = NurbsSurface.ByControlPoints(transPts);
.
Por último, para añadir cierta profundidad a la superficie, construimos un sólido mediante
solid = srf.Thicken(5);
. En este caso, hemos engrosado la superficie 5 unidades en el código, pero siempre podríamos definirla como una variable, denominándola "thickness" (grosor), por ejemplo, y después controlar ese valor con un control deslizante.
La función "nodo para código" automatiza todo el ejercicio que acabamos de completar con un solo clic. No solo es una herramienta eficaz para crear definiciones personalizadas y bloques de código reutilizables, sino que también es una herramienta muy útil para aprender a usar las secuencias de comandos de Dynamo:
Empiece con la secuencia de comandos visual existente del paso 1 del ejercicio. Seleccione todos los nodos, haga clic con el botón derecho en el lienzo y seleccione "Nodo para código". Así de fácil.
Dynamo crea de forma automática una versión basada en texto del gráfico visual, con el encaje incluido. Pruebe esta función con las secuencias de comandos visuales y aproveche las posibilidades del bloque de código.
Existen dos formas fundamentales de crear curvas de forma libre en Dynamo: especificar una colección de puntos y conseguir que Dynamo interpole una curva suavizada entre ellos, o un método de nivel más bajo mediante la especificación de los puntos de control subyacentes de una curva de un determinado grado. Las curvas interpoladas son útiles cuando un diseñador conoce exactamente la forma que debe adoptar una línea o si el diseño tiene restricciones específicas en cuanto a la ubicación que la curva puede o no atravesar. Las curvas especificadas mediante puntos de control son, en esencia, una serie de segmentos de línea recta que un algoritmo suaviza para formar una curva final. La especificación de una curva mediante puntos de control puede resultar útil para explorar formas de curva con diferentes grados de suavizado o cuando se requiere una continuidad suave entre segmentos de curva.
Para crear una curva interpolada, simplemente transfiera un conjunto de puntos al método NurbsCurve.ByPoints.
La curva generada interseca cada uno de los puntos de entrada, comenzando y terminando en el primer y el último punto del conjunto, respectivamente. Se puede utilizar un parámetro periódico opcional para crear una curva periódica cerrada. Dynamo rellenará automáticamente el segmento que falta, por lo que no es necesario un punto final duplicado (idéntico al punto inicial).
Las NurbsCurves se generan de forma muy similar, con puntos de entrada que representan los puntos finales de un segmento de línea recta y un segundo parámetro que especifica la cantidad y el tipo de suavizado de la curva, que se denomina grado. * Una curva con el grado 1 no presenta suavizado; es una polilínea.
Una curva con el grado 2 se suaviza de forma que esta se interseque con el punto medio de los segmentos de polilínea y sea tangente a él:
Dynamo admite curvas NURBS (B-spline racional no uniforme) hasta un grado 20; la siguiente secuencia de comandos ilustra el efecto que tiene el aumento de niveles de suavizado en la forma de una curva:
Tenga en cuenta que debe tener al menos un punto de control más que el grado de la curva.
Otra ventaja de crear curvas mediante vértices de control es la capacidad de mantener la tangencia entre segmentos de curva individuales. Para ello, se extrae la dirección entre los dos últimos puntos de control y se continúa esta dirección con los dos primeros puntos de control de la curva siguiente. En el siguiente ejemplo, se crean dos curvas NURBS independientes que son, no obstante, tan suaves como una curva:
* Esta es una descripción muy simplificada de la geometría de curva NURBS; para obtener una explicación más precisa y detallada, consulte Pottmann, et al. 2007, en las referencias.
Los objetos de los diseños computacionales rara vez se crean explícitamente en su posición y forma finales y, con mayor frecuencia, se convierten, se giran y se colocan de cualquier otro modo a partir de la geometría existente. Las matemáticas vectoriales sirven como una especie de andamiaje geométrico para proporcionar dirección y orientación a la geometría, así como para conceptualizar movimientos a través del espacio 3D sin representación visual.
Como elemento más básico, un vector representa una posición en el espacio 3D y a menudo se considera el punto final de una flecha desde la posición (0, 0, 0) hasta esa posición. Los vectores se pueden crear con el constructor ByCoordinates utilizando la posición X, Y y Z del objeto vectorial que se acaba de crear. Observe que los objetos vectoriales no son objetos geométricos y no aparecen en la ventana de Dynamo. Sin embargo, la información sobre un vector recién creado o modificado se puede imprimir en la ventana de la consola:
Un conjunto de operaciones matemáticas se define en objetos vectoriales, lo que permite sumar, restar, multiplicar y, en general, desplazar objetos en un espacio 3D, tal y como desplazaría números reales en un espacio unidimensional en una línea numérica.
La adición de vectores se define como la suma de los componentes de dos vectores y se puede entender como el vector resultante si las dos flechas de vector de componente se colocan "de la punta a la cola". La adición de vectores se realiza con el método Add y se representa con el diagrama de la izquierda.
Del mismo modo, se pueden restar dos objetos vectoriales entre sí mediante el método Subtract. La resta de vectores se puede entender como la dirección que va desde el primer vector hasta el segundo.
La multiplicación de vectores se puede entender como el desplazamiento del punto final de un vector en su propia dirección mediante un factor de escala especificado.
A menudo, al ajustar la escala de un vector, es deseable que su longitud sea exactamente igual a la cantidad de escala ajustada. Esto se puede conseguir fácilmente. Para ello, debe normalizarse primero un vector, en otras palabras, se debe establecer la longitud del vector en un valor exactamente igual a uno.
c sigue apuntando en la misma dirección que a (1, 2, 3), aunque ahora tiene una longitud exactamente igual a 5.
Existen dos métodos adicionales en las matemáticas vectoriales que no tienen equivalentes claros con las matemáticas unidimensionales: el producto vectorial y el producto escalar. El producto vectorial permite generar un vector ortogonal (a 90 grados) a dos vectores existentes. Por ejemplo, el producto vectorial de los ejes X e Y es el eje Z, aunque los dos vectores de entrada no tienen que ser ortogonales entre sí. Un vector de producto vectorial se calcula con el método Cross.
Una función adicional, aunque algo más avanzada, de matemáticas vectoriales es el producto escalar. El producto escalar entre dos vectores es un número real (no un objeto vectorial) que hace referencia al ángulo entre dos vectores, aunque no exactamente. Una de las propiedades útiles de este tipo de producto es que el producto escalar entre dos vectores será 0 solo si son perpendiculares. El producto escalar se calcula con el método Dot.
El componente análogo bidimensional a una NurbsCurve es la NurbsSurface y, al igual que la NurbsCurve de forma libre, las NurbsSurfaces se pueden crear con dos métodos básicos: la introducción de un conjunto de puntos base y la interpolación entre ellos por parte de Dynamo, y la especificación explícita de los puntos de control de la superficie. Al igual que las curvas de forma libre, las superficies interpoladas son útiles cuando un diseñador conoce con precisión la forma que debe adoptar una superficie o si un diseño requiere que la superficie pase por los puntos de restricción. Por otra parte, las superficies creadas mediante puntos de control pueden ser más útiles para los diseños exploratorios a través de varios niveles de suavizado.
Para crear una superficie interpolada, simplemente genere una colección bidimensional de puntos que se aproxime a la forma de una superficie. La colección debe ser rectangular, es decir, no irregular. El método NurbsSurface.ByPoints crea una superficie a partir de estos puntos.
También se pueden crear NurbsSurfaces de forma libre mediante la especificación de los puntos de control subyacentes de una superficie. Al igual que las NurbsCurves, se puede considerar que los puntos de control representan una malla cuadrilateral con segmentos rectos que, en función del grado de la superficie, se suaviza hasta alcanzar la forma de superficie final. Para crear una NurbsSurface mediante puntos de control, incluya dos parámetros adicionales en NurbsSurface.ByPoints, que indiquen los grados de las curvas subyacentes en ambas direcciones de la superficie.
Podemos aumentar el grado de la NurbsSurface para cambiar la geometría de superficie resultante:
Del mismo modo que las superficies se pueden crear mediante la interpolación entre un conjunto de puntos de entrada, estas se pueden crear mediante la interpolación entre un conjunto de curvas base. Esta operación se denomina solevado. Las curvas solevadas se crean mediante el constructor Surface.ByLoft con una colección de curvas de entrada como único parámetro.
Las superficies de revolución son un tipo adicional de superficie creada mediante el barrido de una curva base alrededor de un eje central. Si las superficies interpoladas son el elemento análogo bidimensional a las curvas interpoladas, las superficies de revolución son el elemento análogo bidimensional a los círculos y los arcos.
Las superficies de revolución se especifican mediante una curva base que representa la "arista" de la superficie; un origen de eje, el punto base de la superficie; una dirección de eje, la dirección central del "núcleo", y un ángulo inicial y final de barrido. Se utilizan como entrada en el constructor Surface.Revolve.
Aunque Dynamo puede crear diversas formas geométricas complejas, las primitivas geométricas simples forman la espina dorsal de cualquier diseño computacional: expresadas directamente en la forma diseñada final o utilizadas como andamiaje a partir del que se genera geometría más compleja.
Aunque no es estrictamente una parte de la geometría, CoordinateSystem es una herramienta importante para crear geometría. Un objeto CoordinateSystem realiza un seguimiento de las transformaciones geométricas y de posición, como la rotación, el corte y la escala.
Para crear un CoordinateSystem centrado en un punto con x = 0, y = 0 y z = 0 sin transformaciones de rotación, escala o corte, basta con llamar al constructor Identity:
Los objetos CoordinateSystem con transformaciones geométricas se encuentran fuera del ámbito de este capítulo, aunque otro constructor permite crear un sistema de coordenadas en un punto específico, CoordinateSystem.ByOriginVectors:
La primitiva geométrica más sencilla es un punto, que representa una ubicación de cero dimensiones en un espacio tridimensional. Como se ha mencionado anteriormente, existen varias formas diferentes de crear un punto en un sistema de coordenadas específico: Point.ByCoordinates crea un punto con las coordenadas X, Y y Z especificadas; Point.ByCartesianCoordinates crea un punto con las coordenadas X, Y y Z especificadas en un determinado sistema de coordenadas; Point.ByCylindricalCoordinates crea un punto en un cilindro con un radio, un ángulo de rotación y una altura, y Point.BySphericalCoordinates crea un punto en una esfera con un radio y dos ángulos de rotación.
En este ejemplo, se muestran puntos creados en varios sistemas de coordenadas:
La siguiente primitiva de Dynamo dimensional superior es un segmento de línea, que representa un número infinito de puntos entre dos puntos finales. Las líneas se pueden crear indicando explícitamente los dos puntos de contorno con el constructor Line.ByStartPointEndPoint o especificando un punto inicial, una dirección y una longitud en esa dirección, Line.ByStartPointDirectionLength.
Dynamo tiene objetos que representan los tipos más básicos de primitivas geométricas en tres dimensiones: cubos, creados con Cuboid.ByLengths; conos, creados con Cone.ByPointsRadius y Cone.ByPointsRadii; cilindros, creados con Cylinder.ByRadiusHeight, y esferas, creadas con Sphere.ByCenterPointRadius.
Algunos objetos de geometría se pueden crear indicando de forma explícita las coordenadas X, Y y Z en un espacio tridimensional. Sin embargo, con mayor frecuencia, la geometría se desplaza a su posición final mediante transformaciones geométricas en el propio objeto o en su CoordinateSystem subyacente.
La transformación geométrica más sencilla es una traslación, que desplaza un objeto un número determinado de unidades en las direcciones X, Y y Z.
Aunque todos los objetos de Dynamo se pueden trasladar mediante la adición del método .Translate al final del nombre del objeto, las transformaciones más complejas requieren transformar el objeto de un CoordinateSystem subyacente a un nuevo CoordinateSystem. Por ejemplo, para girar un objeto 45 grados alrededor del eje X, debemos transformar el objeto de su CoordinateSystem existente sin rotación a un CoordinateSystem que se había girado 45 grados alrededor del eje X con el método .Transform:
Además de trasladarse y rotarse, los objetos CoordinateSystem también se pueden crear cortados o con su escala ajustada. Se puede ajustar la escala de un CoordinateSystem con el método .Scale:
Los objetos CoordinateSystem cortados se crean mediante la introducción de vectores no ortogonales en el constructor CoordinateSystem.
La escala y el corte son transformaciones geométricas más complejas que la rotación y la traslación, por lo que no todos los objetos de Dynamo pueden someterse a ellas. En la siguiente tabla, se describen los objetos de Dynamo que pueden tener objetos CoordinateSystem con escala no uniforme y cortados.
El objeto geométrico más sencillo de la biblioteca de geometría estándar de Dynamo es un punto. Toda la geometría se crea mediante funciones especiales denominadas constructores, que devuelven un nuevo ejemplar de ese tipo de geometría específico. En Dynamo, los constructores empiezan por el nombre del tipo de objeto, en este caso, "Point", seguido del método de construcción. Para crear un punto tridimensional especificado con las coordenadas cartesianas X, Y y Z, utilice el constructor ByCoordinates:
Los constructores de Dynamo se designan normalmente con el prefijo By y, al invocar estas funciones, se devuelve un objeto recién creado de ese tipo. Este objeto recién creado se almacena en la variable designada a la izquierda del signo igual.
La mayoría de los objetos tienen muchos constructores distintos y se puede utilizar el constructor BySphericalCoordinates para crear un punto que resida en una esfera, especificado por el radio de la esfera, y un primer y un segundo ángulo de rotación (especificados en grados):
Los puntos se pueden utilizar para crear geometría dimensional superior como, por ejemplo, líneas. Se puede utilizar el constructor ByStartPointEndPoint para crear un objeto de línea entre dos puntos:
De forma similar, las líneas se pueden utilizar para crear geometría de superficie dimensional superior, por ejemplo, mediante el constructor Loft, que utiliza una serie de líneas o curvas e interpola una superficie entre ellas.
Las superficies también se pueden utilizar para crear geometría sólida dimensional superior, por ejemplo, mediante el engrosado de la superficie a una distancia especificada. Muchos objetos tienen funciones enlazadas a ellos denominadas métodos, que permiten al programador ejecutar comandos en ese objeto específico. Entre los métodos comunes a todas las partes de geometría, se incluyen Translate y Rotate, que trasladan (desplazan) y rotan la geometría una cantidad especificada. Las superficies presentan el método Thicken, que utiliza una única entrada, un número que especifica el nuevo grosor de la superficie.
Los comandos de intersección pueden extraer geometría dimensional inferior de objetos dimensionales superiores. Esta geometría dimensional inferior extraída puede formar la base para una geometría dimensional superior en un proceso cíclico de creación, extracción y recreación. En este ejemplo, se utiliza el sólido generado para crear una superficie y se utiliza la superficie para crear una curva.
Muchos de los ejemplos mostrados hasta ahora se han centrado en la creación de geometría dimensional superior a partir de objetos dimensionales inferiores. Los métodos de intersección permiten que esta geometría dimensional superior genere objetos dimensionales inferiores, mientras que los comandos de recorte y de selección de recorte permiten que el archivo de comandos modifique las formas geométricas una vez creadas.
El método Intersect se define en todas las partes de la geometría de Dynamo, lo que significa que, en teoría, cualquier elemento de geometría se puede intersecar con cualquier otro. Naturalmente, algunas intersecciones no tienen sentido, como las intersecciones que involucran puntos, ya que el objeto resultante siempre será el propio punto de entrada. Las demás combinaciones posibles de intersecciones entre objetos se describen en el siguiente gráfico. En la siguiente tabla, se muestra el resultado de varias operaciones de intersección:
En el siguiente ejemplo muy sencillo, se muestra la intersección de un plano con una NurbsSurface. La intersección genera una matriz de NurbsCurves, que se puede utilizar como cualquier otra NurbsCurve.
El método Trim es muy similar al método Intersect, ya que se define para casi cada elemento de geometría. Sin embargo, existen muchas más limitaciones en el método Trim que en Intersect.
Algo que se debe tener en cuenta en los métodos Trim es el requisito de un punto de "selección", un punto que determina la geometría que se descartará y las partes que se deben conservar. Dynamo busca y descarta la geometría recortada más cercana al punto de selección.
Clase | CoordinateSystem con escala no uniforme | CoordinateSystem cortado |
---|
Arco | No | No |
NurbsCurve | Sí | Sí |
NurbsSurface | No | No |
Círculo | No | No |
Línea | Sí | Sí |
Plano | No | No |
Punto | Sí | Sí |
Polígono | No | No |
Sólido | No | No |
Superficie | No | No |
Texto | No | No |
Uso: Punto | Curva | Plano | Superficie | Sólido |
En: Curva | Sí | No | No | No | No |
Polígono | - | No | Sí | No | No |
Superficie | - | Sí | Sí | Sí | Sí |
Sólido | - | - | Sí | Sí | Sí |
Tipo de datos
Dynamo estándar
Bloque de código equivalente
Números
Cadenas
Secuencias
Rangos
Obtener elemento en índice
Crear lista
Concatenar cadenas
Instrucciones condicionales
Nodo(s)
Bloque de código equivalente
Nota
Cualquier operador (+, &&, >=, Not, etc.)
+, &&, >=, !, etc.
Tenga en cuenta que "Not" se convierte en "!", pero el nodo se denomina "Not" para distinguirlo de "Factorial".
Boolean True
true;
Se deben respetar las minúsculas.
Boolean False
false;
Se deben respetar las minúsculas.
Ahora que hemos mostrado cómo utilizar las secuencias de comandos de Python en Dynamo, vamos a echar un vistazo a la conexión de bibliotecas de Revit en el entorno de secuencias de comandos. Recuerde que hemos importado los nodos estándar de Python y nuestros nodos centrales de Dynamo con las tres primeras líneas del bloque de código mostrado a continuación. Para importar los nodos de Revit, los elementos de Revit y el administrador de documentos de Revit, solo hemos de añadir algunas líneas más:
Esto nos permite acceder a la API de Revit y disponer de secuencias de comandos personalizadas para cualquier tarea de Revit. La combinación del proceso de programación visual con las secuencias de comandos de la API de Revit, mejora significativamente la colaboración y el desarrollo de herramientas. Por ejemplo, un administrador de BIM y un diseñador de esquemas pueden trabajar juntos en el mismo gráfico. En esta colaboración, pueden mejorar el diseño y la ejecución del modelo.
El plan tras el proyecto de Dynamo es ampliar el alcance de la implementación de plataformas. A medida que Dynamo añada más programas a la lista, los usuarios obtendrán acceso a las API específicas de plataforma desde el entorno de secuencias de comandos de Python. Aunque Revit representa el caso real de esta sección, podemos prever más capítulos en el futuro que ofrecerán módulos de aprendizaje completos sobre secuencias de comandos en otras plataformas. Además, hay muchas bibliotecas de IronPython a las que se puede acceder ahora y que se pueden importar a Dynamo.
En los siguientes ejemplos, se muestran métodos para implementar operaciones específicas de Revit desde Dynamo mediante el uso de Python. Para obtener una descripción más detallada de la relación de Python con Dynamo y Revit, consulte la página wiki de Dynamo. Otro recurso útil para Python y Revit es el proyecto Revit Python Shell.
Cree un nuevo proyecto de Revit.
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 estos ejercicios, vamos a explorar secuencias de comandos básicas de Python en Dynamo for Revit. El ejercicio se centrará en el uso de los archivos y elementos de Revit, así como en la comunicación entre Revit y Dynamo.
Este es un método sencillo para recuperar los elementos doc, uiapp y app del archivo de Revit vinculado a la sesión de Dynamo. Es posible que los programadores que hayan trabajado antes en la API de Revit reconozcan los elementos de la lista de inspección. Si estos elementos no le resultan familiares, no hay problema; vamos a usar otros ejemplos en los ejercicios siguientes.
A continuación, se indica cómo vamos a importar los servicios de Revit y recuperar los datos del documento en Dynamo.
Eche un vistazo al nodo de Python en Dynamo. También puede encontrar el código a continuación:
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 curva de modelo simple en Revit mediante el nodo de Dynamo Python.
Empiece creando una nueva familia de masas conceptuales en Revit.
Abra la carpeta de masas conceptuales y utilice el archivo de plantilla Metric Mass.rft.
En Revit, utilice el método abreviado de teclado un
para que se muestre la configuración de unidades del proyecto y cambie la unidad de longitud a metros.
Inicie Dynamo y cree el conjunto de nodos de la imagen siguiente. Crearemos primero dos puntos de referencia en Revit a partir de los nodos de Dynamo.
Cree un bloque de código y asígnele el valor
"0;"
.Conecte este valor a un nodo ReferencePoint.ByCoordinates para las entradas X, Y y Z.
Cree tres controles deslizantes que vayan de -100 a 100 con un tamaño de paso de 1.
Conecte cada control deslizante a un nodo ReferencePoint.ByCoordinates.
Añada un nodo de Python al espacio de trabajo, haga clic en el botón "+" del nodo para añadir otra entrada y conecte los dos puntos de referencia en cada entrada. Abra el nodo de Python.
Eche un vistazo al nodo de Python en Dynamo. A continuación, se muestra el código completo.
System.Array: Revit necesita una matriz del sistema como entrada (en lugar de una lista de Python). Esta es solo una línea de código más, pero prestar atención a los tipos de argumentos facilitará la programación de Python en Revit.
En Dynamo, hemos creado dos puntos de referencia con una línea que los conecta mediante Python. Vamos a ir un poco más lejos en el siguiente ejercicio.
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.
Este es un ejercicio sencillo, pero hace hincapié en la conexión de los datos y la geometría de Revit con Dynamo y viceversa. Comencemos abriendo Revit-StructuralFraming.rvt. Una vez abierto, inicie Dynamo y abra el archivo Revit-StructuralFraming.dyn.
Este archivo de Revit es totalmente básico. Dos curvas de referencia: una dibujada en el nivel 1 y la otra dibujada en el nivel 2. Queremos llevar estas curvas a Dynamo y mantener una conexión activa.
En este archivo, tenemos un conjunto de nodos conectados a cinco entradas de un nodo de Python.
Nodos Select Model Element: pulse el botón de selección para cada uno de ellos y seleccione la curva correspondiente en Revit.
Code Block: mediante la sintaxis
0..1..#x;
, conecte un control deslizante de enteros que abarque de 0 a 20 en la entrada x. De este modo, se designa el número de vigas que se dibujarán entre las dos curvas.Structural Framing Types: en el menú desplegable, elija la viga por defecto W12x26.
Levels: seleccione "Level 1".
Este código de Python es un poco más denso, pero los comentarios del código describen lo que sucede en el proceso.
En Revit, tenemos una matriz de vigas que abarca las dos curvas como elementos estructurales. Nota: Este no es un ejemplo realista; los elementos estructurales se utilizan como ejemplo de ejemplares nativos de Revit creados a partir de Dynamo.
En Dynamo, también podemos ver los resultados. Las vigas del nodo Watch3D hacen referencia a la geometría consultada desde los elementos de Revit.
Observe que existe un proceso continuo de traslación de datos del entorno de Revit al entorno de Dynamo. En resumen, así es como se desarrolla el proceso:
Se selecciona el elemento de Revit.
Se convierte el elemento de Revit en curva de Dynamo.
Se divide la curva de Dynamo en una serie de puntos de Dynamo.
Se utilizan los puntos de Dynamo entre dos curvas para crear líneas de Dynamo.
Se crean vigas de Revit mediante referencias a líneas de Dynamo.
Se generan superficies de Dynamo mediante una consulta sobre la geometría de las vigas de Revit.
Esto puede parecer un poco pesado, pero la secuencia de comandos hace que sea tan sencillo como editar la curva en Revit y volver a ejecutar el solucionador (aunque es posible que deba suprimir las vigas anteriores al hacerlo). Esto se debe al hecho de que hemos colocado vigas en Python, lo que rompe la asociación que tienen los nodos OOTB.
Con una actualización de las curvas de referencia de Revit, obtenemos una nueva matriz de vigas.
¿De qué color es la manzana?
Manazana.color
rojo
¿Está madura la manzana?
Manzana.madura
verdadero
¿Cuánto pesa la manzana?
Manzana.peso
170 g
¿De dónde viene la manzana?
Manzana.padre
árbol
¿Qué crea la manzana?
Manzana.hijo
semillas
¿Esta manzana se producido de forma local?
Manzana.distanciaDeHuerta
96 km
Con: | Superficie | Curva | Plano | Sólido |
Superficie | Curva | Punto | Punto, curva | Superficie |
Curva | Punto | Punto | Punto | Curva |
Plano | Curva | Punto | Curva | Curva |
Sólido | Superficie | Curva | Curva | Sólido |
Los métodos Intersect, Trim y SelectTrim se utilizan principalmente en geometrías dimensionales inferiores como puntos, curvas y superficies. Por otra parte, la geometría sólida cuenta con un conjunto adicional de métodos para modificar la forma después de su creación, tanto sustrayendo material de forma similar a Trim como combinando elementos para formar un todo mayor.
El método Union utiliza dos objetos sólidos para crear un único objeto sólido a partir del espacio cubierto por ambos objetos. El espacio solapado entre los objetos se combina en la forma final. Este ejemplo combina una esfera y un cubo en una forma de esfera-cubo sólida:
El método Difference, al igual que Trim, resta el contenido del sólido de la herramienta de entrada del sólido base. En este ejemplo, se extrae una pequeña hendidura de una esfera:
El método Intersect devuelve el sólido solapado entre dos entradas sólidas. En el siguiente ejemplo, Difference se ha cambiado a Intersect y el sólido resultante es el vacío que falta que se ha eliminado inicialmente:
Python es un lenguaje de programación muy utilizado cuya popularidad tiene mucho que ver con su estilo de sintaxis. Es altamente legible, lo que hace que su aprendizaje sea más sencillo que el de muchos otros idiomas. Python admite módulos y paquetes, y se puede incrustar en aplicaciones existentes. Para obtener información sobre cómo empezar a trabajar con Python, un buen recurso es la página "Getting Started" (Guía de introducción) de Python.org.
En los diseños computacionales, las curvas y las superficies se utilizan con frecuencia como el andamiaje subyacente para crear la geometría posterior. Para que esta geometría inicial se pueda utilizar como base para la geometría posterior, la secuencia de comandos debe poder extraer cualidades como, por ejemplo, la posición y la orientación en toda el área del objeto. Tanto las curvas como las superficies admiten esta extracción y este proceso se denomina parametrización.
Todos los puntos de una curva se pueden considerar como si tuvieran un parámetro único que oscila entre 0 y 1. Si creáramos una NurbsCurve a partir de varios puntos de control o interpolación, el primer punto tendría el parámetro 0 y el último, el parámetro 1. Es imposible saber por adelantado cuál es el parámetro exacto para cualquier punto intermedio, lo que puede parecer una limitación grave, aunque se mitiga mediante una serie de funciones de utilidad. Las superficies tienen una parametrización similar a la de las curvas, aunque con dos parámetros en lugar de uno, denominados u y v. Si creáramos una superficie con los siguientes puntos:
p1 tendría el parámetro u = 0 v = 0, mientras que p9 tendría los parámetros u = 1 v = 1.
La parametrización no resulta especialmente útil a la hora de determinar los puntos utilizados para generar curvas. Su principal finalidad es determinar las ubicaciones si se utilizan los puntos intermedios generados por los constructores NurbsCurve y NurbsSurface.
Las curvas presentan el método PointAtParameter, que utiliza un único argumento doble entre 0 y 1, y devuelve el objeto de punto en ese parámetro. Por ejemplo, esta secuencia de comandos busca los puntos en los parámetros 0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 y 1:
De forma similar, las superficies presentan el método PointAtParameter, que utiliza dos argumentos, el parámetro u y v del punto generado.
Aunque la extracción de puntos individuales en una curva y una superficie puede ser útil, a menudo, es necesario que las secuencias de comandos conozcan las características geométricas específicas de un parámetro, como la dirección hacia la que está orientada la curva o la superficie. El método CoordinateSystemAtParameter no solo busca la posición, sino un CoordinateSystem orientado en el parámetro de una curva o una superficie. Por ejemplo, el siguiente archivo de comandos extrae objetos CoordinateSystem orientados a lo largo de una superficie de revolución y utiliza la orientación de los objetos CoordinateSystem para generar líneas que permanecen en la dirección normal a la superficie:
Como se ha mencionado anteriormente, la parametrización no siempre es uniforme a lo largo de una curva o una superficie, lo que significa que el parámetro 0.5 no siempre se corresponde con el punto medio y 0.25 no siempre se corresponde con el punto un cuarto a lo largo de una curva o una superficie. Para evitar esta limitación, las curvas presentan un conjunto adicional de comandos de parametrización que permiten buscar un punto en longitudes específicas a lo largo de una curva.
Las siguientes secuencias de comandos de Python generan matrices de puntos para varios ejemplos. Se deben pegar en un nodo Python Script, como se indica a continuación:
python_points_1
python_points_2
python_points_3
python_points_4
python_points_5
¿Por qué habría que utilizar la programación textual en el entorno de programación visual de Dynamo? La programación visual tiene muchas ventajas. Permite crear programas sin necesidad de aprender sintaxis especial en una interfaz visual intuitiva. Sin embargo, un programa visual se puede sobrecargar y, a veces, su funcionalidad puede ser reducida. Por ejemplo, Python ofrece métodos mucho más eficaces para escribir instrucciones condicionales (if/then) y bucles. Python es una potente herramienta que permite ampliar las funciones de Dynamo y reemplazar muchos nodos por unas pocas líneas de código concisas.
Programa visual:
Programa textual:
Al igual que los bloques de código, los nodos de Python son una interfaz de secuencias de comandos dentro de un entorno de programación visual. El nodo de Python se encuentra en la biblioteca, en Secuencias de comandos > Editor > Secuencia de comandos de Python.
Al hacer doble clic en el nodo, se abre el editor de secuencias de comandos de Python (también puede hacer clic con el botón derecho en el nodo y seleccionar Editar). Observará que aparece texto modelo en la parte superior como ayuda para hacer referencia a las bibliotecas necesarias. Las entradas se almacenan en la matriz IN. Los valores se devuelven a Dynamo asignándolos a la variable OUT.
La biblioteca Autodesk.DesignScript.Geometry permite utilizar la notación de puntos como ocurre con los bloques de código. Para obtener más información sobre la sintaxis de Dynamo, consulte https://github.com/DynamoDS/DynamoPrimerNew/blob/master-esp/coding-in-dynamo/7_code-blocks-and-design-script/7-2_design-script-syntax.md y la Guía de DesignScript (Para descargar este documento PDF, haga clic con el botón derecho en el vínculo y seleccione "Guardar vínculo como"). Al escribir un tipo de geometría como, por ejemplo, "Point.", se muestra una lista de métodos para crear y consultar puntos.
Los métodos incluyen constructores como ByCoordinates, acciones como Add y consultas como las coordenadas X, Y y 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 ejemplo, vamos a escribir una secuencia de comandos de Python que crea patrones a partir de un módulo sólido y lo vamos a convertir en un nodo personalizado. Vamos a crear primero nuestro módulo sólido mediante nodos de Dynamo.
Rectangle.ByWidthLength: cree un rectángulo que será la base del sólido.
Surface.ByPatch: conecte el rectángulo con la entrada "closedCurve" para crear la superficie inferior.
Geometry.Translate: conecte el rectángulo a la entrada "geometry" para desplazarlo hacia arriba y utilice un bloque de código para especificar el grosor de base del sólido.
Polygon.Points: consulte el rectángulo trasladado para extraer los puntos de esquina.
Geometry.Translate: utilice un bloque de código para crear una lista de cuatro valores correspondientes a los cuatro puntos y traslade una esquina del sólido hacia arriba.
Polygon.ByPoints: utilice los puntos trasladados para reconstruir el polígono superior.
Surface.ByPatch: conecte el polígono para crear la superficie superior.
Ahora que tenemos las superficies superior e inferior, solevaremos los dos perfiles para crear los lados del sólido.
List.Create: conecte el rectángulo inferior y el polígono superior a las entradas de índice.
Surface.ByLoft: soleve los dos perfiles para crear los lados del sólido.
List.Create: conecte las superficies superior, lateral e inferior a las entradas de índice para crear una lista de superficies.
Solid.ByJoinedSurfaces: una las superficies para crear el módulo sólido.
Ahora que ya tenemos el sólido, soltaremos un nodo de secuencia de comandos de Python en el espacio de trabajo.
Para añadir entradas adicionales al nodo, haga clic en el icono + del nodo. Las entradas se denominan IN[0], IN[1] y así sucesivamente para indicar que representan elementos de una lista.
Empezaremos definiendo las entradas y la salida. Haga doble clic en el nodo para abrir el editor de Python. Siga el código mostrado a continuación para modificarlo en el editor.
Este código cobrará más sentido a medida que avancemos en el ejercicio. A continuación, debemos pensar en qué información se requiere para disponer la matriz de nuestro módulo sólido. En primer lugar, es necesario conocer las dimensiones del sólido para determinar la distancia de traslación. Debido a un error del cuadro delimitador, tendremos que utilizar la geometría de curva de borde para crear un cuadro delimitador.
Eche un vistazo al nodo de Python en Dynamo. Observe que estamos utilizando la misma sintaxis que vemos en los títulos de los nodos de Dynamo. Eche un vistazo al código comentado que aparece a continuación.
Ya que vamos a trasladar y girar los módulos sólidos, vamos a utilizar la operación Geometry.Transform. Al observar el nodo Geometry.Transform, vemos que vamos a necesitar un sistema de coordenadas de origen y un sistema de coordenadas de destino para transformar el sólido. El origen es el sistema de coordenadas de contexto del sólido, mientras que el destino será un sistema de coordenadas diferente para cada módulo de matriz. Esto significa que tendremos que crear un bucle a través de los valores de X e Y para transformar el sistema de coordenadas de forma diferente en cada caso.
Haga clic en Ejecutar y, a continuación, guarde el código. Conecte el nodo de Python con la secuencia de comandos existente como se indica a continuación.
Conecte la salida de Solid.ByJoinedSurfaces como la primera entrada para el nodo de Python y utilice un bloque de código para definir las demás entradas.
Cree un nodo Topology.Edges y utilice la salida del nodo de Python como entrada.
Por último, cree un nodo Edge.CurveGeometry y utilice la salida de Topology.Edges como entrada.
Pruebe a cambiar el valor de semilla para crear patrones diferentes. También puede cambiar los parámetros del módulo sólido para obtener distintos efectos.
Ahora que hemos creado una secuencia de comandos de Python útil, vamos a guardarla como un nodo personalizado. Seleccione el nodo de la secuencia de comandos de Python, haga clic con el botón derecho en el espacio de trabajo y seleccione "Crear nodo personalizado".
Asigne un nombre, una descripción y una categoría.
Se abrirá un nuevo espacio de trabajo en el que se puede editar el nodo personalizado.
Inputs: cambie los nombres de las entradas para que sean más descriptivos y añada tipos de datos y valores por defecto.
Output: cambie el nodo de la salida.
Guarde el nodo como un archivo .dyf; debería ver que el nodo personalizado refleja los cambios que acabamos de realizar.
Antes de este capítulo, en el manual de introducción, se describe cómo implementar las eficaces funciones de creación de secuencias de comandos visuales de Dynamo. Un conocimiento exhaustivo de estas funciones constituye una base sólida y el primer paso para la creación de programas visuales potentes. Cuando utilizamos los programas visuales sobre el terreno, los compartimos con compañeros, solucionamos errores o probamos los límites, nos encontraremos con problemas adicionales que deberemos afrontar. Si otra persona va a utilizar el programa o espera abrirlo dentro de seis meses, este debe tener una claridad gráfica y lógica inmediata. Dynamo dispone de numerosas herramientas para gestionar la complejidad del programa y, en este capítulo, se proporcionan las directrices para utilizarlas.
A medida que desarrolla el gráfico de Dynamo y prueba sus ideas, su tamaño y su complejidad pueden aumentar rápidamente. Aunque es importante crear un programa que funcione, es igualmente importante hacerlo lo más sencillo posible. No solo el gráfico se ejecutará de forma más rápida y predecible, sino que además usted y los demás usuarios entenderán su lógica más adelante. A continuación, se incluyen varias formas que le ayudarán a aclarar la lógica del gráfico.
Los grupos permiten crear partes con diferentes funciones a medida que se genera un programa
Los grupos permiten desplazar grandes partes del programa sin perder la modularidad y la alineación
Puede cambiar el color del grupo para diferenciar su finalidad (entradas y funciones)
Puede utilizar grupos para empezar a organizar el gráfico a fin de simplificar la creación de nodos personalizados.
Los colores de este programa identifican la finalidad de cada grupo. Esta estrategia se puede utilizar para crear una jerarquía en cualquier norma o plantilla gráficas que desarrolle.
Grupo de funciones (azul)
Grupo de entradas (naranja)
Grupo de secuencias de comandos (verde)
Para obtener información sobre cómo utilizar los grupos, consulte Administración del programa.
En ocasiones, se puede utilizar un bloque de código para escribir un método de nodo o número de forma más rápida que con la búsqueda (Point.ByCoordinates, Number, String y Formula).
Los bloques de código son útiles cuando se desean definir funciones personalizadas en DesignScript para reducir el número de nodos de un gráfico.
Los ejemplos 1 y 2 realizan la misma función. Se tardó mucho menos en escribir unas pocas líneas de código que en buscar y añadir cada nodo individualmente. El bloque de código también es mucho más conciso.
DesignScript escrito en bloques de código
Programa equivalente en nodos
Para obtener información sobre cómo utilizar el bloque de código, consulte ¿Qué es un bloque de código?.
Puede reducir la complejidad de un gráfico mediante el método de nodo a código, que utilizará una colección de nodos sencillos y escribirá la secuencia DesignScript correspondiente en un único bloque de código.
El método de nodo a código** permite condensar código sin que el programa pierda claridad**.
A continuación, se indican las ventajas de utilizar el método de nodo a código:
Condensa el código fácilmente en un componente que aún puede editarse.
Puede simplificar una parte significativa del gráfico.
Es útil si no se modifica con frecuencia el "miniprograma".
Permite incorporar otras características de bloque de código, como las funciones.
A continuación, se indican las desventajas de utilizar el método de nodo a código:
La asignación de nombres genéricos reduce su facilidad de lectura.
Es más difícil de comprender para otros usuarios.
No hay una forma sencilla de volver a la versión de programación visual.
Programa existente
Bloque de código creado con el método de nodo a código
Para obtener información sobre cómo utilizar el método de nodo a código, consulte Sintaxis de DesignScript.
El uso de List@Level puede ayudarle a reducir la complejidad del gráfico mediante la sustitución de los nodos List.Map y List.Combine, que pueden ocupar una cantidad considerable de espacio en el lienzo.
List@Level proporciona un** método más rápido que List.Map/List.Combine para crear una lógica de nodo**, lo que permite acceder a los datos de cualquier nivel de una lista directamente desde el puerto de entrada de un nodo
Podemos comprobar cuántos valores devuelve True BoundingBox.Contains y en qué listas mediante la activación de List@Level para la entrada "list" de CountTrue. List@Level permite al usuario determinar de qué nivel se obtendrán los datos. El uso de List@Level es flexible, eficaz y muy recomendado frente a otros métodos en los que se utilizan List.Map y List.Combine.
Recuento de valores "true" (verdaderos) en el nivel de lista 2
Recuento de valores "true" (verdaderos) en el nivel de lista 3
Para obtener información sobre cómo utilizar List@Level, consulte Listas de listas.
Además de conseguir que el gráfico sea lo más sencillo y eficaz posible, intente lograr una claridad gráfica. A pesar de hacer todo lo posible para que el gráfico sea intuitivo con agrupaciones lógicas, es posible que las relaciones no sean evidentes a simple vista. Una sencilla nota dentro de un grupo o el cambio de nombre de un control deslizante puede ahorrarle a usted u otro usuario confusión innecesaria o tener que desplazarse por el gráfico. A continuación, se describen varias formas que le ayudarán a aplicar coherencia dentro de los gráficos y entre ellos.
Para reducir el trabajo después de terminar de generar el gráfico, debe intentar asegurarse de que el diseño del nodo sea legible mediante la alineación de los nodos con frecuencia y a medida que progresa.
Si otros van a trabajar con el gráfico, asegúrese de que el diseño de cables y nodos fluya con facilidad antes de enviarlo.
Para facilitar la alineación, utilice la función "Presentación de nodo de limpieza" para alinear automáticamente el gráfico, aunque de forma menos precisa que manualmente.
Gráfico desorganizado
Gráfico alineado
Para obtener información sobre cómo utilizar la alineación de nodos, consulte Administración del programa.
El cambio de nombre de las entradas puede ayudar a otros a comprender más fácilmente el gráfico, sobre todo, si los elementos a los que se van a conectar no aparecen en la pantalla.
Tenga cuidado de no cambiar el nombre de los nodos que no sean entradas. Una alternativa a esto es crear un nodo personalizado a partir de un clúster de nodos y cambiarle el nombre; se comprenderá que contiene otro elemento.
Entradas para la manipulación de superficies
Entradas para los parámetros arquitectónicos
Entradas para la secuencia de comandos de simulación de drenaje
Para cambiar el nombre de un nodo, haga clic con el botón derecho en su nombre y seleccione "Cambiar nombre de nodo".
Debe añadir una nota si alguna parte del gráfico requiere una explicación en lenguaje sencillo que los nodos no pueden expresar.
Debe añadir una nota si un conjunto de nodos o un grupo son demasiado grandes o complejos y no se pueden entender al instante.
Una nota que describe la parte del programa que devuelve distancias de traslado sin procesar.
Una nota que describe el código que asigna esos valores a una onda sinusoidal.
Para obtener información sobre cómo añadir una nota, consulte Administración del programa.
Al crear la secuencia de comandos visual, es importante comprobar que se devuelve lo que se esperaba. No todos los errores o los problemas provocarán que el programa falle inmediatamente, sobre todo, los valores nulos o cero que podrían afectar a niveles inferiores. Esta estrategia también se aborda en el contexto de la creación de secuencias de comandos de texto en las Estrategias de creación de secuencias de comandos. El siguiente procedimiento le ayudará a asegurarse de que obtiene lo que esperaba.
Utilice las burbujas de visualización y vista preliminar al crear el programa para** comprobar que las salidas clave devuelvan lo que esperaba**.
Los nodos de visualización se utilizan para comparar:
Las distancias de traslado sin procesar.
Los valores que se transfieren a través de la ecuación de seno.
Para obtener información sobre cómo utilizar la visualización, consulte Biblioteca.
Es muy probable que otro usuario abra el programa en algún momento, incluso aunque trabaje de forma independiente. Este debería poder comprender rápidamente lo que el programa necesita y genera a partir de sus entradas y salidas. Esto es especialmente importante cuando se desarrolla un nodo personalizado que se compartirá con la comunidad de Dynamo y se utilizará en el programa de otro usuario. Estos procedimientos generan programas y nodos fiables y reutilizables.
Para garantizar la legibilidad y la escalabilidad, debe probar y minimizar las entradas y las salidas lo máximo posible.
Debe intentar elaborar una estrategia de creación de la lógica mediante la elaboración inicial de un esquema aproximado de cómo puede funcionar la lógica antes de añadir un único nodo al lienzo. A medida que desarrolle el esquema aproximado, debe realizar un seguimiento de las entradas y las salidas que se incluirán en las secuencias de comandos.
Si desea insertar en el gráfico condiciones u opciones específicas, debe utilizar valores predefinidos para acceder a ellos rápidamente.
También puede utilizar valores predefinidos para reducir la complejidad mediante el almacenamiento en caché de los valores de controles deslizantes de un gráfico con tiempos de ejecución prolongados.
Para obtener información sobre cómo utilizar los valores predefinidos, consulte Administración de datos con valores predefinidos.
Debe utilizar un nodo personalizado si el programa se puede agrupar en un único contenedor.
Debe utilizar un nodo personalizado si una parte del gráfico se reutilizará a menudo en otros programas.
Debe utilizar un nodo personalizado si desea compartir una función con la comunidad de Dynamo.
La recopilación del programa de traslado de puntos en un nodo personalizado consigue que un programa potente y exclusivo sea más fácil de comprender. Los puertos de entrada con nombres adecuados ayudarán a otros usuarios a comprender cómo utilizar el nodo. No olvide añadir descripciones y los tipos de datos necesarios para cada entrada.
Programa de atractor existente.
Nodo personalizado que recopila este programa, PointGrid.
Para obtener información sobre cómo utilizar nodos personalizados, consulte Introducción a los nodos personalizados.
Puede crear plantillas para establecer normas gráficas en todos los gráficos visuales a fin de garantizar que los colaboradores dispongan de una forma normalizada de comprender el gráfico.
Al crear una plantilla, puede normalizar los colores de grupo y los tamaños de tipo de letra para organizar en categorías los flujos de trabajo o las acciones de datos.
Al crear una plantilla, puede incluso normalizar el modo en que desea utilizar una etiqueta, un color o un estilo para indicar la diferencia entre los flujos de trabajo front-end y back-end del gráfico.
La interfaz de usuario, o front-end, del programa incluye un nombre de proyecto, controles deslizantes de entrada y geometría de importación.
El back-end del programa.
Categorías de colores de grupo (el diseño general, las entradas, las secuencias de comandos de Python y la geometría importada).
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.
Ahora que hemos establecido algunos procedimientos recomendados, vamos a aplicarlos a un programa que hemos creado rápidamente. Aunque el programa genera correctamente la cubierta, el estado del gráfico es un "mapa mental" del autor. Carece de organización o una descripción de su uso. Recorreremos los procedimientos recomendados para organizar, describir y analizar el programa a fin de que otros usuarios puedan comprender cómo utilizarlo.
El programa funciona, pero el gráfico está desorganizado.
Comencemos por determinar los datos y la geometría devueltos por el programa.
Es crucial comprender cuándo se producen cambios importantes en los datos para establecer divisiones lógicas o modularidad. Pruebe a inspeccionar el resto del programa con nodos de visualización para ver si se pueden determinar los grupos antes de pasar al siguiente paso.
Este bloque de código con una ecuación matemática parece una parte crucial del programa. Un nodo Watch indica que se devuelven listas de distancias de traslado.
La finalidad de esta área no es evidente a simple vista. La disposición de los valores "True" (verdadero) en el nivel de lista L2 de BoundingBox.Contains y la presencia de List.FilterByBoolMask sugiere que se están obteniendo muestras de una parte de la rejilla de puntos.
Una vez que entendemos las partes elementales del programa, organicémoslas en grupos.
Los grupos permiten al usuario diferenciar visualmente las partes del programa.
Importar el modelo de emplazamiento 3D.
Trasladar la rejilla de puntos en función de la ecuación de seno.
Obtener muestra de la rejilla de puntos.
Crear una superficie de cubierta arquitectónica.
Crear un muro cortina de vidrio.
Con los grupos establecidos, alinee los nodos para crear continuidad visual en el gráfico.
La continuidad visual ayuda al usuario a ver el flujo del programa y las relaciones implícitas entre nodos.
Consiga que el programa sea más accesible mediante la adición de otra capa de mejoras gráficas. Añada notas para describir cómo funciona un área específica del programa, proporcione nombres personalizados a las entradas y asigne colores a los distintos tipos de grupos.
Estas mejoras gráficas permiten al usuario obtener más información sobre lo que realiza el programa. Los diferentes colores de grupo ayudan a distinguir las entradas de las funciones.
Notas
Entradas con nombres descriptivos
Antes de empezar a condensar el programa, busquemos una ubicación estratégica para introducir el simulador de drenaje de la secuencia de comandos de Python. Conecte la salida de la primera superficie de cubierta a escala con la entrada de secuencias de comandos respectiva.
Hemos optado por integrar secuencias de comandos en este punto del programa para que la simulación de drenaje pueda ejecutarse en la superficie de cubierta original. No se está previsualizando esa superficie específica, pero esto nos evita tener que elegir la superficie superior de la PolySurface achaflanada.
Geometría de origen para la entrada de secuencia de comandos
Nodo de Python
Controles deslizantes de entrada
"Conmutador" de activación/desactivación
Ahora que todo está en su lugar, vamos a simplificar el gráfico.
La condensación del programa con el método de nodo a código y el nodo personalizado ha reducido considerablemente el tamaño del gráfico. Los grupos que crean la superficie de cubierta y los muros se han convertido en código, ya que son muy específicos de este programa. El grupo de traslado de puntos se encuentra en un nodo personalizado, ya que podría utilizarse en otro programa. En el archivo de ejemplo, cree su propio nodo personalizado a partir del grupo de puntos de traslado.
Nodo personalizado que contiene el grupo de "rejilla de puntos de traslado".
Método de nodo a código para condensar los grupos de "crear superficie de cubierta arquitectónica y muro cortina".
Como paso final, cree valores predefinidos para formas de cubierta de ejemplo.
Estas entradas son los controladores principales de la forma de cubierta y ayudarán a los usuarios a ver el potencial del programa.
Nuestro programa con vistas de dos valores predefinidos.
Los patrones de drenaje de la cubierta proporcionan al usuario una vista analítica de los valores predefinidos respectivos.
Esta parte del manual de introducción se ha organizado como un diario de "prácticas recomendadas". Ofrece información sobre varias estrategias que hemos aprendido a través de la experiencia y la investigación para ser más favorables a los flujos de trabajo paramétricos de calidad. Como diseñadores y programadores, nuestro indicador de calidad se basa principalmente en la capacidad de mantenimiento, fiabilidad, facilidad de uso y eficacia de nuestras herramientas. Aunque estas prácticas recomendadas presentan ejemplos específicos para secuencias de comandos visuales o basadas en texto, los principios se aplican a todos los entornos de programación y pueden informar de muchos flujos de trabajo computacionales.
Esta página de referencia amplía las prácticas recomendadas incluidas en las estrategias de creación de secuencias de comandos con más detalles sobre las bibliotecas de códigos, el etiquetado y la aplicación de estilos. Utilizaremos Python para ilustrar los conceptos que se indican a continuación; no obstante, tenga en cuenta que se aplican los mismos principios en Python y C#(Zerotouch), solo que con una sintaxis diferente.
Las bibliotecas estándar son externas a Dynamo y están presentes en los lenguajes de programación Python y C# (Zerotouch). Dynamo también tiene su propio conjunto de bibliotecas que corresponden directamente con su jerarquía de nodos, lo que permite al usuario crear mediante código cualquier elemento que se pueda crear con nodos y líneas. A continuación, se muestra una guía sobre los elementos a los que cada biblioteca de Dynamo proporciona acceso y cuándo utilizar una biblioteca estándar.
Bibliotecas estándar y bibliotecas de Dynamo
Las bibliotecas estándar de Python y C# se pueden utilizar para generar datos avanzados y estructuras de flujo en el entorno de Dynamo.
Las bibliotecas de Dynamo se corresponden directamente con la jerarquía de nodos para crear geometría y otros objetos de Dynamo.
Bibliotecas de Dynamo
ProtoGeometry*
Funciones: Arco, Cuadro delimitador, Círculo, Cono, Sistema de coordenadas, Cubo, Curva, Cilindro, Borde, Elipse, Arco de elipse, Cara, Geometría, Hélice, Grupo de índice, Línea, Malla, Curva Nurbs, Superficie Nurbs, Plano, Punto, Polígono, Rectángulo, Sólido, Esfera, Superficie, Topología, T-Spline, UV, Vector, Vértice.
Cómo importar: import Autodesk.DesignScript.Geometry
``
DSCoreNodes
Funciones: Color, Rango de colores 2D, Fecha y hora, Intervalo de tiempo, IO, Fórmula, Lógica, Lista, Matemáticas, Árbol cuádruple, Cadena, Rosca.
Cómo importar: import DSCore
Teselación
Funciones: Rejilla convexa, Delaunay, Voronoi.
Cómo importar: import Tessellation
DSOffice
Función: Excel.
Cómo importar: import DSOffice
Nota: Tenga en cuenta que, al utilizar ProtoGeometry a través de Python o C#, se crean objetos no administrados, que requieren que la memoria se administre manualmente. Consulte la sección Objetos no administrados mostrada a continuación para obtener más información.
Durante la creación de secuencias de comandos, utilizamos constantemente identificadores para indicar elementos como variables, tipos, funciones y otras entidades. A través de este sistema de notación simbólica, podemos hacer referencia cómodamente a la información mediante etiquetas (normalmente compuestas por una secuencia de caracteres) mientras creamos los algoritmos. En la escritura de código, una correcta denominación de los elementos es importante para que este se pueda leer y entender con facilidad por parte de otras personas y por usted mismo en un momento posterior. A continuación se indican algunos consejos que se deben tener en cuenta al asignar nombres a los elementos de su secuencia de comandos:
Está bien utilizar abreviaturas, pero explique la abreviatura con un comentario:
Evite el etiquetado redundante:
Utilice lógica positiva para los nombres de las variables, en lugar de lógica negativa:
Dé preferencia a la "notación inversa":
Es más apropiado en términos estructurales.
Los alias se deben utilizar para acortar cadenas demasiado largas y a menudo repetidas:
El uso de alias puede generar rápidamente programas muy confusos y no estándares.
Utilice solo las palabras necesarias:
"Todo debe hacerse tan simple como sea posible, pero no más". – Albert Einstein
Por lo general, hay más de una manera de programar prácticamente cualquier cosa, por lo que su "estilo personal" de crear secuencias de comandos es el resultado de las innumerables pequeñas decisiones que usted toma (o no toma) a lo largo del camino. Dicho esto, la legibilidad y las posibilidades de mantenimiento del código son resultado directo de su coherencia interna, así como del cumplimiento de las convenciones estilísticas generales. Como regla general, el código que tiene el mismo aspecto en dos lugares diferentes, también debería funcionar de la misma manera. A continuación, se ofrecen algunos consejos para escribir código claro y coherente.
Convenciones para los nombres: (elija una de las convenciones siguientes para cada tipo de entidad del código y úsela siempre)
Variables, funciones, métodos, paquetes y módulos:
lower_case_with_underscores
Clases y excepciones:
CapWords
Métodos protegidos y funciones internas:
_single_leading_underscore(self, ...)
Métodos privados:
__double_leading_underscore(self, ...)
Constantes:
ALL_CAPS_WITH_UNDERSCORES
Consejo: Evite las variables de una sola letra (especialmente, l, O, I) excepto en bloques muy cortos, cuando el significado es claramente visible desde el contexto inmediato.
Uso de líneas en blanco:
Rodee las definiciones de clase y función de nivel superior con dos líneas en blanco.
Las definiciones de método dentro de una clase se rodean con una sola línea en blanco.
Se pueden utilizar líneas en blanco adicionales (con moderación) para separar grupos de funciones relacionadas.
Evite los espacios innecesarios:
Inmediatamente después de paréntesis, corchetes o llaves:
Inmediatamente antes de coma, punto y coma o dos puntos:
Inmediatamente antes del paréntesis de apertura que inicia la lista de argumentos de una llamada de función:
Inmediatamente antes del paréntesis de apertura que inicia una indexación o un fragmento:
Rodee siempre estos operadores binarios con un solo espacio a cada lado:
Vigile la longitud de las líneas:
No las alargue más allá de aproximadamente 79 caracteres.
La limitación de la anchura necesaria en la ventana del editor permite tener varios archivos abiertos en paralelo y posibilita el correcto funcionamiento de las herramientas de revisión de código que presentan las dos versiones en columnas adyacentes.
Las líneas largas se pueden dividir en varias líneas encerrando las expresiones entre paréntesis:
Evite los comentarios obvios y redundantes:
En algunos casos, se requieren menos comentarios para obtener un código más legible. Especialmente si ello le obliga a utilizar nombres de símbolo significativos en lugar de descripciones.
La adopción de buenos hábitos de codificación reduce la dependencia de los comentarios:
Consejo: Los comentarios indican por qué y el código indica cómo.
Tenga en cuenta el código abierto:
Los proyectos de código abierto se basan en los esfuerzos colaborativos de muchos desarrolladores. Estos proyectos necesitan mantener un alto nivel de legibilidad del código para que el equipo pueda trabajar en conjunto de la forma más eficiente posible. Por lo tanto, es recomendable examinar el código fuente de estos proyectos para observar lo que hacen estos desarrolladores.
Mejore las convenciones:
Pregúntese si cada una de las convenciones funciona o no para las necesidades en cuestión.
¿Se está poniendo en peligro la funcionalidad/eficiencia?
Consulte estas páginas wiki para obtener instrucciones sobre cómo escribir C# para Zerotouch y contribuir con Dynamo:
Este wiki describe algunas normas de codificación generales para documentar y probar el código: https://github.com/DynamoDS/Dynamo/wiki/Coding-Standards.
Este wiki describe específicamente las normas de nomenclatura de bibliotecas, categorías, nombres de nodos, nombres de puertos y abreviaturas: https://github.com/DynamoDS/Dynamo/wiki/Naming-Standards.
Objetos no administrados:
Cuando se utiliza la biblioteca de geometría de Dynamo (ProtoGeometry) desde Python o C#, los objetos de geometría que se creen no se gestionarán mediante la máquina virtual, y la memoria de muchos de estos objetos deberá limpiarse manualmente. Para limpiar objetos nativos o no administrados, puede utilizar el método Dispose o la palabra clave using. Consulte esta entrada wiki para obtener una descripción general: https://github.com/DynamoDS/Dynamo/wiki/Zero-Touch-Plugin-Development#dispose—using-statement.
Solo es necesario eliminar los recursos no administrados que no se devuelvan al gráfico y los que no almacenan una referencia. En el resto de esta sección, nos referiremos a estos objetos como geometría intermedia. Puede ver un ejemplo de esta clase de objeto en el código siguiente. La función de Zero Touch C# singleCube devuelve un único cubo, pero crea 10 000 cubos adicionales durante su ejecución. Podemos fingir que esta otra geometría se ha utilizado como geometría de construcción intermedia.
Es muy probable que esta función de Zero Touch bloquee Dynamo. Esto se debe a que hemos creado 10 000 sólidos, pero solo hemos almacenado uno de ellos y solo hemos devuelto ese mismo. Deberíamos desechar todos los cubos intermedios, excepto el que devolvemos. No debemos desechar lo que devolvemos, ya que se propaga en el gráfico y lo utilizan otros nodos.
El código fijo tendría un aspecto similar al siguiente:
Por lo general, solo es necesario eliminar geometría como Surfaces
, Curves
y Solids
. No obstante, por seguridad, puede eliminar todos los tipos de geometría (Vectors
, Points
y CoordinateSystems
).
Con Dynamo 2.0, podemos especificar una plantilla por defecto (.py extension)
para utilizarla al abrir la ventana de Python por primera vez. Esta ha sido una petición deseada durante mucho tiempo, ya que agiliza el uso de Python en Dynamo. La capacidad de utilizar una plantilla nos permite disponer de importaciones por defecto listas para usar cuando deseamos desarrollar una secuencia de comandos de Python personalizada.
Esta plantilla se encuentra en la ubicación APPDATA
de la instalación de Dynamo.
Por lo general, suele ser ( %appdata%\Dynamo\Dynamo Core\{version}\ )
.
Para utilizar esta función, debemos añadir la siguiente línea en el archivo DynamoSettings.xml
. (Edítelo en el Bloc de notas).
Cuando aparece <PythonTemplateFilePath />
, solo tenemos que sustituir esto por lo siguiente:
Nota: Sustituya CURRENTUSER por su nombre de usuario.
A continuación, debemos crear una plantilla con la funcionalidad integrada que deseamos utilizar. En este caso, insertaremos las importaciones relacionadas con Revit y algunos de los demás elementos habituales al trabajar con Revit.
Puede iniciar un documento del Bloc de notas en blanco y pegar el siguiente código:
Una vez hecho esto, guarde este archivo como PythonTemplate.py
en la ubicación APPDATA
.
Una vez que se haya definido la plantilla de Python, Dynamo la buscará cada vez que se coloque un nodo de Python. Si no se encuentra, se mostrará la ventana de Python por defecto.
Si se encuentra la plantilla de Python (como, por ejemplo, nuestra plantilla de Revit), aparecerán todos los elementos por defecto integrados.
Aquí encontrará información adicional (de Radu Gidei) sobre esta excelente incorporación. https://github.com/DynamoDS/Dynamo/pull/8122
Trabajar en un proceso de programación visual puede ser una potente actividad creativa, pero en muy poco tiempo el flujo de programa y las entradas clave de usuario pueden verse eclipsados por la complejidad o la presentación del espacio de trabajo. Veamos algunos procedimientos recomendados para administrar el programa.
Una vez que hemos añadido varios nodos al espacio de trabajo, es posible que deseemos reorganizar el diseño de los nodos para obtener mayor claridad. Al seleccionar más de un nodo y hacer clic con el botón derecho en el espacio de trabajo, la ventana emergente incluye un menú Alinear selección con opciones de justificación y distribución en X e Y.
Seleccione varios nodos.
Haga clic con el botón derecho en el espacio de trabajo.
Utilice las opciones de Alinear selección.
Con cierta experiencia, es posible que podamos "leer" el programa visual revisando los nombres de nodo y siguiendo el flujo de programa. Para los usuarios de todos los niveles de experiencia, es recomendable también incluir etiquetas y descripciones en lenguaje sencillo. Para ello, Dynamo presenta un nodo Notes con un campo de texto editable. Podemos añadir notas al espacio de trabajo de dos formas:
Vaya al menú Editar > Crear nota.
Utilice el método abreviado de teclado Ctrl + W.
Una vez que se ha añadido la nota al espacio de trabajo, aparece un campo de texto que nos permite editar el texto de la nota. Una vez creada, se puede editar la nota. Para ello, haga doble clic o haga clic con el botón derecho en el nodo Note.
Cuando aumente el tamaño del programa visual, resultará útil identificar los pasos más grandes que se ejecutarán. Podemos resaltar conjuntos más grandes de nodos con un grupo para etiquetarlos con un rectángulo de color en el fondo y un título. Hay tres formas de crear un grupo con más de un nodo seleccionado, como se indica a continuación:
Vaya al menú Editar > Crear grupo.
Utilice el acceso directo de teclado Ctrl + G.
Haga clic con el botón derecho en el espacio de trabajo y seleccione Crear grupo.
Una vez creado un grupo, se pueden editar sus parámetros, como el título y el color.
Consejo: El uso de notas y grupos es una forma eficaz de anotar el archivo y aumentar la legibilidad.
A continuación, se muestra un ejemplo de programa con notas y grupos añadidos:
Nota: "Grid Parameters" (Parámetros de rejilla)
Nota: "Grid Points" (Puntos de rejilla)
Grupo: "Create a Grid of Points" (Crear una rejilla de puntos)
Grupo: "Create an Attractor Point" (Crear un punto de atractor)
Nota: "Calibrate Distance Values" (Calibrar valores de distancia)
Nota: "Variable Grid of Circles" (Rejilla variable de círculos)
Las secuencias de comandos basadas en texto en el entorno de creación de secuencias de comandos visual permite relaciones visuales y potentes mediante DesignScript, Python y ZeroTouch (C#). El usuario puede visualizar elementos como, por ejemplo, controles deslizantes de entrada, condensar operaciones grandes en DesignScript y acceder a herramientas y bibliotecas eficaces a través de Python o C# en el mismo espacio de trabajo. Si se administran de manera eficaz, la combinación de estas estrategias puede proporcionar una gran cantidad de personalización, claridad y eficacia a todo el programa. A continuación, se ofrece un conjunto de directrices para ayudarle a aumentar la secuencia de comandos visual con la secuencia de comandos de texto.
La creación de secuencias de comandos de texto puede establecer relaciones de una mayor complejidad que la programación visual, aunque sus funciones también se solapan considerablemente. Esto es así porque los nodos son código compilado previamente de forma eficaz y es probable que podamos escribir un programa de Dynamo completo en DesignScript o Python. Sin embargo, utilizamos la creación de secuencias de comandos visuales porque la interfaz de nodos y cables crea un flujo intuitivo de información gráfica. Saber dónde las funciones de creación de secuencias de comandos de texto superan a la creación de secuencias de comandos visuales le proporcionará importantes pistas sobre cuándo deben utilizarse sin renunciar a la naturaleza intuitiva de los nodos y los cables. A continuación, se proporcionan directrices sobre cuándo crear una secuencia de comandos y qué lenguaje se debe utilizar.
Utilice secuencias de comandos de texto para:
Creación de bucles
Repetición
Acceso a bibliotecas externas
Elija un lenguaje:
Consulte Referencia de secuencias de comandos para obtener una lista de los elementos a los que cada biblioteca de Dynamo proporciona acceso.
Al crear secuencias de comandos en Dynamo, un entorno inevitablemente paramétrico, es aconsejable estructurar el código en relación con la estructura de nodos y cables en los que se basará. Considere el nodo que contiene la secuencia de comandos de texto como si se tratara de cualquier otro nodo del programa con unas pocas entradas específicas, una función y una salida prevista. Esto proporciona al instante al código del nodo un conjunto de variables desde las que trabajar, la clave para obtener un sistema paramétrico limpio. A continuación, se proporcionan algunas directrices para una integración más eficaz del código en un programa visual.
Identifique las variables externas:
Intente determinar los parámetros especificados en el problema de diseño para que pueda construir un modelo que se base directamente en esos datos.
Antes de escribir el código, identifique las variables:
Un conjunto mínimo de entradas
La salida deseada
Constantes
Se han establecido varias variables antes de escribir el código.
La superficie en la que vamos a simular la lluvia.
El número de gotas de lluvia (agentes) que deseamos.
Hasta dónde deseamos que se desplacen las gotas de lluvia.
Alterne entre descender la ruta más escarpada o atravesar la superficie.
El nodo de Python con el número respectivo de entradas.
Un bloque de código para establecer en azul las curvas devueltas.
Diseñe las relaciones internas:
El uso de parámetros permite editar determinados parámetros o variables para manipular o modificar el resultado final de una ecuación o un sistema.
Siempre que las entidades de la secuencia de comandos estén relacionadas lógicamente, el objetivo es definirlas como funciones entre sí. De este modo, al modificar una, la otra se puede actualizar de forma proporcional.
Minimice el número de entradas visualizando solo los parámetros clave:
Si un conjunto de parámetros se puede derivar de más parámetros principales, solo se mostrarán los parámetros principales como entradas de la secuencia de comandos. Esto aumenta la facilidad de uso de la secuencia de comandos al reducir la complejidad de su interfaz.
El código "modules" del ejemplo de nodo de Python.
Entradas.
Variables internas de la secuencia de comandos.
Un bucle que utiliza estas entradas y variables para realizar su función.
Consejo: Céntrese tanto en el proceso como lo hace en la solución.
Cuando hay varias formas de expresar lo mismo en la secuencia de comandos, en algún momento, las representaciones duplicadas quedarán fuera de la sincronización, lo que puede llevar a problemas de mantenimiento, factorización incorrecta y contradicciones internas.
El principio de no repetición (DRY, Don't Repeat Yourself) se define como "Cada parte del conocimiento debe tener una representación única, sin ambigüedades y autorizada dentro de un sistema":
Si se aplica correctamente este principio, todos los elementos relacionados de la secuencia de comandos cambiarán de forma predecible y uniforme, y todos los elementos no relacionados no presentarán consecuencias lógicas entre sí.
Consejo: Antes de duplicar entidades en la secuencia de comandos (como la constante en el ejemplo anterior), pregúntese si puede establecer un vínculo con el origen en su lugar.
A medida que aumenta la longitud y la complejidad del código, la "gran idea" (o el algoritmo general) se vuelve cada vez más ilegible. También resulta más difícil realizar un seguimiento de los eventos y su ubicación, identificar errores cuando hay problemas, integrar otro código y asignar tareas de desarrollo. Para evitar estos problemas, es aconsejable escribir código en módulos, una estrategia organizativa que divide el código en función en la tarea que ejecuta. A continuación, se incluyen algunos consejos para que las secuencias de comandos sean más manejables a través de la modularización.
Escribir código en módulos:
Un "módulo" es un grupo de código que realiza una tarea específica, similar a un nodo de Dynamo en el espacio de trabajo.
Puede tratarse de cualquier elemento que se deba separar visualmente del código adyacente (una función, una clase, un grupo de entradas o las bibliotecas que se van a importar).
El desarrollo de código en módulos aprovecha la calidad visual e intuitiva de los nodos, así como las relaciones complejas que solo pueden obtenerse mediante secuencias de comandos de texto.
Estos bucles llaman a una clase denominada "agente" que desarrollaremos más detalladamente en el ejercicio.
Un módulo de código que define el punto inicial de cada agente.
Un módulo de código que actualiza el agente.
Un módulo de código que dibuja una trayectoria para la ruta del agente.
Detección de la reutilización de código:
Si detecta que el código realiza la misma tarea (o una muy similar) en más de una ubicación, busque formas de agruparlo en una función a la que se pueda llamar.
Las funciones de "administrador" controlan el flujo del programa y contienen principalmente llamadas a funciones de "trabajo" que gestionan detalles de bajo nivel, como desplazar datos entre estructuras.
En este ejemplo, se crean esferas con radios y colores basados en el valor Z de los centros.
Dos funciones principales de "trabajo": una que crea esferas con radios y colores de visualización en función del valor Z del centro.
Una función principal de "administrador" que combina las dos funciones de trabajo. Al llamar a esta, se llamará a las dos funciones incluidas en ella.
Muestre solo lo que se necesite ver:
Una interfaz de módulo indica los elementos que el módulo proporciona y necesita.
Una vez definidas las interfaces entre las unidades, el diseño detallado de cada unidad puede continuar por separado.
Capacidad de separación/sustitución:
Los módulos no se conocen ni se preocupan entre sí.
Formas generales de modularización:
Agrupación de código:
Funciones:
Clases:
Al desarrollar secuencias de comandos de texto en Dynamo, es recomendable asegurarse constantemente de que lo que se crea en realidad está en consonancia con lo que se espera. Esto garantizará que los eventos imprevistos, como errores de sintaxis, discrepancias lógicas, valores imprecisos y salidas anómalas, entre otros, se detecten y se aborden rápidamente a medida que aparecen en lugar de todos al final. Como las secuencias de comandos se encuentran dentro de los nodos en el lienzo, ya están integradas en el flujo de datos del programa visual. Esto permite que la supervisión continua de la secuencia de comandos sea tan sencilla como asignar los datos que se van a obtener, ejecutar el programa y evaluar los flujos externos a la secuencia de comandos que utilizan un nodo de visualización. A continuación, se proporcionan algunos consejos para inspeccionar de forma continua las secuencias de comandos a medida que las crea.
Realice pruebas durante el proceso:
Cuando complete un grupo de funciones, realice lo siguiente:
Retroceda y revise el código.
Sea crítico. ¿Un colaborador puede entender la finalidad del código? ¿Es necesario que haga esto? ¿Esta función se puede realizar de forma más eficaz? ¿Estoy creando dependencias o duplicados innecesarios?
Realice pruebas rápidas para asegurarse de que se devuelven datos que "tienen sentido".
Asigne los datos más recientes con los que está trabajando en la secuencia de comandos como salida para que el nodo siempre presente datos pertinentes cuando se actualice la secuencia de comandos:
Compruebe que todos los bordes del sólido se devuelvan como curvas para crear un cuadro delimitador alrededor.
Compruebe que las entradas de recuento se hayan convertido correctamente en intervalos.
Compruebe que los sistemas de coordenadas se hayan trasladado y rotado correctamente en este bucle.
Anticipar "casos extremos":
Durante la creación de secuencias de comandos, establezca los parámetros de entrada en los valores mínimo y máximo del dominio asignado para comprobar si el programa sigue funcionando en condiciones extremas.
Aunque el programa funcione en los extremos, compruebe si devuelve valores nulos, vacíos o cero no deseados.
En algunos casos, los errores y las incidencias que revelan algún problema subyacente en la secuencia de comandos solo se detectarán durante estos casos extremos.
Conozca las causas del error y decida posteriormente si se debe corregir internamente o si se debe volver a definir un dominio de parámetro para evitar el problema.
Consejo: Siempre presuponga que el usuario utilizará todas las combinaciones de cada uno de los valores de entrada que se le hayan presentado. Esto ayudará a eliminar sorpresas no deseadas.
La depuración es el proceso de eliminar "errores" de la secuencia de comandos. Los errores pueden ser incidencias, aspectos ineficaces, imprecisiones o resultados no deseados. La resolución de errores puede ser tan sencilla como corregir un nombre de variable mal escrito hasta hacer frente a problemas generalizados y estructurales en la secuencia de comandos. Lo ideal es que el ajuste de la secuencia de comandos durante el proceso de creación le ayude a detectar estos problemas potenciales en una fase inicial, aunque esto no garantiza que esté libre de errores. A continuación, se revisan varios procedimientos recomendados indicados anteriormente para ayudarle a resolver los errores de forma sistemática.
Utilice la burbuja de visualización:
Compruebe los datos devueltos en diferentes partes del código. Para ello, asígnelos a la variable OUT, de modo similar al proceso de ajuste del programa.
Escriba comentarios descriptivos:
Un módulo de código será mucho más fácil de depurar si se describe con claridad el resultado previsto.
Por lo general, esto supone una cantidad excesiva de comentarios y líneas en blanco, pero, cuando se depura, puede ser útil dividir la información en partes manejables.
Aproveche la modularidad del código:
El origen de un problema se puede aislar en determinados módulos.
Una vez identificado el módulo defectuoso, se puede corregir de forma mucho más fácil el problema.
Cuando se debe modificar un programa, el código desarrollado en los módulos será mucho más fácil de cambiar:
Puede insertar módulos nuevos o depurados en un programa existente con la seguridad de que el resto del programa no cambiará.
Depuración del archivo de ejemplo del nodo de Python.
La geometría de entrada devuelve un cuadro delimitador de mayor tamaño, como podemos ver si se asigna xDist e yDist a OUT.
Las curvas de borde de la geometría de entrada devuelven un cuadro delimitador adecuado con las distancias correctas para xDist e yDist.
El "módulo" de códigos que hemos insertado para solucionar el problema del valor de xDist e yDist.
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.
Teniendo en cuenta los procedimientos recomendados de creación de secuencias de comandos de texto, vamos a escribir una secuencia de comandos de simulación de lluvia. Aunque hemos podido aplicar los procedimientos recomendados a un programa visual desorganizado en Estrategias gráficas, es mucho más difícil hacerlo con el lenguaje de secuencias de comandos de texto. Las relaciones lógicas establecidas en las secuencias de comandos de texto son menos visibles y pueden ser casi imposibles de desentrañar en un código complicado. La eficacia que proporciona la creación de secuencias de comandos de texto también conlleva una mayor responsabilidad en cuanto a la organización. Recorreremos cada paso y aplicaremos los procedimientos recomendados durante el proceso.
La secuencia de comandos se aplica a una superficie deformada por un atractor.
Lo primero que debemos hacer es importar las bibliotecas de Dynamo necesarias. Esto proporcionará acceso global a las funciones de Dynamo en Python.
Todas las bibliotecas que tenemos intención de utilizar deben importarse aquí.
A continuación, debemos definir las entradas y las salidas de la secuencia de comandos, que se mostrarán como puertos de entrada en el nodo. Estas entradas externas son la base de nuestra secuencia de comandos y la clave para establecer un entorno paramétrico.
Se deben definir entradas que se correspondan con variables en la secuencia de comandos de Python y determinar la salida deseada:
La superficie que deseamos descender.
El número de agentes que deseamos que realicen el recorrido.
El número máximo de pasos que pueden dar los agentes.
Una opción para tomar la ruta descendente más corta por la superficie o para atravesarla.
El nodo de Python con identificadores de entrada que corresponden a entradas de la secuencia de comandos (IN[0], IN[1]).
Las curvas de salida que se pueden mostrar con un color diferente.
Ahora utilicemos el procedimiento de modularidad y creemos el cuerpo de nuestra secuencia de comandos. La simulación de la ruta descendente más corta por una superficie para varios puntos iniciales es una tarea importante que requerirá varias funciones. En lugar de llamar a las diferentes funciones a lo largo de la secuencia de comandos, podemos modularizar el código recopilándolas en una sola clase, nuestro agente. Se puede llamar a las diferentes funciones de esta clase o "módulo" con distintas variables, o incluso volver a utilizarlas en otra secuencia de comandos.
Necesitaremos definir una clase o un plan de acción para un agente con la intención de descender la superficie optando por el desplazamiento en la dirección más escarpada posible cada vez que este dé un paso:
Nombre.
Atributos globales que comparten todos los agentes.
Atributos de ejemplar exclusivos de cada agente.
Una función para dar un paso.
Una función para catalogar la posición de cada paso en una lista de trayectorias.
Inicializaremos los agentes mediante la definición de su ubicación inicial. Esta es una buena oportunidad para ajustar nuestra secuencia de comandos y asegurarnos de que funciona la clase de agente.
Tendremos que crear una instancia de todos los agentes cuyo descenso por la superficie deseamos observar y definir sus atributos iniciales:
Una nueva lista de trayectorias vacía.
La ubicación en la que se iniciará el paseo por la superficie.
Hemos asignado la lista de agentes como salida para comprobar lo que devuelve la secuencia de comandos aquí. Se devuelve el número correcto de agentes, pero necesitaremos ajustar de nuevo la secuencia de comandos más adelante para comprobar la geometría que devuelve.
Actualice cada agente en cada paso. A continuación, deberemos introducir un bucle anidado en el que, para cada agente y paso, actualizaremos y registraremos la posición en la lista de trayectorias. En cada paso, también nos aseguraremos de que el agente no haya alcanzado un punto de la superficie donde no pueda dar otro paso, lo que le permitirá descender. Si se cumple esa condición, finalizaremos el desplazamiento del agente.
Ahora que se han actualizado por completo los agentes, volvamos a la geometría que los representa. Una vez que todos los agentes hayan alcanzado su límite de descenso o su número máximo de pasos, crearemos una PolyCurve a través de los puntos de la lista de trayectorias y generaremos las trayectorias de PolyCurve.
Nuestra secuencia de comandos para buscar las rutas más escarpadas.
Un valor predefinido que simula la lluvia en la superficie subyacente.
En lugar de buscar la ruta más escarpada, se pueden activar o desactivar los agentes para que atraviesen la superficie subyacente.
La secuencia de comandos de texto completa de Python.
Creación de bucles
Repetición
Condensar nodos
Bibliotecas ext.
Abreviatura
DesignScript
Sí
Sí
Sí
No
Sí
Python
Sí
Sí
Parcialmente
Sí
No
ZeroTouch (C#)
No
No
No
Sí
No