Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
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.
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.
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.
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.
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.
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.
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.
Otra forma de descubrir los paquetes de Dynamo es explorar el sitio web de Dynamo Package Manager. 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.
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.
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.
Junto a DynamoUnfold, seleccione el menú de opciones .
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.
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 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 página wiki de Dynamo.
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 Paquetes del Apéndice.
En este caso real, mostraremos cómo importar la biblioteca externa .dll AForge. 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 página de descarga de AForge, seleccione [Download Installer] (Descargar instalador) y realice la instalación una vez que haya finalizado la descarga.
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
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: flickr).
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.
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 BlobCounter.
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.
Los siguientes pasos contienen ciertos procedimientos que permiten familiarizarse con la API de creación de imágenes AForge. 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.
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.
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, mapeado de proyección y realidad aumentada. Para consultar temas más avanzados de AForge relacionados con este ejercicio, consulte este artículo.
Logotipo/imagen
Nombre
