Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Depois de criar alguns nós personalizados, a próxima etapa é começar a organizá-los e publicá-los por meio de pacotes: uma forma conveniente de armazenar e compartilhar os nós com a Comunidade do Dynamo.
O Dynamo oferece muitos nós principais para uma ampla gama de tarefas de programação visual. Às vezes, uma solução mais rápida, mais elegante ou compartilhada com mais facilidade consiste em construir seus próprios nós. Eles podem ser reusados em diferentes projetos e tornam os gráficos mais claros e limpos, além de poderem ser enviados para o gerenciador de pacotes e compartilhados com a comunidade global do Dynamo.
Os nós personalizados são construídos pelo agrupamento de outros nós e dos nós personalizados dentro de um “nó personalizado do Dynamo”, que podemos pensar conceitualmente como um contêiner. Quando esse nó de contêiner é executado no gráfico, tudo dentro dele será executado para permitir a reutilização e o compartilhamento de uma combinação útil de nós.
Quando você tem várias cópias de um nó personalizado no gráfico, é possível atualizar todas elas editando o nó personalizado de base. Isso permite atualizar o gráfico sem problemas, adaptando-se a quaisquer alterações que possam ocorrer no fluxo de trabalho ou no projeto.
O melhor recurso dos nós personalizados é a forma de compartilhamento de trabalho. Se um “usuário avançado” criar um gráfico do Dynamo complexo e o entregar a um designer iniciante no Dynamo, ele poderá condensar o gráfico para exibir o essencial para a interação do projeto. Será possível abrir o nó personalizado para editar o gráfico interno, mas o “contêiner” poderá ser mantido simples. Com esse processo, os nós personalizados permitem que os usuários do Dynamo projetem um gráfico limpo e intuitivo.
Há uma ampla variedade de maneiras de criar nós personalizados no Dynamo. Nos exemplos neste capítulo, vamos criar nós personalizados diretamente na interface do usuário do Dynamo. Se você for um programador e tiver interesse na formatação C# ou Sem toque, poderá consultar esta página na Wiki do Dynamo para obter uma revisão mais aprofundada.
Vamos para o ambiente de nó personalizado e criar um nó simples para calcular uma porcentagem. O ambiente de nó personalizado é diferente do ambiente gráfico do Dynamo, mas a interação é fundamentalmente a mesma. Com isso, vamos criar nosso primeiro nó personalizado.
Para criar um nó personalizado do zero, inicie o Dynamo e selecione Nó personalizado ou digite Ctrl + Shift + N na tela.
Atribua um nome, uma descrição e uma categoria na caixa de diálogo Propriedades de nó personalizado.
Nome: porcentagem
Descrição: calcula a porcentagem de um valor em relação a outro.
Categoria: Math.Functions
Isso abrirá uma tela com um fundo amarelo, indicando que você está trabalhando dentro de um nó personalizado. Nessa tela, você tem acesso a todos os nós principais do Dynamo, bem como aos nós Input e Output, que rotulam os dados que fluem para dentro e para fora do nó personalizado. Eles podem ser encontrados em Entrada>Básico.
Entradas: os nós de entrada criam portas de entrada no nó personalizado. A sintaxe para um nó de entrada é input_name : datatype = default_value(optional).
Saídas: de forma semelhante às entradas, os nós de saída criam e nomeiam as portas de saída no nó personalizado. Considere a possibilidade de adicionar um Comentário personalizado às portas de entrada e saída para indicar os tipos de entrada e saída. Isso é discutido em mais detalhes na seção Criar nós personalizados.
É possível salvar esse nó personalizado como um arquivo .dyf (em oposição ao arquivo .dyn padrão) e ele será automaticamente adicionado à sua sessão e a sessões futuras. Você encontrará o nó personalizado na biblioteca na seção Complementos.
Agora que criamos nosso primeiro nó personalizado, as próximas seções se aprofundarão na funcionalidade dos nós personalizados e como publicar fluxos de trabalho genéricos. Na seção a seguir, vamos analisar o desenvolvimento de um nó personalizado que transfere a geometria de uma superfície para outra.
Acabamos de criar um nó personalizado e aplicá-lo a um processo específico em nosso gráfico do Dynamo. Gostamos tanto desse nó, por isso queremos mantê-lo em nossa biblioteca do Dynamo para usar como referência em outros gráficos. Para fazer isso, vamos publicar o nó localmente. Este é um processo semelhante ao de publicar um pacote, que iremos mostrar em mais detalhes no próximo capítulo.
Quando publicar um nó localmente, o nó estará acessível na biblioteca do Dynamo quando você abrir uma nova sessão. Se nenhum nó for publicado, o gráfico do Dynamo que faz referência a um nó personalizado também deverá ter aquele nó personalizado em sua pasta (ou o nó personalizado deverá ser importado para o Dynamo usando Arquivo > Importar biblioteca).
É possível publicar nós e pacotes personalizados do Dynamo Sandbox na versão 2.17 e mais recentes, desde que não tenham dependências de APIs do hospedeiro. Em versões anteriores, a publicação de nós e pacotes personalizados somente estava ativada no Dynamo for Revit e no Dynamo for Civil 3D.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Vamos avançar com o nó personalizado que criamos na seção anterior. Quando o nó personalizado PointsToSurface é aberto, vemos o gráfico no Editor de nós personalizados do Dynamo. Também é possível abrir um nó personalizado clicando duas vezes nele no Editor de gráficos do Dynamo.
Para publicar um nó personalizado localmente, basta clicar com o botão direito do mouse na tela e selecionar “Publicar este nó personalizado...”
Preencha as informações relevantes de forma similar à imagem acima e selecione “Publicar localmente”. Observe que o campo Grupo define o elemento principal acessível no menu do Dynamo.
Escolha uma pasta para armazenar todos os nós personalizados que você planeja publicar localmente. O Dynamo verificará essa pasta sempre que ela for carregada, portanto, certifique-se de que a pasta esteja em um local permanente. Navegue até essa pasta e escolha “Selecionar pasta”. O nó do Dynamo agora é publicado localmente e permanecerá na biblioteca do Dynamo cada vez que você carregar o programa.
Para verificar a localização da pasta de nós personalizados, vá para Dynamo > Preferências > Configurações do pacote > Caminhos de nós e pacotes.
Nessa janela, vemos uma lista de caminhos.
Documentos\DynamoCustomNodes... refere-se à localização dos nós personalizados que publicamos localmente.
AppData\Roaming\Dynamo... refere-se à localização padrão dos pacotes do Dynamo instalados on-line.
Você pode desejar mover o caminho da pasta local para baixo na ordem da lista (clicando na seta para baixo à esquerda do nome do caminho). A pasta superior é o caminho padrão para a instalação do pacote. Portanto, mantendo o caminho de instalação do pacote do Dynamo padrão como a pasta padrão, os pacotes on-line serão separados dos nós publicados localmente.
Alteramos a ordem dos nomes de caminhos para que o caminho padrão do Dynamo seja o local de instalação do pacote.
Navegando para essa pasta local, poderemos encontrar o nó personalizado original na pasta “.dyf”, que é a extensão de arquivo de nós personalizados do Dynamo. Podemos editar o arquivo nessa pasta e o nó será atualizado na interface do usuário. Também é possível adicionar mais nós à pasta principal DynamoCustomNode e o Dynamo os adicionará à biblioteca ao ser reiniciado.
O Dynamo agora será carregado sempre com “PointsToSurface” no grupo “DynamoPrimer” da biblioteca do Dynamo.
O Dynamo oferece diversas formas de criar um pacote para seu uso pessoal ou para compartilhar com a comunidade do Dynamo. No estudo de caso abaixo, vamos analisar como um pacote é configurado desconstruindo um existente. Este estudo de caso baseia-se nas lições do capítulo anterior, fornecendo um conjunto de nós personalizados para o mapeamento de geometria, por coordenadas UV, de uma superfície do Dynamo para outra.
Vamos trabalhar com um pacote de amostra que demonstra o mapeamento UV de pontos de uma superfície para outra. Já desenvolvemos os conceitos básicos da ferramenta na seção Criar um nó personalizado deste manual. Os arquivos abaixo demonstram como podemos usar o conceito de mapeamento UV e desenvolver um conjunto de ferramentas para uma biblioteca publicável.
Nessa imagem, mapeamos um ponto de uma superfície para outra usando as coordenadas UV. O pacote é baseado nesse conceito, mas com uma geometria mais complexa.
No capítulo anterior, exploramos formas de criar painéis em uma superfície no Dynamo com base nas curvas definidas no plano XY. Este estudo de caso estende esses conceitos para mais cotas de geometria. Vamos instalar esse pacote conforme construído para demonstrar como ele foi desenvolvido. Na próxima seção, demonstraremos como esse pacote foi publicado.
No Dynamo, clique em Pacotes > Package Manager e procure o pacote “MapToSurface” (uma única palavra). Clique em Instalar para iniciar o download e adicionar o pacote à biblioteca.
Após a instalação, os nós personalizados devem estar disponíveis na seção Complementos > DynamoPrimer.
Com o pacote já instalado, vamos analisar como ele está configurado.
O pacote que estamos criando usa cinco nós personalizados que criamos para referência. Vamos examinar o que cada nó faz abaixo. Alguns nós personalizados são criados com base em outros nós personalizados, e os gráficos têm um layout para que outros usuários compreendam de forma simples.
Esse é um pacote simples com cinco nós personalizados. Nas etapas abaixo, falaremos brevemente sobre a configuração de cada nó personalizado.
Esse é um nó personalizado básico e no qual todos os outros nós de mapeamento estão baseados. Em termos simples, o nó mapeia um ponto de uma coordenada UV da superfície de origem para o local da coordenada UV a superfície de destino. Como os pontos são a geometria mais primitiva, a partir da qual se constrói uma geometria mais complexa, podemos usar essa lógica para mapear a geometria 2D e até mesmo a geometria 3D de uma superfície para outra.
A lógica de estender pontos mapeados da geometria 1D para a geometria 2D é demonstrada aqui simplesmente com polígonos. Observe que aninhamos o nó “PointsToSurface” nesse nó personalizado. Dessa forma, é possível mapear os pontos de cada polígono para a superfície e, em seguida, regenerar o polígono com base nesses pontos mapeados. Mantendo a estrutura de dados apropriada (uma lista de listas de pontos), podemos manter os polígonos separados após serem reduzidos a um conjunto de pontos.
A mesma lógica do nó “PolygonsToSurface” se aplica aqui. Mas, em vez de mapear pontos poligonais, estamos mapeando pontos de controle de uma curva Nurbs.
OffsetPointsToSurface
Esse nó é um pouco mais complexo, mas o conceito é simples: como o nó “PointsToSurface”, esse nó mapeia pontos de uma superfície para outra. No entanto, ele também considera os pontos que não estão na superfície de origem, obtém sua distância até o parâmetro UV mais próximo e mapeia essa distância para a normal da superfície-alvo na coordenada UV correspondente. Isso fará mais sentido ao analisar os arquivos de exemplo.
Esse é um nó simples que cria uma superfície paramétrica para mapear da grade de origem para uma superfície ondulada nos arquivos de exemplo.
Os arquivos de exemplo podem ser encontrados na pasta raiz do pacote. Clique na guia Package Manager > Pacotes instalados.
Ao lado de MapToSurface, clique no menu de pontos verticais > Mostrar diretório raiz.
Em seguida, abra a pasta “extra”, que contém todos os arquivos do pacote que não são nós personalizados. Esse é o local onde os arquivos de exemplos (se existirem) são armazenados para pacotes do Dynamo. As capturas de tela abaixo apresentam os conceitos demonstrados em cada arquivo de exemplo.
Esse arquivo de exemplo demonstra como “PointsToSurface” pode ser usado para criar painéis em uma superfície com base em uma grade de retângulos. Isso deve parecer familiar para você, pois demonstramos um fluxo de trabalho similar no capítulo anterior.
Usando um fluxo de trabalho semelhante, esse arquivo de exercício mostra uma configuração para o mapeamento de círculos (ou polígonos que representam círculos) de uma superfície para outra. Isso usa o nó “PolygonsToSurface”.
Esse arquivo de exemplo adiciona alguma complexidade ao trabalhar com o nó “NurbsCrvToSurface”. A superfície alvo é deslocada uma determinada distância e a curva Nurbs é mapeada para a superfície alvo original e para a superfície de deslocamento. A partir daí, as duas curvas mapeadas são elevadas para criar uma superfície, que então se torna mais espessa. Esse sólido resultante apresenta uma ondulação representativa das normais da superfície-alvo.
Esse arquivo de exemplo demonstra como mapear uma PolySurface plissada de uma superfície de origem para uma superfície-alvo. A superfície de origem e a de destino são uma superfície retangular que se estende pela grade e uma superfície de revolução, respectivamente.
A PolySurface de origem é mapeada da superfície de origem para a superfície de destino.
Como os nós personalizados são capazes de mapear diferentes tipos de curvas, esse último arquivo faz referência a um arquivo SVG exportado do Illustrator e mapeia as curvas importadas para uma superfície-alvo.
Durante a análise da sintaxe de um arquivo .svg, as curvas são convertidas do formato .xml para policurvas do Dynamo.
As curvas importadas são mapeadas para uma superfície-alvo. Isso nos permite projetar explicitamente (apontar e clicar) uma panorâmica no Illustrator, importar para o Dynamo e aplicar a uma superfície de destino.
O Dynamo oferece um grande número de recursos prontos para uso e também mantém uma ampla biblioteca de pacotes que pode estender significativamente a capacidade do Dynamo. Um pacote é uma coleção de nós personalizados ou funcionalidades adicionais. O Dynamo Package Manager é um portal para a comunidade fazer download de qualquer pacote que tenha sido publicado on-line. Esses conjuntos de ferramentas são desenvolvidos por terceiros para estender a funcionalidade central do Dynamo, acessível a todos, e prontos para download com o clique do botão.
Um projeto de código aberto, como o Dynamo, prospera com esse tipo de envolvimento da comunidade. Com desenvolvedores de terceiros dedicados, o Dynamo é capaz de estender seu alcance para os fluxos de trabalho em uma variedade de setores. Por esse motivo, a equipe do Dynamo tem feito esforços em conjunto para simplificar o desenvolvimento e a publicação de pacotes (que serão discutidos mais detalhadamente nas seções a seguir).
A maneira mais fácil de instalar um pacote é usando a opção de menu Pacotes na interface do Dynamo. Vamos entrar nele e instalar um pacote agora. Neste exemplo rápido, vamos instalar um pacote popular para criar painéis quadrados em uma grade.
No Dynamo, vá para Pacotes > Package Manager...
Na barra de pesquisa, vamos procurar “quadrados na grade retangular”. Após alguns momentos, você deverá ver todos os pacotes que correspondem a essa consulta de pesquisa. Queremos selecionar o primeiro pacote com o nome correspondente.
Clique em Instalar para adicionar esse pacote à biblioteca e, em seguida, aceite a confirmação. Concluído.
Observe que agora temos outro grupo em nossa biblioteca do Dynamo, chamado “buildz”. Esse nome se refere ao desenvolvedor do pacote e o nó personalizado é colocado nesse grupo. Podemos começar a usá-lo imediatamente.
Use Bloco de código para definir rapidamente uma grade retangular, gere a saída do resultado para um nó Polygon.ByPoints e, subsequentemente, um nó Surface.ByPatch para visualizar a lista de painéis retangulares que você acabou de criar.
O exemplo acima se concentra em um pacote com um nó personalizado, mas você usa o mesmo processo para fazer o download de pacotes com diversos nós personalizados e arquivos de dados de suporte. Vamos demonstrar isso agora, com um pacote mais abrangente: o Dynamo Unfold.
Como no exemplo acima, comece selecionando Pacotes > Package Manager...
Desta vez, vamos procurar “DynamoUnfold”, uma palavra. Quando os pacotes forem exibidos, faça o download clicando em Instalar para adicionar o Dynamo Unfold à biblioteca do Dynamo.
Na biblioteca do Dynamo, temos um grupo DynamoUnfold com várias categorias e vários nós personalizados.
Agora, vamos analisar a estrutura de arquivos do pacote.
Primeiro, vá para Pacotes > Package Manager > Pacotes instalados.
Em seguida, clique em Mostrar diretório raiz para abrir a pasta raiz desse pacote.
Isso nos leva ao diretório raiz do pacote. Observe que temos três pastas e um arquivo.
A pasta bin contém os arquivos .dll. Esse pacote do Dynamo foi desenvolvido usando a funcionalidade Sem toque; por isso, os nós personalizados são mantidos nessa pasta.
A pasta dyf contém os nós personalizados. Esse pacote não foi desenvolvido usando os nós personalizados do Dynamo; portanto, a pasta está vazia para esse pacote.
A pasta extra contém todos os arquivos adicionais, inclusive os arquivos de exemplo.
O arquivo pkg é um arquivo de texto básico que define as configurações do pacote. Podemos ignorar isso por enquanto.
Abrindo a pasta “extra”, vemos muitos arquivos de exemplo que foram obtidos por download com a instalação. Nem todos os pacotes têm arquivos de exemplo, mas será possível encontrá-los se fizerem parte de um pacote.
Vamos abrir “SphereUnfold”.
Após abrir o arquivo e pressionar “Executar” no solucionador, teremos uma esfera desdobrada. Arquivos de exemplo como esses são úteis para saber como trabalhar com um novo pacote do Dynamo.
No Package Manager, é possível procurar pacotes usando as opções de classificação e filtragem na guia Procurar pacotes. Há vários filtros disponíveis para o programa hospedeiro, status (novo, obsoleto ou não) e se o pacote tem dependências.
Através da classificação de pacotes, é possível identificar os pacotes com alta classificação ou aqueles com mais downloads, ou encontrar pacotes com atualizações recentes.
Também é possível acessar mais detalhes em cada pacote clicando em Exibir detalhes. Isso abre um painel lateral no Package Manager, onde é possível encontrar informações como controle de versão e dependências, URL do site ou do repositório, informações de licença etc.
Se você quiser ver onde os arquivos dos pacotes estão armazenados, na parte superior da navegação, clique em Dynamo > Preferências > Configurações do pacote > Localizações dos arquivos de nós e pacotes. Você poderá encontrar o diretório da pasta raiz atual aqui.
Por padrão, os pacotes são instalados em uma localização similar a este caminho de pasta: C:/Usuários/[nome de usuário]/AppData/Roaming/Dynamo/[versão do Dynamo].
A comunidade do Dynamo está crescendo e evoluindo constantemente. Explorando o Dynamo Package Manager periodicamente, você encontrará alguns novos desenvolvimentos empolgantes. Nas seções a seguir, analisaremos com mais detalhes os pacotes, da perspectiva do usuário final até a criação do seu próprio pacote do Dynamo.
Nas seções anteriores, analisamos os detalhes de como o pacote MapToSurface é configurado com nós personalizados e arquivos de exemplo. Mas como publicamos um pacote que foi desenvolvido localmente? Este estudo de caso demonstra como publicar um pacote de um conjunto de arquivos em uma pasta local.
Há diversas formas de publicar um pacote. Confira abaixo o processo que aconselhamos: publicar localmente, desenvolver localmente e publicar on-line. Vamos começar com uma pasta contendo todos os arquivos do pacote.
Antes de passarmos para a publicação do pacote MapToSurface, se você instalou o pacote da lição anterior, desinstale-o para que não esteja trabalhando com pacotes idênticos.
Para começar, vá para a guia Pacotes > Package Manager > Pacotes instalados > ao lado de MapToSurface, clique no menu de pontos verticais > Excluir.
Em seguida, reinicie o Dynamo. Depois de reabrir, quando você verificar a janela “Gerenciar pacotes”, o MapToSurface não deverá mais estar lá. Agora estamos prontos para começar.
É possível publicar nós e pacotes personalizados do Dynamo Sandbox na versão 2.17 e mais recentes, desde que não tenham dependências de APIs do hospedeiro. Em versões anteriores, a publicação de nós e pacotes personalizados somente estava ativada no Dynamo for Revit e no Dynamo for Civil 3D.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Este é o primeiro envio para o nosso pacote e colocamos todos os arquivos de exemplo e nós personalizados em uma pasta. Com essa pasta preparada, estamos prontos para carregar no Dynamo Package Manager.
Essa pasta contém cinco nós personalizados (.dyf).
Essa pasta também contém cinco arquivos de exemplo (.dyn) e um arquivo de vetor importado (.svg). Esses arquivos servirão como exercícios introdutórios para mostrar ao usuário como trabalhar com os nós personalizados.
No Dynamo, comece clicando na guia Pacotes > Package Manager > Publicar novo pacote.
Na guia Publicar um pacote, preencha os campos relevantes no lado esquerdo da janela.
Em seguida, adicionaremos arquivos de pacote. É possível adicionar arquivos um a um ou todas as pastas selecionando Adicionar diretório (1). Para adicionar arquivos que não são arquivos .dyf, assegure-se de alterar o tipo de arquivo na janela do navegador para “Todos os arquivos (.)”. Observe que vamos adicionar indiscriminadamente cada arquivo, nó personalizado (.dyf) ou arquivo de exemplo (.dyn). O Dynamo categorizará esses itens quando o pacote for publicado.
Depois de selecionar a pasta MapToSurface, o Package Manager mostrará o conteúdo da pasta. Se você estiver carregando seu próprio pacote com uma estrutura de pastas complexa e não quiser que o Dynamo faça alterações na estrutura de pastas, poderá ativar a alternância “Manter estrutura de pastas”. Essa opção é para usuários avançados e, se o pacote não for configurado deliberadamente de uma forma específica, será melhor deixar essa alternância desativada e permitir que o Dynamo organize os arquivos conforme necessário. Clique em Avançar para continuar.
Aqui, você tem a chance de visualizar como o Dynamo organizará os arquivos do pacote antes da publicação. Clique em Concluir para continuar.
Publique clicando em “Publicar localmente” (1). Após completar esses passos, certifique-se de clicar em “Publicar localmente” e não em “Publicar on-line” para evitar ter um acúmulo de pacotes duplicados no Package Manager.
Após a publicação, os nós personalizados devem estar disponíveis no grupo “DynamoPrimer” ou na Biblioteca do Dynamo.
Agora, vamos examinar o diretório raiz para ver como o Dynamo formatou o pacote que acabamos de criar. Para fazer isso, vá para a guia Pacotes instalados > ao lado de MapToSurface, clique no menu de pontos verticais > selecione Mostrar diretório raiz.
Observe que o diretório raiz está na localização local do pacote (lembre-se de que publicamos o pacote “localmente”). O Dynamo está fazendo referência a esta pasta para ler nós personalizados. Portanto, é importante publicar localmente o diretório em uma localização de pasta permanente (ou seja, não na área de trabalho). Veja a seguir o detalhamento da pasta do pacote do Dynamo.
A pasta bin contém os arquivos .dll criados com bibliotecas C# ou Sem toque. Não temos nenhum arquivo desse tipo nesse pacote; portanto, a pasta está em branco neste exemplo.
A pasta dyf contém os nós personalizados. Depois de abrir essa pasta, serão exibidos todos os nós personalizados (arquivos .dyf) desse pacote.
A pasta adicional contém todos os arquivos adicionais. É provável que esses arquivos sejam arquivos do Dynamo (.dyn) ou qualquer arquivo adicional necessário (.svg, .xls, .jpeg, .sat, etc.).
O arquivo pkg é um arquivo de texto básico que define as configurações do pacote. Isso é automatizado no Dynamo, mas pode ser editado se você deseja entrar nos detalhes.
Observação: Siga estas etapas somente se você estiver realmente publicando um pacote próprio.
Quando estiver pronto para publicar, na janela Pacotes > Package Manager > Pacotes instalados, selecione o botão à direita do pacote que deseja publicar e escolha Publicar.
Se você estiver atualizando um pacote que já foi publicado, selecione “Publicar versão” e o Dynamo atualizará o pacote on-line com base nos novos arquivos no diretório raiz do pacote. Simples assim!
Ao atualizar os arquivos na pasta raiz do pacote publicado, também é possível publicar uma nova versão do pacote selecionando “Publicar versão...” na guia Meus pacotes. Essa é uma forma perfeita para fazer atualizações necessárias ao conteúdo e para compartilhar com a comunidade. A opção Publicar versão só funcionará se você for o administrador do pacote.
O Kit de ferramentas de malha do Dynamo fornece ferramentas para importar malhas de formatos de arquivos externos, para criar uma malha com base nos objetos de geometria do Dynamo e para criar manualmente malhas de acordo com seus vértices e índices. A biblioteca também fornece ferramentas para modificar malhas, reparar malhas ou extrair camadas horizontais para uso na fabricação.
O Kit de ferramentas de malha do Dynamo faz parte da pesquisa contínua sobre malhas da Autodesk e, como tal, continuará a crescer nos próximos anos. Pode contar com o aparecimento frequente de novos métodos no kit de ferramentas. Sinta-se à vontade para entrar em contato com a equipe do Dynamo com comentários, bugs e sugestões de novos recursos.
No Dynamo, vá para Pacotes > Package Manager... na barra de menus superior. No campo de pesquisa, digite MeshToolkit, uma única palavra. Clique em Instalar e aceite as confirmações para iniciar o download. É tão simples quanto isso.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Neste exemplo, vamos analisar o nó Intersect no kit de ferramentas de malha. Vamos importar uma malha e intersecioná-la com uma série de planos de entrada para criar fatias. Esse é o ponto inicial para preparar o modelo para fabricação de um cortador a laser, um cortador a jato de água ou uma fresa CNC.
Para começar, abra Mesh-Toolkit_Intersect-Mesh.dyn in Dynamo.
Caminho do arquivo: localize o arquivo de malha a ser importado (stanford_bunny_tri.obj). Os tipos de arquivo suportados são .mix e .obj
Mesh.ImportFile: conecte o caminho do arquivo para importar a malha
Point.ByCoordinates: crie um ponto, ele será o centro de um arco.
Arc.ByCenterPointRadiusAngle: crie um arco em torno do ponto. Essa curva será usada para posicionar uma série de planos. __ As configurações são as seguintes: __
radius: 40, startAngle: -90, endAngle:0
Crie uma série de planos orientados ao longo do arco.
Bloco de código: crie 25 números entre 0 e 1.
Curve.PointAtParameter: conecte o arco à entrada “curva” e a saída do bloco de código à entrada “parâmetro” para extrair uma série de pontos ao longo da curva.
Curve.TangentAtParameter: conecte as mesmas entradas do nó anterior.
Plane.ByOriginNormal: conecte os pontos à entrada “origem” e os vetores à entrada “normal” para criar uma série de planos em cada ponto.
Em seguida, usaremos esses planos para fazer a interseção com a malha.
Mesh.Intersect: faça a interseção dos planos com a malha importada, criando uma série de contornos de policurvas. Clique com o botão direito do mouse em Nó e defina a amarra como a mais longa
PolyCurve.Curves: divida as policurvas em seus fragmentos de curva.
Curve.EndPoint: extraia os pontos finais de cada curva.
NurbsCurve.ByPoints: use os pontos para criar uma curva Nurbs. Use um nó Booleano definido como True para fechar as curvas.
Antes de continuar, desative a visualização de alguns dos nós, como: Mesh.ImportFile, Curve.EndPoint, Plane.ByOriginNormal e Arc.ByCenterPointRadiusAngle para ver melhor o resultado.
Surface.ByPatch: crie as correções de superfícies para cada contorno para criar “fatias” da malha.
Adicione um segundo conjunto de fatias para obter um efeito waffle/caixa de ovos.
Você pode ter notado que as operações de intersecção são calculadas mais rapidamente com uma malha do que com um sólido comparável. Fluxos de trabalho como o demonstrado neste exercício ajudam a trabalhar com malhas.
Logo de início, o Dynamo tem uma grande quantidade de funções armazenadas em sua Biblioteca de nós. Para as rotinas usadas com frequência ou aquele gráfico especial que você deseja compartilhar com a comunidade, os pacotes e nós personalizados são uma ótima maneira de estender o Dynamo ainda mais.
Ao lado de DynamoUnfold, selecione o menu de opções .
Outra forma de descobrir pacotes do Dynamo é explorar o site do . Nesse site, é possível encontrar estatísticas sobre os pacotes e criar quadros de pontuação. Também é possível fazer o download dos arquivos do pacote no Dynamo Package Manager, mas fazer isso diretamente no Dynamo é um processo mais intuitivo.
O exercício abaixo demonstra algumas operações básicas de malha usando o Kit de ferramentas de malha. No exercício, intersecionamos uma malha com uma série de planos, que podem ser computacionalmente caros usando sólidos. Ao contrário de um sólido, uma malha tem uma “resolução” definida e não é definida matematicamente, e sim topologicamente, sendo possível definir essa resolução com base na tarefa em questão. Para obter mais detalhes sobre as relações entre malhas e sólidos, consulte o capítulo neste manual. Para uma análise mais completa do Kit de ferramentas de malha, consulte a Vamos analisar o pacote no exercício abaixo.
A importação sem toque é um método simples de apontar e clicar para importar bibliotecas C#. O Dynamo lê os métodos públicos de um arquivo .dll e os converte em nós do Dynamo. É possível usar a funcionalidade Sem toque para desenvolver seus próprios nós e pacotes personalizados e para importar bibliotecas externas para o ambiente do Dynamo.
Arquivos .dll
Nós do Dynamo
Com a funcionalidade Sem toque, é possível importar de fato uma biblioteca que não foi necessariamente desenvolvida para o Dynamo e criar um conjunto de novos nós. A funcionalidade Sem toque atual demonstra a mentalidade do projeto do Dynamo entre plataformas.
Esta seção demonstra como usar a funcionalidade Sem toque para importar uma biblioteca de terceiros. Para obter informações sobre como desenvolver sua própria biblioteca sem toque, consulte a página wiki do Dynamo.
Os pacotes sem toque são um bom complemento aos nós personalizados definidos pelo usuário. Alguns pacotes que usam bibliotecas C# são listados na tabela abaixo. Para obter informações mais detalhadas sobre os pacotes, consulte a seção Pacotes no Apêndice.
Neste estudo de caso, vamos mostrar como importar a biblioteca .dll externa AForge. O AForge é uma biblioteca robusta que oferece uma variedade de funcionalidades de processamento de imagens para inteligência artificial. Vamos fazer referência à classe de imagens no AForge para fazer alguns exercício de processamento de imagens abaixo.
Vamos começar por fazer o download do AForge. Na página de download do AForge, selecione [Instalador de download] e faça a instalação após a conclusão do download.
No Dynamo, crie um novo arquivo e selecione Arquivo > Importar biblioteca...
Em seguida, localize o arquivo dll.
Na janela pop-up, navegue até a pasta de lançamento na instalação do AForge. Provavelmente isso estará em uma pasta semelhante a esta: C:\Arquivos de Programas (x86)\AForge.NET\Framework\Release.
AForge.Imaging.dll: somente queremos usar esse arquivo da biblioteca do AForge para este estudo de caso. Selecione este arquivo .dll e clique em “Abrir”.
De volta ao Dynamo, você deve ver um grupo de nós do AForge adicionados à biblioteca. Agora, temos acesso à biblioteca de imagens do AForge do nosso programa visual.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Agora que a biblioteca foi importada, começaremos de forma simples com este primeiro exercício (01-EdgeDetection.dyn). Vamos fazer um processamento básico de imagens em uma imagem de amostra para mostrar como o AForge filtra as imagens. Usaremos o nó “Inspeção de imagem” para mostrar nossos resultados e aplicar filtros no Dynamo de forma similar aos do Photoshop.
Para importar uma imagem, adicione um nó Caminho do arquivo à tela e selecione “soapbubbles.jpg” na pasta de exercícios (créd. foto: flickr).
O nó Caminho do arquivo simplesmente fornece uma sequência de caracteres do caminho para a imagem que selecionamos. Em seguida, precisamos convertê-la em um arquivo de imagem usável no Dynamo.
Use Arquivo do caminho para converter o item do caminho do arquivo em uma imagem no ambiente do Dynamo.
Conecte o nó Caminho do arquivo ao nó File.FromPath.
Para converter esse arquivo em uma imagem, usaremos o nó Image.ReadFromFile.
Por último, vamos ver o resultado. Solte um nó Inspeção de imagem na tela e conecte-se a Image.ReadFromFile. Ainda não usamos o AForge, mas importamos com êxito uma imagem para o Dynamo.
Em AForge.Imaging.AForge.Imaging.Filters (no menu de navegação), você notará que há uma ampla gama de filtros disponíveis. Agora, vamos usar um desses filtros para diminuir a saturação de uma imagem com base nos valores-limite.
Solte três controles deslizantes na tela, altere seus intervalos para que fiquem de 0 a 1 e seus valores de etapas para 0,01.
Adicione o nó Grayscale.Grayscale à tela. Esse é um filtro do AForge que aplica um filtro de escala de cinza a uma imagem. Conecte os três controles deslizantes da etapa 1 a cr, cg e cb. Altere os controles deslizantes superior e inferior para ter um valor de 1 e o controle deslizante do meio para ter um valor de 0.
Para aplicar o filtro escala de cinza, é necessário executar uma ação em nossa imagem. Para isso, usamos BaseFilter.Apply. Conecte a imagem à entrada de imagem e Grayscale.Grayscale à entrada baseFilter.
A conexão a um nó Inspeção de imagem permitirá obter uma imagem sem saturação.
Podemos ter controle sobre como diminuir a saturação dessa imagem com base nos valores-limite para vermelho, verde e azul. Esses valores são definidos pelas entradas para o nó Grayscale.Grayscale. Observe que a imagem parece muito escura, pois o valor verde está definido como 0 no controle deslizante.
Altere os controles deslizantes superior e inferior para ter um valor de 0 e o controle deslizante do meio para ter um valor de 1. Dessa forma, obtemos uma imagem sem saturação mais legível.
Vamos usar a imagem sem saturação e aplicar outro filtro. A imagem sem saturação tem algum contraste, por isso, vamos testar a detecção de bordas.
Adicione um nó SobelEdgeDetector.SobelEdgeDetector à tela.
Conecte-o a BaseUsingCopyPartialFilter.Apply e conecte a imagem sem saturação à entrada de imagem desse nó.
O Sobel Edge Detector realçou as bordas em uma nova imagem.
Aproximando o zoom, o detector de bordas destacou os contornos das bolhas com pixels. A biblioteca AForge tem ferramentas para obter resultados como este e criar a geometria do Dynamo. Vamos explorar isso no próximo exercício.
Agora que aprendemos alguns conceitos básicos do processamento de imagens, vamos usar uma imagem para determinar a geometria do Dynamo. Neste exercício, em um nível elementar, temos como objetivo fazer um “Traço automático” de uma imagem usando o AForge e o Dynamo. Vamos simplificar e extrair retângulos de uma imagem de referência, mas há ferramentas disponíveis no AForge para operações mais complexas. Vamos trabalhar com 02-RectangleCreation.dyn dos arquivos de exercício que transferimos por download.
Com o nó Caminho do arquivo, navegue para grid.jpg na pasta de exercícios.
Conecte as séries restantes de nós acima para revelar um eixo paramétrico de curso.
Nesta próxima etapa, queremos fazer referência aos quadrados brancos na imagem e convertê-los em geometria real do Dynamo. O AForge tem muitas ferramentas eficazes de Pesquisa visual computacional e, aqui, vamos usar uma ferramenta particularmente importante para a biblioteca chamada BlobCounter.
Após adicionar BlobCounter à tela, precisamos de uma forma de processar a imagem (de modo semelhante à ferramenta BaseFilter.Apply no exercício anterior).
Infelizmente, o nó “Processar imagem” não está imediatamente visível na biblioteca do Dynamo. Isso acontece porque a função pode não estar visível no código fonte do AForge. Para corrigir isso, precisamos encontrar uma solução alternativa.
Adicione um nó Python à tela e adicione o seguinte código ao nó Python. Esse código importa a biblioteca AForge e, em seguida, processa a imagem importada.
Conectando a saída da imagem à entrada do nó Python, obtemos um resultado AForge.Imaging.BlobCounter do nó Python.
As próximas etapas abrangem alguns truques que demonstram familiaridade com a API de imagem do AForge. Não é necessário aprender tudo isso para trabalhar no Dynamo. Esta é mais uma demonstração de como trabalhar com bibliotecas externas dentro da flexibilidade do ambiente do Dynamo.
Conecte a saída do script Python a BlobCounterBase.GetObjectRectangles. Essa ação faz a leitura de objetos em uma imagem, com base em um valor-limite, e extrai retângulos quantificados do espaço de pixel.
Adicione outro nó Python à tela, conecte-se a GetObjectRectangles e insira o código abaixo. Isso criará uma lista organizada de objetos do Dynamo.
Transponha a saída do nó Python da etapa anterior. Isso cria quatro listas, cada uma representando X, Y, Largura e Altura para cada retângulo.
Usando o bloco de código, organizamos os dados em uma estrutura que acomoda o nó Rectangle.ByCornerPoints (código abaixo).
Temos uma matriz de retângulos representando os quadrados brancos na imagem. Através da programação, fizemos algo (quase) similar a um traço automático no Illustrator.
No entanto, ainda precisamos fazer um pouco de limpeza. Aumentando o zoom, podemos ver que temos vários retângulos pequenos indesejados.
Em seguida, vamos escrever códigos para nos livrar de retângulos indesejados.
Insira um nó Python entre o nó GetObjectRetangle e outro nó Python. O código do nó está abaixo e remove todos os retângulos que estão abaixo de um determinado tamanho.
Com os retângulos supérfluos removidos, apenas para testar, vamos criar uma superfície com base nesses retângulos e efetuar a extrusão deles por uma distância baseada em suas áreas.
Por último, altere a entrada both_sides para falso e obtemos uma extrusão em uma direção. Mergulhe a peça em resina e você obtém uma mesa supermoderna.
Esses são exemplos básicos, mas os conceitos descritos aqui também podem ser usados em aplicativos reais incríveis. É possível usar a pesquisa visual computacional para diversos processos. Para nomear apenas alguns: leitores de código de barras, correspondência de perspectiva, mapeamento de projeção e realidade aumentada. Para obter informações sobre tópicos mais avançados com o AForge relacionados a este exercício, leia este artigo.
O Dynamo oferece vários métodos diferentes para criar nós personalizados. É possível criar nós personalizados do zero, com base em um gráfico existente ou explicitamente em C#. Nesta seção, vamos abordar a criação de um nó personalizado na IU do Dynamo com base em um gráfico existente. Este método é ideal para limpar o espaço de trabalho, bem como para empacotar uma sequência de nós para reutilização em outro lugar.
Na imagem abaixo, é mapeado um ponto de uma superfície para outra usando as coordenadas UV. Usaremos esse conceito para criar uma superfície de painel que faz referência a curvas no plano XY. Criaremos painéis quadrados aqui, mas usando a mesma lógica, podemos criar uma ampla variedade de painéis com o mapeamento UV. Esta é uma ótima oportunidade para o desenvolvimento de nós personalizados, pois poderemos repetir um processo semelhante mais facilmente neste gráfico ou em outros fluxos de trabalho do Dynamo.
Faça o download do arquivo de exemplo clicando no link abaixo.
É possível encontrar uma lista completa de arquivos de exemplo no Apêndice.
Vamos começar criando um gráfico que desejamos aninhar em um nó personalizado. Neste exemplo, vamos criar um gráfico que mapeia os polígonos de uma superfície base para uma superfície alvo usando as coordenadas UV. Esse processo de mapeamento UV é algo que usamos com frequência, o que faz dele um bom candidato para um nó personalizado. Para obter mais informações sobre as superfícies e o espaço UV, consulte a página Superfícies. O gráfico completo é UVmapping_Custom-Node.dyn do arquivo .zip obtido por download acima.
Bloco de código: use essa linha para criar um intervalo de 10 números entre -45 e 45
45..45..#10;Point.ByCoordinates: conecte a saída do Bloco de código às entradas “x” e “y” e defina a amarra como referência cruzada. Agora, você deve ter uma grade de pontos.
Plane.ByOriginNormal: conecte a saída “Ponto” à entrada “origem” para criar um plano em cada um dos pontos. Será usado o vetor normal padrão de (0,0,1).
Rectangle.ByWidthLength: conecte os planos da etapa anterior à entrada “plano” e use um Bloco de código com um valor de 10 para especificar a largura e o comprimento.
Agora, você deve ver uma grade de retângulos. Vamos mapear esses retângulos para uma superfície-alvo usando as coordenadas UV.
Polygon.Points: conecte a saída de Rectangle.ByWidthLength da etapa anterior à entrada “polígono” para extrair os pontos de canto de cada retângulo. Esses são os pontos que serão mapeados para a superfície-alvo.
Rectangle.ByWidthLength: use um Bloco de código com um valor de 100 para especificar a largura e o comprimento de um retângulo. Esse será o limite da nossa superfície de base.
Surface.ByPatch: conecte o Rectangle.ByWidthLength da etapa anterior à entrada “closedCurve” para criar uma superfície de base.
Surface.UVParameterAtPoint: conecte a saída “Ponto” do nó Polygon.Points e a saída “Superfície” do nó Surface.ByPatch para retornar o parâmetro UV em cada ponto.
Agora que temos uma superfície de base e um conjunto de coordenadas UV, é possível importar uma superfície-alvo e mapear os pontos entre as superfícies.
File Path: selecione o caminho do arquivo da superfície que você deseja importar. O tipo de arquivo deve ser .SAT. Clique no botão “Procurar...” e navegue até o arquivo UVmapping_srf.sat do arquivo .zip obtido por download acima.
Geometry.ImportFromSAT: conecte o caminho do arquivo para importar a superfície. Você deve ver a superfície importada na visualização da geometria.
UV: conecte a saída do parâmetro UV a um nó UV.U e a um nó UV.V.
Surface.PointAtParameter: conecte a superfície importada, bem como as coordenadas u e v. Agora, você deve visualizar uma grade de pontos 3D na superfície-alvo.
A última etapa é usar os pontos 3D para construir as correções de superfícies retangulares.
PolyCurve.ByPoints: conecte os pontos na superfície para construir uma policurva através dos pontos.
Booleano: adicione um valor booleano ao espaço de trabalho, conecte-o à entrada “connectLastToFirst” e alterne para True para fechar as policurvas. Agora, você deve ver os retângulos mapeados para a superfície.
Surface.ByPatch: conecte as policurvas à entrada “closedCurve” para construir as correções de superfícies.
Agora, vamos selecionar os nós que desejamos aninhar em um nó personalizado, pensando no que desejamos que sejam as entradas e saídas do nosso nó. Desejamos que nosso nó personalizado seja o mais flexível possível, para que possa mapear qualquer polígono, não apenas retângulos.
Selecione os seguintes nós (começando com Polygon.Points), clique com o botão direito do mouse no espaço de trabalho e selecione “Criar nó personalizado”.
Na caixa de diálogo Propriedades do nó personalizado, atribua um nome, uma descrição e uma categoria ao nó personalizado.
Nome: MapPolygonsToSurface
Descrição: Mapear polígonos de uma superfície base para a superfície alvo
Categoria de complementos: Geometry.Curve
O nó personalizado limpou consideravelmente o espaço de trabalho. Observe que as entradas e saídas foram nomeadas com base nos nós originais. Vamos editar o nó personalizado para tornar os nomes mais descritivos.
Clique duas vezes no nó personalizado para editá-lo. Isso abrirá um espaço de trabalho com um fundo amarelo que representa o interior do nó.
Entradas: altere os nomes das entradas para baseSurface e targetSurface.
Saídas: adicione mais uma saída para os polígonos mapeados.
Salve o nó personalizado e volte para o espaço de trabalho inicial. Observe que o nó MapPolygonsToSurface reflete as alterações que acabamos de fazer.
Também é possível aumentar a robustez do nó personalizado adicionando Comentários personalizados. Os comentários podem ajudar a indicar os tipos de entrada e saída ou explicar a funcionalidade do nó. Os comentários aparecerão quando o usuário passar o cursor sobre uma entrada ou saída de um nó personalizado.
Clique duas vezes no nó personalizado para editá-lo. Isso reabrirá o espaço de trabalho de fundo amarelo.
Comece editando o Bloco de código de entrada. Para iniciar um comentário, digite “//” seguido do texto do comentário. Digite qualquer coisa que possa ajudar a esclarecer o nó. Aqui, descreveremos a targetSurface.
Também definiremos o valor padrão da inputSurface definindo o tipo de entrada igual a um valor. Aqui, definiremos o valor padrão como o conjunto Surface.ByPatch original.
Também é possível aplicar os comentários às saídas.
Edite o texto no bloco de código de saída. Digite “//” seguido do texto do comentário. Aqui, esclareceremos as saídas Polígonos e surfacePatches adicionando uma descrição mais detalhada.
Passe o cursor sobre as entradas dos nós personalizados para ver os comentários.
Com o valor padrão definido em inputSurface, também é possível executar a definição sem uma entrada de superfície.
Logotipo/Imagem
Nome
