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...
Loading...
Loading...
Loading...
Loading...
Loading...
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.
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.
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?
Dynamo es una aplicación de programación visual 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.
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.
Los nodos y los cables son los componentes clave de Dynamo que impulsan el proceso de programación visual. 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.
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.
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 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.
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.
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.
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.
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.
Consulte el para obtener información sobre lo que puede aprender en esta guĆa.
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 una incidencia sobre cualquier aspecto, publĆquelo en la pĆ”gina de incidencias de GitHub: .
Si desea contribuir con una nueva sección, modificaciones o cualquier otra aportación a este proyecto, consulte el repositorio de GitHub para empezar: .
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.
o
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 .
DynamoBIM: la mejor fuente de información adicional, contenido de aprendizaje y foros es el sitio web de DynamoBIM.
Dynamo en GitHub Dynamo es un proyecto de código abierto en GitHub. Para colaborar, consulte DynamoDS.
Contacto Infórmenos de cualquier problema relacionado con este documento.
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
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.
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 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.
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.
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.
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.
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.
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.
ā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 (GuĆa de introducción) de .
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:
Al abrir un grƔfico, los nodos marcados como "Is Input" se muestran en el Reproductor y puede interactuar con ellos.
En algunas entradas, se le llevarÔ a un modo de selección en el que puede seleccionar elementos de la escena. Haga clic en Confirm selection para aceptar la selección y volver a ver las entradas del grÔfico.
Haga clic en Run en Dynamo Player para ejecutar el grƔfico. Cuando haya terminado, los nodos Watch y Watch 3D marcados como "Is Output" se mostrarƔn de la siguiente manera:
Los grĆ”ficos que generan geometrĆa le ofrecen la opción de previsualizarla y aƱadirla al sitio. Haga clic en el icono de ojo para activar y desactivar la vista preliminar y, a continuación, haga clic en Add para aƱadir la geometrĆa al sitio.




















Dynamo estÔ disponible como extensión en Forma. Por el momento, estÔ disponible en estos dos formatos: una versión conectada al escritorio y una integración basada en la nube, que se ofrece como versión beta cerrada. Obtenga mÔs información sobre la versión de escritorio en esta entrada del blog y sobre la integración en la nube en versión beta en esta entrada del blog. Tenga en cuenta que el blog se publicó durante la fase beta cerrada; la integración en la nube estÔ actualmente en fase beta abierta y disponible para todos los usuarios de Forma.
Autodesk Forma es un software basado en la nube que ofrece eficaces herramientas basadas en IA, pero fĆ”ciles de usar, para el diseƱo previo y esquemĆ”tico. Los arquitectos y los diseƱadores utilizan Forma para modelar complejos diseƱos en 3D en cuestión de minutos, optimizar la calidad de vida y la sostenibilidad mediante anĆ”lisis medioambientales en tiempo real y continuar el proceso de diseƱo mediante la conexión fluida con Revit, Rhino y Dynamo. Puede obtener mĆ”s información e iniciar la versión de prueba gratuita o comprar el producto aquĆ: Autodesk Forma. Forma se incluye como parte de la AEC Collection.
Dynamo Player es una extensión que ofrece una gran variedad de funciones de automatización del diseño a los usuarios de Forma. Estas son algunas de las principales ventajas de utilizar Dynamo Player con Forma:
Automatización optimizada: Dynamo Player simplifica el proceso de automatización de tareas y flujos de trabajo repetitivos en Forma. Los grÔficos personalizados creados con el entorno de programación visual de Dynamo se pueden ejecutar directamente en Forma con solo unos clics. Los grÔficos se muestran en forma de lista en Dynamo Player, lo que facilita su selección y ejecución siempre que sea necesario. Este proceso optimizado le permite ejecutar rÔpidamente tareas repetitivas, lo que reduce errores y aumenta la eficiencia.
Interfaz fÔcil de usar: Dynamo Player ofrece una interfaz fÔcil de usar que lo hace accesible a los usuarios de Forma, sin necesidad de tener conocimientos sobre Dynamo. En el futuro, tenemos previsto publicar mÔs grÔficos de ejemplo que le permitan acceder a automatizaciones impulsadas por Dynamo sin necesidad de recurrir a desarrolladores o conocimientos avanzados de codificación.
ParĆ”metros personalizables: Dynamo Player le permite definir parĆ”metros de entrada para los grĆ”ficos de automatización, por lo que podrĆ” personalizar el comportamiento de los grĆ”ficos en función de los requisitos especĆficos del proyecto. Puede configurar opciones y valores que se pueden modificar fĆ”cilmente cada vez que se ejecuta el grĆ”fico, lo que proporciona flexibilidad y capacidad de adaptación a diferentes situaciones.
Reutilizar y compartir: Dynamo Player fomenta la colaboración y el intercambio de conocimientos entre los usuarios de Forma. Los grÔficos de automatización pueden guardarse y reutilizarse en varios sitios, lo que garantiza la coherencia y la eficacia. AdemÔs, puede compartir sus secuencias de comandos con otros miembros de la comunidad de Forma, lo que facilita que todos se beneficien mutuamente de las soluciones de automatización.






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.
Dynamo no serĆa lo que es sin un grupo fiel de fervientes usuarios y colaboradores activos. Participe en la comunidad: siga el blog, aƱada su trabajo a la galerĆa o hable de Dynamo en el foro.
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.
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.
Imagen original por cortesĆa de: sixtysecondrevit.com
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.
Una vez que haya configurado Dynamo Player, puede abrir los archivos en el Reproductor. Si utiliza la versión de escritorio, también deberÔ tener Dynamo abierto.
Si utiliza la versión de escritorio de Dynamo, el Reproductor reconocerÔ un grÔfico abierto en Dynamo y le ofrecerÔ la opción de abrirlo en el Reproductor.
En las fichas Service y Desktop, encontrarƔ un Ɣrea denominada Upload graph [ 1 ] donde puede arrastrar y soltar archivos .dyn para aƱadirlos al Reproductor. TambiƩn puede hacer clic en el Ɣrea para abrir un cuadro de diƔlogo en el que buscar y aƱadir archivos.
Los grÔficos que cargue aparecerÔn en Uploaded graphs [ 2 ]. Puede abrir el grÔfico o hacer clic en el menú de opciones (tres puntos) para eliminar, descargar o compartir el grÔfico.
Los grƔficos se pueden compartir en un sitio o un centro [ 3 ]. Un centro incluye varios sitios. Para compartir un grƔfico, haga clic en Share graph e introduzca los detalles del grƔfico. Puede elegir si desea compartir el grƔfico en el sitio o en el centro. Al hacer clic en Share, el grƔfico pasa a estar disponible para otros usuarios con acceso a ese sitio o centro.
Dynamo Player incluye varios grÔficos prediseñados en la sección Graphs provided by Autodesk [ 4 ]. Estos son un excelente punto de partida para la exploración y la experimentación.
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.
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.
Un 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]
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.
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.
// copy this code into a Code Block
// to start writing DesignScript
x = "Let's create some geometry!";






















En esta pƔgina, se destacan las diferencias que debe tener en cuenta al escribir programas de Dynamo para que se ejecuten en el contexto de la nube del servicio de cƔlculo de Dynamo.
DaaS, Dynamo como servicio, servicio de cÔlculo de Dynamo y otros términos relacionados hacen referencia a lo mismo, el tiempo de ejecución central de Dynamo al ejecutarse en un contexto de nube. Esto significa que el grÔfico no se estÔ ejecutando en el equipo. Actualmente, solo se puede acceder a DaaS a través de la extensión Dynamo Player para Forma, donde los usuarios pueden cargar y gestionar archivos .dyn creados en el entorno de escritorio, ejecutar archivos .dyn compartidos por sus compañeros a través de la extensión o utilizar rutinas de .dyn precargadas proporcionadas por Autodesk como ejemplos.
Debido a que los grÔficos se ejecutan en este contexto de nube y no en el equipo, por el momento, DaaS no puede utilizar directamente los contextos de anfitrión tradicionales de Dynamo (Revit, Civil 3D, etc.). Si desea utilizar tipos de esos programas en el grÔfico, deberÔ serializarlos (guardarlos) en el grÔfico mediante el nodo Data.Remember u otras técnicas de serialización dentro del grÔfico. Estos son similares a los flujos de trabajo que debe utilizar al escribir grÔficos para la función Diseño generativo de Revit.
La versión se basa en 3.x y se actualiza con frecuencia en función de la rama principal de código abierto de Dynamo.
La mayorĆa de los nodos principales; consulte la siguiente sección para conocer algunas limitaciones especĆficas.
Paquete DynamoFormaBeta para interactuar con la API de Forma.
VASA para voxelización/anÔlisis eficiente.
MeshToolKit para la manipulación de mallas. El Kit de herramientas de malla también estÔ disponible de forma predefinida a partir de Dynamo 3.4.
RefineryToolkit para algoritmos útiles que permiten pruebas de conflictos, distancia de visualización, la ruta mÔs corta, isovistas, etc.
Los nodos de Python no funcionarƔn. Estos no se ejecutarƔn actualmente.
No se pueden utilizar paquetes personalizados.
La capa de interfaz de usuario/vista de los nodos de interfaz de usuario no se ejecutarĆ”. No prevemos que esto sea un problema con la funcionalidad principal, pero es recomendable tenerlo en cuenta si observa un error asociado a un nodo con la interfaz de usuario personalizada.
Las funciones solo para Windows no estarƔn operativas. Por ejemplo, si intenta utilizar el Registro de Windows o WPF, se producirƔ un error.
No se cargarƔn las extensiones de vista.
Los nodos filesystem no resultarÔn muy útiles. Todos los archivos a los que haga referencia en el equipo local no existirÔn cuando se ejecuten en DaaS.
Los nodos de interoperabilidad de Excel/DSOffice no funcionarĆ”n. DeberĆan funcionar los nodos de Open XML.
En general, las solicitudes de red no funcionarƔn, aunque podrƔ realizar llamadas a la API de Forma.
En el futuro, tenemos la intención de proporcionar herramientas dentro de Dynamo para la versión de escritorio que facilitarÔn que el grÔfico se ejecute de la misma forma en ambos contextos.
Durante esta versión beta, no se cobrarÔ el tiempo de cÔlculo.
Consulte la entrada del blog, la serie de YouTube o los ejemplos de la extensión de Forma para comenzar. Estos le guiarÔn a través de los siguientes procedimientos:
Obtención de acceso a Autodesk Forma
Instalación de DynamoFormaBeta para Dynamo en el escritorio y la extensión de Dynamo en Forma
Escritura del primer grƔfico
Tenga en cuenta que los grƔficos compartidos se almacenan en Forma.
El tiempo mÔximo de ejecución del grÔfico actual es inferior a 30 minutos. Este valor puede cambiar.
Las solicitudes de ejecución presentan una velocidad limitada, por lo que es posible que se produzcan errores si realiza muchas solicitudes de cÔlculo en un periodo demasiado corto.
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.
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.).
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.
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.
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
out_points = []
for i in range(11):
sub_points = []
for j in range(11):
z = 0
if (i == 5 and j == 5):
z = 1
elif (i == 8 and j == 2):
z = 1
sub_points.append(Point.ByCoordinates(i, j, z))
out_points.append(sub_points)
OUT = out_pointspython_points_2
out_points = []
for i in range(11):
z = 0
if (i == 2):
z = 1
out_points.append(Point.ByCoordinates(i, 0, z))
OUT = out_pointspython_points_3
out_points = []
for i in range(11):
z = 0
if (i == 7):
z = -1
out_points.append(Point.ByCoordinates(i, 5, z))
OUT = out_pointspython_points_4
out_points = []
for i in range(11):
z = 0
if (i == 5):
z = 1
out_points.append(Point.ByCoordinates(i, 10, z))
OUT = out_pointspython_points_5
out_points = []
for i in range(11):
sub_points = []
for j in range(11):
z = 0
if (i == 1 and j == 1):
z = 2
elif (i == 8 and j == 1):
z = 2
elif (i == 2 and j == 6):
z = 2
sub_points.append(Point.ByCoordinates(i, j, z))
out_points.append(sub_points)
OUT = out_pointsLos 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" y "string" son dos 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
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:
s1 = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin, 6);
s2 = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin.Translate(4, 0,
0), 6);
combined = s1.Union(s2);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:
s = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin, 6);
tool = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin.Translate(10, 0,
0), 6);
result = s.Difference(tool);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:
s = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin, 6);
tool = Sphere.ByCenterPointRadius(
CoordinateSystem.Identity().Origin.Translate(10, 0,
0), 6);
result = s.Intersect(tool);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.
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.
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.
¿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.
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 ).
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.
Keysdebe ser una cadena, mientras quevaluespuede ser diversos tipos de objeto.
Por último, ahora podemos recuperar una habitación del diccionario con su número de habitación.
StringserĆ” 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.ValueAtKeyutilizarÔ 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.
Dynamo es un proyecto activo de desarrollo de código abierto. Obtenga la .
Dynamo viene preinstalado en software como Revit3D, FormIt, Civil3D, etc.
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.
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 . Tanto las versiones oficiales como las preliminares o las anteriores estÔn disponibles en la pÔgina de descarga. Visite la pÔgina 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.
Antes de iniciar la versión que haya descargado, deberÔ descomprimir el contenido en la carpeta que desee.
Descargue e instale 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.
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.
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).
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.
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.
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.
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.
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.
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 de este manual de introducción. Para examinar de forma mĆ”s exhaustiva el Kit de herramientas de malla, consulte la . 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 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 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.
Para utilizar Dynamo con Forma, tiene estas dos opciones: puede usar Dynamo como servicio (DaaS) basado en la nube o la versión de escritorio de Dynamo. Cada una tiene sus ventajas en función de lo que desee hacer, asà que antes de empezar, considere la opción que mejor se adapte a sus necesidades. Sin embargo, tenga en cuenta que puede alternar entre estas opciones en cualquier momento.
Comparación entre Dynamo como servicio y la versión de escritorio de Dynamo
En esta pÔgina, explicaremos cómo configurar ambas opciones.
Dynamo en Forma estÔ disponible actualmente como versión beta abierta de acceso anticipado, lo que significa que las funciones y la interfaz de usuario pueden cambiar con frecuencia.
En primer lugar, instalaremos Dynamo Player en Forma.
En el sitio de Forma, vaya a Extensions en el barra lateral izquierda y haga clic en Add extension. Se abre el sitio web de Autodesk App Store.
Busque Dynamo y añada la versión beta de Dynamo Player. Lea la limitación de responsabilidades y haga clic en Agree.
Dynamo Player estƔ ahora disponible en sus extensiones. Haga clic en Ʃl para abrirlo.
Ya puede utilizar Dynamo Player.
Para utilizar la versión de escritorio de Dynamo, necesitarÔ Dynamo, ya sea como Sandbox independiente o conectado a Revit o Civil 3D. También necesitarÔ el paquete DynamoForma.
Siga estas instrucciones para configurar Dynamo en Revit y el paquete DynamoForma.
Asegúrese de tener instalado Revit 2024.1 o una versión posterior.
Abra Dynamo en Revit mediante Gestionar > Dynamo.
En Dynamo, instale el paquete DynamoForma. Vaya a Paquetes > Package Manager y, a continuación, busque DynamoForma.
Si dispone de Revit 2024, instale el paquete DynamoForma for 2.x.
Si dispone de Revit 2025, instale el paquete DynamoForma.
Siga estas instrucciones para configurar Dynamo en Civil 3D y el paquete DynamoForma.
Asegúrese de tener instalado Civil 3D 2024.1 o una versión posterior.
Abra Dynamo en Civil 3D mediante Gestionar > Dynamo.
En Dynamo, instale el paquete DynamoForma. Vaya a Paquetes > Package Manager y, a continuación, busque DynamoForma.
Si dispone de Civil 3D 2024, instale el paquete DynamoForma for 2.x.
Si dispone de Civil 3D 2025, instale el paquete DynamoForma.
Siga estas instrucciones para instalar Dynamo Sandbox y el paquete DynamoForma.
Descargue Dynamo 2.18.0 o superior desde las . Para obtener la mejor experiencia, elija la última de las versiones mÔs estables, que aparece en la parte superior.
Las versiones diarias son versiones de desarrollo y pueden incluir funciones incompletas o en curso.
Extraiga Dynamo mediante en la carpeta que elija.
Ejecute DynamoSandbox.exe desde la carpeta de instalación de Dynamo.
En Dynamo, instale el paquete DynamoForma. Vaya a Paquetes > Package Manager y, a continuación, busque DynamoForma.
Si dispone de Dynamo 2.x, instale el paquete DynamoForma for 2.x.
Si dispone de Dynamo 3.x, instale el paquete DynamoForma.
Una vez que Dynamo esté instalado, podrÔ utilizarlo con Forma. Al ejecutar la opción de escritorio de Dynamo en Forma, deberÔ tener Dynamo abierto para poder utilizar la extensión de Dynamo Player.
En primer lugar, instalaremos Dynamo Player en Forma.
En el sitio de Forma, vaya a Extensions en el barra lateral izquierda y haga clic en Add extension. Se abre el sitio web de Autodesk App Store.
Busque Dynamo y añada la versión beta de Dynamo Player. Lea la limitación de responsabilidades y haga clic en Agree.
Dynamo Player estƔ ahora disponible en sus extensiones. Haga clic en Ʃl para abrirlo.
En la parte superior, haga clic en Desktop para acceder a la versión de escritorio de Dynamo.
Ya puede utilizar Dynamo Player. Si ya tiene un grƔfico abierto en Dynamo, haga clic en "Open" debajo de Connected graph para verlo en el Reproductor.
























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



FÔcil configuración.
Proceso de instalación en varios pasos.
No es necesario instalar Dynamo ni tenerlo abierto.
Es necesario tener abierto Dynamo.
No reconoce un grƔfico que ya se haya abierto en Dynamo
Abra un grÔfico en el Reproductor que ya se haya abierto en Dynamo con solo hacer clic en un botón.
No se puede utilizar Python.
Se puede utilizar Python.
Solo se pueden utilizar paquetes autorizados.
Se puede utilizar cualquier paquete.













































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.
GuĆas interactivas: recorridos que le guiarĆ”n paso a paso por diversas funciones de Dynamo.
Muestras: archivos de ejemplo de referencia. Solo estÔn disponibles en programas anfitrión, incluidos Revit y Civil 3D.
Diccionario de Dynamo: recurso con documentación sobre todos los nodos.
Sitio web de Dynamo: sitio web para obtener información sobre Dynamo y vĆnculos a recursos como el foro, el blog, etc.
Repositorio de Dynamo: consulte 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.
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.
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.
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.
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.
Utilice el menú contextual para bloquear la operación de unión de sólidos.
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.
Para desbloquear los nodos, haga clic con el botón derecho y desactive la opción Bloquear.
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.
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.
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.
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.
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.
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.
Las curvas 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
Una lĆnea 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.
NURBS 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.
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
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.
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.
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.
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.
Actualmente, no es posible transferir la propiedad de los paquetes mediante Package Manager. Puede solicitar al equipo de Dynamo que aƱada un propietario adicional. Tenga en cuenta que no se pueden eliminar propietarios existentes, solo aƱadir mĆ”s responsables del paquete. Si desea aƱadir una cuenta como propietario al paquete existente, envĆe un mensaje de correo electrónico a [email protected]. AsegĆŗrese de proporcionar el nombre del paquete y el de la cuenta que desea aƱadir.
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.
šÆ Cree un grupo de puntos para cada descripción de punto COGO exclusiva.
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.
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.
š Ā”Misión cumplida!
A continuación, se ofrecen algunas ideas sobre cómo podrĆa ampliar las posibilidades de este grĆ”fico.
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.
// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10
surf = NurbsSurface.ByPoints(python_points_1);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.
// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10
// create a surface of degree 2 with smooth segments
surf = NurbsSurface.ByPoints(python_points_1, 2, 2);Podemos aumentar el grado de la NurbsSurface para cambiar la geometrĆa de superficie resultante:
// python_points_1 is a set of Points generated with
// a Python script found in Chapter 12, Section 10
// create a surface of degree 6
surf = NurbsSurface.ByPoints(python_points_1, 6, 6);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.
// python_points_2, 3, and 4 are generated with
// Python scripts found in Chapter 12, Section 10
c1 = NurbsCurve.ByPoints(python_points_2);
c2 = NurbsCurve.ByPoints(python_points_3);
c3 = NurbsCurve.ByPoints(python_points_4);
loft = Surface.ByLoft([c1, c2, c3]);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.
pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);
crv = NurbsCurve.ByPoints(pts);
axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);
surf = Surface.ByRevolve(crv, axis_origin, axis, 0,
360);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:
// create a point with the following x, y, and z
// coordinates:
x = 10;
y = 2.5;
z = -6;
p = Point.ByCoordinates(x, y, z);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):
// create a point on a sphere with the following radius,
// theta, and phi rotation angles (specified in degrees)
radius = 5;
theta = 75.5;
phi = 120.3;
cs = CoordinateSystem.Identity();
p = Point.BySphericalCoordinates(cs, radius, theta,
phi);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:
// create two points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);
// construct a line between p1 and p2
l = Line.ByStartPointEndPoint(p1, p2);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.
// create points:
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);
p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);
p5 = Point.ByCoordinates(9, -10, -2);
p6 = Point.ByCoordinates(-11, -12, -4);
// create lines:
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
l3 = Line.ByStartPointEndPoint(p5, p6);
// loft between cross section lines:
surf = Surface.ByLoft([l1, l2, l3]);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.
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);
p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
surf = Surface.ByLoft([l1, l2]);
// true indicates to thicken both sides of the Surface:
solid = surf.Thicken(4.75, true);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.
p1 = Point.ByCoordinates(3, 10, 2);
p2 = Point.ByCoordinates(-15, 7, 0.5);
p3 = Point.ByCoordinates(5, -3, 5);
p4 = Point.ByCoordinates(-5, -6, 2);
l1 = Line.ByStartPointEndPoint(p1, p2);
l2 = Line.ByStartPointEndPoint(p3, p4);
surf = Surface.ByLoft([l1, l2]);
solid = surf.Thicken(4.75, true);
p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),
Vector.ByCoordinates(1, 1, 1));
int_surf = solid.Intersect(p);
int_line = int_surf.Intersect(Plane.ByOriginNormal(
Point.ByCoordinates(0, 0, 0),
Vector.ByCoordinates(1, 0, 0)));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:
pts = [ [p1, p2, p3],
[p4, p5, p6],
[p7, p8, p9] ];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:
pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(6, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(3, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
crv = NurbsCurve.ByPoints(pts);
pts_at_param = crv.PointAtParameter(0..1..#11);
// draw Lines to help visualize the points
lines = Line.ByStartPointEndPoint(pts_at_param,
Point.ByCoordinates(4, 6, 0));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:
pts = {};
pts[0] = Point.ByCoordinates(4, 0, 0);
pts[1] = Point.ByCoordinates(3, 0, 1);
pts[2] = Point.ByCoordinates(4, 0, 2);
pts[3] = Point.ByCoordinates(4, 0, 3);
pts[4] = Point.ByCoordinates(4, 0, 4);
pts[5] = Point.ByCoordinates(5, 0, 5);
pts[6] = Point.ByCoordinates(4, 0, 6);
pts[7] = Point.ByCoordinates(4, 0, 7);
crv = NurbsCurve.ByPoints(pts);
axis_origin = Point.ByCoordinates(0, 0, 0);
axis = Vector.ByCoordinates(0, 0, 1);
surf = Surface.ByRevolve(crv, axis_origin, axis, 90,
140);
cs_array = surf.CoordinateSystemAtParameter(
(0..1..#7)<1>, (0..1..#7)<2>);
def make_line(cs : CoordinateSystem) {
lines_start = cs.Origin;
lines_end = cs.Origin.Translate(cs.ZAxis, -0.75);
return = Line.ByStartPointEndPoint(lines_start,
lines_end);
}
lines = make_line(Flatten(cs_array));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.
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.
num_pts = 6;
s = Math.Sin(0..360..#num_pts) * 4;
pts = Point.ByCoordinates(1..30..#num_pts, s, 0);
int_curve = NurbsCurve.ByPoints(pts);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).
pts = Point.ByCoordinates(Math.Cos(0..350..#10),
Math.Sin(0..350..#10), 0);
// create an closed curve
crv = NurbsCurve.ByPoints(pts, true);
// the same curve, if left open:
crv2 = NurbsCurve.ByPoints(pts.Translate(5, 0, 0),
false);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.
num_pts = 6;
pts = Point.ByCoordinates(1..30..#num_pts,
Math.Sin(0..360..#num_pts) * 4, 0);
// a B-Spline curve with degree 1 is a polyline
ctrl_curve = NurbsCurve.ByControlPoints(pts, 1);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:
num_pts = 6;
pts = Point.ByCoordinates(1..30..#num_pts,
Math.Sin(0..360..#num_pts) * 4, 0);
// a B-Spline curve with degree 2 is smooth
ctrl_curve = NurbsCurve.ByControlPoints(pts, 2);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:
num_pts = 6;
pts = Point.ByCoordinates(1..30..#num_pts,
Math.Sin(0..360..#num_pts) * 4, 0);
def create_curve(pts : Point[], degree : int)
{
return = NurbsCurve.ByControlPoints(pts,
degree);
}
ctrl_crvs = create_curve(pts, 1..11);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:
pts_1 = {};
pts_1[0] = Point.ByCoordinates(0, 0, 0);
pts_1[1] = Point.ByCoordinates(1, 1, 0);
pts_1[2] = Point.ByCoordinates(5, 0.2, 0);
pts_1[3] = Point.ByCoordinates(9, -3, 0);
pts_1[4] = Point.ByCoordinates(11, 2, 0);
crv_1 = NurbsCurve.ByControlPoints(pts_1, 3);
pts_2 = {};
pts_2[0] = pts_1[4];
end_dir = pts_1[4].Subtract(pts_1[3].AsVector());
pts_2[1] = Point.ByCoordinates(pts_2[0].X + end_dir.X,
pts_2[0].Y + end_dir.Y, pts_2[0].Z + end_dir.Z);
pts_2[2] = Point.ByCoordinates(15, 1, 0);
pts_2[3] = Point.ByCoordinates(18, -2, 0);
pts_2[4] = Point.ByCoordinates(21, 0.5, 0);
crv_2 = NurbsCurve.ByControlPoints(pts_2, 3);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:
<PythonTemplateFilePath>
<string>C:\Users\CURRENTUSER\AppData\Roaming\Dynamo\Dynamo Core\2.0\PythonTemplate.py</string>
</PythonTemplateFilePath>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:
import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *
from Autodesk.Revit.DB.Structure import *
clr.AddReference('RevitAPIUI')
from Autodesk.Revit.UI import *
clr.AddReference('System')
from System.Collections.Generic import List
clr.AddReference('RevitNodes')
import Revit
clr.ImportExtensions(Revit.GeometryConversion)
clr.ImportExtensions(Revit.Elements)
clr.AddReference('RevitServices')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uidoc=DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument
#Preparing input from dynamo to revit
element = UnwrapElement(IN[0])
#Do some action in a Transaction
TransactionManager.Instance.EnsureInTransaction(doc)
TransactionManager.Instance.TransactionTaskDone()
OUT = elementUna 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
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.
Estos tres mƩtodos se pueden utilizar para alternar entre distintas vistas preliminares:
a. Usar los iconos ubicados en la parte superior derecha
Vista preliminar de grƔfico
Vista preliminar 3D
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:
Ajustar en ventana
Ampliar
Reducir
Encuadre
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:
Ajustar en ventana
Ampliar
Reducir
Encuadre
Ćrbita
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.
El 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 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 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.
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.
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.
Una vez que Dynamo estƩ abierto, aparecerƔ la pantalla de inicio. Haga clic en Nuevo para abrir un espacio de trabajo en blanco.
Ahora deberĆa aparecer un espacio de trabajo vacĆo. Vamos a ver Dynamo en acción. Este es nuestro objetivo:
šÆ Cree un grĆ”fico de Dynamo que inserte texto en el espacio modelo.
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.
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.
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.
”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.
š Ā”Misión cumplida!
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.
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.
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 . Si es un programador y desea participar en el desarrollo de Dynamo, consulte el . AdemĆ”s, un recurso excelente para las bibliotecas de terceros es . 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.
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.
šÆ Utilice un bloque de perfil de vehĆculo para generar sólidos 3D de envolvente libre a lo largo de una obra lineal.
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.
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.
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.
š Ā”Misión cumplida!
A continuación, se ofrecen algunas ideas sobre cómo podrĆa ampliar las posibilidades de este grĆ”fico.
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.















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















// create a point at x = 1, y = 2, z = 3
p = Point.ByCoordinates(1, 2, 3);
// translate the point 10 units in the x direction,
// -20 in y, and 50 in z
// p2ās new position is x = 11, y = -18, z = 53
p2 = p.Translate(10, -20, 50);cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
10, 10, 10);
new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Rotate(Point.ByCoordinates(0, 0),
Vector.ByCoordinates(1,0,0.5), 25);
// get the existing coordinate system of the cube
old_cs = CoordinateSystem.Identity();
cube2 = cube.Transform(old_cs, new_cs2);cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
10, 10, 10);
new_cs = CoordinateSystem.Identity();
new_cs2 = new_cs.Scale(20);
old_cs = CoordinateSystem.Identity();
cube2 = cube.Transform(old_cs, new_cs2);new_cs = CoordinateSystem.ByOriginVectors(
Point.ByCoordinates(0, 0, 0),
Vector.ByCoordinates(-1, -1, 1),
Vector.ByCoordinates(-0.4, 0, 0));
old_cs = CoordinateSystem.Identity();
cube = Cuboid.ByLengths(CoordinateSystem.Identity(),
5, 5, 5);
new_curves = cube.Transform(old_cs, new_cs);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


















































































































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.
Sumar (+)
var[]...[], var[]...[]
var[]...[]
Restar (-)
var[]...[], var[]...[]
var[]...[]
Multiplicar (*)
var[]...[], var[]...[]
var[]...[]
Dividir (/)
var[]...[], var[]...[]
var[]...[]
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.
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.
El cúmulo de nodos del paso anterior funcionarÔ correctamente, pero conlleva mucho trabajo. Para crear un flujo de trabajo mÔs eficiente, consulte DesignScript 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.
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.
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 crecimiento de las semillas de girasol.
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.
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.
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.
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".
Imagine que tiene un racimo de uvas. Si quisiera hacer zumo de uva, no las exprimirĆa una a una, sino que las pasarĆa todas por el exprimidor a la vez. La replicación en Dynamo funciona de forma similar; en lugar de aplicar una operación a un elemento cada vez, Dynamo puede aplicarla a toda una lista de una sola vez.
Los nodos de Dynamo reconocen automÔticamente cuÔndo estÔn trabajando con listas y aplican sus operaciones a varios elementos. Esto significa que no es necesario recorrer manualmente los elementos, simplemente ocurre. Pero, ¿cómo decide Dynamo cómo procesar las listas cuando hay mÔs de una?
De una de las siguientes formas:
Digamos que estÔ en la cocina haciendo zumos de frutas. Tiene una lista de frutas ({apple, orange, pear}) y una cantidad fija de agua para cada zumo (1 cup). Desea hacer zumo con cada fruta utilizando la misma cantidad de agua. En este caso, entra en juego la replicación cartesiana.
En Dynamo, esto significa que estÔ introduciendo la lista de frutas en la entrada de frutas del nodo Juice.Maker, mientras que la entrada de agua se mantiene constante en 1 taza. A continuación, el nodo procesa cada fruta individualmente, combinÔndola con la cantidad fija de agua. El resultado es el siguiente:
apple juice with 1 cup of water orange juice with 1 cup of water pear juice with 1 cup of water
Cada fruta se combina con la misma cantidad de agua.
La replicación Zip funciona de forma algo diferente. Si tuviera dos listas, una para frutas ({apple, orange, pear}) y otra para cantidades de azĆŗcar ({2 tbsp, 3 tbsp, 1 tbsp}), la replicación Zip combinarĆa los elementos correspondientes de cada lista. Por ejemplo:
apple juice with 2 tablespoons of sugar orange juice with 3 tablespoons of sugar pear juice with 1 tablespoon of sugar
Cada fruta se combina con su correspondiente cantidad de azĆŗcar.
Para obtener mĆ”s información sobre cómo funciona, consulte las guĆas de replicación y 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 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.
Junto a DynamoUnfold, seleccione el menĆŗ de opciones .
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 . Aquà puede encontrar dependencias de paquetes e información sobre compatibilidad de anfitrión y versión proporcionada por los autores de los paquetes. 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].
Para los usuarios que preguntan si es posible implantar Dynamo (de cualquier forma) con paquetes enlazados previamente: el enfoque que resuelve este problema y permite llevar el control desde una ubicación central para todos los usuarios con instalaciones de Dynamo consiste en añadir una ruta de paquete personalizada a cada instalación.
AƱadir una carpeta de red para que el administrador de BIM u otros usuarios puedan supervisar el almacenamiento de la carpeta con paquetes aprobados por la oficina
En la interfaz de usuario de una aplicación individual, vaya a Dynamo -> Preferencias -> Configuración de paquetes -> Ubicaciones de archivo de nodos y paquetes. En el cuadro de diÔlogo, presione el botón "Añadir ruta" y busque la ubicación de red del recurso de paquete compartido.
Como proceso automatizado, implicarĆa aƱadir información al archivo de configuración que se instala con Dynamo:
C:\Users\[Username]\AppData\Roaming\Dynamo\Dynamo Revit\[Dynamo Version]\DynamoSettings.xml.
Por defecto, la configuración de Dynamo for Revit es:
<CustomPackageFolders>
<string>C:\Users\[Username]\AppData\Roaming\Dynamo\Dynamo Revit\[Dynamo Version]</string>
</CustomPackageFolders>
La adición de una ubicación personalizada tendrĆa el siguiente aspecto:
<CustomPackageFolders>
<string>C:\Users\[Username]\AppData\Roaming\Dynamo\Dynamo Revit\[Dynamo Version]</string>
<string>N:\OfficeFiles\Dynamo\Packages_Limited</string>
</CustomPackageFolders>
La administración central de esta carpeta también se puede controlar simplemente haciendo que la carpeta sea de solo lectura.
Es posible que una organización desee estandarizar los paquetes instalados por diferentes estaciones de trabajo y usuarios. Una forma de hacerlo podrĆa consistir en instalar estos paquetes desde Dynamo -> Preferencias -> Configuración de paquetes -> Ubicaciones de archivo de nodos y paquetes, seleccionar una carpeta de red como ubicación de instalación y hacer que las estaciones de trabajo aƱadan esa ruta a Manage Node and Package Paths.
Si bien el escenario planteado funciona correctamente para paquetes que contengan solo nodos personalizados, es posible que no funcione para los paquetes que contengan archivos binarios, como los nodos Zero Touch. Este problema se debe a las que .NET Framework aplica a la carga de ensamblajes cuando proceden de una ubicación de red. Desafortunadamente, el uso del elemento de configuración loadFromRemoteSources, como se sugiere en el hilo vinculado, no es una solución factible para Dynamo, ya que se distribuye como componente y no como aplicación.
Una posible solución alternativa es utilizar una unidad de red asignada que apunte a la ubicación de la red y hacer que las estaciones de trabajo hagan referencia a esa ruta. Los pasos para crear una unidad de red asignada se describen .
La comunidad de Dynamo estĆ” en constante crecimiento y evolución. Si explora el administrador de paquetes de Dynamo 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.
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.
šÆ 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.
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.
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.
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.
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.
š Ā”Misión cumplida!
A continuación, se ofrecen algunas ideas sobre cómo podrĆa ampliar las posibilidades de este grĆ”fico.
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.
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:
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.










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
// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10
surf = NurbsSurface.ByPoints(python_points_5, 3, 3);
WCS = CoordinateSystem.Identity();
pl = Plane.ByOriginNormal(WCS.Origin.Translate(0, 0,
0.5), WCS.ZAxis);
// intersect surface, generating three closed curves
crvs = surf.Intersect(pl);
crvs_moved = crvs.Translate(0, 0, 10);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Ć
// python_points_5 is a set of Points generated with
// a Python script found in Chapter 12, Section 10
surf = NurbsSurface.ByPoints(python_points_5, 3, 3);
tool_pts = Point.ByCoordinates((-10..20..10)<1>,
(-10..20..10)<2>, 1);
tool = NurbsSurface.ByPoints(tool_pts);
pick_point = Point.ByCoordinates(8, 1, 3);
result = surf.Trim(tool, pick_point);




















































If (If)
test, true, false
resultado
Code Block ((x?y:z);)
x? y, z
resultado










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.
Icono de encaje: indica la opción de encaje especificada para las entradas de lista coincidentes (se explicarÔ detalladamente mÔs adelante).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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:
Booleano
NĆŗmero
Cadena
Control deslizante de nĆŗmero
Ruta de directorio
Control deslizante de entero
Ruta de archivo
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.
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.
Escriba Circle.ByCenterPointRadius(x,y);
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.
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.
Object.IsNull
obj
bool
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.
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.
šÆ 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.
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.
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.
š Ā”Misión cumplida!
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.
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.
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.
šÆ 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.
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.
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.
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.
š Ā”Misión cumplida!
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.
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.
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.
/*This is a multi-line comment,
which continues for
multiple lines*/
def FunctionName(in1,in2)
{
//This is a comment
sum = in1+in2;
return sum;
};Invoque la función con otro bloque de código en el mismo archivo asignando el nombre y la misma cantidad de argumentos. Funciona igual que los nodos predefinidos de la biblioteca.
FunctionName(in1,in2);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:
def sphereByZ(inputPt) { };El parÔmetro inputPt es el nombre que se le ha asignado para representar los puntos que controlarÔn la función. En este momento, la función no realiza ninguna acción, pero la ampliaremos en los pasos siguientes.
Al añadir la función de bloque de código, se coloca un comentario y una variable sphereRadius que consulta la posición Z de cada punto. Recuerde que inputPt.Z no necesita paréntesis como método. Se trata de una consulta de las propiedades de un elemento existente, por lo que no se necesita ninguna entrada:
def sphereByZ(inputPt,radiusRatio) { //get Z Value, ise ot to drive radius of sphere sphereRadius=inputPt.Z; };
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:
sphereByZ(Pt)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:
def sphereByZ(inputPt,radiusRatio) { //get Z Value, use it to drive radius of sphere sphereRadius=inputPt.Z/radiusRatio; //Define Sphere Geometry sphere=Sphere.ByCenterPointRadius(inputPt,sphereRadius); //Define output for function return sphere; };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.
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.
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
¿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.


















































































































































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.

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).
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..#50en 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.
Utilizamos un bloque de código con la 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 transposeList:
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 a los nodos List.Transpose, List.Count y Number Range.
4. El cuatro bloque de código consulta una lista de listas y sustituye al nodo List.GetItemAtIndex.
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):
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..-7es 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.
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.
¿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 ha producido de forma local?
Manzana.distanciaDeHuerta
96 km

















// create a CoordinateSystem at x = 0, y = 0, z = 0,
// no rotations, scaling, or sheering transformations
cs = CoordinateSystem.Identity();// create a CoordinateSystem at a specific location,
// no rotations, scaling, or sheering transformations
x_pos = 3.6;
y_pos = 9.4;
z_pos = 13.0;
origin = Point.ByCoordinates(x_pos, y_pos, z_pos);
identity = CoordinateSystem.Identity();
cs = CoordinateSystem.ByOriginVectors(origin,
identity.XAxis, identity.YAxis, identity.ZAxis);// create a point with x, y, and z coordinates
x_pos = 1;
y_pos = 2;
z_pos = 3;
pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);
// create a point in a specific coordinate system
cs = CoordinateSystem.Identity();
pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,
y_pos, z_pos);
// create a point on a cylinder with the following
// radius and height
radius = 5;
height = 15;
theta = 75.5;
pCyl = Point.ByCylindricalCoordinates(cs, radius, theta,
height);
// create a point on a sphere with radius and two angles
phi = 120.3;
pSphere = Point.BySphericalCoordinates(cs, radius,
theta, phi);p1 = Point.ByCoordinates(-2, -5, -10);
p2 = Point.ByCoordinates(6, 8, 10);
// a line segment between two points
l2pts = Line.ByStartPointEndPoint(p1, p2);
// a line segment at p1 in direction 1, 1, 1 with
// length 10
lDir = Line.ByStartPointDirectionLength(p1,
Vector.ByCoordinates(1, 1, 1), 10);// create a cuboid with specified lengths
cs = CoordinateSystem.Identity();
cub = Cuboid.ByLengths(cs, 5, 15, 2);
// create several cones
p1 = Point.ByCoordinates(0, 0, 10);
p2 = Point.ByCoordinates(0, 0, 20);
p3 = Point.ByCoordinates(0, 0, 30);
cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);
cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);
// make a cylinder
cylCS = cs.Translate(10, 0, 0);
cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);
// make a sphere
centerP = Point.ByCoordinates(-10, -10, 0);
sph = Sphere.ByCenterPointRadius(centerP, 5);
























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.


















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 Zeta) 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.Transpose 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.
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:
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
# Import Revit elements
from Revit.Elements import *
# Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
import SystemEsto 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:
# Load the Python Standard and DesignScript Libraries
import sys
import clr
#Import DocumentManager
clr.AddReference("RevitServices")
import RevitServices
from RevitServices.Persistence import DocumentManager
#Place your code below this line
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application
#Assign your output to the OUT variable
OUT = [doc,uiapp,app]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.
import sys
import clr
# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
#Import Revit elements
from Revit.Elements import *
import System
#define inputs
startRefPt = IN[0]
endRefPt = IN[1]
#define system array to match with required inputs
refPtArray = System.Array[ReferencePoint]([startRefPt, endRefPt])
#create curve by reference points in Revit
OUT = CurveByPoints.ByReferencePoints(refPtArray)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.
import clr
#import Dynamo Geometry
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# Import RevitNodes
clr.AddReference("RevitNodes")
import Revit
# Import Revit elements
from Revit.Elements import *
import System
#Query Revit elements and convert them to Dynamo Curves
crvA=IN[0].Curves[0]
crvB=IN[1].Curves[0]
#Define input Parameters
framingType=IN[3]
designLevel=IN[4]
#Define "out" as a list
OUT=[]
for val in IN[2]:
#Define Dynamo Points on each curve
ptA=Curve.PointAtParameter(crvA,val)
ptB=Curve.PointAtParameter(crvB,val)
#Create Dynamo line
beamCrv=Line.ByStartPointEndPoint(ptA,ptB)
#create Revit Element from Dynamo Curves
beam = StructuralFraming.BeamByCurve(beamCrv,designLevel,framingType)
#convert Revit Element into list of Dynamo Surfaces
OUT.append(beam.Faces)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.
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.
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.
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.
El rango de color es similar al nodo Remap Range del ejercicio ; 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
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.
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.
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.
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.
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.
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.
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.
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.
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.


















// construct a Vector object
v = Vector.ByCoordinates(1, 2, 3);
s = v.X + " " + v.Y + " " + v.Z;a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);
// c has value x = 9, y = 6, z = 0
c = a.Add(b);a = Vector.ByCoordinates(5, 5, 0);
b = Vector.ByCoordinates(4, 1, 0);
// c has value x = 1, y = 4, z = 0
c = a.Subtract(b);a = Vector.ByCoordinates(4, 4, 0);
// c has value x = 20, y = 20, z = 0
c = a.Scale(5);a = Vector.ByCoordinates(1, 2, 3);
a_len = a.Length;
// set the a's length equal to 1.0
b = a.Normalized();
c = b.Scale(5);
// len is equal to 5
len = c.Length;a = Vector.ByCoordinates(1, 0, 1);
b = Vector.ByCoordinates(0, 1, 1);
// c has value x = -1, y = -1, z = 1
c = a.Cross(b);a = Vector.ByCoordinates(1, 2, 1);
b = Vector.ByCoordinates(5, -8, 4);
// d has value -7
d = a.Dot(b);

















































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
































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.
Logotipo/imagen
Nombre
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.
import sys
import clr
clr.AddReference('AForge.Imaging')
from AForge.Imaging import *
bc= BlobCounter()
bc.ProcessImage(IN[0])
OUT=bcAl 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.
OUT = []
for rec in IN[0]:
subOUT=[]
subOUT.append(rec.X)
subOUT.append(rec.Y)
subOUT.append(rec.Width)
subOUT.append(rec.Height)
OUT.append(subOUT)
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).
recData;
x0=List.GetItemAtIndex(recData,0);
y0=List.GetItemAtIndex(recData,1);
width=List.GetItemAtIndex(recData,2);
height=List.GetItemAtIndex(recData,3);
x1=x0+width;y1=y0+height;
p0=Autodesk.Point.ByCoordinates(x0,y0);
p1=Autodesk.Point.ByCoordinates(x0,y1);
p2=Autodesk.Point.ByCoordinates(x1,y1);
p3=Autodesk.Point.ByCoordinates(x1,y0);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.
rectangles=IN[0]
OUT=[]
for rec in rectangles:
if rec.Width>8 and rec.Height>8:
OUT.append(rec)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.
Āæ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:
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
solid = IN[0]
seed = IN[1]
xCount = IN[2]
yCount = IN[3]
solids = []
yDist = solid.BoundingBox.MaxPoint.Y-solid.BoundingBox.MinPoint.Y
xDist = solid.BoundingBox.MaxPoint.X-solid.BoundingBox.MinPoint.X
for i in xRange:
for j in yRange:
fromCoord = solid.ContextCoordinateSystem
toCoord = fromCoord.Rotate(solid.ContextCoordinateSystem.Origin,Vector.ByCoordinates(0,0,1),(90*(i+j%val)))
vec = Vector.ByCoordinates((xDist*i),(yDist*j),0)
toCoord = toCoord.Translate(vec)
solids.append(solid.Transform(fromCoord,toCoord))
OUT = solidsAl 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.
# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]
#A Number that determines which rotation pattern to use
seed = IN[1]
#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]
#Create an empty list for the arrayed solids
solids = []
# Place your code below this line
# Assign your output to the OUT variable.
OUT = solidsEste 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.
# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]
#A Number that determines which rotation pattern to use
seed = IN[1]
#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]
#Create an empty list for the arrayed solids
solids = []
#Create an empty list for the edge curves
crvs = []
# Place your code below this line
#Loop through edges an append corresponding curve geometry to the list
for edge in solid.Edges:
crvs.append(edge.CurveGeometry)
#Get the bounding box of the curves
bbox = BoundingBox.ByGeometry(crvs)
#Get the x and y translation distance based on the bounding box
yDist = bbox.MaxPoint.Y-bbox.MinPoint.Y
xDist = bbox.MaxPoint.X-bbox.MinPoint.X
# Assign your output to the OUT variable.
OUT = solidsYa 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.
# Load the Python Standard and DesignScript Libraries
import sys
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
# The inputs to this node will be stored as a list in the IN variables.
#The solid module to be arrayed
solid = IN[0]
#A Number that determines which rotation pattern to use
seed = IN[1]
#The number of solids to array in the X and Y axes
xCount = IN[2]
yCount = IN[3]
#Create an empty list for the arrayed solids
solids = []
#Create an empty list for the edge curves
crvs = []
# Place your code below this line
#Loop through edges an append corresponding curve geometry to the list
for edge in solid.Edges:
crvs.append(edge.CurveGeometry)
#Get the bounding box of the curves
bbox = BoundingBox.ByGeometry(crvs)
#Get the x and y translation distance based on the bounding box
yDist = bbox.MaxPoint.Y-bbox.MinPoint.Y
xDist = bbox.MaxPoint.X-bbox.MinPoint.X
#Get the source coordinate system
fromCoord = solid.ContextCoordinateSystem
#Loop through x and y
for i in range(xCount):
for j in range(yCount):
#Rotate and translate the coordinate system
toCoord = fromCoord.Rotate(solid.ContextCoordinateSystem.Origin, Vector.ByCoordinates(0,0,1), (90*(i+j%seed)))
vec = Vector.ByCoordinates((xDist*i),(yDist*j),0)
toCoord = toCoord.Translate(vec)
#Transform the solid from the source coord syste, to the target coord system and append to the list
solids.append(solid.Transform(fromCoord,toCoord))
# Assign your output to the OUT variable.
OUT = solidsHaga 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.
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.
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.
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
sysyclr, que son necesarios para que el intérprete de Python funcione correctamente. En concreto, el móduloclrpermite 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
usingoImportsde 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
OUTal final de la secuencia de comandos.
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.
šÆ Obtenga la geometrĆa de contorno de todas las cuencas vertientes de un dibujo.
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!
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.
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.
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.
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.
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.
š Ā”Misión cumplida!
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.


























Objeto Autodesk.AutoCAD.DynamoNodes.Object
Entidad Autodesk.AutoCAD.DatabaseServices.Entity
CivilObject Autodesk.Civil.DynamoNodes.CivilObject
Entidad Autodesk.Civil.DatabaseServices.Entity
# Cargar las bibliotecas de normas y DesignScript de Python
import sys
import clr
# AƱadir ensamblajes para AutoCAD y Civil 3D
clr.AddReference('AcMgd')
clr.AddReference('AcCoreMgd')
clr.AddReference('AcDbMgd')
clr.AddReference('AecBaseMgd')
clr.AddReference('AecPropDataMgd')
clr.AddReference('AeccDbMgd')
clr.AddReference('ProtoGeometry')
# Importar referencias de AutoCAD
from Autodesk.AutoCAD.Runtime import *
from Autodesk.AutoCAD.ApplicationServices import *
from Autodesk.AutoCAD.EditorInput import *
from Autodesk.AutoCAD.DatabaseServices import *
from Autodesk.AutoCAD.Geometry import *
# Importar referencias de Civil 3D
from Autodesk.Civil.ApplicationServices import *
from Autodesk.Civil.DatabaseServices import *
from Autodesk.DesignScript.Geometry import Point as DynPoint
# Las entradas de este nodo se almacenarƔn como una lista en las variables IN.
objs = IN[0]
output = []
if objs is None:
sys.exit("La entrada es nula o estĆ” vacĆa.")
if not isinstance(objs, list):
objs = [objs]
adoc = Application.DocumentManager.MdiActiveDocument
editor = adoc.Editor
with adoc.LockDocument():
with adoc.Database as db:
with db.TransactionManager.StartTransaction() as t:
for obj in objs:
id = obj.InternalObjectId
aeccObj = t.GetObject(id, OpenMode.ForRead)
if isinstance(aeccObj, Catchment):
catchment = aeccObj
acPnts = catchment.BoundaryPolyline3d
dynPnts = []
for acPnt in acPnts:
pnt = DynPoint.ByCoordinates(acPnt.X, acPnt.Y, acPnt.Z)
dynPnts.append(pnt)
output.append(dynPnts)
# Validar antes de finalizar la transacción
t.Commit()
pass
# Asigne la salida a la variable OUT.
OUT = output





























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 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.
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.


























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.
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.
NĆŗmero 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.
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.ByCylindricalCoordinates 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.
**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.
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.ByCylindricalCoordinates 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.





























































































































































































































