Antes deste capítulo, a introdução abordou como implementar os recursos avançados de scripts visuais do Dynamo. Uma boa compreensão desses recursos é uma base sólida e a primeiro etapa para criação de programas visuais robustos. Quando usamos nossos programas visuais no campo, os compartilhamos com colegas, solucionamos erros ou testamos limites adicionais com os quais você precisa lidar. Se outra pessoa usar seu programa no futuro ou se você estiver esperando abri-lo daqui a seis meses, ele precisará ter uma clareza gráfica e lógica imediata. O Dynamo tem muitas ferramentas para gerenciar a complexidade do programa, e este capítulo fornecerá diretrizes sobre quando usá-las.
À medida que você desenvolve o gráfico do Dynamo e testa ideias, ele pode aumentar rapidamente em tamanho e complexidade. Embora seja importante criar um programa funcional, é igualmente importante o tornar o mais simples possível. Assim, além de o gráfico ser executado de forma mais rápida e previsível, você e outros usuários compreenderão a lógica posteriormente. Confira a seguir diversas formas que ajudarão você a esclarecer a lógica do gráfico.
Os grupos permitem criar partes funcionalmente distintas enquanto você cria um programa
Os grupos permitem mover grandes partes do programa enquanto a modularidade e o alinhamento são mantidos
É possível alterar a cor do grupo para diferenciar o que os grupos estão fazendo (entradas versus funções)
É possível usar grupos para iniciar a organização do gráfico para simplificar a criação do nó personalizado
As cores deste programa identificam o propósito de cada grupo. Essa estratégia pode ser usada para criar hierarquia em qualquer norma gráfica ou modelo que você desenvolver.
Grupo de funções (azul)
Grupo de entradas (laranja)
Grupo de scripts (verde)
Para saber como usar Grupos, consulte Como gerenciar o programa.
Às vezes, é possível usar um bloco de código para digitar um método de nó ou número mais rapidamente do que pesquisando (Point.ByCoordinates, Number, String, Formula)
Os blocos de código são úteis quando você deseja definir funções personalizadas no DesignScript para reduzir o número de nós em um gráfico
Tanto 1 quanto 2 executam a mesma função. Era muito mais rápido escrever algumas linhas de código do que procurar e adicionar cada nó individualmente. O bloco de código também é muito mais conciso.
DesignScript escrito no bloco de código
Programa equivalente nos nós
Para saber como usar o bloco de código, consulte O que é um bloco de código?
É possível reduzir a complexidade de um gráfico com a opção Nó para código, que usa um conjunto de nós simples e grava o DesignScript correspondente em um único bloco de código
O Nó para código pode** condensar o código sem eliminar a clareza do programa**
Vantagens do uso de Nó para código:
Condensa facilmente o código em um componente que ainda é editável
Pode simplificar uma parte significativa do gráfico
Será útil se o “miniprograma” não for editado com frequência
É útil para incorporar outras funcionalidades de bloco de código, como funções
Desvantagens do uso de Nó para código:
A nomenclatura genérica o torna menos legível
É mais difícil de entender para outros usuários
Não há uma forma fácil de retornar à versão de programação visual
Programa existente
Bloco de código criado usando Nó para código
Para saber como usar Nó para código, consulte Sintaxe do DesignScript.
O uso do recurso List@Level pode ajudar a reduzir a complexidade do gráfico substituindo os nós List.Map e List.Combine, que podem ocupar um volume considerável de espaço da tela
O recurso List@Level oferece uma** forma mais rápida do que List.Map/List.Combine para criar a lógica do nó** permitindo acessar dados em qualquer nível de uma lista diretamente da porta de entrada de um nó
É possível verificar quantos valores verdadeiros BoundingBox.Contains retorna e em quais listas, ativando List@Level para a entrada de “lista” de CountTrue. O recurso List@Level permite que o usuário determine de qual nível a entrada extrairá os dados. O uso de List@Level é flexível, eficiente e altamente recomendável em relação a outros métodos que envolvem List.Map e List.Combine.
Contagem de valores verdadeiros no Nível de lista 2
Contagem de valores verdadeiros no Nível de lista 3
Para saber como usar List@Level, consulte Listas de listas.
Além de tornar o gráfico o mais simples e eficiente possível, tente obter maior clareza gráfica. Apesar de seus melhores esforços para tornar o gráfico intuitivo com agrupamentos lógicos, os relacionamentos podem não ser evidentes. Uma Nota simples dentro de um grupo ou a renomeação de um controle deslizante pode poupar confusão desnecessária ou a aplicação de pan pelo gráfico para você ou outro usuário. Confira a seguir diversas formas que ajudarão você a aplicar consistência gráfica nos gráficos e entre eles.
Para reduzir o trabalho após terminar de criar o gráfico, você deve tentar garantir que o layout dos nós seja legível alinhando os nós com frequência e conforme você avança
Se outras pessoas estiverem trabalhando com o gráfico, você deverá garantir que o layout fio/nó flua com facilidade antes do envio
Para ajudar com o alinhamento, use o recurso “Limpeza do layout do nó” para alinhar automaticamente o gráfico, porém de forma menos precisa do que se você fizesse isso manualmente
Gráfico não organizado
Gráfico alinhado
Para saber como usar o alinhamento de nós, consulte Gerenciar o programa.
A renomeação de entradas poderá ajudar outras pessoas a entender facilmente o gráfico, principalmente se o item a que elas se conectam estiver fora da tela
Tenha cuidado ao renomear nós que não sejam entradas. Uma alternativa para isso é criar um nó personalizado de um cluster de nós e renomeá-lo; assim, ficará subentendido que ele contém outra coisa
Entradas para manipulação de superfície
Entradas para parâmetros arquitetônicos
Entradas para o script de simulação de drenagem
Para renomear um nó, clique com o botão direito do mouse no nome e selecione “Renomear nó...”.
Adicione uma nota se algo no gráfico necessitar de uma explicação em linguagem simples que os nós não podem expressar
Você deverá adicionar uma nota se um conjunto de nós ou um grupo for muito grande ou complexo e não puder ser facilmente compreendido de imediato
Uma nota que descreve a parte do programa que retorna as distâncias brutas de conversão
Uma nota que descreve o código que mapeia esses valores para uma onda sinusoidal
Para saber como adicionar uma nota, consulte Como gerenciar o programa.
Ao criar o script visual, é importante verificar se o que está sendo retornado é o que você esperava. Nem todos os erros ou problemas causarão a falha imediata do programa, principalmente valores nulos ou zero que possam afetar algo distante a jusante. Essa estratégia também é discutida no contexto de scripts de texto em Estratégias de script. A prática a seguir ajudará a garantir que você obtenha o que esperava.
Use balões de visualização ou inspeção durante a criação do programa para** verificar se as saídas principais estão retornando o que você esperava**
Os nós de inspeção são usados para comparar:
As distâncias de conversão brutas
Os valores passados pela equação de seno
Para saber como usar a Inspeção, consulte Biblioteca.
É altamente provável que outra pessoa esteja abrindo o programa em algum momento, mesmo que você esteja trabalhando de forma independente. Ela deve ser capaz de entender rapidamente o que o programa precisa e produz com base em suas entradas e saídas. Isso é especialmente importante ao desenvolver um nó personalizado para ser compartilhado com a comunidade do Dynamo e usado no programa de outra pessoa. Essas práticas resultam em programas e nós robustos e reutilizáveis.
Para garantir a legibilidade e a escalabilidade, tente minimizar as entradas e saídas o máximo possível
Você deve tentar estabelecer uma estratégia de como criará a lógica elaborando um esboço de como a lógica poderia funcionar antes mesmo de adicionar um único nó à tela. À medida que desenvolve o esboço, você deve monitorar quais entradas e saídas farão parte de scripts
Se houver opções ou condições específicas que você queira incorporar ao gráfico, use as predefinições para obter acesso rápido
Também é possível usar as predefinições para reduzir a complexidade armazenando em cache os valores específicos de controle deslizante em um gráfico com tempos de execução longos
Para saber como usar as predefinições, consulte Gerenciar os dados com as predefinições.
Você deverá usar um nó personalizado se o programa puder ser coletado em um único contêiner
Você deverá usar um nó personalizado quando uma parte do gráfico for reutilizada com frequência em outros programas
Você deverá usar um nó personalizado se desejar compartilhar uma funcionalidade com a comunidade do Dynamo
A coleta do programa de conversão de pontos em um nó personalizado torna portátil e muito mais fácil de entender um programa robusto e exclusivo. Portas de entrada bem nomeadas ajudarão outros usuários a entender como usar o nó. Lembre-se de adicionar descrições e tipos de dados necessários a cada entrada.
Programa atrativo existente
Nó personalizado que coleta este programa, PointGrid
Para saber como usar nós personalizados, consulte Introdução aos nós personalizados.
É possível criar modelos para estabelecer padrões gráficos nos gráficos visuais para garantir que os colaboradores tenham um modo padronizado de entender o gráfico
Durante a criação de um modelo, é possível padronizar as cores de grupo e os tamanhos de fonte para categorizar os tipos de fluxos de trabalho ou as ações de dados.
Durante a criação de um modelo, é possível até mesmo padronizar como você quer definir legendas, cores ou estilos para diferenciar entre os fluxos de trabalho de front-end e back-end no gráfico.
A interface do usuário, ou o front-end, do programa inclui um nome de projeto, controles deslizantes de entrada e geometria de importação.
O back-end do programa.
Categorias de cor de grupo (o projeto geral, as entradas, o script do Python, a geometria importada).
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 estabelecemos várias práticas recomendadas, vamos aplicá-las a um programa que foi montado rapidamente. Embora o programa seja bem-sucedido na geração do telhado, o estado do gráfico é um “mapa mental” do autor. Ele não possui nenhuma organização ou descrição de seu uso. Vamos examinar as práticas recomendadas para organizar, descrever e analisar o programa de modo que outros usuários possam entender como usá-lo.
O programa está funcionando, mas o gráfico está desorganizado.
Vamos começar determinando os dados e a geometria retornados pelo programa.
A compreensão de quando ocorrem as principais alterações nos dados é crucial para estabelecer divisões lógicas ou modularidade. Tente inspecionar o restante do programa com os nós de inspeção para ver se é possível determinar grupos antes de passar para a próxima etapa.
Esse bloco de código com uma equação matemática se parece com uma parte crucial do programa. Um nó de inspeção mostra que ele está retornando listas de distâncias de conversão.
O objetivo dessa área não é evidente. A disposição dos valores True no nível de lista L2 de BoundingBox.Contains e a presença de List.FilterByBoolMask sugerem que estamos fazendo uma amostragem de uma parte da grade de pontos.
Quando entendermos as partes elementares do programa, vamos colocá-las em grupos.
Os grupos permitem que o usuário diferencie visualmente as partes do programa.
Importar o modelo de terreno 3D
Converter a grade de ponto com base na equação de seno
Parte de exemplo da grade de pontos
Criar a superfície de telhado arquitetônico
Criar a parede cortina de vidro
Com os grupos estabelecidos, alinhe os nós para criar a continuidade visual no gráfico.
A continuidade visual ajuda o usuário a ver o fluxo do programa e as relações implícitas entre os nós.
Torne o programa mais acessível adicionando mais uma camada de melhorias gráficas. Adicione notas para descrever como funciona uma área específica do programa, atribua nomes personalizados às entradas e atribua cores a diferentes tipos de grupos.
Essas melhorias gráficas dão mais informações ao usuário sobre o que o programa está fazendo. As diferentes cores de grupo ajudam a diferenciar as entradas das funções.
Notas
Entradas com nomes descritivos
Antes de começarmos a condensar o programa, vamos encontrar uma localização estratégica para introduzir o simulador de drenagem do script do Python. Conecte a saída da primeira superfície de telhado dimensionado à respectiva entrada de script.
Escolhemos integrar scripts neste ponto no programa para que a simulação de drenagem possa ser executada na superfície original de telhado único. Essa superfície específica não está sendo visualizada, mas nos poupa a necessidade de escolher a superfície superior da PolySurface chanfrada.
Geometria de origem para entrada de script
Nó do Python
Controles deslizantes de entrada
“Chave” ligar/desligar
Vamos simplificar o gráfico agora que tudo está em seu devido lugar.
A condensação do nosso programa com Nó para código e Nó personalizado reduziu consideravelmente o tamanho do gráfico. Os grupos que criam a superfície do telhado e as paredes foram convertidos em código, já que são muito específicos deste programa. O grupo de conversão de pontos está contido em um Nó personalizado, pois ele pode ser usado em outro programa. No arquivo de exemplo, crie seu próprio nó personalizado com base no grupo de conversão de pontos.
Nó personalizado para conter o grupo “converter grade de pontos”
Nó para código para condensar os grupos “criar superfície de telhado arquitetônico e parede cortina”
Como etapa final, crie predefinições de formas de telhado exemplares.
Essas entradas são os principais acionadores da forma do telhado e ajudarão os usuários a ver o potencial do programa.
Nosso programa com vistas de duas predefinições.
Os padrões de drenagem do telhado fornecem ao usuário uma vista analítica das predefinições respectivas.
