Você está na página 1de 44

Pgina 1

Manual do Dynamo Idioma

Page 2
1.
Noes bsicas de lnguas
2.
Noes bsicas de geometria
3.
Primitivas geomtricas
4.
Vector Math
5.
Faixa Expresses
6.
Coleces
7.
Funes
8.
Matemtica
9.
Curvas: interpretados e Pontos de Controlo
10.
Translao, rotao e outras transformaes
11. condicionais e lgica booleana
12. Looping
Guias de replicao 13.
14.
Coleo Rank e Jagged Coleces
15.
Superfcies: interpretada, pontos de controle, Loft, Revolve
16.
Parametrizao geomtrica
17.
Interseo e guarnio
18.
Booleans geomtricas
A-1. Apndice 1: Geradores Python Ponto
Contedo

Pgina 3
Linguagens de programao so criados para expressar idias, normalmente
envolvendo lgica e clculo. Alm destes objectivos, a
Linguagem textual Dynamo (anteriormente DesignScript) tem sido
criado para expressar intenes de design. geralmente reconhecido
que a concepo computacional exploratria, e Dynamo tenta
apoiar esta: ns esperamos que voc encontrar a linguagem flexvel e rpido
o suficiente para levar um projeto, desde a concepo, atravs de iteraes de
projeto,
sua forma final.
Este manual est estruturado para dar a um usurio sem o conhecimento de
ou programao ou geometria arquitetural exposio total a uma
variedade de temas destas disciplinas de cruzamento. Indivduos
com fundos mais experientes devem saltar para o indivduo
sees que so relevantes para os seus interesses e problema
domnio. Cada seco auto-contido, e no requer nenhuma
conhecimento alm das informaes apresentadas nas sees anteriores.
Blocos de texto inserir na fonte Consolas deve ser colado em um
N Code Block. A sada do bloco de cdigo deve ser
conectado em um n Watch para ver o resultado pretendido. Imagens
so includas na margem esquerda ilustra a sada correcta da
seu programa.
Introduo

Page 4
Este documento discute a programao textual Dynamo
linguagem, usada dentro do editor Dynamo (s vezes chamada
como "Dynamo Sandbox"). Para criar um novo script Dynamo, aberta
o editor Dynamo, e selecione o boto "Novo" no "FILES"
grupo:
Isto ir abrir um grfico Dynamo em branco. Para escrever um texto Dynamo
roteiro, clique duas vezes em qualquer lugar na tela. Isso far com que um
N "Code Block". A fim de ver facilmente os resultados da nossa
os scripts, anexar um n "Watch" para a sada do seu bloco de cdigo
n, como mostrado aqui:
Cada script uma srie de comandos escritos. Alguns desses
comandos criam geometria; outros a resolver matemtica
problemas, gravar arquivos de texto, ou gerar seqncias de texto. Um
simples, uma
programa de linha que gera as citaes "Menos mais." parece
esta:
O n Assista esquerda mostra a sada do script.
"Menos mais.";
1: Noes bsicas de lnguas

Page 5
O comando gera um novo objeto String. Cordas em Dynamo
so designados por duas aspas (
"
), E o fechado
caracteres, incluindo espaos, so passados para fora do n. Cdigo
Ns Bloco no se limitam a gerao de Strings. Um bloco de cdigo
n para gerar o nmero 5420 se parece com isso:
Cada comando na Dynamo terminada por um ponto e vrgula. Se voc
no incluir um, o Editor ir adicionar um para voc. Observe tambm que
o nmero ea combinao de espaos, tabulaes e transporte
retornos, chamados de espao em branco, entre os elementos de um comando
no importa. Este programa produz a mesma sada exata como
o primeiro programa:
Naturalmente, a utilizao de espao em branco deve ser usado para ajudar a
melhorar
a legibilidade do cdigo, tanto para si e para os futuros leitores.
Os comentrios so outra ferramenta para ajudar a melhorar a legibilidade do
seu cdigo. Na Dynamo, uma nica linha de cdigo ", comentou" com
duas barras,
//
. Isso faz com que o n ignorar tudo
escrito depois das barras, at um retorno de carro (o fim do
linha). Comentrios mais longos do que uma linha comear com uma barra
asterisco,
/*
, E terminam com uma barra asterisco,
*/
.
5420;
"Menos Mais."
;

Page 6
At agora, os argumentos cdigo de bloco foram valores "literal",
ou uma cadeia de texto ou um nmero. No entanto, muitas vezes mais til
para os argumentos da funo a ser armazenado em recipientes de dados
chamado
variveis, que tanto fazem o cdigo mais legvel, e eliminar
comandos redundantes em seu cdigo. Os nomes de variveis so
at programadores individuais para decidir, embora cada varivel
nome deve ser nico, comear com uma letra maiscula ou inferior, e
conter apenas letras, nmeros ou sublinhados,
_
. Os espaos no so
permitidos em nomes de variveis. Os nomes de variveis devem, embora
sejam
no necessrio, para descrever os dados que eles contm. Por exemplo, uma
varivel para controlar a rotao de um objecto pode ser chamado
rotao
. Para descrever os dados com palavras mltiplas, programadores
normalmente usam duas convenes comuns: separar as palavras por
maisculas, chamado camelCase (as letras maisculas sucessivas
imitar as corcovas de um camelo), ou para separar palavras individuais com
ressalta. Por exemplo, uma varivel para descrever a rotao de um
pequeno disco pode ser nomeado
smallDiskRotation
ou
small_disk_rotation
, Dependendo estilstica do programador
preferncia. Para criar uma varivel, escreva o seu nome esquerda de um
sinal de igual, seguido do valor que voc deseja atribuir a ele. Para
exemplo:
Alm de tornar facilmente perceptvel que o papel da cadeia de texto
, variveis podem ajudar a reduzir a quantidade de cdigo que precisa
atualizar, se as alteraes de dados no futuro. Por exemplo, o texto do
seguinte citao s precisa ser mudado em um s lugar, apesar de
sua aparncia trs vezes no programa.
// Esta uma nica linha de comentrio
/ * Esta uma linha de comentrio mltipla,
que continua por mltiplas
linhas. * /
// Todas estas observaes no tm efeito sobre
// A execuo do programa
// Esta linha imprime uma citao por Mies van der Rohe
"Menos Mais";
quote = "Menos mais.";

Pgina 7
Aqui estamos nos juntando umas citaes por Mies van der Rohe trs vezes,
com espaos entre cada frase. Observe o uso do +
operador '' concatenar as strings e variveis em conjunto para
formar uma sada contnua.
// Minha citao favorita arquitetura
quote = "Menos mais.";
Citao + "" + citaes + "" Citao +;
// Minha nova citao favorita arquitetura
quote = "Menos um tdio.";
Citao + "" + citaes + "" Citao +;

Page 8
O objeto geomtrica simples do padro Dynamo
biblioteca geometria um ponto. Toda a geometria criada usando especial
funes chamadas construtores, que cada retornam uma nova instncia
de que tipo de geometria particular. Na Dynamo, construtores comeam
com o nome do tipo do objeto, neste caso
Ponto
, Seguido por
o mtodo de construo. Para criar um ponto tridimensional
especificado por x, y, e z coordenadas cartesianas, utilizar o
ByCoordinates
constructor:
Construtores em Dynamo so normalmente designada com o "
De
"
prefixo, e invocando dessas funes retorna um recm-criado
objeto desse tipo. Este objeto recm-criado armazenado na
varivel chamada no lado esquerdo do sinal de igual, e qualquer uso de
que mesmo ponto original.
A maioria dos objetos tem muitos construtores diferentes, e podemos usar
a
BySphericalCoordinates
construtor para criar um ponto de mentir
sobre uma esfera, indicado pelo raio da esfera, uma primeira rotao
ngulo, e um ngulo de rotao segundo (especificadas em graus):
// Criar um ponto com a seguinte x, y, z e
// Coordenadas:
x = 10;
y = 2,5;
z = -6;
p = Point.ByCoordinates (x, y, z);
// Criar um ponto sobre uma esfera com o seguinte raio,
// Teta e phi ngulos de rotao (especificadas em graus)
Raio = 5;
teta = 75,5;
phi = 120,3;
cs = CoordinateSystem.Identity ();
p = Point.BySphericalCoordinates (cs, raio, teta,
phi);
2: Noes bsicas de geometria

Page 9
Os pontos podem ser utilizados para construir maior geometria dimensional
tais como linhas. Podemos usar o
ByStartPointEndPoint
construtor para criar um objeto de linha entre dois pontos:
Do mesmo modo, as linhas podem ser utilizadas para criar a superfcie de
elevada dimenso
geometria, por exemplo, utilizando o
Sto
construtor, que leva um
srie de linhas ou curvas e interpola uma superfcie entre
eles.
Surfaces tambm pode ser usado para criar slida superior dimensional
geometria, por exemplo, pelo espessamento da superfcie por um especificado
distncia. Muitos objetos tm funes que lhes so inerentes, chamado
mtodos, permitindo que o programador para executar comandos em que
nomeadamente objeto. Mtodos comuns a todas as partes da geometria
incluir
Traduzir
e
Rotate
, Respectivamente, que traduzem
(Mover) e girar a geometria por um valor especificado. Superfcies
tenha um
Engrossar
mtodo, que tomar uma nica entrada, um nmero
especificando a nova espessura da superfcie.
// Criar dois pontos:
P1 = Point.ByCoordinates (3, 10, 2);
P2 = Point.ByCoordinates (-15, 7, 0,5);
// Construir uma linha entre P1 e P2
l = Line.ByStartPointEndPoint (P1, P2);
// Criar pontos:
P1 = Point.ByCoordinates (3, 10, 2);
P2 = Point.ByCoordinates (-15, 7, 0,5);
p3 = Point.ByCoordinates (5, -3, 5);
P4 = Point.ByCoordinates (-5, -6, 2);
P5 = Point.ByCoordinates (9, -10, -2);
P6 = Point.ByCoordinates (-11, -12, -4);
// Cria linhas:
L1 = Line.ByStartPointEndPoint (P1, P2);
L2 = Line.ByStartPointEndPoint (P3, P4);
L3 = Line.ByStartPointEndPoint (P5, P6);
// Soto entre as linhas de seo transversal:
ressaca = Surface.ByLoft ({L1, L2, L3});

Page 10
Interseo
comandos podem extrair inferior dimensional
geometria a partir de objetos de dimenses mais elevadas. Este extrado menor
geometria dimensional pode formar a base para maior dimensional
geometria, num processo cclico de criao geomtrica, extraco,
e recreao. Neste exemplo, usamos o slido gerado para
criar uma superfcie, e usar a superfcie para criar uma curva.
P1 = Point.ByCoordinates (3, 10, 2);
P2 = Point.ByCoordinates (-15, 7, 0,5);
p3 = Point.ByCoordinates (5, -3, 5);
P4 = Point.ByCoordinates (-5, -6, 2);
L1 = Line.ByStartPointEndPoint (P1, P2);
L2 = Line.ByStartPointEndPoint (P3, P4);
ressaca = Surface.ByLoft ({L1, L2});
// True indica a engrossar ambos os lados da superfcie:
slido = surf.Thicken (4,75, true);
P1 = Point.ByCoordinates (3, 10, 2);
P2 = Point.ByCoordinates (-15, 7, 0,5);
p3 = Point.ByCoordinates (5, -3, 5);
P4 = Point.ByCoordinates (-5, -6, 2);
L1 = Line.ByStartPointEndPoint (P1, P2);
L2 = Line.ByStartPointEndPoint (P3, P4);
ressaca = Surface.ByLoft ({L1, L2});
slido = surf.Thicken (4,75, true);
p = Plane.ByOriginNormal (Point.ByCoordinates (2, 0, 0),
Vector.ByCoordinates (1, 1, 1));
int_surf = solid.Intersect (p);
int_line = int_surf.Intersect (Plane.ByOriginNormal (
Point.ByCoordinates (0, 0, 0),
Vector.ByCoordinates (1, 0, 0)));

Page 11
Enquanto dnamo capaz de criar uma variedade de complexo
formas geomtricas, primitivas geomtricas simples formam a espinha dorsal
de qualquer design computacional: ou diretamente expressou na final
projetado forma, ou usado como andaimes fora dos quais mais complexo
geometria gerado.
Embora no seja estritamente uma pea de geometria, o CoordinateSystem
uma importante ferramenta para a construo de geometria. A
CoordinateSystem
objeto mantm o controle de ambas as posies e transformaes geomtricas
como a rotao, pura e dimensionamento.
Criando um CoordinateSystem centrado em um ponto com x = 0, y =
0, z = 0, sem transformaes rotaes, escala ou sheering,
simplesmente requer chamar o construtor da identidade:
CoordinateSystems com transformaes geomtricas esto alm
o escopo deste captulo, embora outro construtor permite que voc
para criar um sistema de coordenadas em um ponto especfico,
CoordinateSystem.ByOriginVectors
:
O primitivo simples geomtrico um ponto, o que representa um zero
localizao dimensional no espao tridimensional. como mencionado
anteriormente, existem vrias maneiras diferentes de criar um ponto em um
nomeadamente o sistema de coordenadas:
Point.ByCoordinates
cria um
// Criar um CoordinateSystem em x = 0, y = 0, z = 0,
// no h rotaes, transformaes de escala, ou sheering
cs = CoordinateSystem.Identity ();
// Criar um CoordinateSystem em um local especfico,
// no h rotaes, transformaes de escala, ou sheering
x_pos = 3,6;
y_pos = 9,4;
z_pos = 13,0;
origem = Point.ByCoordinates (x_pos, y_pos, z_pos);
CoordinateSystem.Identity identidade = ();
cs = CoordinateSystem.ByOriginVectors (origem,
identity.XAxis, identity.YAxis, identity.ZAxis);
3: primitivas geomtricas

Page 12
ponto com x especificado, y, z e coordenadas;
Point.ByCartesianCoordinates
cria um ponto com um especificado
x, y, z e coordenadas em um sistema de coordenadas especfico;
Point.ByCylindricalCoordinates
cria um ponto deitado em uma
cilindro com raio, ngulo de rotao, e altura; e
Point.BySphericalCoordinates
cria um ponto deitado em uma
esfera com raio e dois ngulo de rotao.
Este exemplo mostra pontos criados em vrios coordenada
sistemas:
O prximo maior dimensional Dynamo primitivo um segmento de linha,
representando um nmero infinito de pontos entre dois pontos finais.
As linhas podem ser criadas por afirmar explicitamente os dois pontos de
contorno
com o construtor
Line.ByStartPointEndPoint
, Ou pela
especificando um ponto de partida, direo e comprimento nessa direo,
Line.ByStartPointDirectionLength
.
// Criar um ponto com x, y, z e coordenadas
x_pos = 1;
y_pos = 2;
z_pos = 3;
pCoord = Point.ByCoordinates (x_pos, y_pos, z_pos);
// Cria um ponto em um sistema de coordenadas especfico
cs = CoordinateSystem.Identity ();
pCoordSystem = Point.ByCartesianCoordinates (cs, x_pos,
y_pos, z_pos);
// Criar um ponto sobre um cilindro com o seguinte
// Raio e altura
Raio = 5;
height = 15;
teta = 75,5;
pCyl = Point.ByCylindricalCoordinates (cs, raio, teta,
altura);
// Criar um ponto sobre uma esfera com ngulos de raio e dois
phi = 120,3;
pSphere = Point.BySphericalCoordinates (cs, raio,
theta, phi);

Page 13
Dynamo tem objetos que representam os tipos mais bsicos de
primitivas geomtricas em trs dimenses: cuboids, criados com
Cuboid.ByLengths
; Cones, criado com
Cone.ByPointsRadius
e
Cone.ByPointsRadii
; Cilindros, criado com
Cylinder.ByRadiusHeight
; e esferas, criados com
Sphere.ByCenterPointRadius
.
P1 = Point.ByCoordinates (-2, -5, -10);
P2 = Point.ByCoordinates (6, 8, 10);
// Um segmento de linha entre dois pontos
l2pts = Line.ByStartPointEndPoint (P1, P2);
// Um segmento de recta na direco em p1 1, 1, 1 com
// Comprimento 10
LDIR Line.ByStartPointDirectionLength = (p1,
Vector.ByCoordinates (1, 1, 1), 10);
// Criar um cubide com comprimentos especificados
cs = CoordinateSystem.Identity ();
filhote = Cuboid.ByLengths (cs, 5, 15, 2);
// Criar vrios cones
P1 = Point.ByCoordinates (0, 0, 10);
P2 = Point.ByCoordinates (0, 0, 20);
p3 = Point.ByCoordinates (0, 0, 30);
cone1 = Cone.ByPointsRadii (P1, P2, 10, 6);
cone2 = Cone.ByPointsRadii (P2, P3, 6, 0);
// Fazer um cilindro
cylCS = cs.Translate (10, 0, 0);
cil = Cylinder.ByRadiusHeight (cylCS, 3, 10);
// Fazer uma esfera
centerP = Point.ByCoordinates (-10, -10, 0);
SPH = Sphere.ByCenterPointRadius (centerP, 5);

Page 14
Objetos em projetos computacionais raramente so criados explicitamente no
sua posio final e forma, e so mais frequentemente traduzido,
girado, e de outra forma posicionado com base fora da geometria existente.
Vector matemtica serve como uma espcie de andaime-geomtrica para dar
direo e orientao geometria, assim como conceituar
movimentos atravs do espao 3D sem representao visual.
No seu mais bsico, um vetor representa uma posio no espao 3D, e
muitas vezes considerado como o ponto final de uma seta da
posio (0, 0, 0) a essa posio. Os vectores podem ser criados com o
ByCoordinates
construtor, tendo o x, y, e a posio z do
recm-criado Vector objeto. Note-se que no so objectos do vetor
objetos geomtricos, e no aparecem na janela do Dynamo.
No entanto, informaes sobre um vetor recm-criado ou modificado
podem ser impressos na janela do console:
Um conjunto de operaes matemticas so definidos em objetos Vector,
permitindo-lhe adicionar, subtrair, multiplicar e, caso contrrio mover
objetos no espao 3D como seria de se mover nmeros reais em 1D
espao em uma linha de nmero.
Alm vector definido como a soma dos componentes de dois
vectores, e pode ser considerado como o vector resultante, se os dois
setas componente do vetor so colocados "ponta a cauda." Alm Vector
realizada com o
Adicionar
mtodo, e representado pela
diagrama esquerda.
// Construir um objeto Vector
v = Vector.ByCoordinates (1, 2, 3);
s = vX + "" + Vy + "" + vZ;
a = Vector.ByCoordinates (5, 5, 0);
b = Vector.ByCoordinates (4, 1, 0);
// C tem um valor x = 9, y = 6, z = 0
c = a.Add (b);
4: Vector Math

Pgina 15
Da mesma forma, dois objectos de vetores podem ser subtrados uns dos
outros
com o
Subtrair
mtodo. Vector subtraco pode ser pensado
como o sentido do primeiro vector para o segundo vector.
Vector de multiplicao pode ser entendido como um deslocamento do ponto
de extremidade de
um vetor em sua prpria direo por um determinado fator de escala.
Muitas vezes desejado ao dimensionar um vetor para que o resultante
comprimento do vector exactamente igual ao valor escalado. Isto facilmente
conseguida por normalizando primeiro um vector, em outras palavras que
definem o
comprimento do vector exactamente igual a um.
c
ainda aponta na mesma direco
uma
(1, 2, 3), que tem agora
comprimento exactamente igual a 5.
a = Vector.ByCoordinates (5, 5, 0);
b = Vector.ByCoordinates (4, 1, 0);
// C tem um valor x = 1, y = 4, z = 0
c = a.Subtract (b);
a = Vector.ByCoordinates (4, 4, 0);
// C tem um valor x = 20, y = 20, z = 0
c = a.Scale (5);
a = Vector.ByCoordinates (1, 2, 3);
a_len = a.length;
// Definido do comprimento igual a 1,0
b = a.Normalized ();
c = b.scale (5);
// Len igual a 5
len = c.Length;
Page 16
Dois mtodos adicionais existem no vector matemtica que no tm
claros paralelos com 1D matemtica, o produto cruzado e produto escalar.
O produto cruzado um meio de produo de um vector que
ortogonais (a 90 graus) para dois vetores existentes. Para
exemplo, o produto transversal dos eixos X e Y o eixo Z,
embora os dois vectores de entrada no necessita de ser ortogonais entre
de outros. Um vector de produto cruzado calculada com o
Atravessar
mtodo.
Uma funo adicional, embora um pouco mais avanado de
vector a matemtica o produto escalar. O produto de pontos entre os dois
vetores um nmero real (no um objeto Vector) que se relaciona com, mas
no exactamente, o ngulo entre dois vectores. Um til
Propriedades do produto de ponto que o produto de pontos entre os dois
vetores ser 0 se e somente se eles so perpendiculares. O dot
produto calculada com a
Ponto
mtodo.
um Vector.ByCoordinates = (1, 0, 1);
b = Vector.ByCoordinates (0, 1, 1);
// C tem um valor x = -1, y = -1, z = 1
c = a.Cross (b);
a = Vector.ByCoordinates (1, 2, 1);
b = Vector.ByCoordinates (5, -8, 4);
// D tem um valor -7
d = a.Dot (b);

Page 17
Quase todo projeto envolve elementos repetitivos, e explicitamente
digitando os nomes e construtores de cada ponto, linha e
outros primitivos em um script seria proibitivamente tempo consumindo.
Expresses Faixa dar um programador Dynamo os meios para
expressar conjuntos de valores de parmetros como em ambos os lados dois
pontos
(
..
), A gerao de nmeros intermdios entre estes dois
extremos.
Por exemplo, variveis, enquanto ns vimos que contm um nico
nmero, possvel com expresses de intervalo para ter variveis
que contm um conjunto de nmeros. A mais simples expresso de intervalo
preenche os incrementos de nmeros inteiros entre o incio e intervalo
fim.
Em exemplos anteriores, se um nico nmero transmitido como o
argumento de uma funo, que iria produzir um nico resultado. Da mesma
forma,
se uma gama de valores transmitido como o argumento de uma funo, um
gama de valores devolvido.
Por exemplo, se passar um intervalo de valores para a Linha
construtor, o Dnamo retorna um intervalo de linhas.
Por padro expresses Faixa de preencher o intervalo entre os nmeros
incrementando por algarismos inteiros, o que pode ser til para uma
rpido esboo topolgico, mas so menos adequados para real
projetos. Ao adicionar uma segunda reticncias (
..
) Para o intervalo
expresso, voc pode especificar a quantidade a expresso de intervalo
incrementa entre os valores. Aqui queremos que todos os nmeros
entre 0 e 1, incrementando por 0,1:
a = 1..6;
x_pos = 1..6;
y_pos = 5;
z_pos = 1;
lines = Line.ByStartPointEndPoint (Point.ByCoordinates (0,
0, 0), (Point.ByCoordinates x_pos, y_pos, z_pos));
5: Faixa Expresses

Page 18
Um problema que pode surgir quando se especifica o incremento
entre fronteiras expresso de intervalo que os nmeros
gerada nem sempre recair sobre o valor final intervalo. Para
exemplo, se criar uma expresso de intervalo entre 0 e 7,
incremento de 0,75, os seguintes valores so gerados:
Se um desenho requer um intervalo de expresso gerado para terminar
precisamente no valor mximo expresso de intervalo, o Dnamo pode
aproximar um incremento, chegando to perto quanto possvel, enquanto
ainda
manter uma distribuio igual de nmeros entre o intervalo
limites. Isto feito com o sinal aproximada () antes da
terceiro parmetro:
No entanto, se voc quiser Dynamo para interpolar entre os intervalos
com um nmero discreto de elementos, os
#
operador permite que voc
especificar isto:
a = 0..1..0.1;
a = 0..7..0.75;
// DesignScript ser incrementado em 0,777 No 0,75
a = 0..7..0.75;
// Interpolar entre 0 e 7 tal que
// "A" conter nove elementos
a = 0..7 .. # 9;

Page 19
As colees so tipos especiais de variveis que possuem conjuntos de
valores. Por exemplo, um conjunto pode conter os valores de 1 a
10,
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
, Geometria variada
a partir do resultado de uma operao de interseo,
{Surface, Point,
Linha, Ponto}
, Ou mesmo um conjunto de colees prprias,
{{1, 2,
3}, {4, 5}, 6}
.
Uma das maneiras mais fceis para gerar uma coleo com intervalo
expresses (ver: Gama Expresses). Expresses Faixa de
default gerar colees de nmeros, no entanto, se estes
coleces so passados para funes ou construtores, colees
de objetos so devolvidos.
Quando expresses alcance no so apropriados, as colees podem ser
criado vazio e cheio manualmente com os valores. o quadrado
operador de suporte (
[]
) utilizado para os membros de acesso dentro de uma
coleo. Os colchetes so escritos aps a varivel de
nomear, com o nmero do membro arrecadao individual
contido no interior. Este nmero chamado do membro coleo
ndice. Por razes histricas, a indexao comea em 0, ou seja, o
primeiro elemento de uma coleo acessado com:
coleo [0]
,
e muitas vezes chamado o nmero "zeroth". Membros posteriores
so acedidos atravs do aumento do ndice por uma, por exemplo:
Os membros individuais de um conjunto podem ser modificados utilizando o
mesmo operador ndice aps a coleta foi criado:
// Utilizar uma expresso de intervalo para gerar um conjunto de
// nmeros
nums = 0..10..0.75;
// Utilizar o conjunto de nmeros para gerar um
// Coleo de Pontos
pontos = Point.ByCoordinates (nums, 0, 0);
// Uma coleo de nmeros
nums = 0..10..0.75;
// Cria um nico ponto com o 6

do elemento
// Coleo
pontos = Point.ByCoordinates nums ([5], 0, 0);
6: Coleces

Page 20
De facto, um conjunto completo pode ser criado atravs da criao
explicitamente
cada membro da coleo individualmente. Coleces explcitas
so criados com o operador chaveta (
{}
) Envolvendo a
valores iniciais da coleo, ou deixado vazio para criar um vazio
coleo:
Coleces tambm podem ser utilizados como os ndices para gerar novo sub
coleces de uma coleo. Por exemplo, uma coleco contendo
os nmeros
{1, 3, 5, 7}
, Quando usada como o ndice de um
recolha, se extrair a 2
nd
,4

,6

E8

elementos de um
coleo (lembre-se que os ndices comeam em 0):
Dynamo contm funes de utilidade para ajudar a gerenciar colees. O
Contagem
funo, como o nome indica, conta uma coleo e
retorna o nmero de elementos que ele contm.
// Gerar uma srie de nmeros
a = 0..6;
// Mudar vrios dos elementos de um conjunto
um [2] = 100;
um [5] = 200;
// Criar uma coleo explicitamente
a = {45, 67, 22};
// Criar uma coleo vazia
b = {};
// Mudar vrios dos elementos de um conjunto
b [0] = 45;
b [1] = 67;
b [2] = 22;
a = 5..20;
ndices = {1, 3, 5, 7};
// Criar uma coleo por meio de uma coleo de ndices
b = a [ndices];

Page 21
// Criar uma coleo com 10 elementos
a = 1..10;
num_elements = Count (a);

Page 22
Quase toda a funcionalidade demonstrada na medida DesignScript
expressa atravs de funes. Voc pode dizer um comando um
funo quando contm uma palavra-chave sufixo por um parntese
contendo vrias entradas. Quando uma funo chamada em
DesignScript, uma grande quantidade de cdigo executado, o processamento
do
entradas e retornando um resultado. A funo de construtor
Point.ByCoordinates (x: double, y: double, z: double)
leva trs entradas, processa-os, e retorna um objeto Point.
Como a maioria das linguagens de programao, d DesignScript
programadores a habilidade de criar as suas prprias funes. Funes
so uma parte crucial de scripts eficazes: o processo de tomada de blocos
de cdigo com funcionalidade especfica, envolvendo-os em uma clara
Descrio das entradas e sadas acrescenta tanto legibilidade ao seu cdigo
e torna mais fcil de modificar e reutilizar.
Suponha que um programador tinha escrito um roteiro para criar uma diagonal
rtese em uma superfcie:
Este simples ato de criar diagonais sobre uma superfcie, no entanto,
leva vrias linhas de cdigo. Se quisssemos encontrar as diagonais de
centenas, se no milhares de superfcies, um sistema de individualmente
extraindo os pontos de canto e diagonais desenho seria
completamente impraticvel. Criando uma funo para extrair o
P1 = Point.ByCoordinates (0, 0, 0);
P2 = Point.ByCoordinates (10, 0, 0);
l = Line.ByStartPointEndPoint (P1, P2);
// Extrudir uma linha vertical para criar uma superfcie
ressaca = l.Extrude (Vector.ByCoordinates (0, 0,
1), 8);
// Extrair os pontos de canto da superfcie
corner_1 surf.PointAtParameter = (0, 0);
corner_2 surf.PointAtParameter = (1, 0);
corner_3 = surf.PointAtParameter (1, 1);
corner_4 surf.PointAtParameter = (0, 1);
// Conectar os pontos de canto opostas para criar diagonais
diag_1 = Line.ByStartPointEndPoint (corner_1, corner_3);
diag_2 = Line.ByStartPointEndPoint (corner_2, corner_4);
7: Funes

Page 23
diagonais de uma superfcie permite que um programador para aplicar o
funcionalidade de vrias linhas de cdigo com qualquer nmero de base de
insumos.
Funes so criados por escrito o
def
palavra-chave, seguido pela
nome da funo, e uma lista de entradas de funo, chamados argumentos, em
parntese. O cdigo que contm a funo fechado
dentro de chaves:
{}
. Em DesignScript, funes devem retornar um
valor, indicada por "atribuio de" um valor para o
Retorna
palavra chave
varivel. Por Exemplo
Esta funo recebe um nico argumento e retorna esse argumento
multiplicado por 2:
Funes no precisa necessariamente ter argumentos. um simples
funo para retornar a proporo urea parece com isso:
Antes de criar uma funo para embrulhar o nosso cdigo diagonal, note que
funes s podem retornar um nico valor, mas nosso cdigo diagonal
gera duas linhas. Para contornar este problema, ns podemos envolver dois
objetos em chaves,
{}
, A criao de um nico objeto de coleo. Para
exemplo, aqui uma funo simples que retorna dois valores:
def functionName (argument1, argument2, etc, etc,...)
{
// Cdigo vai aqui
retornar = ReturnVariable;
}
def getTimesTwo (arg)
{
retorno = arg * 2;
}
times_two = getTimesTwo (10);
def getGoldenRatio ()
{
retornar = 1.61803399;
}
gr = getGoldenRatio ();

Page 24
Se ns envolvemos o cdigo diagonal em uma funo, podemos criar
diagonais mais de uma srie de superfcies, por exemplo as faces de um
cubide.
returnTwoNumbers def ()
{
regresso = {1, 2};
}
two_nums returnTwoNumbers = ();
def makeDiagonal (superfcie)
{
corner_1 surface.PointAtParameter = (0, 0);
corner_2 surface.PointAtParameter = (1, 0);
corner_3 = surface.PointAtParameter (1, 1);
corner_4 surface.PointAtParameter = (0, 1);
diag_1 = Line.ByStartPointEndPoint (corner_1,
corner_3);
diag_2 = Line.ByStartPointEndPoint (corner_2,
corner_4);
retornar = {diag_1, diag_2};
}
c = Cuboid.ByLengths (CoordinateSystem.Identity (),
10, 20, 30);
diags = makeDiagonal (c.Faces.SurfaceGeometry ());

Page 25
A biblioteca padro Dynamo contm uma variedade de
funes matemticas para auxiliar de escrita e algoritmos
manipulao de dados. As funes matemticas so prefixados com o
Matemtica
namespace, exigindo-lhe para acrescentar funes com "
Math.
" dentro
para us-los.
As funes
Andar
,
Teto
E
Volta
permitem converter
entre nmeros de ponto flutuante e inteiros com previsvel
resultados. Todas as trs funes levar um nico nmero de ponto flutuante
como entrada, embora
Andar
retorna um inteiro por sempre arredondamento
baixa,
Teto
retorna um inteiro por sempre arredondamento para cima, e
Volta
arredondado para o nmero inteiro mais prximo
Dynamo tambm contm um conjunto padro de funes trigonomtricas
para calcular o seno, cosseno, tangente, arco-seno, arco cosseno, e
arco de tangente de ngulos, com a
Pecado
,
Cos
,
Bronzeado
,
Como Em
,
Acos
E
Um Bronzeado
funes respectivamente.
Enquanto uma descrio abrangente de trigonometria est alm do
mbito deste manual, as funes seno e cosseno fazer com freqncia
ocorrer em modelos computacionais, devido a sua capacidade de traar
posies sobre um crculo com raio 1. Ao introduzir uma crescente
ngulo de grau, muitas vezes rotulado
theta
, para dentro
Cos
para a posio x, e
Pecado
para a posio y, as posies em um crculo so calculados:
Val = 0,5;
f = Math.floor (Val);
c = Math.Ceiling (Val);
r = Math.Round (Val);
R2 = Math.Round (val + 0,001);
8: Math

Page 26
Um conceito de matemtica relacionado no estritamente parte do padro de
matemtica
biblioteca o operador mdulo. O operador mdulo, indicado
por um sinal de porcentagem (%), retorna o resto de uma diviso
entre dois nmeros inteiros. Por exemplo, 7 divididas por 2 a 3
com uma sobra (por exemplo, 2 x 3 + 1 = 7). O mdulo de entre 7 e 2
Por conseguinte, de 1. Por outro lado, divide uniformemente em 2 6, e
Por conseguinte, o mdulo de entre 6 e 2 0. A seguir
exemplo ilustra o resultado de vrias operaes mdulo.
num_pts = 20;
// Obter valores de grau 0-360
teta = 0..360 .. # num_pts;
p = Point.ByCoordinates (Math.cos (teta),
Math.Sin (teta), 0);
7% 2;
6% 2;
10% 3;
19% 7;

Page 27
H duas maneiras fundamentais para a criao de curvas de forma livre em
Dynamo: especificando uma coleo de pontos e ter Dynamo
interpretar uma curva suave entre eles, ou um baixo nvel mais
mtodo especificando os pontos de controlo subjacentes de uma curva de um
certo grau. Curvas interpretadas so teis quando um designer
sabe exatamente a forma de uma linha deve tomar, ou se o projeto tem
restries especficas para que a curva pode e no pode passar
Atravs dos. Curvas especificados atravs de pontos de controle so, em
essncia, um
srie de segmentos de linha reta que um algoritmo suaviza em
uma forma curva final. Especificando uma curva atravs de pontos de controle
pode ser
til para a explorao de formas de curvas com diferentes graus de
alisamento, ou quando uma continuidade suave entre a curva
segmentos necessria.
Para criar uma curva interpretado, basta passar em uma coleo de
Chama a ateno para o
NurbsCurve.ByPoints
mtodo.
A curva gerada intersecta cada um dos pontos de entrada,
comeando e terminando no primeiro e ltimo ponto da coleo,
respectivamente. Um parmetro peridica opcional pode ser usado para
criar uma curva peridica que fechada. Dynamo vai
preencher automaticamente o segmento em falta, portanto, um ponto final
duplicado
(Idnticas ao ponto de incio) no necessria.
num_pts = 6;
s = Math.Sin (0..360 .. # num_pts) * 4;
pts = Point.ByCoordinates (1..30 .. # num_pts, s, 0);
int_curve = NurbsCurve.ByPoints (pts);
pts = Point.ByCoordinates (Math.cos (0..350 .. # 10),
Math.Sin (0..350 .. # 10), 0);
// Criar uma curva fechada
CRV = NurbsCurve.ByPoints (pts, true);
// A mesma curva, se deixada em aberto:
crv2 = NurbsCurve.ByPoints (pts.Translate (5, 0, 0),
false);
9: Curvas: interpretados e Pontos de Controlo

Page 28
NurbsCurves so gerados da mesma maneira, com a entrada
Os pontos representam os pontos de extremidade de um segmento de linha
reta, e um
segundo parmetro especificando a quantidade eo tipo de alisamento
a curva sofre, o chamado grau. * Uma curva com um grau
no tem de alisamento; uma polilinha.
Uma curva com grau 2 alisada de tal forma que as interseces da curva
e tangente ao ponto mdio dos segmentos poligonais:
Dynamo suporta NURBS (B-spline racional no uniforme) curvas
at 20 graus, e o script a seguir ilustra o efeito
o aumento dos nveis de alisamento tem a forma de uma curva de:
num_pts = 6;
pts = Point.ByCoordinates (1..30 .. # num_pts,
Math.Sin (0..360 .. # num_pts) * 4, 0);
// Uma curva B-Spline com grau 1 uma polilinha
ctrl_curve = NurbsCurve.ByControlPoints (pts, 1);
num_pts = 6;
pts = Point.ByCoordinates (1..30 .. # num_pts,
Math.Sin (0..360 .. # num_pts) * 4, 0);
// Uma curva B-Spline com grau 2 suave
ctrl_curve = NurbsCurve.ByControlPoints (pts, 2);

Page 29
Note que voc deve ter pelo menos mais um ponto de controle do que o
o grau da curva.
Outro benefcio da construo de curvas por vrtices de controle o
capacidade de manter a tangncia entre os segmentos individuais da curva.
Isto feito atravs da extraco da direco entre os dois ltimos
pontos de controle, e continuar nessa direo, com os dois primeiros
pontos de controle da curva seguinte. O exemplo a seguir
cria duas curvas NURBS separados que so, no entanto, como
Suave como uma curva:
num_pts = 6;
pts = Point.ByCoordinates (1..30 .. # num_pts,
Math.Sin (0..360 .. # num_pts) * 4, 0);
def create_curve (pts: Ponto [], grau: int)
{
retornar = NurbsCurve.ByControlPoints (pts,
grau);
}
ctrl_crvs = create_curve (pts), 1..11;

Page 30
* Esta uma descrio muito simplificada de geometria curva NURBS,
para uma discusso mais precisa e detalhada ver Pottmann, et al ,
De 2007, nas referncias.
pts_1 = {};
pts_1 [0] = Point.ByCoordinates (0, 0, 0);
pts_1 [1] = Point.ByCoordinates (1, 1, 0);
pts_1 [2] = Point.ByCoordinates (5, 0,2, 0);
pts_1 [3] = Point.ByCoordinates (9, -3, 0);
pts_1 [4] = Point.ByCoordinates (11, 2, 0);
crv_1 = NurbsCurve.ByControlPoints (pts_1, 3);
pts_2 = {};
pts_2 [0] = pts_1 [4];
end_dir = pts_1 [4] .Subtract (pts_1 [3] .AsVector ());
pts_2 [1] = Point.ByCoordinates (pts_2 [0] + .X end_dir.X,
pts_2 [0] .Y + end_dir.Y, pts_2 [0] + .Z end_dir.Z);
pts_2 [2] = Point.ByCoordinates (15, 1, 0);
pts_2 [3] = Point.ByCoordinates (18, -2, 0);
pts_2 [4] = Point.ByCoordinates (21, 0,5, 0);
crv_2 = NurbsCurve.ByControlPoints (pts_2, 3);
Page 31
Certos objectos geometria pode ser criado por afirmar explicitamente x, y,
e z coordenadas no espao tridimensional. mais frequente,
no entanto, a geometria movido para a sua posio final usando
transformaes geomtricas sobre o objeto em si ou em seu subjacente
sistema de coordenadas.
O mais simples transformao geomtrica uma traduo, que
move-se um objecto de um determinado nmero de unidades em x, y, e z
direes.
Enquanto todos os objetos no Dynamo pode ser traduzido anexando o
.Translate
mtodo para o fim do nome do objecto, mais
transformaes complexas exigem transformar o objeto de um
subjacente CoordinateSystem para uma nova CoordinateSystem. Para
exemplo, para rodar um objecto 45 graus em torno do eixo x, ns
transformaria o objeto de seu CoordinateSystem existente
sem rotao, para um CoordinateSystem que tinha sido rodado
45 graus em torno do eixo X com o
.Transform
Mtodo:
// Cria um ponto em x = 1, y = 2, z = 3
p = Point.ByCoordinates (1, 2, 3);
// Traduzir o ponto 10 unidades na direo x,
// -20 Em y, e z 50 em
// A nova posio de p2 x = 11, y = -18, z = 53
P2 = p.Translate (10, -20, 50);
cubo = Cuboid.ByLengths (CoordinateSystem.Identity (),
10, 10, 10);
new_cs CoordinateSystem.Identity = ();
new_cs2 = new_cs.Rotate (Point.ByCoordinates (0, 0),
Vector.ByCoordinates (1,0,0.5), 25);
// Obtm o sistema de coordenadas existente do cubo
old_cs CoordinateSystem.Identity = ();
CUBE2 = cube.Transform (old_cs, new_cs2);
10: translao, rotao e outras transformaes

Page 32
Alm de ser traduzido e rodados, CoordinateSystems
pode tambm ser criada dimensionado ou cortado. A CoordinateSystem pode
ser escalado com o
.Scale
Mtodo:
CoordinateSystems cortadas so criados atravs da introduo no-
vetores ortogonais para o construtor CoordinateSystem.
cubo = Cuboid.ByLengths (CoordinateSystem.Identity (),
10, 10, 10);
new_cs CoordinateSystem.Identity = ();
new_cs2 = new_cs.Scale (20);
old_cs CoordinateSystem.Identity = ();
cubo = cube.Transform (old_cs, new_cs2);
new_cs = CoordinateSystem.ByOriginVectors (
Point.ByCoordinates (0, 0, 0),
Vector.ByCoordinates (-1, -1, 1),
Vector.ByCoordinates (-0,4, 0, 0));
old_cs CoordinateSystem.Identity = ();
cubo = Cuboid.ByLengths (CoordinateSystem.Identity (),
5, 5, 5);
new_curves = cube.Transform (old_cs, new_cs);

Page 33
Dimensionamento e cisalhamento so comparativamente mais complexo
geomtrico
transformaes que rotao e translao, ento nem todos os
Dynamo objeto pode passar por essas transformaes. Os seguintes
tabela descreve quais objetos Dynamo pode ter no uniformemente
CoordinateSystems escalados, e CoordinateSystems cortadas.
Aula
No uniformemente
Scaled
sistema de coordenadas
Cortados
sistema de coordenadas
Arco
No
No
NurbsCurve
Sim
Sim
NurbsSurface
No
No
Crculo
No
No
Linha
Sim
Sim
Avio
No
No
Ponto
Sim
Sim
Polgono
No
No
Slido
No
No
Superfcie
No
No
Texto
No
No

Page 34
Uma das caractersticas mais poderosas de uma linguagem de programao
a capacidade de olhar para os objetos existentes em um programa e variam
a execuo do programa de acordo com essas qualidades dos objetos.
Linguagens de programao mediar entre os exames de um
qualidades do objeto e da execuo de cdigo especfico atravs de um
sistema
chamado de lgica booleana.
Lgica booleana examina se as declaraes so verdadeiras ou falsas.
Toda declarao na lgica booleana ser verdadeira ou falsa, h
h outros estados; talvez no, possvel, ou talvez exista. O
maneira mais simples para indicar que uma expresso booleana verdadeira
com
a
verdade
palavra-chave. Da mesma forma, a maneira mais simples para indicar um
afirmao falsa com o
falso
palavra-chave. O
E se
afirmao
permite determinar se uma declarao verdadeira da falsa: se verdade,
a primeira parte do bloco de cdigo executado, se for falsa, o segundo
bloco de cdigo executado.
No exemplo a seguir, o
E se
declarao contm uma
verdade
Expresso booleana, assim que os primeiros executa o bloco e um ponto
gerado:
Se a declarao contida alterado para
falso
, O segundo cdigo
bloco executa e uma linha gerado:
geometria = [Imperativo]
{
if ( verdadeiro )
{
retorno = Point.ByCoordinates (1, 4, 6);
}
outro
{
retornar = Line.ByStartPointEndPoint (
Point.ByCoordinates (0, 0, 0),
Point.ByCoordinates (10, -4, 6));
}
}
11: Condicionais e lgica booleana

Page 35
Declaraes static boolean como estes no so particularmente til; a
poder da lgica booleana vem de examinar as qualidades de
objetos em seu script. Lgica booleana tem seis operaes bsicas para
avaliar os valores: menos de (
<
), Melhor que (
>
), Inferior a ou igual
(
<=
), Maior do que ou igual (
>=
), Igual (
==
), E igual a (
!=
).
O quadro a seguir descreve os resultados booleanos
<
Retorna verdadeiro se o nmero no lado esquerdo menor do que o nmero
no lado direito
lado.
>
Retorna verdadeiro se o nmero no lado esquerdo maior do que o nmero de
lado direito.
<=
Retorna verdadeiro nmero de no lado esquerdo menos do que ou igual
nmero do lado direito. *
>=
Retorna verdadeiro nmero de no lado esquerdo maior do que ou igual
para o nmero do lado direito. *
==
Retorna true se os dois nmeros so iguais *
!=
Retorna true se tanto em nmero no so iguais *
* Ver o captulo "Tipos nmero" para limitaes da igualdade de testes
entre dois nmeros de ponto flutuante.
Usando um desses seis operadores em dois nmeros retorna
verdade
ou
falso
:
geometria = [Imperativo]
{
// Muda verdadeiro para falso
if ( false )
{
retorno = Point.ByCoordinates (1, 4, 6);
}
outro
{
retornar = Line.ByStartPointEndPoint (
Point.ByCoordinates (0, 0, 0),
Point.ByCoordinates (10, -4, 6));
}
}
resultado = 10 <30;

Page 36
Existem trs outros operadores booleanos para comparar
verdade
e
falso
e declaraes: (
&&
), Ou (
||
), e no (
!
).
&&
Retorna true se os valores de ambos os lados so verdadeiras.
||
Retorna true se um dos valores de ambos os lados so verdadeiras.
!
Retorna o booleano oposto
Refatorao do cdigo no exemplo inicial demonstra
diferentes caminhos de execuo de cdigo com base nas entradas que mudam
de
uma expresso de intervalo:
resultado = 15 <= 15;
resultado = 99 = 99!;
result = verdadeiro && falso ;
result = verdadeiro || falso ;
result =! falsa ;

Page 37
make_geometry def (i)
{
retornar = [Imperativo]
{
// Test se a entrada divisvel
// Por 2 ou 3. Veja "Math"
if (i == 0% 2% 3 || i == 0)
{
retornar = Point.ByCoordinates (i, -4, 10);
}
outro
{
retornar = Line.ByStartPointEndPoint (
Point.ByCoordinates (4, 10, 0),
Point.ByCoordinates (I, -4, 10));
}
}
}
g = make_geometry (0..20);
Page 38
Loops so comandos para repetir a execuo ao longo de um bloco de cdigo.
O nmero de vezes que um loop chamado pode ser regido por um
recolha, onde um circuito chamada com cada elemento da
recolha como entrada, ou com uma expresso booleana, onde o lacete
chamado at os Expresso booleana Devolve
falso
. Loops podem
ser usado para gerar colees, procurar uma soluo, ou
caso contrrio, adicionar repetio sem expresses alcance.
O
enquanto
declarao avalia uma expresso booleana, e
continua re-executar o bloco de cdigo contido at que a
Expresso booleana
verdade
. Por exemplo, este script continuamente
cria e recria uma linha at que tem um comprimento maior do que 10:
No cdigo Dynamo associativa, se uma coleo de elementos utilizado
como entrada a uma funo que toma normalmente um valor nico, o
funo chamada individualmente para cada membro de uma
coleco. Dentro
imperativo Dynamo cdigo de um programador tem a opo de escrever
cdigo que itera manualmente sobre a coleta, extrair
membros da coleo individuais um de cada vez.
O
para
declarao extrai elementos de uma coleo em um
chamado varivel, uma vez para cada membro de uma coleco. O
sintaxe
para
:
para(
"Varivel extrado"
dentro
"Coleo de entrada"
)
geometria = [Imperativo]
{
x = 1;
iniciar Point.ByCoordinates = (0, 0, 0);
end Point.ByCoordinates = (x, x, x);
line = Line.ByStartPointEndPoint (incio, fim);
enquanto (line.Length <10)
{
X = x + 1;
end Point.ByCoordinates = (x, x, x);
line = Line.ByStartPointEndPoint (incio, fim);
}
retornar = linha;
}
12: Looping

Page 39
geometria = [Imperativo]
{
collection = 0..10;
pontos = {};
for (i na coleo)
{
pontos [i] = Point.ByCoordinates (i, 0, 0);
}
retornar = pontos;
}

Page 40
A linguagem Dynamo foi criado como uma ferramenta especfica de domnio
para
arquitetos, designers e engenheiros, e como tal, tem vrios
recursos de linguagem especificamente para estas disciplinas. UMA
elemento comum nestas disciplinas a prevalncia de objetos
vestiu grades repetitivas, de paredes de tijolos e piso de cermica para fachada
grades e painis de coluna. Enquanto expresses oferecem uma gama
meio conveniente de gerar uma coleces de dimensionais
elementos, guias de replicao oferecem um meio conveniente de
gerando dois e trs colees dimensionais.
Guias de replicao tomar colees dois ou trs unidimensionais,
e emparelhar os elementos juntos para gerar um, dois ou trs
recolha dimensional. Guias de replicao so indicados por
colocando os smbolos
<1>
,
<2>
Ou
<3>
aps um dois ou trs
colees em uma nica linha de cdigo. Por exemplo, podemos usar
variar expresses para gerar dois conjuntos de unidimensionais,
e usar essas colees para gerar uma coleo de pontos:
Neste exemplo, o primeiro elemento de
x_vals
emparelhado com o primeiro
elemento de
y_vals
, O segundo com o segundo, e assim por diante para a
comprimento inteiro da coleo. Isto gera pontos com valores
(0, 0, 0), (1, 1, 0), (2, 2, 0), (3, 3, 0), etc .... Se aplicarmos uma
guia de replicao para esta mesma linha de cdigo, podemos ter Dynamo
gerar uma rede bidimensional a partir dos dois unidimensional
colees:
x_vals = 0..10;
y_vals = 0..10;
p = Point.ByCoordinates (x_vals, y_vals, 0);
x_vals = 0..10;
y_vals = 0..10;
// Aplicar guias de replicao para as duas colees
p = Point.ByCoordinates (x_vals <1>, y_vals <2>, 0);
13: Guias de replicao

Page 41
Atravs da aplicao de guias para replicao
x_vals
e
y_vals
, Dynamo
gera todas as combinaes possveis de valores entre os dois
colees, primeiro emparelhar o 1
st
elemento
x_vals
com toda a
elementos em
y_vals
, Em seguida, emparelhar o 2
nd
elemento de
x_vals
com
todos os elementos em
y_vals
, E assim por diante para cada elemento
de
x_vals
.
A ordem dos nmeros guia de replicao (
<1>
,
<2>
, E / ou
<3>
)
determina o fim da recolha subjacente. na sequncia
exemplo, os mesmos dois conjuntos de unidimensionais so usados para
formar dois conjuntos de bidimensionais, embora com o fim de
<1>
e
<2>
trocados.
Curve1
e
curve2
traar a ordem de elementos gerados em
duas matrizes; notar que eles so rodados 90 graus para cada
de outros. p1 foi criado por elementos de extraco
x_vals
e
emparelhar com eles
y_vals
, Enquanto p2 foi criado por extraco
elementos de
y_vals
e emparelhamento-los com
x_vals
.
Guias de replicao tambm trabalham em trs dimenses, emparelhando um
terceira coleo com um smbolo terceiro replicao,
<3>
.
x_vals = 0..10;
y_vals = 0..10;
p1 = Point.ByCoordinates (x_vals <1>, y_vals <2>, 0);
// Aplicar as guias de replicao com uma ordem trocada
// E definir os pontos 14 unidades maiores
p2 = Point.ByCoordinates (x_vals <2>, y_vals <1>, 14);
Curve1 = NurbsCurve.ByPoints (Flatten (p1));
curve2 = NurbsCurve.ByPoints (Flatten (p2));
Page 42
Isso gera todas as combinaes possveis de valores de
combinando os elementos de
x_vals
,
y_vals
E
z_vals
.
x_vals = 0..10;
y_vals = 0..10;
z_vals = 0..10;
// Gerar uma matriz de pontos 3D
p = Point.ByCoordinates (x_vals <1>, y_vals <2>, z_vals <3>);

Page 43
A classificao de uma coleo definida como a maior profundidade de
elementos dentro de uma coleo. Uma coleo de valores individuais tem um
Rank de 1, enquanto uma coleo de colees de valores individuais tem um
posto de 2. Terminou pode ser vagamente definido como o nmero de praa
suporte (
[]
) Os operadores necessrios para acessar o membro mais profundo de
uma coleo. Coleces de categoria 1 s precisa de um nico quadrado
suporte para acessar o membro mais profundo, enquanto colees de
classificao
trs requerem trs suportes subsequentes. A seguinte tabela
delineia colees de 1-3 fileiras, embora as colees podem existir at
a qualquer profundidade rank.
Categoria
Coleo
Acesso 1
st
Elemento
1
{1, 2, 3, 4, 5}
coleo [0]
2
{{1, 2}, {3, 4}, {5, 6}}
recolha [0] [0]
3
{{{1, 2}, {3, 4}},
{{5, 6}, {7, 8}}}
recolha [0] [0] [0]
...
Coleces Superior classificados gerados por expresses alcance e
guias de replicao so sempre homognea, em outras palavras
cada objecto de uma recolha na mesma profundidade (isto acedido
com o mesmo nmero de
[]
operadores). No entanto, nem todos Dynamo
coleces conter elementos na mesma profundidade. Estes
colees so chamadas irregulares, depois do facto de que a profundidade
aumenta-se
e para baixo ao longo do comprimento do conjunto. O cdigo a seguir
gera uma coleco irregular:
falhar quando ele tenta executar operaes no compatveis, por um
coleo.
J = {};
j [0] = 1;
j [1] = {2, 3, 4};
j [2] = 5;
j [3] = {{6, 7}, {{8}}};
j [4] = 9;
14: Coleo Rank e Jagged Coleces

Page 44
O exemplo a seguir mostra como acessar todos os elementos de
esta coleo irregular:
// Gerar uma coleco irregular
J = {1, {2, 3, 4}, 5, {{6, 7}, {{8}}}, 9};
s = j [0] + "" + J [1] [0] + "" + J [1] [1] + "" +
j [1] [2] + "" + J [2] + "" +
j [3] [0] [0] + "" + j [3] [0] [1] + "" +
j [3] [1] [0] [0] + "" + J [4];

Page 45
O anlogo bidimensional para um NurbsCurve a
NurbsSurface, e como o NurbsCurve de forma livre, NurbsSurfaces
pode ser construdo com dois mtodos bsicos: um conjunto de introduo
pontos base e tendo Dynamo interpretar entre eles, e
especificando explicitamente os pontos da superfcie de controle. tambm
gosto
curvas de forma livre, superfcies interpretadas so teis quando um designer
sabe precisamente a forma de uma superfcie precisa tomar, ou se um design
requer a superfcie de passar atravs dos pontos de restrio. no
Por outro lado, superfcies criadas por pontos de controlo pode ser mais
til para projetos exploratrios em vrios nveis de alisamento.
Para criar uma superfcie interpretado, simplesmente gerar um perodo de dois
coleo dimensional de pontos de aproximao a forma de um
superfcie. A coleo deve ser retangular, ou seja, no irregular.
O mtodo
NurbsSurface.ByPoints
constri uma superfcie de
esses pontos.
NurbsSurfaces forma livre tambm pode ser criado atravs da especificao
pontos de controle subjacentes de uma superfcie. Como NurbsCurves, o
Os pontos de controlo pode ser considerado como representando um
quadriltero
malha com segmentos rectos, que, dependendo do grau de
a superfcie, alisada na forma de superfcie definitiva. Para criar um
NurbsSurface por pontos de controle, incluem dois adicionais
parmetros para
NurbsSurface.ByPoints
, Indicando os graus de
as curvas subjacentes em ambos os sentidos da superfcie.
// Python_points_1 um conjunto de pontos gerados com
// Um script Python encontrada no Apndice 1
ressaca = NurbsSurface.ByPoints (python_points_1);
// Python_points_1 um conjunto de pontos gerados com
// Um script Python encontrada no Apndice 1
// Criar uma superfcie de grau 2, com segmentos suaves
ressaca = NurbsSurface.ByPoints (python_points_1, 2, 2);
15: Superfcies: Interpretada, pontos de controle, Loft, revolva

Page 46
Ns podemos aumentar o grau de NurbsSurface para alterar o
resultando geometria da superfcie:
Assim como superfcies podem ser criados atravs da interpretao de entre
um conjunto de
Os pontos de entrada, que pode ser criado atravs da interpretao de entre um
conjunto de
curvas de base. Isso chamado lofting. Uma curva de loft criado usando
a
Surface.LoftFromCrossSections
construtor, com um
coleo de curvas de entrada como o nico parmetro.
As superfcies de revoluo so um tipo adicional de superfcie criada
varrendo uma curva de base em torno de um eixo central. Se interpretado
superfcies so o anlogo bidimensional para curvas interpretados,
em seguida, as superfcies de revoluo o anlogo bidimensional
crculos e arcos. As superfcies de revoluo so especificados por uma base
curva, que representa o "bordo" da superfcie; uma origem eixo, o
ponto base da superfcie; uma direco do eixo, o "ncleo" central,
direo; um ngulo inicial de varredura; e um ngulo de fim de
varredura. esses so
usada como a entrada para o
Surface.Revolve
construtor.
// Python_points_1 um conjunto de pontos gerados com
// Um script Python encontrada no Apndice 1
// Criar uma superfcie de grau 6
ressaca = NurbsSurface.ByPoints (python_points_1, 6, 6);
Python_points_2 //, 3 e 4 so gerados com
// scripts Python encontrados no Apndice 1
C1 = (NurbsCurve.ByPoints python_points_2);
C2 = NurbsCurve.ByPoints (python_points_3);
C3 = NurbsCurve.ByPoints (python_points_4);
sto = Surface.LoftFromCrossSections ({C1, C2, C3});

Page 47
pts = {};
Pontos [0] = Point.ByCoordinates (4, 0, 0);
Pontos [1] = Point.ByCoordinates (3, 0, 1);
Pontos [2] = Point.ByCoordinates (4, 0, 2);
Pontos [3] = Point.ByCoordinates (4, 0, 3);
Pontos [4] = Point.ByCoordinates (4, 0, 4);
Pontos [5] = Point.ByCoordinates (5, 0, 5);
Pontos [6] = Point.ByCoordinates (4, 0, 6);
Pontos [7] = Point.ByCoordinates (4, 0, 7);
CRV = NurbsCurve.ByPoints (pts);
axis_origin Point.ByCoordinates = (0, 0, 0);
eixo Vector.ByCoordinates = (0, 0, 1);
ressaca = Surface.ByRevolve (crv, axis_origin, eixo 0,
360);

Page 48
Em modelos computacionais, curvas e superfcies so frequentemente
utilizado como andaime para construir subjacente subsequente
geometria. Para esta geometria cedo para ser utilizado como um
fundao para a geometria mais tarde, o script deve ser capaz de extrair
qualidades tais como a posio e orientao ao longo de toda a rea
do objecto. Ambas as curvas e superfcies suportam esta extraco,
e chamado de parametrizao.
Todos os pontos sobre uma curva pode ser pensado como tendo uma nica
parmetro que varia de 0 a 1. Se fssemos criar uma NurbsCurve
pontos baseado fora de vrios controle ou interpretadas, o primeiro ponto
teria o parmetro 0, e o ltimo ponto teria o
parmetro 1. impossvel saber com antecedncia o que o Exato
parmetro qualquer ponto intermedirio , o que pode soar como uma
grave limitao que atenuado por uma srie de utilidade
funes. As superfcies tm uma parametrizao semelhante como curvas,
embora com dois parmetros em vez de um, chamado de u e v . Se ns
foram para criar uma superfcie com os seguintes pontos:
p1
teria parmetro u = 0 v = 0, enquanto
p9
teria
parmetros u = 1 v = 1.
Parametrizao no particularmente til ao determinar pontos
utilizado para gerar curvas, o seu uso principal determinar a
locais se pontos intermdios gerados por e NurbsCurve
Construtores NurbsSurface.
Curves tem um mtodo
PointAtParameter
, O que leva um nico
duplo argumento entre 0 e 1, e retorna o objeto Point
nesse parmetro. Por exemplo, este script encontra os pontos em
parmetros 0, 0,1, 0,2, 0,3, 0,4, 0,5, 0,6, 0,7, 0,8, 0,9, e 1:
Pontos = {{P1, P2, P3},
{P4, p5, p6},
{P7, P8, P9}};
16: Parametrizao geomtrica

Page 49
Do mesmo modo, as superfcies tm uma forma que leva PointAtParameter
dois argumentos, o u e v parmetros do ponto gerado.
Ao extrair pontos individuais de uma curva e a superfcie pode ser
teis, roteiros, muitas vezes requer conhecer o particular geomtrica
caractersticas em um parmetro, como que direo a Curva
ou de superfcie est enfrentando. Os mtodos
CoordinateSystemAtParameterAlongCurve
e
CoordinateSystemAtParameter
encontrar no s a posio, mas uma
CoordinateSystem orientada no parmetro de uma curva e
Superfcie respectivamente. Por exemplo, o seguinte extractos de script
CoordinateSystems orientadas ao longo de uma superfcie revolvida e usos
a orientao das CoordinateSystems para gerar linhas, que
so degola fora normal superfcie:
pts = {};
Pontos [0] = Point.ByCoordinates (4, 0, 0);
Pontos [1] = Point.ByCoordinates (6, 0, 1);
Pontos [2] = Point.ByCoordinates (4, 0, 2);
Pontos [3] = Point.ByCoordinates (4, 0, 3);
Pontos [4] = Point.ByCoordinates (4, 0, 4);
Pontos [5] = Point.ByCoordinates (3, 0, 5);
Pontos [6] = Point.ByCoordinates (4, 0, 6);
CRV = NurbsCurve.ByPoints (pts);
pts_at_param = crv.PointAtParameter (0..1 .. # 11);
// Desenha linhas para ajudar a visualizar os pontos
linhas = Line.ByStartPointEndPoint (pts_at_param,
Point.ByCoordinates (4, 6, 0));

Page 50
Como mencionado anteriormente, parametrizao nem sempre uniforme
em todo o comprimento de uma curva ou uma superfcie, o que significa que o
parmetro 0.5 nem sempre corresponde ao ponto mdio, e
0,25 nem sempre corresponde ao ponto de um quarto ao longo de um
curva ou superfcie. Para contornar esta limitao, Curves tem um
conjunto adicional de comandos de parametrizao que permitem que voc
encontrar um ponto em comprimentos especficos ao longo de uma curva.
pts = {};
Pontos [0] = Point.ByCoordinates (4, 0, 0);
Pontos [1] = Point.ByCoordinates (3, 0, 1);
Pontos [2] = Point.ByCoordinates (4, 0, 2);
Pontos [3] = Point.ByCoordinates (4, 0, 3);
Pontos [4] = Point.ByCoordinates (4, 0, 4);
Pontos [5] = Point.ByCoordinates (5, 0, 5);
Pontos [6] = Point.ByCoordinates (4, 0, 6);
Pontos [7] = Point.ByCoordinates (4, 0, 7);
CRV = NurbsCurve.ByPoints (pts);
axis_origin Point.ByCoordinates = (0, 0, 0);
eixo Vector.ByCoordinates = (0, 0, 1);
ressaca = Surface.ByRevolve (crv, axis_origin, eixo, 90,
140);
cs_array = surf.CoordinateSystemAtParameter (
(0..1 .. # 7) <1>, (0..1 .. # 7) <2>);
def make_line (cs: CoordinateSystem) {
lines_start = cs.Origin;
lines_end = cs.Origin.Translate (cs.ZAxis, -0,75);
retornar = Line.ByStartPointEndPoint (lines_start,
lines_end);
}
linhas = make_line (Achate (cs_array));

Page 51
Muitos dos exemplos at agora tm-se centrado na construo de
maior geometria dimensional de objectos tridimensionais inferiores.
Mtodos de interseco permitir que esta geometria de dimenso superior a
gerar objetos dimensionais mais baixos, enquanto a guarnio e selecione
guarnio
comandos permite que o script fortemente modificar formas geomtricas
depois
eles foram criados.
O
Interceptar
mtodo definido em todas as peas de geometria em
Dynamo, o que significa que, em teoria, qualquer pea de geometria pode ser
intersectada com qualquer outra pea de geometria. Naturalmente alguns
intersees so sem sentido, como cruzamentos envolvendo
Pontos, que o objecto resultante ir sempre ser o prprio ponto de entrada.
As outras combinaes possveis de cruzamentos entre objectos
so descritos na tabela a seguir. O grfico a seguir descreve o
resultado de vrias operaes de interseo:
Se cruzam:
Com:
Superfcie
Curva
Avio
Slido
Superfcie
Curva
Ponto
Point, Curve Superfcie
Curva
Ponto
Ponto
Ponto
Curva
Avio
Curva
Ponto
Curva
Curva
Slido
Superfcie
Curva
Curva
Slido
O seguinte exemplo muito simples demonstra a interseo
de um avio com uma NurbsSurface. A interseco gera um
NurbsCurve matriz, que pode ser utilizado como qualquer outro NurbsCurve.
// Python_points_5 um conjunto de pontos gerados com
// Um script Python encontrada no Apndice 1
ressaca = NurbsSurface.ByPoints (python_points_5, 3, 3);
WCS = CoordinateSystem.Identity ();
PL = Plane.ByOriginNormal (WCS.Origin.Translate (0, 0,
0,5), WCS.ZAxis);
// Intersectar a superfcie, gerando trs curvas fechadas
CRVs = surf.Intersect (pl);
crvs_moved crvs.Translate = (0, 0, 10);
17: Interseco e guarnio

Page 52
O
Aparar
mtodo muito semelhante ao mtodo de Interseco, na medida em que
definido para quase todas as peas de geometria. Ao contrrio de interseo,
h muito mais limitaes sobre
Aparar
do que na
Interceptar
Aparar
Usando:
Ligar:
Ponto
Curva
Avio
Superfcie
Slido
Curva
Sim
No
No
No
No
Polgono
N/D
No
Sim
No
No
Superfcie
N/D
Sim
Sim
Sim
Sim
Slido
N/D
N/D
Sim
Sim
Sim
Algo a notar sobre
Aparar
mtodos o requisito de um
"Selecione" ponto, ponto que determina qual a geometria
descartar e quais peas para manter. Dynamo encontra o lado mais prximo
da geometria aparada ao ponto de seleo, e este lado
torna-se o lado de se desfazer.
// Python_points_5 um conjunto de pontos gerados com
// Um script Python encontrada no Apndice 1
ressaca = NurbsSurface.ByPoints (python_points_5, 3, 3);
tool_pts = Point.ByCoordinates ((- 10..20..10) <1>,
(-10..20..10) <2>, 1);
ferramentas = NurbsSurface.ByPoints (tool_pts);
pick_point = Point.ByCoordinates (8, 1, 3);
// Aparar com a superfcie da ferramenta, e manter a superfcie
// Mais prximo de pick_point
result = surf.Trim (ferramenta, pick_point);

Page 53
Interceptar
,
Aparar
E
SelectTrim
so utilizados principalmente em minsculas
dimensional geometria tais como pontos, curvas e superfcies.
Geometria slida, por outro lado, tem um conjunto adicional de
mtodos para modificar forma aps a sua construo, tanto por
material de subtraco de um modo semelhante ao
Aparar
e combinando
elementos juntos para formar um todo maior.
O
Unio
mtodo leva dois objetos slidos e cria um nico
slido objecto para fora do espao coberto por ambos os objectos. O
espao de sobreposio entre os objetos combinado para a final
Formato. Este exemplo combina uma esfera e um Cuboid em um
nico slido esfera forma-Cube:
O
Diferena
mtodo, como Trim, subtrai fora o contedo
da ferramenta de entrada slido a partir da base de slido. Neste exemplo,
esculpir um pequeno recuo para fora de uma esfera:
O
Interceptar
mtodo retorna a sobreposio entre Slidos
Duas entradas slidos. No exemplo a seguir,
Diferena
foi
alterado para
Interceptar
, E o slido resultante o vazio ausente
inicialmente esculpido:
S1 = Sphere.ByCenterPointRadius (
. CoordinateSystem.Identity () Origem, 6);
s2 = Sphere.ByCenterPointRadius (
CoordinateSystem.Identity (). Origin.Translate (4, 0,
0), 6);
combinado = s1.Union (s2);
s = Sphere.ByCenterPointRadius (
. CoordinateSystem.Identity () Origem, 6);
ferramenta = Sphere.ByCenterPointRadius (
CoordinateSystem.Identity (). Origin.Translate (10, 0,
0), 6);
result = s.Difference (ferramenta);
18: Booleans geomtricos

Page 54
s = Sphere.ByCenterPointRadius (
. CoordinateSystem.Identity () Origem, 6);
ferramenta = Sphere.ByCenterPointRadius (
CoordinateSystem.Identity (). Origin.Translate (10, 0,
0), 6);
result = s.Intersect (ferramenta);
Page 55
Os seguintes scripts Python gerar matrizes de ponto para vrios
exemplos. Eles devem ser colado em um n Python Script como
segue:
python_points_1
out_points = []
for i in range (11):
sub_points = []
para j in range (11):
z=0
if (i == 5 e j == 5):
z=1
elif (i == 8 e j == 2):
z=1
sub_points.Add (Point.ByCoordinates (i, j, z))
out_points.Add (sub_points)
Out = out_points
Geradores Python Point: A-1

Page 56
python_points_2
python_points_3
python_points_4
out_points = []
for i in range (11):
z=0
if (i == 2):
z=1
out_points.Add (Point.ByCoordinates (i, 0, z))
Out = out_points
out_points = []
for i in range (11):
z=0
if (i == 7):
z = -1
out_points.Add (Point.ByCoordinates (i, 5, z))
Out = out_points
out_points = []
for i in range (11):
z=0
if (i == 5):
z=1
out_points.Add (Point.ByCoordinates (i, 10, Z))
Out = out_points

Page 57
python_points_5
out_points = []
for i in range (11):
sub_points = []
para j in range (11):
z=0
if (i == 1 e j == 1):
z=2
elif (i == 8 e j == 1):
z=2
elif (i == 2 e j == 6):
z=2
sub_points.Add (Point.ByCoordinates (i, j, z))
out_points.Add (sub_points)
Out = out_points