# Índice de nós

Este índice fornece informações adicionais sobre todos os nós usados neste manual de introdução, bem como outros componentes que você pode considerar úteis. Esta é apenas uma introdução a alguns dos 500 nós disponíveis no Dynamo.

## Exibição

### Cor

|   |                                                                                                                        |   |
| - | ---------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                  |   |
|   | <p><strong>Color.ByARGB</strong><br>Crie uma cor usando os componentes alfa, vermelho, verde e azul.</p>               | ! |
| ! | <p><strong>Color Range</strong><br>Obtenha uma cor de um gradiente de cores entre uma cor inicial e uma cor final.</p> |   |
|   | AÇÕES                                                                                                                  |   |
|   | <p><strong>Color.Brightness</strong><br>Retorna o valor de brilho dessa cor.</p>                                       |   |
| ! | <p><strong>Color.Components</strong><br>Lista os componentes da cor na ordem: alfa, vermelho, verde, azul.</p>         | ! |
|   | <p><strong>Color.Saturation</strong><br>Retorna o valor de saturação dessa cor.</p>                                    | ! |
|   | <p><strong>Color.Hue</strong><br>Retorna o valor de matiz desda cor.</p>                                               | ! |
|   | CONSULTAR                                                                                                              |   |
| ! | <p><strong>Color.Alpha</strong><br>Localize o componente alfa de uma cor, 0 a 255.</p>                                 | ! |
|   | <p><strong>Color.Blue</strong><br>Localize o componente azul de uma cor, 0 a 255.</p>                                  | ! |
|   | <p><strong>Color.Green</strong><br>Localize o componente verde de uma cor, 0 a 255.</p>                                | ! |
|   | <p><strong>Color.Red</strong><br>Localize o componente vermelho de uma cor, 0 a 255.</p>                               | ! |

|   |                                                                                            |   |
| - | ------------------------------------------------------------------------------------------ | - |
|   | CRIAR                                                                                      |   |
|   | <p><strong>GeometryColor.ByGeometryColor</strong><br>Exibe a geometria usando uma cor.</p> | ! |

### Inspeção

|   |                                                                                          |   |
| - | ---------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                    |   |
| ! | <p><strong>View\.Watch</strong><br>Visualize a saída do nó.</p>                          | ! |
| ! | <p><strong>View\.Watch 3D</strong><br>Mostra uma visualização dinâmica da geometria.</p> | ! |

## Entrada

|   |                                                                                                            |   |
| - | ---------------------------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                                      |   |
|   | <p><strong>Boolean</strong><br>Seleção entre true e false.</p>                                             | ! |
| ! | <p><strong>Code Block</strong><br>Permite que o código DesignScript seja criado diretamente.</p>           | ! |
| ! | <p><strong>Directory Path</strong><br>Permite selecionar um diretório no sistema para obter o caminho</p>  | ! |
| ! | <p><strong>File Path</strong><br>Permite selecionar um arquivo no sistema para obter o nome de arquivo</p> | ! |
| ! | <p><strong>Integer Slider</strong><br>Um controle deslizante que produz valores inteiros.</p>              | ! |
|   | <p><strong>Number</strong><br>Cria um número.</p>                                                          |   |
| ! | <p><strong>Number Slider</strong><br>Um controle deslizante que produz valores numéricos.</p>              | ! |
|   | <p><strong>String</strong><br>Cria uma cadeia de caracteres.</p>                                           | ! |
| ! | <p><strong>Object.IsNull</strong><br>Determina se o objeto determinado é nulo.</p>                         | ! |

## Lista

|   |                                                                                                                                                                                                                                                                          |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | CRIAR                                                                                                                                                                                                                                                                    |   |
| ! | <p><strong>List.Create</strong><br>Cria uma nova lista com base nas entradas fornecidas.</p>                                                                                                                                                                             | ! |
| ! | <p><strong>List.Combine</strong><br>Aplica um combinador a cada elemento em duas sequências</p>                                                                                                                                                                          | ! |
|   | <p><strong>Number Range</strong><br>Cria uma sequência de números no intervalo especificado.</p>                                                                                                                                                                         |   |
|   | <p><strong>Number Sequence</strong><br>Cria uma sequência de números.</p>                                                                                                                                                                                                | ! |
|   | AÇÕES                                                                                                                                                                                                                                                                    |   |
| ! | <p><strong>List.Chop</strong><br>Divida uma lista em um conjunto de listas que contêm a quantidade determinada de itens.</p>                                                                                                                                             | ! |
|   | <p><strong>List.Count</strong><br>Retorna o número de itens armazenados na lista determinada.</p>                                                                                                                                                                        | ! |
| ! | <p><strong>List.Flatten</strong><br>Nivela uma lista de listas aninhada por um determinado valor.</p>                                                                                                                                                                    | ! |
| ! | <p><strong>List.FilterByBoolMask</strong><br>Filtra uma sequência examinando os índices correspondentes em uma lista separada de booleanos.</p>                                                                                                                          | ! |
| ! | <p><strong>List.GetItemAtIndex</strong><br>Retorna um item da lista determinada que está localizada no índice especificado.</p>                                                                                                                                          | ! |
|   | <p><strong>List.Map</strong><br>Aplica uma função em todos os elementos de uma lista, gerando uma nova lista com base nos resultados</p>                                                                                                                                 | ! |
|   | <p><strong>List.Reverse</strong><br>Cria uma nova lista que contém os itens da lista determinada, mas na ordem inversa</p>                                                                                                                                               | ! |
| ! | <p><strong>List.ReplaceItemAtIndex</strong><br>Substitua um item da lista determinada que está localizada no índice especificado</p>                                                                                                                                     | ! |
| ! | <p><strong>List.ShiftIndices</strong><br>Troca os índices da lista à direita pelo valor fornecido</p>                                                                                                                                                                    | ! |
| ! | <p><strong>List.TakeEveryNthItem</strong><br>Obtém os itens da lista determinada em índices que são múltiplos do valor fornecido, após o deslocamento fornecido.</p>                                                                                                     | ! |
| ! | <p><strong>List.Transpose</strong><br>Troca as linhas e as colunas de uma lista de listas. Se houver algumas linhas mais curtas do que outras, os valores nulos serão inseridos como espaços reservados na matriz resultante de forma que ela seja sempre retangular</p> | ! |

## Lógica

|                                                                                                                                                                                                  |                                                                                                                                                                                                                                   |   |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|                                                                                                                                                                                                  | AÇÕES                                                                                                                                                                                                                             |   |
| ![](https://244128891-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F2qE9MHrCjjcYhCOUtPm6%2Fuploads%2Fgit-blob-7309f56b92340e49cf9390a21ead106bcb987a0d%2FIf.jpg?alt=media) | <p><strong>If</strong><br>Declaração condicional. Verifica o valor booleano da entrada de teste. Se a entrada de teste for true, o resultado retornará a entrada true. Caso contrário, o resultado retornará a entrada false.</p> | ! |

## Matemática

|   |                                                                                                                                   |   |
| - | --------------------------------------------------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                                                             |   |
| ! | <p><strong>Math.Cos</strong><br>Retorna o cosseno de um ângulo.</p>                                                               | ! |
| ! | <p><strong>Math.DegreesToRadians</strong><br>Converte um ângulo em graus em um ângulo em radianos.</p>                            | ! |
| ! | <p><strong>Math.Pow</strong><br>Eleva um número à potência especificada.</p>                                                      | ! |
| ! | <p><strong>Math.RadiansToDegrees</strong><br>Converte um ângulo em radianos em um ângulo em graus.</p>                            | ! |
| ! | <p><strong>Math.RemapRange</strong><br>Ajusta o intervalo de uma lista de números, preservando o coeficiente de distribuição.</p> | ! |
| ! | <p><strong>Math.Sin</strong><br>Localiza o seno de um ângulo.</p>                                                                 | ! |
|   | <p><strong>Map</strong><br>Mapeia um valor para um intervalo de entrada</p>                                                       | ! |

## Sequência de caracteres

|   |                                                                                                                                                                                                                |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                                                                                                                                          |   |
| ! | <p><strong>String.Concat</strong><br>Concatena várias sequências de caracteres em uma única sequência de caracteres.</p>                                                                                       | ! |
| ! | <p><strong>String.Contains</strong><br>Determina se a sequência de caracteres fornecida contém a subsequência de caracteres determinada.</p>                                                                   | ! |
| ! | <p><strong>String.Join</strong><br>Concatena várias sequências de caracteres em uma única sequência de caracteres, inserindo o separador fornecido entre cada sequência de caracteres unida.</p>               | ! |
| ! | <p><strong>String.Split</strong><br>Divide uma única sequência de caracteres em uma lista de sequência de caracteres, com as divisões determinadas pelas sequências de caracteres do separador fornecidas.</p> | ! |
| ! | <p><strong>String.ToNumber</strong><br>Converte uma sequência de caracteres em um número inteiro ou um duplo.</p>                                                                                              | ! |

## Geometria

### Círculo

|   |                                                                                                                                                                             |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                       |   |
| ! | <p><strong>Circle.ByCenterPointRadius</strong><br>Cria um círculo com o ponto central de entrada e o raio no plano XY universal, com o Z universal como normal.</p>         | ! |
| ! | <p><strong>Circle.ByPlaneRadius</strong><br>Crie um círculo centralizado na origem do plano de entrada (raiz), que reside no plano de entrada, com o raio especificado.</p> | ! |

|   |                                                                                                                                                                                                          |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                                                    |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Crie um CoordinateSystem com origem no ponto de entrada, com os eixos X e Y definidos como eixos X e Y do sistema de coordenadas universal.</p>         | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Cria um CoordinateSystem nos parâmetros de coordenadas cilíndricas especificadas com relação ao sistema de coordenadas especificado</p> | ! |

### Cubo

|   |                                                                                                                                                                                 |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                           |   |
| ! | <p><strong>Cuboid.ByLengths</strong><br>Cria um cubo centralizado com origem no sistema de coordenadas universal e com largura, comprimento e altura.</p>                       | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (origem)</p><p>Crie um cubo centralizado no ponto de entrada, com largura, comprimento e altura especificados.</p>                         | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (coordinateSystem)</p><p>Cria um cubo centralizado com origem no sistema de coordenadas universal e com largura, comprimento e altura.</p> | ! |
|   | <p><strong>Cuboid.ByCorners</strong></p><p>Cria um cubo que se estende do ponto baixo ao ponto alto.</p>                                                                        | ! |
| ! | <p><strong>Cuboid.Length</strong></p><p>Retorna as cotas de entrada do cubo e NÃO as cotas reais do espaço universal. \*\*</p>                                                  | ! |
|   | <p><strong>Cuboid.Width</strong></p><p>Retorna as cotas de entrada do cubo e NÃO as cotas reais do espaço universal. \*\*</p>                                                   | ! |
|   | <p><strong>Cuboid.Height</strong></p><p>Retorna as cotas de entrada do cubo e NÃO as cotas reais do espaço universal. \*\*</p>                                                  | ! |
| ! | <p><strong>BoundingBox.ToCuboid</strong></p><p>Retorna a caixa delimitadora como um cubo de sólido.</p>                                                                         | ! |

{% hint style="warning" %}
\*\*Em outras palavras, se você criar um comprimento de largura do cubo (eixo X) 10 e transformá-lo em um CoordinateSystem com dimensionamento de 2 vezes em X, a largura ainda será 10. O ASM não permite extrair os vértices de um corpo em nenhuma ordem previsível; portanto, é impossível determinar as cotas após uma transformação.
{% endhint %}

### Curva

|   |                                                                                                                                                    |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                                                                              |   |
| ! | <p><strong>Curve.Extrude</strong> (distância)<br>Efetua a extrusão de uma curva na direção do vetor normal.</p>                                    | ! |
| ! | <p><strong>Curve.PointAtParameter</strong><br>Obtenha um ponto na curva com um parâmetro especificado entre StartParameter() e EndParameter().</p> | ! |

### Modificadores de geometria

|   |                                                                                                                                          |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | AÇÕES                                                                                                                                    |   |
| ! | <p><strong>Geometry.DistanceTo</strong><br>Obtenha a distância desta geometria até outra.</p>                                            | ! |
| ! | <p><strong>Geometry.Explode</strong><br>Separa elementos compostos ou não separados em suas partes do componente.</p>                    | ! |
| ! | <p><strong>Geometry.ImportFromSAT</strong><br>Lista de geometrias importadas</p>                                                         | ! |
| ! | <p><strong>Geometry.Rotate</strong> (basePlane)<br>Rotaciona o objeto em torno da origem e normal do plano por um grau especificado.</p> | ! |
| ! | <p><strong>Geometry.Translate</strong><br>Converte qualquer tipo de geometria pela distância fornecida na direção determinada.</p>       | ! |

### Linha

|   |                                                                                                                                                                       |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                 |   |
| ! | <p><strong>Line.ByBestFitThroughPoints</strong><br>Cria uma linha que melhor se aproxima à dispersão de uma plotagem de pontos.</p>                                   | ! |
| ! | <p><strong>Line.ByStartPointDirectionLength</strong><br>Crie uma linha reta começando no ponto e estendendo-se na direção do vetor pelo comprimento especificado.</p> | ! |
| ! | <p><strong>Line.ByStartPointEndPoint</strong><br>Cria uma linha reta entre dois pontos de entrada.</p>                                                                | ! |
| ! | <p><strong>Line.ByTangency</strong><br>Crie uma linha tangente à curva de entrada, posicionada no ponto do parâmetro da curva de entrada.</p>                         | ! |
|   | CONSULTAR                                                                                                                                                             |   |
| ! | <p><strong>Line.Direction</strong><br>A direção da curva.</p>                                                                                                         | ! |

### NurbsCurve

|   |                                                                                                                   |   |
| - | ----------------------------------------------------------------------------------------------------------------- | - |
|   | Criar                                                                                                             |   |
| ! | <p><strong>NurbsCurve.ByControlPoints</strong><br>Crie uma BSplineCurve usando pontos de controle explícitos.</p> | ! |
| ! | <p><strong>NurbsCurve.ByPoints</strong><br>Crie uma BSplineCurve interpolando entre os pontos</p>                 | ! |

### NurbsSurface

|   |                                                                                                                                                                                     |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | Criar                                                                                                                                                                               |   |
| ! | <p><strong>NurbsSurface.ByControlPoints</strong><br>Crie uma NurbsSurface usando pontos de controle explícitos com os graus U e V especificados.</p>                                | ! |
| ! | <p><strong>NurbsSurface.ByPoints</strong><br>Cria uma NurbsSurface com os graus U e V e pontos interpolados especificados. A superfície resultante passará por todos os pontos.</p> | ! |

### Plano

|   |                                                                                                                          |   |
| - | ------------------------------------------------------------------------------------------------------------------------ | - |
|   | CRIAR                                                                                                                    |   |
| ! | <p><strong>Plane.ByOriginNormal</strong><br>Crie um plano centralizado no ponto raiz, com o vetor normal de entrada.</p> | ! |
| ! | <p><strong>Plane.XY</strong><br>Cria um plano no XY universal</p>                                                        | ! |

### Ponto

|   |                                                                                                                                                         |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                   |   |
| ! | <p><strong>Point.ByCartesianCoordinates</strong><br>Forme um ponto em um determinado sistema de coordenadas com três coordenadas cartesianas</p>        | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (2d)<br>Forme um ponto no plano XY com base em duas coordenadas cartesianas fornecidas. O componente Z é 0.</p> | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (3d)<br>Forme um ponto com três coordenadas cartesianas fornecidas.</p>                                         | ! |
| ! | <p><strong>Point.Origin</strong><br>Obtenha o ponto de origem (0,0,0)</p>                                                                               | ! |
|   | AÇÕES                                                                                                                                                   |   |
| ! | <p><strong>Point.Add</strong><br>Adicione um vetor a um ponto. O mesmo que Converter (vetor).</p>                                                       | ! |
|   | CONSULTAR                                                                                                                                               |   |
| ! | <p><strong>Point.X</strong><br>Obtenha o componente X de um ponto</p>                                                                                   | ! |
| ! | <p><strong>Point.Y</strong><br>Obtenha o componente Y de um ponto</p>                                                                                   | ! |
| ! | <p><strong>Point.Z</strong><br>Obtenha o componente Z de um ponto</p>                                                                                   | ! |

### Policurva

|   |                                                                                                                                                                                                                  |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                                                            |   |
| ! | <p><strong>Polycurve.ByPoints</strong><br>Crie a PolyCurve com base na sequência de linhas que conectam os pontos. Para a curva fechada, o último ponto deve estar na mesma localização que o ponto inicial.</p> | ! |

### Retângulo

|   |                                                                                                                                                                                                                            |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                                                                      |   |
| ! | <p><strong>Rectangle.ByWidthLength</strong> (Plano)<br>Crie um retângulo centralizado na raiz do plano de entrada, com a largura (tamanho do eixo X do plano) e o comprimento (tamanho do eixo Y do plano) de entrada.</p> | ! |

### Esfera

|   |                                                                                                                                         |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                   |   |
| ! | <p><strong>Sphere.ByCenterPointRadius</strong><br>Crie uma esfera sólida centralizada no ponto de entrada, com o raio especificado.</p> | ! |

### Superfície

|   |                                                                                                                                                                                    |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                              |   |
| ! | <p><strong>Surface.ByLoft</strong><br>Crie uma superfície efetuando a elevação entre as curvas de seção transversal de entrada.</p>                                                | ! |
| ! | <p><strong>Surface.ByPatch</strong><br>Crie uma superfície preenchendo o interior de um contorno fechado definido por curvas de entrada.</p>                                       |   |
|   | AÇÕES                                                                                                                                                                              |   |
| ! | <p><strong>Surface.Offset</strong><br>Desloque a superfície na direção da normal da superfície pela distância especificada.</p>                                                    | ! |
|   | <p><strong>Surface.PointAtParameter</strong><br>Retorne o ponto nos parâmetros U e V especificados.</p>                                                                            | ! |
|   | <p><strong>Surface.Thicken</strong><br>Torne mais espessa a superfície em um sólido, efetuando a extrusão na direção de normais de superfície em ambos os lados da superfície.</p> | ! |

### UV

|   |                                                                                 |   |
| - | ------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                           |   |
| ! | <p><strong>UV.ByCoordinates</strong><br>Crie um UV com base em dois duplos.</p> | ! |

### Vetor

|   |                                                                                                 |   |
| - | ----------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                           |   |
| ! | <p><strong>Vector.ByCoordinates</strong><br>Forme um vetor com três coordenadas euclidianas</p> | ! |
|   | <p><strong>Vector.XAxis</strong><br>Retorna o vetor do eixo X canônico (1,0,0)</p>              | ! |
|   | <p><strong>Vector.YAxis</strong><br>Retorna o vetor do eixo Y canônico (0,1,0)</p>              | ! |
|   | <p><strong>Vector.ZAxis</strong><br>Retorna o vetor do eixo Z canônico (0,0,1)</p>              | ! |
|   | AÇÕES                                                                                           |   |
| ! | <p><strong>Vector.Normalized</strong><br>Obtenha a versão normalizada de um vetor</p>           | ! |

## CoordinateSystem

|   |                                                                                                                                                                                                          |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | CRIAR                                                                                                                                                                                                    |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Crie um CoordinateSystem com origem no ponto de entrada, com os eixos X e Y definidos como eixos X e Y do sistema de coordenadas universal.</p>         | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Cria um CoordinateSystem nos parâmetros de coordenadas cilíndricas especificadas com relação ao sistema de coordenadas especificado</p> | ! |

## Operadores

|   |                                                                                                                       |   |
| - | --------------------------------------------------------------------------------------------------------------------- | - |
| ! | <p><strong>+</strong><br>Adição</p>                                                                                   | ! |
| ! | <p><strong>-</strong><br>Subtração</p>                                                                                | ! |
| ! | <p><strong>\*</strong><br>Multiplicação</p>                                                                           | ! |
| ! | <p><strong>/</strong><br>Divisão</p>                                                                                  | ! |
|   | <p><strong>%</strong><br>A divisão modular localiza o resto da primeira entrada após dividir pela segunda entrada</p> | ! |
|   | <p><strong><</strong><br>Menor que</p>                                                                                | ! |
| ! | <p><strong>></strong><br>Maior que</p>                                                                                | ! |
| ! | <p><strong>==</strong><br>Testes de igualdade entre dois valores.</p>                                                 | ! |
