Algoritmigenerativi traduzido pt-br by João Victor Do Nascimento

algoritmos generativos com GRASSHOPPER

ZUBIN KHABAZI

edição italiana editada por Antonino Marsala, www.mandarinoblu.com antonio@mandarinoblu.com © 2010 Zubin Mohamad Khabazi Este livro é produzido e publicado em formato digital para uso público. A reprodução total ou parcial é permitida sem a permissão do autor, exceto para revisões. Para ver as últimas atualizações ou em caso de dúvidas, por favor visite o meu site,

www.MORPHOGENESISM.com zubin.khabazi@googlemail.com

introdução Você já jogou com conjuntos de robótica LEGO Mindstorms NXT? Bem, a modelagem associativa é algo. Se tudo começa a se tornar algorítmica e paramétrico, por que não fazer a arquitetura? Durante meu Mestre "Tecnologias Emergentes e Design (EmTech)" na Architectural Association (AA), eu decidi compartilhar a experiência no campo da Generative algoritmos de modelagem associativa e paramétrico com Grasshopper, que eu acho ser uma plataforma muito poderoso para este tipo de design. Nesta segunda edição, como eu mudei o nome de "Algotmica Modeling" para "Generative Algoritmos", eu tentei atualizar algumas experiências e problemas com as alterações que foram feitas ao projeto Grasshopper, ainda em evolução. Espero que este tutorial vai ajudar a entender melhor Gafanhoto e algoritmos generativos. Gostaria de atualizá-los, mas você tem que considerar que a maioria dos experimentos e exemplos foram feitas em uma versão anterior do plug-in, por isso, se você encontrar as diferenças pode depender dela. Eu acho que o livro precisa de revisões editoriais, no entanto, uma vez que é um produto sem fins lucrativos, não-comercial, por favor, perdoe-me por esta falta. Eles estão muito satisfeitos pelo fato de que, desde que publicou este livro, eu encontrei grandes amigos ao redor do mundo. Considere, portanto, livre para contactar-me para qualquer solicitação e explicações técnicas. Bom trabalho e boa sorte! Agradecimentos Primeiro de tudo eu gostaria de agradecer Bob McNeel por sua ajuda conGrasshoper3D e David Rutten para a inspiração, bem como para o seu apoio. Eu também estou feliz rigrazione diretores de AA / EmTech e tutor, Mike Weinstock, Michael Hensel, Achim Menges bem como que verificou a minha paramétrico e conceitos computacionais. Obrigado novamente por Stylianos Dritsas (AA / KPF), Dr.Toni Kotnik (AA / ETH) para seus cursos de computação, scripting e geometria avançada. Estou extremamente grato aos estudantes, arquitetos e progettisi que me contactaram e compartilharam de seu conhecimento e apontaram os erros. Zubin M Khabazi março 2010 Nota do Tradutor Em primeiro lugar gostaria de agradecer Zubin Khabazi por ter compartilhado isso antes, e depois por ter aceite a minha proposta de colaboração. Durante meus anos de trabalho com Rhinoceros Eu aprendi tanto de alguém como Zubin, ele disponibilizou sua experiência e conhecimento que me permitiu não só para usar o programa, mas também para entender o que está por trás de cada escolha, a fim de ensiná-lo e passá-la para meus alunos. Eu tentei ser o mais fiel possível ao texto original pelo upgrade da versão 0.6 (em que foi feita a segunda edição) para o atual 0,8. . Nas palavras do autor da versão original, também seria necessário tradução de uma revisão editorial mais cuidadoso. No entanto, também preferido aqui favorecer a publicação, deixando em aberto a possibilidade de aperfeiçoar a fluência do texto. Exorto todos aqueles que têm sugestões ou perguntas para me contacte para explicar algumas passagens que podem não ser totalmente clara.

Antonino Marsala - Fevereiro de 2011

conteúdo Capitolo_1_AlgoritmiGenerativi................................................................................................................. 6 1_1_Algoritmi Generative ......................................................................................................................................... 6

Capitolo_2_L'inizio .............................................................................................................................................. 9 2_1_ Método............................................................................................................................................................. 10 2_2_Conoscenze Básico......................................................................................................................................... 10 2_2_1_Interfaccia, área de trabalho ................................................................................................................. 10 2_2_2_Componenti................................................................................................................................................ 10 2_2_3_Combinazione dados ... ................................................. ............................................ 18 2_2_4_Help para componentes (menu contextual) .................................................................................... 20 2_2_5_ Encontrando e adicionando um teclado componente ... ........................................ ........... 20

dados Capitolo_3_Insiemi e Matemática ... ............................................ .............. 21 dados numéricos 3_1_Insiemi ............................................................................................................................ 22 3_2_Punti e grades de pontos ............................................................................................................................ 24 3_3_Altri conjuntos numéricos .......................................................................................................................... 26 3_4_Funzioni ............................................................................................................................................................ 28 3_5_Dati booleana ................................................................................................................................................. 31 lista 3_6_Cull ............................................................................................................................................................ 32 dados 3_7_Liste ...................................................................................................................................................... 34 3_8_Pattern para geometrias planares ........................................................................................................... 38

Capitolo_4_Trasformazioni 50

... ...... ... .......................................... ........................

4_1_Vettori e Planos .............................................................................................................................................. 51 4_2_Curve e geometrias lineares ....................................................................................................................... 52 4_3_Esperimento combinado: Swiss Re ........................................................................................................... 58 4_4_Attrattori ........................................................................................................................................................... 66

Parametric Capitolo_5_Spazio 76

... ...... ... .......................................... ..............

5_1_Spazio paramétrico dimensional .............................................................................................................. 77 5_2_Spazio paramétrico bidimensional............................................................................................................ 78 5_3_Transizioni entre espaços ............................................................................................................................ 79 paramétrico básica 5_4_Componenti ............................................................................................................... 80 5_4_1_Valutazione de curvas ............................................................................................................................. 80 5_4_2_Valutazione superfícies ........................................................................................................................... 81 5_4_3_Punto mais perto da curva e a superfície .......................................................................................... 83 5_5_Proliferazione de objetos no espaço de parâmetros .......................................................................... 83 dados 5_6_Alberi ..................................................................................................................................................... 91

Capítulo 6_Deformazioni e morphing 100

... ...... ... .......................................... ...

6_1_Deformazioni e moprhing .......................................................................................................................... 101 6_2_Pannellizzazione ........................................................................................................................................... 103 4

nível micro 6_3_Manipolazioni ......................................................................................................................... 106 6_4_Modulazione reactivo ................................................................................................................................. 109

Capitolo_7_Superfici NURBS e malha ... ...... ... ...................................... ................ 116 7_1_Superfici NURBS paramétrico ................................................................................................................... 117 7_2_Geometria e Topologia ............................................................................................................................... 124 7_3_Mesh ................................................................................................................................................................ 125 cor 7_4_Analisi ....................................................................................................................................................... 134 7_5_Manipolazione da malha como um método de criação .................................................................. 137

Capitolo_8_Fabbricazione 140

... ................ ... ................................ ......................

8_1_Datasheet ....................................................................................................................................................... 141 manifatturazione 8_2_Tagli e corte a laser ................................................................................................... 152

projeto Capitolo_9_Strategia bibliografia 171

... ................................................. .............. 167

... ...... ... .......................................... ......................

1_1_ Generative Algoritmos Se olharmos para a arquitetura como um objeto representado no espaço, para compreender e para projetá-lo, nós sempre temos que raciocinar com a geometria e um pouco de matemática. Na história da arquitetura, estilos arquitetônicos apresentaram diferentes tipos de geometria e lógica de articulação, e cada vez que ele encontrou uma maneira de se comunicar com seus problemas e questões relacionados com a geometria. Desde que os computadores começaram a ajudar os arquitetos, simulando o espaço e articulações geométricas, estes tornaram-se uma ferramenta fundamental no processo de design. Geometria computacional tornou-se um assunto interessante de estudo e a combinação de programação algorítmica com a geometria, produziu algumas geometrias algorítmicos conhecidos como Generative Algoritmos. Os arquitetos começaram a usar curvas de forma livre e superfícies para desenhar e espaços de design que vão além das limitações da geometria convencional do "espaço euclidiano". É foi uma combinação de Arquitetura e Digital que trouxe 'a bolha' à tona, tornando mais progressos. Apesar do crescimento do cálculo é extremamente rápido, arquitetura tem tentado manter-se com esta digital de ritmo acelerado. Após a era do "blob", arquitectura contemporânea parece ser mais clara sobre este assunto. O projeto arquitetônico foi influenciado pelo potencial de geometria computacional algorítmica, com múltiplas hierarquias e alto nível de complexidade. Projeto e forma livre modelo de superfícies e curvas como se fossem elementos de edifícios associados com componentes diferentes e ter um padrão múltipla, não é uma tarefa fácil de ser realizada utilizando métodos tradicionais. O poder de algoritmos e scripts que se movem para cima do bar de design, é isso. É óbvio que, mesmo para geometrias complexas acho que precisamos de ferramentas adequadas, especialmente aplicativos que podem simular a geometria e controlar suas propriedades. Como resultado, arquitetos estão agora interessados a utilizar Enxames, Cellular Automata e algoritmos genéticos para criar projetos de algoritmos e ir além das formas atuais e limitações de espaço. No horizonte aparece um catálogo cheio de complexidade e multiplicidade que combina criatividade e ambição.

modelagem figura 1.1 Parametric para "Computação Evolucionária e Algoritmo Genético, Zubin Mohamad khabazi, Seminário Visível, AA", realizado por Michael Weinstock, Fall 2008 Dando um passo para a frente, parece agora possível incorporar as propriedades de sistemas de material em um design algorítmica com o conceito paramétrica. Olhando para os materiais e os seus efeitos 6

acolher reacções para o ambiente durante a fase de concepção, agora o potencial inato dos componentes e sistemas podem ser aplicados a modelos paramétricos para cartão. Não são apenas estes algoritmos diálogo generativo com a geração de forma, mas também revelam um grande potencial para incorporar a lógica de materiais. "A lógica básica do desenho paramétrico, aqui pode ser explorada como um método de concepção alternativa, uma em que o rigor geométrico de modelagem paramétrica pode ser distribuído primeiro a integrar as limitações de fabrico, a lógica do conjunto e as características do material na definição de componentes simples, e, em seguida, para a reprodução dos componentes no interior de edifícios e sistemas maiores. Esta abordagem emprega a exploração de variáveis paramétricas para entender o comportamento de um tipo de sistema, e depois usa esse conhecimento para estudar uma estratégia de resposta do sistema para as condições ambientais e as forças externas "(Hensel, Menges, 2008) Para trabalhar com objetos complexos, o processo de design começa a partir de um primeiro nível mais simples, às quais se juntam novas camadas; formas complexas são feitas de diferentes hierarquias, cada um associado a sua própria lógica e seus detalhes. Esses níveis também estão interligados, e seus membros afetam uns aos outros. Neste sentido, este método é chamado de "associativa". Em geral, a modelação associativo refere-se a um método em que os elementos de desenho são construídos gradualmente em alguns parâmetros múltiplos e em cada nível de hierarquia, estes elementos são extraídos para gerar outros elementos no outro nível e este processo continua, passo por o passo para produzir a geometria global. Assim, o ponto extremo de uma curva pode ser o centro de uma circunferência: cada mudança na curva leva a uma mudança associada na circunferência. Basicamente, esse método de criação interage com uma grande quantidade de dados e cálculos e é através do fluxo do algoritmo. A principal coisa é que todas essas geometrias são facilmente ajustados após o julgamento. Os designers sempre têm acesso aos elementos de design de produto, desde o ponto de partida para os detalhes. De fato, desde o design do produto é o resultado de um algoritmo, a entrada de algoritmo pode ser editado e o resultado pode ser actualizado em conformidade. E agora, portanto, possível fazer um esboço digital de um modelo e gerar centenas de variações, ajustando as mais simples parâmetros geométricos. É também possível' para incorporar as propriedades de sistemas de materiais, limitações de fabricação e montagem lógica em parâmetros. E 'também pode responder ao ambiente e ser associativo em sentido amplo. " ... o desenho paramétrico permite o reconhecimento dos padrões geométricos de comportamento, e sua capacidade e sistema performativas tendências. Em um feedback contínuo com o ambiente externo, essas tendências comportamentais podem, em seguida, informar o desenvolvimento ontogenético de um sistema específico através da diferenciação paramétrico "(subgrupos Hensel, Menges, 2008).

Fig.1.2.Ricerca no campo das membranas e das superfícies mínimas, modelo físico de B. membranas Movimento modelados com Grasshopper Zubin Mohamad Khabazi, EmTech-Core Study, AA, realizado por Michael Hensel e Achim Menges, Fall 2008 Gafanhoto é uma plataforma que permite relacionar através rinoceronte com algoritmos generativos e técnicas de modelação associativos. Os próximos capítulos são projetados para combinar as questões geométricas com os algoritmos para resolver alguns problemas de projeto de arquitetura para um método 'algorítmica'. Os exemplos são projetados de forma a alargar o tema da geometria e usar mais comandos possível.

CAPITOLO_2_L'inizio

2_1_Metodo Esta nova edição das anteriores "Algorithmic Modeling" agora chamados "algoritmos generativos" foi feita devido às exigências dos meus amigos do gafanhoto em todo o mundo, devido às alterações que foram feitas para o plugin. Desde Grasshopper é um projeto em andamento que é alterado e completado rapidamente, ele sentiu a necessidade de atualizar o livro agora (e eu não estou totalmente convencido de que quando você lê-lo, sem novas atualizações) serão necessários. Considere que a maioria dos experimentos foram feitos com uma versão anterior do plugin, mas eu tentei atualizá-los sempre que necessário, e estou convencido de que, se você encontrar qualquer diferença, não será muito difícil de ir sozinho. O principal objetivo do livro é concentrar-se em algumas questões geométricas e arquitetônicas, projetos e o desenvolvimento da compreensão de algoritmos generativos e modelagem paramétrica, design baseado em experiências, em vez de uma descrição do tipo ou matemática geométrica. Para isso, os casos Maggiora, irá assumir que você sabe os ingredientes básicos da discussão e eu não vou entrar na definição do grau da curva, exceto em alguns casos em que a espera que você precisa. Grasshopper está crescendo rapidamente e se tornou uma plataforma adequada para o projeto de arquiteturas. Mais do que uma ferramenta ou uma aplicação, apresenta uma maneira de pensar sobre o design, que chamou um método paramétrico ou filiação. Este método está a desenvolver pelos usuários em todo o mundo como um exemplo de inteligência distribuída. Como estes desenvolvimentos métodos ocorrem constantemente, e sempre há atualizações para o software, bem como discussões interessantes, você deve verificar a página Grasshopper. Em qualquer caso, neste capítulo vou discutir brevemente as questões gerais do trabalho e o básico do que nós sabemos o que temos de saber com antecedência.

http://www.Grasshopper3d.com/

2_2_Conoscenze Básico 2_2_1_Interfaccia, área de trabalho Além do menu típico do Windows, há duas partes importantes da interface do Grasshopper: o painel de componentes e o Canvas. Os membros do painel fornece todos os elementos de que precisamos para os nossos projectos, enquanto a tela é a área de trabalho onde você pode inserir componentes e definir nossos algoritmos. Clique em qualquer objeto do painel, e clique novamente na tela para trazêlos na área de trabalho, ou arrastá-los. As outras zonas

Interface são fáceis de explorar e familiarizar-se com o uso. mais você pode encontrá-los aqui http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryPluginInterfaceExplained.html

Fig.2.1. Painel de componentes e Canvas

2_2_2_Componenti

Em Grasshopper existem diferentes tipos de objetos, painéis e componentes, menu que vamos usar para criar. O último a ligar em dez mesas diferentes: Parâmetros, matemática, Sets, Vector, Curve, Surface, Mesh, Intersect, XForms

Cada cartão contém vários painéis e tantos objetos. Os comandos são classificadas dentro desses painéis. Não há objectos que desenhar formas, tais como linhas, círculos, e há também vários comandos para mover, escala, dividir e deformar essas geometrias. Assim, alguns objetos desenhar e gerar dados, alguns geometria mudança ou dados existentes. Os parâmetros são objectos que representam os dados como um ponto ou uma linha. Você pode desenhar sobre os parâmetros relacionados ou você pode defini-los manualmente por um objeto desenhado diretamente 11

Rinoceronte. Os componentes são objetos que fazem algo, como se mover, guiar ou reverter. Normalmente precisamos fornecer para recuperar os dados relevantes para fazê-los funcionar. Como já foi dito, cada função corresponde a um objecto que pode ser trazido para a tela. Neste livro eu vou usar o termo componente para falar sobre cada objeto no painel Componentes para simplificar as coisas. Vou usar o termo <> para nomeá-los, por isso é fácil de identificá-los no texto. Por exemplo, para indicar o componente que gera um ponto, eles vão usar <ponto>.

Componente <Point> (período) Ao clicar no botão direito do mouse em um componente, um menu que contém alguns aspectos básicos: este menu é chamado "menu de contexto"

menu de contexto

A partir de agora você vai ter que encontrar os componentes certos dos painéis e configurar a conexão entre esses componentes, a fim de criar o seu projeto de algoritmos, para que possa ver os resultados do trabalho do rinoceronte. Se abstrato scripting rappresentauna e codificação dos algoritmos, com Grasshopper, a tela se torna um lugar de representação visual de algoritmos, como um fluxograma que entre as mãos do designer é mais sensível e flexível. 12

Fig.2.2 Fluxo algoritmo gráfico vs Grasshopper Definição de geometrias externas Na maioria das vezes, começamos com a importação de Grasshopper sobre tela de objetos desenhados em Rhino. Estes podem ser um ponto, uma curva ou uma superfície para um valor múltiplo e complexos objectos. Isso significa que podemos usar nossos objetos criados manualmente, ou objetos gerados pelo script do rinoceronte Grasshopper como fonte externa. Uma vez que cada geometria Grasshopper precisa de um componente na tela para ser capaz de trabalhar, precisamos definir os nossos geometrias externas na tela através dos componentes certos. Por esta razão, podemos olhar na guia Parâmetros, no painel de Geometria. Há uma lista de diferentes tipos de geometrias que você pode usar para definir um objeto externo a partir do trabalho do rinoceronte. Depois de tomar o componente geométrica apropriadamente, definimos o objeto de rinoceronte clicar no botão direito no componente e, em seguida, selecionando "definir um ... / múltipla do conjunto ..." (definir um .... / sets múltipla .....) para atribuir os objetos para os componentes. Agora você precisa selecionar o seu geometria em Rhinoceros. Ao importar um ou mais objetos com um componente, estes tornam-se objetos do gafanhoto e agora pode ser usado para cada finalidade.

Fig.2.3 Os diferentes tipos de geometria Params> Geometria

Vamos dar um exemplo simples Temos três pontos na janela do Rhino, e queremos desenhar um triângulo passando por esses pontos em Grasshopper. Primeiro temos de importar estes pontos em Grasshopper. Precisamos de três componentes <Ponto> podemos encontrar em Params> Geometry> ponto e para cada um, podemos ir no menu de contexto (botão direito) e selecione 'definir um ponto' (ponto de ajuste) e, em seguida, selecionar o ponto a partir da janela rinoceronte . (Fig. 2.4)

Fig.2.4. Defina o ponto de rinoceronte através de um componente Grasshopper

Fig. 2.5. A lona do gafanhoto e os três pontos definidos que se tornam cruzes vermelhas (X) na janela do Rhino. I renomeado os componentes como Ponto A / B / C via o primeiro item no menu de contexto, para que você reconhecê-los facilmente na tela. 14

Conexão Component Existem várias ações que podem ser aplicadas aos componentes. Geralmente um componente leva dados de uma ou mais fontes e retorna os resultados. Precisamos conectar os componentes que incluem os dados de entrada em componentes que os processam e se conectam por sua vez, os resultados para outros componentes que requerem estes resultados e assim por diante. Voltando ao exemplo, se formos na guia Curvas, no painel Primitive, encontrar o componente <line>. Pegá-lo na tela. Em seguida, conecte <ponto A> entrada A do <line> e <ponto B> entrada B (para conectar os componentes, basta clicar sobre o semicírculo na parte direita de <ponto> e trascinatalo para o outro semicírculo sobre o destino componente (entrada a / B <line>). neste ponto, você vai ver Rhinoceros traçou uma linha entre os dois pontos.

Fig.2.6 Ligação do componente <ponto> componente <line> arrastando a saída do <ponto B> na <line>. Agora adicionar outro componente <line> para <ponto B> e <ponto C>. Mesma coisa entre <ponto C> e <ponto A> com o terceiro componente <line>. Oh sim! Há um triângulo na janela do Rhino.

Fig. 2.7. Componente <> linha traçada entre dois componentes <Ponto>. Como você pode ver cada componente pode ser usado mais de uma vez como fonte de informação para outras ações

Fig. 2.8 Se agora alterar manualmente a posição dos pontos directamente sobre Rhino, a posição dos pontos de gafanhoto (aqueles com X) e o triângulo resultante irá ser alterada em conformidade, mas as linhas entre os pontos (o triângulo) permanecerá e será actualizado . Como você pode ver neste primeiro exemplo, a técnica associativa torna possível manipular os pontos, mantendo a geometria do triângulo feito de pontos sem que outras mudanças são necessárias. A idéia é preparar os objetos ( 'alimentar' a entrada algoritmo), configurar a relação entre objetos e adicionar outras manipulações (as funções algoritmo) e construir o projeto (cálculo). Vamos trabalhar sobre este conceito para desenvolver uma compreensão dos algoritmos. Input / Output Como já foi mencionado, cada um dos componentes do gafanhoto dos conectores de entrada (input) e de saída (saída), o que significa que o componente processa os dados de entrada e devolve-los na saída. A porta de entrada situa-se no lado esquerdo do componente, enquanto que a saída está no lado direito. Os dados que chegam de cada fonte ligada à secção de entrada do componente e na saída temos o resultado que o componente gera através de uma função específica. Leia mais (texto em Inglês) http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryVolatileDataInheritance.html You 'sempre precisa saber o tipo de entrada que você precisa para essa função específica e que você terá após o julgamento. Nós falaremos mais tarde sobre os diferentes tipos de dados que teremos de obter. Para mais explicações, eu sugiro que você segure o mouse sobre cada conector de entrada ou saída: Aparecerá uma nota em que um valor padrão pode ler o nome, o tipo de dados necessários, se ele tiver sido definido ou não, e especialmente a função do componente.

Fig.2.9 Deixando o ponteiro do rato sobre o conector da componente de entrada / saída é apresentada uma caixa de sugestão. 16

várias conexões Às vezes é necessário para se conectar a um componente de mais de uma fonte de dados. Imagine que, no exemplo a seguir, você quer desenhar duas linhas do <ponto A> para <ponto B> e, em seguida, para o <ponto C>. É possível utilizar dois componentes diferentes <linha> ou usar um componente <linha> pela ligação tanto do ponto B e o ponto C para o ponto B do <linha> componente. Para fazer isso, você deve pressionar a tecla Shift quando você se conectar a segunda fonte de dados para o componente. Sem este truque Grasshopper vai substituir o segundo conector para o primeiro. Quando você pressiona Shift, o ponteiro aparece um círculo verde com um pequeno ícone (+) que normalmente é cinza. Você também pode usar Ctrl para desconectar um componente de outro (geralmente você também pode fazer isso usando o menu de contexto).

Fig. 02:10 ligação múltipla de um componente usando a tecla Shift O código de cores Em Grasshopper existe um sistema de código de cor cuja finalidade é mostrar o "estado" do componente.

Fig. 2.11 O código de cor Um componente cinza indica que não há problemas e o tipo de conjunto de dados é certo ou, pelo menos, o componente funciona corretamente. Laranja indica que temos de ter cuidado! Há pelo menos um problema que onde a ser resolvido para o componente continua a funcionar. O componente vermelho indica um erro e não pode trabalhar nesta situação. A fonte de erro devem ser descobertos e resolvidos para permitir seu uso. Você pode encontrar uma primeiros socorros sobre o erro no menu de contexto do componente (menu de contexto> Runtime aviso / erro) e depois verificar os dados de entrada para compreender a razão do problema. A cor verde significa que em vez do componente seleccionado. A geometria associada com o 17

o componente em si também se torna verde na janela Rhinoceros (enquanto todos default geometrias Gafanhoto são vermelhas). visualização Todos os componentes que produzem um objeto em Rhinoceroshanno a opção de exibição de visualização em seu menu. Podemos usá-lo para ocultar ou mostrar as geometrias no espaço de trabalho. Cada desmarcada (saída escondida) preview significa que o nome do componente torna-se pontilhada. Normalmente usamos a opção de visualização para esconder geometrias não desejados, tais como pontos de base e linhas de modelos complexos, de modo a evitar distrações. Esta opção, em modelos complexos, permite processar dados mais rapidamente, por isso é melhor para esconder as formas básicas quando você não precisa vê-los. 2_2_3_ Combinar dados Para muitos componentes do gafanhoto, você sempre pode especificar uma lista de dados em vez de uma única entrada. É, com efeito, criar uma lista de pontos, por exemplo, e conectá-los a um <line> componente para representar várias linhas em vez de um. Dando-nos as informações necessárias será possível tirar centenas de objetos a partir de um único componente. Nós olhamos para o seguinte exemplo: Eu tenho dois conjuntos diferentes, cada um contendo sete pontos. Eu usei dois componentes <ponto> e eu set 'set point múltiplo' (vários set points) para entrar todos os pontos mais altos em um grupo e todos os mais baixos na outra. Como você pode ver, ligando estes dois grupos de pontos em um componente <line>, que são geradas sete linhas que passam pelos pontos. Estamos, portanto, pode gerar mais de um objeto de cada componente. (Fig. 2.12)

Fig.2.12 Configurando múltiplos pontos através dos quais linhas são gerados Mas o que aconteceria se os dois conjuntos o número de pontos não é o mesmo? No exemplo abaixo, eu tenho sete pontos na linha superior e dez na parte inferior. Por isso, precisamos, portanto, para introduzir o conceito de administração em dados Grasshopper, chamados de dados combinação (ou cruzamento). Se você olhar para o menu de contexto do componente, você vai ver que existem três opções de compra 18

menor lista (a lista curta) lista mais longa (mais de lista) Referência Cruzada (referência cruzada) Dê uma olhada nas diferenças mostrados na figura 2.13 E 'evidente que lista mais curta irá produzir como resultado uma série de linhas igual ao número dos dados da lista mais curtos, enquanto a lista mais longa irá criar um número de linhas igual ao número de dados presentes na lista mais longa, combinando o último valor na lista mais curto mais de uma vez. A opção Referência Cruzada conecta todos os pontos de acordo com todas as combinações possíveis. E 'opção alto consumo de memória e algumas vezes você pode tomar algum tempo' porque a cena é atualizado. Tendo em conta que as imagens são claras, eu vou parar por aqui com a descrição. Para mais informações consulte o seguinte link (texto em Inglês) http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryDataStreamMatchingAlgorithms.html

A Fig. 02:13 combinação de dados A: lista shortes, B: lista mais longa e C: referência cruzada

2_2_4 Suporte para componentes (menu contextual) Considerando que não é útil para explicar todos os componentes, a melhor coisa é tentar entender como usá-los gradualmente durante os experimentos. Sugiro, portanto, para brincar, escolher um componente, vá para o mesmo menu contextual (botão direito) e ler a ajuda que será de grande ajuda para entender como isso funciona, que tipo de dados são necessários e que o tipo de dados de saída produz. Há outras características úteis no menu que veremos mais adiante.

Fig. Menu de 2,14 Contexto e a secção de Ajuda no componente 2_2_5 busca e adicionar um teclado de discagem Para encontrar rapidamente uma parte do que sabemos o nome, em vez de desperdiçar o tempo no interior das placas de componentes, você pode clicar duas vezes sobre a tela e escrever o nome do componente para trazê-lo para o espaço de trabalho. Para aqueles que estão acostumados a usar o teclado para trabalhar, este poderia ser um truque. Fig. 2.15 Pesquisa <line> componente no menu de contexto. Para ativá-lo você deve clicar duas vezes sobre a tela, e digite o nome. Este componente será levado desta forma na área de trabalho.

CAPITOLO_3_ Dados define e Matemรกtica

Capitolo_3_ Dados define e Matemática Embora os aplicativos para 3D podemos selecionar geometrias de menus e atraí-los explicitamente sem pensar sobre os aspectos matemáticos por trás, a fim de trabalhar com algoritmos generativos, como o nome sugere, precisamos pensar sobre os dados e matemática para criar valores entrada para alimentar o algoritmo e gerar objetos. Porque nós não queremos desenhar tudo à mão, precisamos de algumas fontes de dados como ingredientes básicos para alimentar o algoritmo, a fim de fazê-lo funcionar mais de uma vez para produzir mais de um objeto. A forma como o algoritmo funciona (workflow) é simples. Ele prevê que há dados de entrada, processar esses dados, e um resultado de saída. Este processo ocorre em todo o algoritmo ou, se olharmos com cuidado, em cada parte. Então, em vez de usar o método de concepção convencional, precisamos nos obter a informação, que será processado através de um algoritmo e uma geometria será criado como resultado. Como já mencionado, por exemplo, em vez de copiar um item de '100 vezes' em a direção do x positivo 'uma distância de' 3 'podemos dizer o algoritmo para copiar o elemento' 100 vezes em um 'sentido positivo do X 'com uma diferença de 3 a fazer isso, definimos' 100 'como o número de cópias' Tudo o que fazemos na geometria tem pouco matemática por trás. Podemos usar estas funções matemáticas simples em nossos algoritmos com números como objetos, para gerar combinações geométricas infinitas. Ela começa com números e conjuntos de dados numéricos. Vamos dar uma olhada, é muito mais fácil do que parece!

3_1_ conjuntos de dados numéricos Todos os matemática e algoritmos começar com números. Os números são o código oculto do universo! Para começar, em primeiro lugar temos de olhar para os componentes numéricos, para ver como você pode gerar vários conjuntos de dados numéricos no Grasshopper, e, portanto, a maneira em que podemos usá-los para desenhar algo. valor numérico único

O gerador de números mais utilizado é <deslizante Number> componente (Params> Special> Número deslizante) que gera um número editável manualmente. Ele pode ser um número inteiro, real, par ou ímpar com os limites inferiores ou superiores. Essas configurações podem ser ajustadas a partir do item 'Editar' no menu de contexto. Para atribuir um valor numérico único que você pode ir para Params> Primitive> Integer / Número de definir um inteiro ou valor real através do contexto do <Int> / <Menu Num> de números

Nós podemos produzir uma lista de números através do componente <série> (Conjuntos> Sequência> série) Este componente produz uma lista de números que podem ser alteradas através do primeiro número (S), o passo (N), e o número de valores de série (C) 0, 1, 2, 3, ..., 100 0, 2, 4, 6, ..., 100 10, 20, 30, 40, ..., 1000000 Intervalo de números

Podemos dividir um intervalo numérico entre um valor mínimo e máximo com o número de passos e produzir um intervalo numérico. Devemos definir um intervalo para definir os limites superiores e inferiores, bem como o número de etapas em que se divide (Sets> Sequence> Series) Cada gama numérica (por exemplo de 1 a 10) pode ser dividido num número infinito de peças 1, 2, 3, ..., 10 1, 2,5, 5, ..., 10 1, 5, 10

Domínio (intervalos)

Domínio ( 'Intervalo' em versões anteriores) cria um intervalo de números reais entre um valor inferior e superior. Há domínios unidimensionais e bidimensionais que será discutido mais tarde. E 'pode definir um domínio fixo utilizando os Parâmetros do componente> Primitive> Domínio / 2 2 Domínio ou podemos ir para Math> Domínio> Domínio / Domínio para gerar um grupo de componentes para trabalhar de uma forma mais flexível. Os domínios por si só não produzem números. Só de extremos, com um limite superior e inferior. Como você sabe, a cada dois números reais não são infinitas. Podemos usar diferentes funções para dividir e utilizar os fatores de divisão como valores numéricos. Para ver as diferenças e usos, tente outros exemplos.

3_2_ pontos e grades de pontos Os pontos estão entre os elementos básicos para a geometria e algoritmos generativos. Os pontos de marcar posições precisas no espaço, podem ser usados como pontos de partida para as curvas, centros de círculos, origens de planos ou desempenham outras funções. Em Grasshopper podemos gerar pontos de várias maneiras: - Nós podemos simplesmente escolher um ponto ou uma série de pontos de cena e importá-los para o espaço de trabalho através do componente <Point> (Params> Geometry> ponto) e usá-los para qualquer finalidade (Estes pontos podem ser modificados, movendo-os manualmente na cena rinoceronte, e afetar todo o projeto - Verifique os exemplos no capítulo 2). - Podemos colocar pontos através do componente <ponto xyz> (Vector> Point> ponto xyz) e alimentar as coordenadas dos pontos pelos números, ou alimentá-los de diferentes conjuntos de dados, de acordo com nossas necessidades. -Nós podemos criar uma grade de pontos através dos componentes <grade hexagonal> e <grade retangular> Os pontos de extracto -que de outras geometrias de formas diferentes, tais como terminais, etc pontos médios (OSNAP) -Às vezes podemos usar os aviões (origens) e operadoras (finais) como pontos de partida para outra 24

geometrias e vice-versa. Você viu os primeiros exemplos para a criação de pontos no Capítulo 2, mas podemos dar uma olhada nas formas que produzem através dos componentes <série de sistemas de pontos>, <range> e <número deslizante> e outras ferramentas que geram dados numéricos .

Fig. 3.1 Alimentação de um componente <ponto xyz> ou <pt> através de três <número deslizante> para gerar um ponto, introduzindo manualmente as coordenadas x, y e z

Fig. 3.2 Geração de uma grade de pontos através dos componentes <series> e <pt>. Enquanto o <número deslizante> controla a distância através dos pontos (tamanho do passo) e o segundo controla o número de pontos na rede através do número de valores da componente <série> (A combinação de <dados pt> é definido para atravessar referência para criar uma grade, mas você pode tentar todas as combinações).

Fig. 3.3 Divisão de uma gama numérica de 0 a 1 por meio de um número (5) e de alimentação controlável manualmente de um componente <pt> com a combinação de 'lista mais longa. Neste caso, dividimos o intervalo para 5, a criação de 6 pontos entre o ponto de origem (0,0) e (1,1) na janela Rhinoceros (é possível modificar o limite inferior ou superior do intervalo para alterar as coordenadas dos pontos . para fazer isso você precisa clicar o botão direito no componente conector D (indicando o domínio) e alterá-lo). Mais tarde veremos outras maneiras de trabalhar com e e mudar intervalos. Desde a nossa primeira experiência parece fácil, podemos continuar, mas você deve fornecer 25

para testar o funcionamento desses componentes em seu próprio país, a criação de diferentes redes de pontos com diferentes posições e distâncias

Outros conjuntos numéricos 3_3_ Jogo de números aleatórios Agora queremos criar uma distribuição aleatória de números para diferentes fins. O que precisamos é um conjunto de números aleatórios em vez de <componentes de série> e <pt>. Selecione então um componente <random> (aleatório) por Set> Sequence> Aleatório. Um componente <random> gera uma lista de números aleatórios que podemos controlar o domínio. O componente <random>, portanto, produz um conjunto de números aleatórios, mas não temos os mesmos valores para x, y e z. Para evitar os mesmos valores, todas as direções devem ser números aleatórios independentes. Precisamos, portanto, ou embaralhar a lista com números ou três listas de números aleatórios, criado por três componentes <random> com sementes diferentes (a semente, semente, é a parte que 'gatilhos' a geração de números aleatórios). Através da alimentação do componente <random> para a porta S com vários números, podemos gerar diferentes números aleatórios: se não o fizemos desta forma, todos os componentes aleatórios, gerar os mesmos valores.

Fig. 3.4 Geração de um conjunto de pontos aleatórios. O componente <random> 10 produz números aleatórios que são controlados por um <número deslizante>. A lista é então misturado pelo componente <jitter> (Sets> Sequence> Jitter) para as coordenadas do Y, e ainda uma outra vez Z coordena Desejando que você pode ver outros sistemas dentro do padrão de grade (conectando um <aleatório> no plano x, y e z de <pt> sem usar <jitter>). A combinação de dados é definida lista mais longa. Na Figura 3.4 todos os pontos estão distribuídos em um espaço entre 0 e 1, em cada direco do sistema de referência. Para alterar a área de distribuição, podemos alterar o domínio numérico, em que o componente <random> produz números. Isto é possível definindo a gama do componente ou domínio ajustando manualmente o 'domínio do intervalo numérico aleatório' directamente sobre rinoceronte clicando com o botão direito sobre a ligação R (aleatório números domínio / domínio de números aleatórios), alterando os valores por meio do cursor ( Fig. 3.5)

Fig. 3.5 Configuração de um domínio através do componente <domínio> para alterar os pontos da área de distribuição (dar uma olhada para a densidade da malha na cena com relação ao de fig. 3.4) Série Fibonacci Que tal criar uma grade com um espaçamento não-uniforme? Vamos olhar para os componentes que temos disponíveis. E 'necessário ter uma série de números que crescem rapidamente e novamente sob a placa e define o painel de Sequence, podemos encontrar o componente <Fibonacci> Isto representa uma série de números em que os dois primeiros números definidos (0 e 1) e o número seguinte, são a soma dos dois anteriores. N (0) = 0, N (1) = 1, N (2) = 1, N (3) = 2, N (4) = 3, N (5) = 5, ..., N (i) = N (i-2) + N (i-1) Seguem-se alguns números de série: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Como você pode ver os números estão crescendo rápido Neste caso I utilizada uma série <de Fibonacci> (Conjuntos> Sequência> Fibonacci) para produzir números incrementais que alimentam o componente <pt>

Fig. 3.6 Usando uma série <de Fibonacci> produzir um aumento da distância (com um espaçamento variável) para gerar pontos. O número de pontos pode ser controlada com um <número deslizante> 27

3_4_Funzioni componentes predefinidos contidos Grasshopper, pode não ser sempre a melhor maneira de desenhar. Talvez seja necessário gerar dados específicos ou manipular pelo menos aqueles de componentes existentes. Para fazer isso, você deve usar funções matemáticas e mudar o poder, distâncias, .... de números. A função do componente é, por conseguinte um objeto que pode executar funções matemáticas em Grasshopper. Existem funções com diversas variáveis (Math> Script). Às vezes, pode estar com os dados relevantes necessários para alimentar as funções (nem sempre os números, mas também valores booleanos, cordas, etc.) que serão executadas com base nas entradas. Para definir uma função, você pode clicar o botão direito no componente porta F e digite-o diretamente ou usar o editor de expressões matemáticas. Este editor tem muitas funções internas e uma biblioteca de funções matemáticas para ajudar. É importante prestar atenção ao nome de variáveis para uso em expressões e dados associados que podem ser combinados nas funções dos componentes. funções matemáticas Como escrito, use um componente padrão nem sempre é suficiente, mas para obter os resultados desejados podemos usar a função matemática para alterar os conjuntos de dados e alimentá-los para gerar geometrias.

Fig. 3.7 paramétrico círculo criado pela função matemática. Podemos encontrar tanto o <pecado> (mama) e <cos> (cosseno) em Math> Trig. (F (x) = x * 2Pi)

Fig. 3.8 Outros experimentos. Série de pontos em que é definida uma série <de Fibonacci> e funções matemáticas simples (x: F (x) = x / 100, y: M (x) = x / 10). A função seleccionada em F verde (x) é uma função que adiciona dois para o valor de <número deslizante> (F (x) = x + 2) para criar valores de um número equivalente ao número de Fibonacci (a série de Fibonacci tem outra os primeiros dois valores). O objetivo é mostrar como é fácil de manipular esses conjuntos de dados e gerar um resultado diferentes geometrias.

Fig. 3.9 Um <gama> de números de 0 a 2, multiplicado por 2Pi com <Função> que cria uma gama numérica de 0 a 4pi. Esta gama é dividida em 60 partes. O resultado alimenta o componente <pt> através do seguinte função matemática: X = t * Sin (t), Y = t * cos (t) trigonométricas conhecimento para componentes <pecado> e <cos> é um dado adquirido. Para aplicar t * sin / cos eu usei o componente <multiplicação> De matemática> Operadores. Aqui você pode encontrar as ferramentas adequadas para outras operações matemáticas.

Fig. 3.10. Aqui estão um complexo! Algoritmo criado por duas espirais invertidos criados por dois conjuntos de pontos. O domínio do componente <gama> é de 0 a 4, e é dividido em 400 pontos, e depois multiplicado pela função que alimenta os dois pontos: Primeiro <pt>: X: F (x) = x * sen (x * 2 Pi), Y: F (x) = x * cos (x * 2 Pi) O segundo <pt> tem a mesma função, mas inverteu 29

Fig. 3.11 Moebius por um conjunto de pontos. <U> e <v> são componentes <range> posteriormente renomeado. O domínio numérico de cada um pode ser lido na cena. A função matemática que gera um Moebius é como se segue X = sin (u) * (- 2 + v * sin (u / 2)) Y = cos (u) * (- 2 + v * sin (u / 2)) Z = v * cos (u / 2) Brincando com funções matemáticas pode tirar uma infinidade de tempo! Você pode encontrar muitos recursos matemáticos para combinar seus conjuntos de números. O importante é que você tem a capacidade de manipular e gerar vários originais digitalizados, e com estes outros componentes alimentares. Como você viu a partir de simples conjunto de dados numéricos, você pode começar a gerar geometrias: Isso mostra como os algoritmos. A partir de agora, precisamos construir nosso conhecimento baseado em conceitos diferentes geométricas com o método algoritmo, para resolver os problemas e situações de design como esta superfície bonita Enneper (do rinoceronte Math função plugin)

3_5_ booleana dados Os dados não se limita a apenas números. Existem outros tipos de dados que são úteis para diferentes finalidades na programação algorítmica. Uma vez que estamos lidando com algoritmos, sabemos que o seu caminho nem sempre é linear. Às vezes precisamos decidir quando fazer algo e quando você fazer qualquer outra coisa. Programadores chamam isso de construção 'construção condicional.' O resultado do-construção decisão é um simples sim ou não. Para os algoritmos que usamos os dados booleanos para representar este tipo de resposta. Os dados booleanos representam apenas TRUE / falso e verdadeiro / falso. Se a construção reflete os critérios, a resposta será TRUE, FALSE caso contrário. Como veremos mais tarde, este tipo de dados é muito útil em muitas situações, especialmente quando è deve decidir, em relação a alguma coisa, selecionar objetos por critérios, objetos espécie etc.

Fig. 3.12 através do componente foram gerados dez horas <valores aleatórios> e <maior> (maior) (Math> Operadores> Maior), eu quero ver se esses números estão abaixo de um certo <Limite_superior> (limite superior) (valor estabelecida por um <número deslizante>) ou não. Como você pode ver, se os números refletem os critérios (ou seja, que são menores do que o limite superior), o retorno componente 'TRUE' ou 'FALSE' se ele não reflete-los. Eu usei o componente <painel> do Params> especial para mostrar o conteúdo de <aleatório> e o resultado da <maior> componente.

Fig. 03:13 Para o próximo passo, I 30 valores gerados com o componente <série>. Eu usei o componente <módulo> (Math> Operadores> Modulus) para procurar o resto da divisão de três números e analisado a saída para o componente <iguala> (igual) para ver se o resultado é zero ou não. Como você pode ver o resultado é outro <painel> com os valores TRUE / FALSE Como você pode ver nos exemplos, existem várias possibilidades para controlar os critérios de valores

numérico e têm valores booleanos como resultados. Mas às vezes você precisa de saber se as situações que enfrentam outros critérios, e queremos decidir com base nos resultados. Por exemplo, com base na experiência anterior, nós queremos ver quando um valor está abaixo de um certo limite superior e, ao mesmo tempo, se for divisível por três. Para saber o resultado, precisamos trabalhar sobre o resultado de ambas as funções, o que significa que temos de operar com um valor booleano. Se você verificar sob a placa no Painel de matemática booleana, você vai descobrir que existem vários componentes que trabalham com dados booleanos.

Fig. 3.14 combinação de ambos os conceitos. É sido usado componente <Porta E> (Math> Boolean> Porta E) e eu ligado ambas as funções para criar uma ligação entre eles. Como você pode ver, esses valores numéricos, que são menores do que um limite superior e divisível por três, que vão de encontro aos critérios e passar o valor TRUE no final. No painel booleano, podemos encontrar diferentes operadores booleanos que podem ser usadas de forma combinada para construir seus critérios de decisão, e construir seus projetos com base nessas respostas. Vamos discutir mais tarde sobre como usar valores booleanos.

3_6_ lista Cull Existem muitas razões pelas quais nós podemos ter a necessidade de selecionar alguns itens de um determinado conjunto e não se aplicam a mesma função em tudo. Para fazer isso, precisamos de ambos para selecionar itens específicos de uma lista, ou omitir outros. Entre as muitas opções disponíveis, podemos começar com o que nos leva a omitir listas de dados / filtro. Atualmente, existem três componentes do tipo <abate> para filtrar uma lista de dados sobre Grasshopper. Enquanto <abate Nth> omite um item cada N de uma determinada lista, <abate pattern> leva um padrão booleano (TRUE / FALSE) e filtra uma lista de dados com base neste padrão. Isto significa que cada elemento associado com um verdadeiro valor booleano na lista passa, enquanto aqueles associados com False, estes são omitidos da lista em si. Se os números dos valores da lista de dados e a lista booleana são os mesmos, cada item na lista de dados é avaliada pelo elemento correspondente na lista booleano. Mas você pode definir 32

um padrão simples de valores booleanos (por exemplo FALSE / FALSE / TRUE / VERDADEIRO já pré-definidos nos componentes) e o componente <abate> riepeterà o mesmo padrão para todos os elementos da lista de dados. Para entender melhor, aqui queremos introduzir algumas maneiras de selecionar nossa geometria desejada (neste caso pontos) fora de um conjunto de dados predefinidos.

Exemplo da distância Pretendemos selecionar alguns itens de um conjunto constituído por pontos, dependendo da distância a partir de outro ponto (de referência). Tanto o conjunto de pontos que o ponto de referência são definidos por um componente <ponto>. Primeiro de tudo, precisamos de um componente <distância> (Vector> Point> Distância), que mede as distâncias entre pontos e o de referência, resultando em uma lista de números (distâncias). Comparamos estas distâncias através de um número definido pelo usuário (<number deslizante>) com um (função Math> Script> F2 / de duas variáveis) <F2> componente. Esta comparação vai gerar valores booleanos (verdadeira / falsa) para mostrar tanto que o valor é menor (verdadeiro) ou maior (falso) do limite superior F = x> y (isto é, a mesma tendência que o <maior> componente). Vou usar para essa finalidade, Como relatado anteriormente, <abate pattern> leva uma lista de dados genéricos e uma lista de dados booleanos e remover os membros da lista genérica de dados associados com 'False'. Neste caso, o resultado do componente <pattern abate> é um grupo de pontos associados com o valor TRUE. Isto significa que estão mais próximos da referência com respeito ao número especificado no <número _slider> porque a função de x> y sempre retorna um valor de VERDADEIRA para todos os números menores de Y, o que significa que as distâncias mais curtas (y = distância). Para ver melhor eu só tiver conectado-los ao ponto de referência através de um simples componente <line>

Fig. 03:15 Selecção dos pontos de tomadas a partir de um conjunto através da distância a partir de uma referência através do componente <padrão abate>. exemplo topográfica Após ter tentado o primeiro distância lógica, eu quero selecionar alguns pontos que estão associados com a curva de nível em um modelo topográfico com base na sua altura.

Fig. 03:16 Topografia com pontos associados com as curvas de nível O que temos aqui é um conjunto de pontos definidos por um componente <Point> (chamado topografia). Eu preciso da altura dos pontos e com a mesma lógica do exemplo da distância, eu posso selecionar os objetos desejados. Então eu usei um componente <Decompose> (Vector> Point> Decompose) para obter o valor Z das coordenadas dos pontos (altura). O componente <decompor> me dá as coordenadas X, Y e Z de cada ponto de entrada. I comparar estes valores com um determinado número (de <número deslizante>) com <maior> componente para criar uma lista associativas valores booleanos. O componente <padrão abate> passa os pontos associados com o valor TRUE, ou seja, os pontos seleccionados serão maiores do que as definidas pelo utilizador para a altura.

A Fig. 3.17 Os pontos seleccionados têm uma altura maior do que 4.7550 unidades (conjunto como valor para o utilizador). Estes pontos são agora pronto para plantar sua Pini!

3_7_ Listas de dados E 'agora quase claro que um algoritmos de chave é a lista de dados. A lista de dados pode conter todos os tipos de objetos, tais como números, pontos, geometria e assim por diante. Rolagem para baixo na guia Sets, sob o painel de lista, há vários componentes que manipulam listas de dados. Podemos extrair um elemento através do seu índice numérico, podemos extrair parte de uma lista através de um índice inferior e superior. Estas listas lidar com os elementos, nos ajudando a obter um conjunto de dados para os nossos fins de planejamento.

Fig. 18.3 Lista de pontos. Queremos selecionar os pontos com valores de x menor. Como mencionado anteriormente, o componente <ponto decompor> nos dá as coordenadas dos próprios pontos. O que precisamos é encontrar o menor valor de X entre todos estes pontos. Para permitir isso, eu preciso antes de encomendar todos os valores de X, e em seguida, encontrar o mínimo. Isto é o que <tipo lista> fará por nós. Basicamente o componente <tipo>, pedir uma ou mais listas de dados, de acordo com uma lista de dados numéricos, como se eles foram ordenados chaves. Então, quando essas teclas são ordenados, ele irá também ser associado dados. Ali estávamos nós, portanto, ordenou que todos os valores de X como os dados da chave. O que precisamos agora é selecionar o primeiro item na lista. Para fazer isso requer um componente <item> (Elemento), cuja função é extrair um elemento com o seu índice numérico. Dado que o primeiro elemento (com índice zero) tem o menor valor de X, o índice é extraída de modo a obter como resultado um ponto onde o valor de X é o conjunto mínimo,. Vemos outros exemplos

triângulos Desenvolvemos agora nossos experimentos com um manipulador de dados. Imagine que tem uma rede de pontos e querendo para desenhar linhas para criar os triângulos seguindo o padrão mostrado na Figura 3.19. Este conceito é útil para a geração da malha, em panelization e em outras situações, mas desta vez é importante ser capaz de produzir os conceitos básicos.

Fig. Triângulos 03:19 Gerando através de uma rede de pontos. 35

O primeiro passo é criar uma rede de pontos através dos componentes <series> e <pt>. O próximo passo, em vez planos para encontrar os lugares certos para desenhar linhas. Sempre que precisamos de uma linha que começa a partir de um ponto e o próximo ponto em termos da mesma linha e coluna seguinte, e, em seguida, uma outra linha que vai desde o último ponto para a coluna anterior ea próxima linha e uma linha final que tornos volta à estaca zero. Para fazê-lo seria melhor fazer três listas de pontos, um para cada 'primeiro ponto', um para cada 'segundo passo' e outro para cada 'terceiro ponto' e então desenhar as linhas. E 'possível usar o ponto original como a lista de todos os pontos de partida. O primeiro 'segundo ponto' é o segundo ponto no grupo de pontos, e, em seguida, a lista continua, um de cada vez. Assim, para a seleção do 'segundo ponto' Eu só mudou a lista original através do componente <lista shift> (Sets> Lista> Lista Shift) com uma distância de deslocamento igual a 1, o que significa que o segundo elemento da lista (índice 1 ) torna-se o primeiro elemento (índice 0) e o resto da lista procede da mesma maneira. Esta nova lista é a 'lista segundo ponto' O 'terceiro ponto' dos triângulos são na mesma coluna do 'primeiro passo', mas a linha seguinte. Em termos de índices numéricos, se a grade contém N colunas, o primeiro ponto da segunda linha tem o índice de igual ao índice do primeiro ponto (0) + N Em uma grade com 6 colunas, o primeiro ponto do índice da segunda linha é 6. I aqui ainda movido a lista original de pontos com uma distância de deslocamento igual ao número de colunas, de modo a obter o primeiro ponto da linha seguinte ( a distância de deslocamento depende do <número deslizante> indicando as colunas) para encontrar todos os pontos terceiros.

Fig. 03:20 O item seleccionado é movido para o ponto através de uma distância de deslocamento igual ao número de colunas que produzem todo o 'terceiro ponto' dos triângulos. Para completar a tarefa, precisamos manipular esta lista um pouco mais, de modo que ainda se concentram: 1. Em primeiro lugar, os pontos da lista 'primeiros passos' última coluna nunca serão os primeiros pontos da lista de 'segunda etapa'. 2. Mesmo os pontos da primeira coluna nunca pode ser 'segundo passo', então temos de removê-los de 'segunda etapa' da lista. 3. Mesma coisa para os 'pontos terceiros', onde os pontos na última coluna nunca pode ser pontos terceiros.

Se combinarmos todos esses três partes, imaginá-los e atraí-los, vamos entender que em todas estas três listas, não serão usados os pontos da última coluna. Basicamente, precisamos de uma maneira para omitir a última coluna de cada lista de dados. E é por isso que estamos conectados todas as listas de pontos a um componente <Cull Nth>. Este componente, excluir um item a cada número N de uma lista de dados e N é designado por frequência de recolha (frequência abate) (Figura 3.20). Neste caso, todas as listas de dados são filtrados através do número de colunas. Isto porque, por exemplo, se temos seis colunas, elimina um elemento cada seis, ou seja, o elemento da última coluna. O resultado será uma nova lista com as últimas colunas eliminadas. Nós, então, conectado a <número deslizante> que define o número de colunas para cada componente <abate enésimo> para estabelecer a frequência da recolha.

Fig. 3:21 Nós usamos <abate enésimo> para excluir as últimas colunas do primeiro, segundo e terceiro listas de pontos. O último passo é para alimentar os componentes <line> e ligar os primeiros pontos para o segundo, em seguida, o segundo eo terceiro e, finalmente, o terceiro com o primeiro.

Fig. 03:22 Criação de linhas através dos pontos de ligação da lista filtrou-se para o componente <A linha>. Não se esqueça de definir a opção de cruzar referência o componente <pt> e lista mais longa para o componente <line>.

Fig. 3:23 Agora modificar o <número deslizante> é possível obter diferentes grades de pontos que produzem estes triângulos. Embora ainda existam vários problemas com o nosso projeto, nós sabemos que nós não queremos começar todos os pontos do triângulo da última linha (e vamos removê-los da 'lista primeiros pontos'), mas o conceito é claro .... vá em frente. Vamos voltar a este conceito quando falamos a geometria da malha e tentar apresentar os conceitos. A idéia principal é ver como os dados podem ser gerados e manipulados. Vamos buscar os conceitos através de outras experiências.

3_8_ Padrão para geometrias planares Os padrões geométricos estão entre os assuntos mais interessantes a serem tratados com os algoritmos em Grasshopper generativa. Temos potencial para chamar a razão e, em seguida, criá-los como um padrão que pode ser usado como base para outros produtos de design. No caso de design padrão, podemos olhar para o nosso projeto / modelo e extrair a lógica que produz a forma inteira no mesmo momento em que é repetido. Através do desenho da geometria de base, que podem copiar-lo para produzir o padrão do tamanho desejado (Fig. 3.22)

Fig. 03:24 Extração do conceito padrão para geometrias simples. Continuamos a insistir em trabalhar com os conjuntos de dados e as funções matemáticas simples, em vez de usar outros componentes úteis apenas para ver como essas operações simples e conjuntos de dados numéricos têm um grande potencial para a geração de formas, incluindo geometrias clássicas.

Fig. 3.25 geometrias complexas na Mesquita Lotfollah Sheikh no Irã. Os azulejos são formados a partir de padrões simples, que são criados através de cálculos matemáticos / geométricas. Padrão linear simples Aqui eu decidi projetar um padrão com alguns pontos básicos e linhas. O objetivo é usar conceitos simples, como na Figura 3.26

Fig. 3.26 conceitos básicos para geração de modelos Primeiro de tudo, quero gerar alguns pontos básicos como uma geometria de partida, e depois desenhar linhas entre esses pontos. Eu comecei a minha definição, através de um <series> que faz o controle dos valores numéricos possíveis (número de pontos), o tamanho do passo (distância entre pontos). Através deste <série> eu gerado um conjunto de pontos com apenas valores sobre o X (com y e z igual a zero).

A Fig. 3.27 foram gerados o primeiro conjunto de pontos com os componentes <série> e <pt>. Acrescentamos aqui um componente <receiver> podemos encontrar em Params> Especiais> receptor. Este componente recebe dados a partir de outro componente e passa-los para uma outra através da remoção dos cabos de ligação da lona. Em projetos complexos, quando você quer usar uma fonte de dados para muitos componentes, que nos ajuda a limpar a área de trabalho de modo a evitar distracções devido aos traços das conexões. Como você pode ver na segunda foto, o componente <receiver>, recebe dados do <series>.

Fig. 03:28 Para criar um ziguezague forma, precisamos de duas linhas de pontos como geometria básica. E outra <receptor> 'foi usado para obter dados a partir de uma <série> e com um outro <pt> foi gerado a segunda fila de pontos com valores de y a partir de uma <número deslizante> 40

Fig. 3.29 Nas próximas etapas, precisamos remover alguns pontos de cada lista para obter-nos os pontos para o teste padrão de ziguezague. Aqui, os pontos foram eliminados através de um <pattern abate> seguidos usando booleano VERDADEIRO padrão / FALSE eo outro usando FALSE / VERDADEIRO

A Fig. 03:30 Agora, se conecta ambos os componentes <abate> a um componente <line poli> from Curve> ranhura> Polyline que desenha curvas lineares mais vértices laços em vez de apenas dois, você vai ver como resultado das linhas que formam a Z. Isso ocorre porque os pontos não são classificados e deve ser posicionado em uma lista nesta sequência: o primeiro ponto da primeira linha, o primeiro ponto da segunda linha, o segundo ponto da primeira linha, o segundo ponto da segunda linha.

Fig. 03:31 O componente que ordena os pontos da maneira descrita é a <onda> (Sets> lista> Wave). Leva dados a partir de diferentes fontes e classifica-os de acordo com um padrão, que deve ser definido na sua ligação P (como sempre, ler a ajuda do componente, a fim de obter informações mais detalhadas). O resultado será uma lista de itens ordenou que quando conectado ao componente <Pline> irá mostrar o primeiro ziguezague.

Fig. 03:32 Com o mesmo conceito, foi gerado a terceira fila de pontos, e com uma outra componente <tecer> e <PLINHA>, foi desenhada uma segunda linha em zig-zag

Fig. 03:33 Embora existam maneiras mais rápidas de gerar estas linhas, eu usar o mesmo conceito para os pontos e polilinhas da terceira fila. E 'a opção de visualização desmarcada (preview) para <pt>, <abate> e <tecer> (a partir de seu menu contextual) para esconder todos os pontos e ver apenas a polilinha.

A Fig. 03:34 Se você ainda copiar o mesmo processo e desta vez vamos inverter o valor Y de <pt> componente negativa, (podemos utilizar o mesmo <número deslizante> com um tipo (x) = f - x) será obtida um grupo de poligonais espelhado. Agora manipular distâncias, você pode ter padrões com diferentes escalas e formas.

Fig. 03:35 E 'pode mudar a maneira pela qual os pontos gerado básicos das listas ou dados filtrados. O resultado pode ser padrões diferentes, cruzamentos simples de linhas, mas poderia ser uma geometria gerador para produzir modelos complexos.

A Fig. 03:36 Este é o primeiro resultado do projecto. O padrão se repete de forma simples e 43

resultado pode ser usado de qualquer maneira, de acordo com as diferentes necessidades.

Fig. 3:37 Este é apenas um exemplo das centenas de possibilidades para usar os padrões de base para projetos de desenvolvimento. Mais tarde você vai ter o potencial de se diferenciar o padrão básico e para alterar os resultados dos projectos. padrão circular A modelagem associada nos permite infinitas possibilidades para criar motivos e padrões. A fig. 03:38 mostra outras razões, em que os desenhos são baseados na geometria circular que, em vez de a um linear. Uma vez que existem várias curvas, com todos a mesma lógica, será descrita uma parte dos algoritmos enquanto o resto vai ser até você.

Fig. 03:38 padrão geométrico circular. O ponto de partida este padrão é um conjunto de dados que produz uma série de pontos ao longo de uma circunferência, como o exemplo previamente feito. Esta informação pode ser escalado a partir do centro para criar vários círculos concêntricos. Este conjunto de pontos serão filtrados da mesma forma

o último exemplo. Assim, ele irá gerar um padrão repetitivo zig zag através destes pontos em escala que, uma vez conectado a um com o outro, vai desenhar uma curva em forma de estrela. A sobreposição dessas estrelas poderiam criar uma parte desse fundamento.

A Fig. 03:39 por criação de um intervalo de 0 a 2Pi e utilizando as funções de seno e co-seno, que cria o primeiro grupo de pontos em uma geometria circular. Eu usei esta função com duas variáveis para multiplicar o resultado seno e cosseno através de outra <número deslizante> para alterar o raio de um círculo.

Fig. 03:40 Aumento do seno e cosseno, graças à multiplicando-as por <número deslizante> ea criação do segundo conjunto de pontos com um raio maior. Como você pode ver o resultado desta seção é um conjunto de dois pontos. I <pt> componentes foram renomeados.

Fig. 3.41 O primeiro e o segundo pontos de circunferência A fim de filtrar os pontos, podemos simplesmente usar <abate pattern> para os pontos e utilizar TRUE / FALSE como o último exemplo. Mas como você classificar a lista de pontos? Se você pode usar o mesmo método, aqui eu decidi optar por outro, portanto, use um outro conceito relacionado com a ordenação, que acreditamos pode usar calhar mais tarde: queremos classificar os pontos de acordo com o seu número de índice em ' juntos. Primeiro de tudo o que precisamos para criar um diretório de números. Uma vez que temos produzido um componente <gama> de números reais, precisamos de um componente <series> para adquirir inteiros como índices dos pontos da lista. Os parâmetros do N <gama> definir o número de passos ou divisões, em seguida, o componente <gama> produzir N + 1 números. E é por esta razão que precisamos de um <series> com os valores N + 1 para ser os índices dos pontos.

Fig. 03:42 Geração índice numérico para os pontos (a lista de números inteiros a partir de 0)

Fig. 03:43 Neste ponto preciso escolher os pontos e os índices como no exemplo anterior. Então, usei o componente <Mesclar> (Sets> Tree> Merge) para gerar uma lista de dados ambas as listas <abate>. A operação foi aplicada tanto para os pontos que para os índices. Embora o resultado da união de <series> continuam a produzir os números de todo o conjunto de dados, a ordem não será o mesmo e estará mais próxima à dos pontos. Agora, através da ordenação dos índices como chaves ordenados, podemos encomendar da mesma maneira também os pontos.

Fig. 3:44 Os pontos são classificadas com um <tipo> componente enquanto a sua chave de classificação é o índice. Um polígono é desenhada entre os pontos ordenados.

Fig. 3:45 Os índices antes e após separação, e ordenados pontos e associados que geram uma poligonal em forma de estrela A mesma lógica pode ser usado para criar geometrias mais complexas com um simples geração do conjunto de outros pontos, filtrada e ligado para produzir o padrão desejado. O truque é escolher o melhor grupo de pontos e como conectá-los a outros conjuntos.

Fig. 03:46 E 'possível pensar em outras possibilidades de padrões e geometrias lineares e suas aplicações, tais como, por exemplo, as projecções sobre outras geometrias. Embora ele insistiu ao gênero todos os modelos anteriores através de conjuntos de dados e funções matemáticas simples, queremos ver os componentes mais simples que tornam possível reduzir todo o processo ou alterar a nossa forma de recuperar os dados. Li irá discutir todos juntos

Fig. 03:47 Modelo Final

Capítulo 4. Transformações

Capítulo 4_ Transformações As transformações são passos essenciais, tanto na modelagem e na geometria generativa. Eles permitem obter variações de objetos iniciais simples, ajudando a escala, orientação, mover, copiar ou espelhar nossas geometrias. Existem diferentes tipos de transformações, mas para classificar o podem ser divididos em grupos: a primeira divisão que podemos apontar é que entre transformações lineares e transformações espaciais. A transformação linear é implementado em um espaço 2D, enquanto o espaço tem lugar em um 3D. Outra forma de classificar as transformações, poderia ser a de dividi-los, dependendo do estado inicial do objeto: transformações, tais como traduções, rotações, reflexões, manter a forma original, enquanto a escala ea inclinação da mudança. Há também as transformações não lineares. Além de tradução, rotação e reflexão, que têm diferentes tipos de deformação não uniformes no espaço 3D e escadas, bem como transformações em forma de espiral ou hélice e projecções que criam variações no espaço tridimensional. A fim de transformar, temos de avançar ou objetos Oriente (ou suas partes, que vértices ou cantos) no espaço, e para isso precisamos usar operadoras e planos como base para estas operações matemáticas / geométrica. Nós não vamos discutir os conceitos básicos de geometria e lógica matemática, mas vamos olhar para operadoras e planos, porque vamos precisar para o nosso trabalho.

Fig. 4.1 As transformações revelam o excelente potencial na geração de formas complexas, a partir das mais simples. A natureza mostra em seus grandes exemplos de transformações obras.

4_1_ Carriers e Planos O vector é um objecto matemático que tem um módulo (ou comprimento), numa direcção e numa direcção. Parte de um ponto, prossiga na direção de outro em uma direção específica. As operadoras têm uma ampla gama de usos e são usados, além das mudanças em vários campos da ciência e da geometria.

Figura 4.2 elementos básicos de um vector.; Movendo um ponto por um vector Se temos um ponto e um vector, este vector pode transportar o ponto a uma distância dada a partir do módulo e para uma determinada direção, de modo a criar uma nova posição final para o próprio ponto. Iremos utilizar este conceito simples para criar, mover, escala e orientar as geometrias com o nosso método associativo. Os planos são outro grupo de geometrias úteis e podem ser descritos como superfícies planas e sem fim, tendo um ponto de origem. Os topos de edifícios Rhino, representa esse tipo de objeto. Podemos usar estes planos para nos inserir nossa geometria, aplicar certas transformações com base em sua orientação e origem. Por exemplo, no espaço 3D, não podemos orientar um objeto em uma única transportadora, mas precisamos de dois vetores para criar um plano que pode incorporar a geometria. Os vectores têm um sentido e um módulo, enquanto o piso tem uma orientação e uma fonte representados por X, Y e Z, tais como vectores unitários e planos XY, XZ e YZ. Nos próximos exemplos, vamos discutir vários outros componentes que produzem e modificá-los. Assim, começamos nossas experiências de projeto, começando com um dos usos mais simples para nossos transportadores, e em seguida, avançar passo a passo.

4_2_Curve e geometrias lineares Já experimentou com os pontos que são geometrias de tamanho 0, podemos agora começar a pensar da curva como objetos unidimensionais. Como os pontos, curvas pode ser a base para a construção de diferentes tipos de objetos. Nós podemos expulsar uma curva ao longo de outro para criar uma superfície, podemos colocar diferentes curvas em conjunto para criar superfícies sólidas e, em seguida, podemos distribuir cada objeto ao longo de uma curva com um intervalo específico ou podemos pensar em muitas outras maneiras de tirar proveito desta geometria como uma base para gerar outros itens.

mudanças No Capítulo 3, geramos diferentes grades de pontos através dos componentes <seris> e <pt>, mas agora é hora de introduzir um outro componente, chamado <retangular grade> (Vector> Grades> grade retangular) que produz uma grade de pontos. Podemos controlar ambas as distâncias entre os pontos (iguais em ambos os sentidos) que a quantidade está na direcção X que Y.

Fig. 4.3 Um componente simples <retangular grade> com seus valores padrão. E 'pode alterar o tamanho da grade através de um <número deslizante> ligado à entrada (S) indicando a distância. Também pode também alterar a orientação dos pontos. Para fazer isso precisamos de um plano em que para colocar a grade. Introduzimos o componente <plano XY> (Vector> Plane> plano XY), que é uma orientação plano infinito produzido pelos eixos X e Y e que se moveu ao longo do eixo Z através da unidade de componente <Z> (Vector> vetor> Z Unidade), que é um vector paralelo ao eixo Z, com o comprimento igual a um. Nós podemos modificar a altura deste movimento através do tamanho do vector ligando-o a um <número deslizante> conectado com a entrada do <z unidade> componente. Ao modificar o <plano xy posição> ao longo do eixo Z, será possível alterar a posição da grelha

Fig. 4.4 As grelhas (seleccionado em verde) são modificados por uma <número deslizante> que dimensionar a distância entre os pontos, e uma outra barra deslizante ligada a uma <unidade z> e um <plano xy> para alterar as coordenadas dos pontos da grelha no eixo Z. 53

Então, se você olhar para o resultado de um <grade retangular> você pode ver que temos acesso a todos os pontos das células da grade e centros de celulares. Para esta experiência, nós olhamos para um conjunto de linhas que partem do centro das células da grade, e para o espaço. Nós podemos simplesmente ligar os pontos pelos dois <Grid> componentes através da porta para o componente M <line> para gerar um grupo de linhas. Assim, alterando o tamanho da segunda grelha será desenhar linhas com diferentes direcções. O problema é o comprimento das linhas, que neste caso serão diferentes uns dos outros, enquanto nós queremos desenhar linhas com o mesmo comprimento. Para fazer isso precisamos de uma outra estratégia, que é por isso que estamos indo para usar o <line SDL> componente. Um componente <linha SDL> desenha uma linha a partir de um ponto (S), com uma direcção (D) e um comprimento (L). Assim, o comprimento das linhas pode ser controlada. Exatamente o que precisamos; temos tanto o ponto de partida (centro da célula) que o comprimento da linha (seja ele qual for). E sobre a liderança? Queremos usar o ponto central da segunda células da grade como o segundo ponto das linhas, então a direção das minhas linhas será a direção das linhas conectadas ao ponto central da grade. Para definir essas direções que precisamos operadoras. E é por isso criamos um conjunto de vetores com estes dois pontos para criar as direções para o meu <line SDL> componente.

Fig. 4.5 Criação de vectores a partir do ponto central da primeira rede para o ponto central das células da segunda grelha através do componente <vector 2p> (Vector>> 2pt vector). Este componente cria portadores através do seu ponto de partida e de chegada.

A Fig. 4.6 O componente <A linha SDL> gera diferentes linhas do ponto central de uma grade que se move para o espaço, devido à maior distância da segunda grade. E 'pode mudar o comprimento das linhas através do <número deslizante> e é possível mudar sua direção, alterando o tamanho da segunda grade.

Para a próxima etapa nós queremos adicionar um polígono no final de cada linha e expulse-o no ponto das linhas de partida para ver o potencial generativo. Para gerar os polígonos que adicionou vários andares para os pontos finais das linhas como um plano básico para criar polígonos.

Fig. 4.7 Usando o componente <endpoint> (Curve> Análise> End Point) e usar esse ponto de extremidade como o ponto de origem para os planos definidos, você pode gerar os planos básicos. E 'foi usado aqui o componente <plano normal> (Vector> Plane> plano normal) que produz um plano de um ponto de origem (extremidades das linhas) e uma direcção Z vetor normal ao plano (um vector normal, é um vector perpendicular ao plano). Aqui nós usamos as mesmas linhas como vetores das direcções normais para os planos.

Fig. 4.8 Adição de um componente <polígono> e utilização de plantas geradas como planos de base para polígonos, este produzirá um conjunto de polígonos no final de cada linha e perpendicular aos mesmos linhas. Como você pode ver esses polígonos têm o mesmo tamanho, mas queremos aplicar um sistema de diversificar as medidas para ter uma forma chanfrada no final.

Fig. 4.9 com um <lista comprimento> Componente obter os números de linhas, enquanto o componente seguinte <função> que é uma raiz quadrada de entrada (F (x) = SQRT (x)), calcula o número de linhas de cada linha. E um <série> componente com o ponto de partida 'foi usado com o tamanho de passo igual a 0,1, enquanto que o número de valores vem a partir do número de linhas. E uma lista de números que crescem gradualmente, em número igual ao dos polígonos de cada linha 'foi então gerada. A fim de usar estes valores para todos os polígonos, eles foram duplicar as listas de dados com o valor das colunas (neste caso, igual ao das linhas) e ligados à entrada do raio polígonos. Como você pode ver no modelo, para cada linha,

Fig. 4.10 Na última etapa, foi utilizado um componente <ponto de extrusão> (Surface> freeform> Extrude Point) e ligado ao ponto da linha que apontam para o que é extrudido quero o meu polígono de partida.

Fig. 04:11 Usando o 'painel de controle remoto', ou seja o painel de controle remotamente, você pode facilmente alterar o valor de números para diferentes opções e controlar a forma final do modelo e selecionar o melhor. Não se esqueça de desmarcar a pré-visualização de objetos desnecessários.

Fig. 04:12 modelo final

4_3 Experiência combinada: Swiss Re Hoje em dia é muito comum para desenhar o conceito das torres com o método de modelagem associativa. Isso permite que os designers para criar modelos diferenciados, em um fácil e rápido. O potencial para diferenciar projetos é extensa e os melhores resultados podem ser obtidos rapidamente. Decidimos para modelar uma torre, e o "Swiss Re" de "Foster and Partners" parece ser bastante sofisticado para uma experiência em modelagem. Primeiro vamos olhar para o projeto

Fig.4.13 Swiss Re HQ, 30 St Mary Axe, London, Reino Unido, 1997-2004, fotografias do site Foster and Partners, http://www.fosterandpartners.com. Primeiro a idéia: vamos desenhar os círculos para identificar o tamanho da torre e copiá-los para formar planos em que as mudanças fachada de curvatura. Nós escalar os planos para torná-los se encaixam para formar, em seguida, construir o revestimento usando os planos. Para concluir, vamos adicionar as seções poligonais para os elementos estruturais da fachada. Para fazer isso ipotizzerò tanto o tamanho e as proporções, e eu vou cobrir o modelo com geometrias simples, a fim de tornar o processo mais fácil. Vamos começar com os planos. Eles sabem que os planos da Swiss Re são os círculos que alguns cortes em forma de V, mas aqui usamos um anel simples como um perfil. Nós copiar estes chão a uma certa altura, o que tornará possível visualmente ser capaz de jogar com as proporções. Como já foi mencionado, estes pontos são posicionados nos pontos onde as alterações da curvatura da fachada.

Fig. 4.14 Componente <círculo> a <número deslizante> como raio exterior da torre. Esta circunferência é copiado seis vezes ao longo da direcção Z positiva, graças ao componente <movimento>, por meio de um vector <unidade z>. Estes números são fornecidos pelo ajuste manual 'set

Vários números e são utilizados como distâncias das diferentes partes da torre (feito na base da dimensão da circunferência de partida). Apesar de terem sido criados estes círculos básicos tudo a mesma coisa, sabemos que os planos não são do mesmo tamanho, por isso precisamos de redimensionamento. Se dermos uma olhada na seção torre, veremos que a partir da base das circunferências começam a crescer até uma certa altura, permanecem constantes na parte central e, em seguida, começam a diminuir até que a ponta da torre. Aqui vamos assumir os fatores de escala para os planos. Você pode alterar esses valores para verificar que o projeto é semelhante ao original.

Fig. 04:15 Precisamos de um <escala> componente (Xform> Affine> Scale) para redimensionar os planos de referência. O <escala> componente precisa modificar uma geometria, um ponto de referência e um factor de escala. Então, precisamos alimentar a parte geométrica através dos nossos planos ou circunferências que irá provar ser a saída do componente <move>. O centro padrão para o dimensionamento é o ponto de origem, mas se escalar todos os planos através do mesmo centro, eles serão movidos para o espaço, porque ele vai subir ainda sua altura. Precisamos, portanto, o centro de escalar a torre é o nível em cada andar. Deve haver um para cada exatamente no centro do chão. Por esta razão, nós usamos o componente <center> (Curve> Análise> centro) que nos traz de volta ao centro dos círculos. Conectando-se ao <escala> podemos ver que todos os círculos serão escalados ao seu nível sem ser movido. Lembre-se que os fatores de escala são presumidos, assim como as feitas alturas anteriores. Estes valores podem ser alterados para ver qual se encaixa melhor para a combinação visual total. Eles são tudo pronto para ser um componente <number>.

Fig. 04:16 Se agora aplicar uma superfície com loft para estes planos (através de um componente <sótão> (superfície> freeform> loft)), será exibida a primeira imagem da torre. Lentamente, vamos limpar a opção de visualização de pontos gerados anteriormente para limpar a cena. Neste ponto, podemos começar os elementos de fachada. Os elementos estruturais da fachada são de forma helicoidal, e tem uma secção constituída por dois triângulos interligados, mas para simplificar só irá moldar a parte visível, o que se assemelha a um triângulo no plano. Nós vamos usar o loft entre essas seções para criar o seu volume. Queremos gerar essas seções triangulares na fachada. Para isso, primeiro precisamos encontrar a posição destes triângulos na fachada. Eu acho que se nós criamos uma curva na superfície da fachada e dividir, pode resultar em um lugar aceitável para colocar todos os triângulos antes de qualquer transformação.

Fig. 4.17 Nós usamos o componente <endpoint> para obter os pontos de início / fim dos meus planos de amostragem. Ao ligar estes pontos como vértices de um componente <interpolado> (curvas> estriado> interpolate), será possível obter uma curva posicionados na fachada. 61

Fig. 4.18. Aqui as curvas <interpolados> em 40 partes foram divididas. O número das divisões ajuda a bisel os elementos quando queremos ajustar a fachada.

A Fig. 4.19 Agora, os pontos de divisão tornam-se pontos básicos para gerar o <polígono> na fachada. três lados foram definidos para gerar triângulos e seu tamanho, a parte 'R' (raio) é controlável por meio de um <número deslizante>

Fig. 4:20 Os elementos de fachada estruturais são espirais que correm em torno da pele, até ao topo da ponta da torre. Para permitir isso, é preciso girar as seções triangulares gradualmente. Queremos usar o componente <girar> e para isso precisamos dos ângulos de rotação. Como disse, os cantos da ração deve ser uma lista de números que crescem 62

gradualmente. O componente <series> gera nossos ângulos de rotação e contém elementos iguais em número às <divide componentes> (pontos-triângulos). Como resultado, todas as seções triangulares giram em torno da fachada.

Fig. 4.21 Agora temos que criar um loft entre todos os triângulos, e veremos um único elemento fachada. O ângulo de rotação e o tamanho dos elementos será controlável de modo a combaciarli com a fachada, na sua melhor forma. domínios Como já disse o domínio é um intervalo numérico. Eles são números reais variam de um menor para um limite superior. Desde falamos sobre números reais, isso significa que entre dois números que pertencem a este conjunto claro, temos um número infinito, o que permite que diferentes tipos de uso para estes domínios numéricos. Como já foi experimentado antes, podemos dividir o intervalo numérico e ter as divisões uniformemente distribuídos através de dois extremos. Por isso, queremos distribuir os elementos de fachada em torno da circunferência base. Para fazer isso precisamos de um intervalo para cobrir toda a circunferência base.

Fig. 04:22 Um componente <domínio> (Math> Domínio> Domínio) tem sido utilizado para definir uma gama numérica de 0 a 360. Esta gama numérica é dividido por meio de um componente <gama> em 10 partes e o resultado é usado como um factor angular para um componente <girar>. Assim, como mostrado, os elementos de fachada são distribuídos na circunferência de base.

A Fig. 04:23 Se fizermos um <espelho> (espelho) (Xform> euclidiana> Espelho) através de um <XY> (Vector> Plane> YZ) da geometria, teremos os elementos da fachada de uma forma helicoidal espelhado que, eventualmente, produzir uma grade ao redor da torre.

A Fig. 04:24 Aqui está outro pré-visualização da fachada, que mostra uma representação nãoacabado da "Swiss rei" com uma técnica associativa. 64

Fig. 04:25 Para gerar a geometria de rinoceronte, podemos seleccionar os componentes que criam a geometria desejada, e, em seguida, optar por 'cozer objecto seleccionado', a partir da barra acima da tela ou do menu de contexto do componente.

Fig. 04:26 modelo final. Apesar de nĂŁo ser idĂŞntico ao original, para ser um modelo de partida, e criado em um curto espaĂ§o de tempo, ele funciona bem. 65

Fig. 04:27 No meio dos elementos estruturais principais, existem outras pequenas estruturas que podem modelar sozinho. author

4_4_ Attractors 'O atractor é um conjunto de estados para o qual tende a evoluir de um sistema físico dinâmico, sem ter em conta as condições de arranque do sistema. Um ponto atractor é um atractor, que consiste de um único estado. Por exemplo, uma bola que rola em um copo vai parar no final, sempre no ponto mais baixo, para o centro inferior; o movimento é um ponto de atracção '(Dictionary.com/Science dicionário) uma vez que a posição final tenha sido terminada.

Fig.4.28. Attractor estranho (Ilustração tomada de http://www.cs.swan.ac.uk/~cstony/research/star/)

No caso do desenho e geometria, os atractores são elementos (geralmente pontos, mas também poderia ser curvado ou qualquer outra geometria) que produzem efeitos sobre outras geometrias em espaço, mudando o seu comportamento fazendo com que eles se movam, re-orientar, rescale etc. Eles podem articular o espaço em torno de si e introduzir o campo de atração raio. Atratores têm diferentes aplicações em desenho paramétrico, uma vez que têm o potencial de mudar todos os objetos constantemente. Ao definir um campo, atractores podem também afectar os agentes de um sistema com acções diferentes. Os métodos de influência e de energia dos atractores, depender de parâmetros ajustáveis. Vamos ver o conceito de atratores em várias ocasiões, e, em seguida, começar imediatamente com os primeiros exemplos simples. Pontos atração Temos uma grade de pontos e queremos gerar um conjunto de polígonos a partir desses pontos. Temos também chamado de ponto <atrator 1> a que temos desenhado em torno de um <círculo>, apenas para torná-lo mais claro. Eu quero o meu <atrator _1> afeta toda a minha <Polygon> em seu campo de ação. Isso significa que, de acordo com a distância entre cada <polígono> e <attractor_1> e no domínio de <attractor_1> cada <polígono> atrator responde mudando seu tamanho.

Fig. 4.29 Base de <point_grid> com <polígono> e <attractor_1> O algoritmo é muito simples. De acordo com o <distância> entre <attractor_1> e <pt-grid> queremos influenciar o raio do polígono, para que realzione entre atrator e polígonos é definida pela distância. Precisamos de um componente <distância> para medir a distância entre <attractor_1> e o centro do polígono ou o <pt_grid>. Devido ao número que pode ser muito grande, precisamos <divisão> (Math> Operadores> Division) distanciar com um número dado por um <número deslizante> para reduzir o poder de <attractor_1> em meu lazer.

Fig. 4.3 O <Distância> é dividido por um número para controlar a potência do componente <attractor_1>. Embora tenhamos criado um grupo através <attractor_1> e sua circunferência, parece que a nova versão do Grasshopper aceitar vários clusters, e por isso é aconselhável usar um simples <pt> como <attractor_1> Se você agora ligar o componente <div> para o raio (R) do polígono, podemos ver que a escala polígono aumenta à medida que nos aproximamos de todos '<attractor_1>. Embora isso possa parecer um bom resultado, queremos controlar o raio máximo do polígono, caso contrário indo bem, há um risco de que eles se tornam muito grandes, cruzando-se uns com os outros (esta é a mesma coisa que acontece se o poder é muito atratores grande). Devemos, portanto, ter um controle manual do raio do polígono.

Fig. 4.31 Utilizando um componente <mínimo> (Math> Util> mínimo) e um número definido pelo usuário, criamos uma construção que a decisão diz o algoritmo para escolher o valor do componente <div> se for menor do que o número que definido como o raio máximo através do <número deslizante>. Como você pode ver pelas fotos, esses polígonos que crescem para se tornar o maior do <max_rad> permanece constante, e podemos dizer que eles não estão sob a ação do campo atração. Se a área de trabalho Rhino, alterar manualmente a <attractor_1 location>, podemos ver que cada polígono terão seus raios de acordo com o <attractor_1 location> 68

Fig. 4:32 Efeitos do atractor de todos os polígonos. O deslocamento dos atractores, influenciar cada polígono

Fig. 04:33 com o mesmo modo, pode-se mover os polígonos na direcção Z, com base no número que chega a partir de <min> ou mudando as funções matemáticas, se necessário. Assim, o uso dos atratores não está apenas relacionada com o tamanho. Simples !!!. Podemos aplicar qualquer aspecto desses polígonos, para girá-las, mudar a cor, etc. Mas vamos agora considerar o que aconteceria se tivéssemos dois atratores no campo. Nós criar outro cluster, o que significa um outro ponto de rinoceronte associada ao <ponto> e <círculo> Grasshopper. A primeira parte do algoritmo é o mesmo. Mais uma vez, é preciso medir a distância entre este <attractor_2> e o centro do polígono ou o <grade pt_> e depois dividi-lo pelo mesmo <número deslizante> aqui renomeado <att_power> para controlar o poder do atrator

Fig. 04:34 Introdução de um segundo atractor e aplicação do algoritmo. Agora temos duas listas diferentes de dados que inclui o polígono longe um do atrator. Desde o atrator mais próximo pode afetar ainda mais a gama, descobrimos que é mais perto e usá-lo como fonte de iniciativa. Vamos usar um <min> para descobrir qual a distância é menor e, consequentemente, o ponto é mais perto.

Fig. 04:35 Encontre o atrator mais próximo. Depois de encontrar a mais próxima através do componente <min>, o resto do processo irá continuar desta forma. Agora todos os polígonos, são influenciados pelos dois atratores.

Fig. 04:36 E 'pode outra vez mudar a posição dos atractores e ver como os polígonos reagir em conformidade. 70

Nós adicionamos outros atrativos, com o objetivo de encontrar o mais próximo a cada polígono e aplicar efeitos predefinidos. Este conceito é útil quando você quer ver questões de design com um grande número de elementos de pequena escala. curva atractor: o projecto parede Como em muitos casos, é preciso articular o campo de objetos com atratores lineares em vez pontual, nós completamos o discurso com outro exemplo, mas neste caso através de uma curva usada como um atrator. Nosso objetivo é projetar uma parede perfurada por um espaço interior, para ter uma visão enquadrado para o outro lado. Esta parte do trabalho pode ser cortado a partir de material em folha. Na minha concepção espacial que tem uma folha plana (da parede), e duas curvas de um conjunto de pontos distribuídos aleatoriamente como pontos básicos para formas de corte. Decidimos criar alguns retângulos através destes pontos, cortados das folhas para criar uma parede perfurada. Nós também queremos organizar os retângulos através das duas curvas dadas para que, no final, não apenas retângulos dispersos resultar, mas distribuídos aleatoriamente de acordo com as curvas que têm um nível de organização em uma escala macro, mas são controlados em micro-escala. O que precisamos é criar esta série de pontos aleatórios e movê-los para as curvas, de acordo com o poder que começa a partir destes. Eu também decidiu mudar os pontos ao longo de ambas as curvas então você não tem necessidade de selecionar o mais próximo. Agora eu preciso para criar meus retângulos sobre estes pontos para definir, finalmente, o tamanho desses retângulos em relação à sua distância do atrator.

Fig. 04:37 gerar uma lista de pontos distribuídos aleatoriamente, e introdução dos atractores por meio de dois componentes <curvo> (Parâmetros> geometria> Curva) no espaço folha. I utilizado um <domínio> componente para definir o intervalo entre zero (definida manualmente) e a <número deslizante> para a gama de pontos Casule. Nós renomeado <pt> em <Rnd_Pt_Grid>.

A Fig. 04:38 Quando o atractor é um ponto, a geometria pode mover-se em relação a eles. Mas quando o atrator é uma curva, você tem que encontrar um ponto relativo na curva e mover a sua geometria, neste ponto particular. E este ponto tem de ser único para cada geometria., Porque deve haver uma única relação entre os atratores e qualquer geometria. Se imaginarmos um atrator como um ímã, pode atrair a geometria, seu ponto mais próximo ao objeto. Então, basicamente o que precisamos no início é encontrar o ponto mais próximo do <Rnd_pt_grid> em ambos os atratores. Estes pontos estão mais próximos do atrator, para cada membro da <Rnd_Pt_Grid> separadamente. Eu usei o componente <Curve CP> (Curve> Análise>

Fig. 04:39 Para mover pontos para atratores, eu preciso definir um vetor para cada ponto <Rnd_Pt_Grid>, do ponto ao seu ponto mais próximo da atrator. Desde que eu tenho o ponto de partida eo ponto final do vector, use o <vector 2 Pt> componente. O segundo ponto do vector (canal B do componente) é o ponto mais próximo na curva.

Fig. 4:40 Agora eu me conectei todos os meus <Rnd_ Pt_Grid> os dois componentes <move> avançar para atratores. Mas se eu usar os vetores que eu criei na última etapa, este irá mover todos os pontos na curva, mas não é o que eu quero. Se você olhar para o componente <Curve CP> tem um outpunt que retorna a distância entre cada ponto e o ponto mais próximo relevante na curva. Bem! Nós não precisamos de medir a distância dos outros componentes. I utilizado apenas um componente <Função> el ligado a distância X e uma <número deslizante> Y para dividir X / Log / (y) de modo a controlar o factor de deslocamento (A função logarítmica modificação da relação linear entre a distância e os factores resultante). Agora eu preciso para alterar o tamanho dos meus operadoras, de acordo com novos fatores criados. Eu preciso de um componente para alterar o tamanho dos vetores, e é por isso que eu usei um componente <multiplicam> (Vector>> Multiply) que faz isso por mim, então eu ligava o <vector 2P> como a base de vetores e I mudou seu tamanho por meio do fator tamanho e me juntei os vetores resultantes no componente <move> para mover o <Rnd_Pt_Grid> em relação à sua distância dos atratores, e em relação a eles.

Fig. 04:41 O <número deslizante> muda o poder com o qual cada um atrator move objetos em relação a eles

Fig. 04:42 O próximo passo é gerar os rectângulos. I ligou os pontos deslocadas, utilizadas como os pontos de base, o componente rectângulo (curvas> primitivo> rectângulo). Mas como eu disse, eu quero mudar o tamanho dos retângulos com base em sua distância de cada atrator. Em seguida, utilizaram os mesmos valores numéricos que I utilizado para a magnitude do vector e modificado I-los através de duas funções. Dividi esses fatores para 5 no valor X dos rectângulos e dividi-los por 25 em sua dimensão Y. Como você pode ver os retângulos são de tamanhos diferentes, dependendo de sua distância original a partir do atrator, mas todos têm as mesmas proporções, como resultado o fator de divisão aplicada. Você pode alterar esse fator (5,

Fig. 04:43 manipular as variĂĄveis terĂĄ diferentes modelos para escolher o melhor que pudermos para nossos fins de planejamento.

Fig. 04:44 modelo do desenho final de um sistema de paredes ventiladas. Os efeitos de sombreamento diferentes pode ser consideradas como factores para controlar o tamanho das aberturas.

Capítulo 5_ Parametric Espaço

Parametric Capitolo_5_Spazio O nosso estudo da geometria observa objectos no espaço, a representação digital das formas e as tectônica, o diferente articulação dos elementos e geração de múltiplos processos de formas; das idéias clássicas da simetria e padrão para o NURBS e MESH. Portanto, estamos dialogando com os objetos. Estes objectos podem ser paralelepípedos, esferas, cones, superfícies ou qualquer um dos seus articulação. Em termos da sua representação no espaço, em geral, são geralmente divididos em pontos de zero-dimensionais, curvas unidimensionais, bidimensionais e superfícies sólidas tais objectos em 3 dimensões. Nós formular o espaço por meio de um sistema de coordenadas para identificar algumas propriedades fundamentais tais como a posição, orientação e medidas. O sistema de coordenadas cartesianas é um espaço tridimensional que tem um ponto de origem O = (0,0,0) e três eixos que neste ponto que criam as direções X, Y e Z. Mas devemos considerar que este tridimensional sistema de coordenadas , que também inclui sistemas bidimensionais (espaço plano (x, y)) e unidimensionais (espaços lineares (x)). O que conhecemos como desenho paramétrico comunica com esses espaços. Para desenhar curvas de forma livre e superfícies de forma paramétrica, precisamos ir além desses espaços. Desde as mudanças de design paramétrico entre espaços questii, precisamos entendê-los como um espaço paramétrico.

5_1_Spazio paramétrico dimensional O eixo X representa uma recta que contém alguns números associados, posições diferentes ocupantes. Simplesmente X = 0 indica a origem ex = 2,35 ponto na direcção de X positivo que é 2:35 unidades da origem. Este simples sistema de coordenadas unidimensionais podem ser parametrizados com posições diferentes, mas também de uma curva no espaço contém a capacidade de ser parametrizada através de uma série de números reais que mostram uma posição diferente na curva. No nosso espaço paramétrico 1D, quando se trata de pontos, estes poderiam ser descritas por meio de números reais que estão associados com um ponto específico em uma curva levados em consideração. A coisa importante a saber é que uma vez que não estão trabalhando mais no eixo X, cada curva tem o seu próprio espaço de parâmetros, e estes parâmetros não se encaixam exatamente com o sistema de medição universal. Cada curva no Grasshopper tem um espaço de parâmetros que começa em zero e termina em um número real positivo (fig. 5.1)

Fig. 5.1. paramétrico espaço dimensional de uma curva. Para cada valor de 't' é um número real associada a uma localização na curva. 77

Então, falando de curvas e de trabalho e referindo-se a alguns pontos específicos, não temos a obrigação de lidar com mais pontos no espaço 3D com p = (x, y, z), mas podemos tirar um ponto em uma curva através de um parâmetro específico p = t. E é óbvio que sempre podemos converter este espaço de parâmetros em um ponto em um mundo em geral sistema de coordenadas (Fig. 5.2)

Fig. 5.2 paramétrico espaço e conversão em coordenadas 3D unsistema

5_2_Spazio paramétrico bidimensional Dois eixos X e Y, em um sistema de coordenadas global geral, um diálogo com os pontos de uma superfície plana infinita em que, em cada ponto de este espaço está associada com um par de números de p = (x, y). Quase como em um espaço 1D, podemos imaginar que todos os valores de um espaço 2D pode ser monitorado não apenas em um sistema geral das coordenadas de uma superfície plana, mas também em toda a superfície espacial. Assim, podemos parametrizar um sistema de coordenadas no espaço de uma superfície curva, e designar os diferentes pontos através de um par de números de aqui chamados espaço de UV, em que cada ponto P sobre a superfície responde a P = (u, v). Mais uma vez, não precisa de trabalhar com três valores P = (x, y, z), como num espaço 3D para encontrar os pontos, mas que pode trabalhar com os parâmetros de UV sobre a superfície (Fig. 5.3).

Fig. 5.3 UV e 2D espaço paramétrico

Estes '' parâmetros são específicos para cada superfície e não são de dados genéricos, tais como o sistema de coordenadas global, e é por isso que nós os chamamos paramétrico! Nós temos acesso ao espaço 3D e coordena o equivalente para cada ponto sobre a superfície (Fig. 5.4)

Fig. 5.4. Equivalência do ponto p = (u, v) em geral um sistema de coordenadas p = (x, y, z)

5_3_ transição entre espaços Uma parte fundamental em pensar um projeto paramétrico, é saber exatamente o sistema de coordenadas ou espaço de parâmetros que precisam ser capazes de planejar. Ao trabalhar com curvas de forma livre e superfícies, precisamos de obter dados para a criação ou conversão de outras geometrias. Com scripting é mais complicado, mas a interface visual Grasshopper, em comparação com o código, você pode simplesmente identificar que tipo de dados que precisamos para alcançar nossos objetivos de design. Notamos que para recuperar uma geometria com Generative Algoritmos e Grasshopper, nem sempre o que precisamos é um parâmetro ou um valor em um sistema de coordenadas, mas algumas vezes só precisamos de um índice numérico. Se nós estávamos trabalhando com um grupo de pontos, linhas ou qualquer outra coisa, e foram gerados como um grupo de objetos, como uma nuvem de pontos, porque cada objeto é associado a um número natural que mostra a posição em uma lista de objetos, nós só precisa de indicar o número de objetos como índices no lugar de um sistema de coordenadas. A indexação de números, como na série de variáveis de programação é um sistema de computação com base em zero.

Fig. 5.5 Indexação numericamente em um grupo de objetos é a maneira mais fácil de nomeá-los. Este é um sistema de computação com base em zero, isso significa que os números são zero. 79

Portanto, como mencionado anteriormente, na modelagem associativa, criamos nossas geometrias passo a passo como alguns objetos relacionados e, por essa razão, usamos o espaço de parâmetros para cada objeto, a fim de extrair informações específicas sobre o espaço e usá-lo como uma base de dados para as etapas mais tarde. Isso poderia começar a partir de um simples pontos de campo como geradores de base e terminam aos detalhes sutis do modelo resultante.

5_4_ componentes paramétricos básica 5_4_1 curvas Avaliação O componente <avaliar> é a função que localiza os pontos em uma curva ou sobre uma superfície, dependendo do parâmetro passado. O componente <avaliar curvas> (Curve> Análise> Avaliar curvas) leva uma curva e um parâmetro (um número) e retorna um ponto em uma curva com base neste parâmetro.

Fig.5.6 O ponto estimado em <curvada> com base em um parâmetro específico, que se origina a partir de um <número deslizante>

Fig. 5.7 Podemos usar qualquer <curvada> desenhado em Rhinoceroso Grasshopper porque ele é derivado. E podemos usar um <series> de números como paramétrico <avaliar> em vez de um parâmetro. No exemplo acima, devido a alguns dos números <série> componente que são maiores do que o domínio da curva, é possível que o componente <avaliar> retorna um aviso (cuidado!) E muda para laranja porque ii pontos estão posicionados no imaginário continuação da curva

A Fig. 5.8 Embora a produção de um <curva> o 'Q' componente retorna o domínio de uma curva (mínimo e máximo para os parâmetros da curva) alternadamente que pode mover-se uma curva externa (Parâmetros> geometria> curvas) e no seu menu contextual pode escolha 'reparameterize' (Reparameterize). Este define o domínio da curva de valores entre zero e um. Basicamente, portanto, podemos percorrer todas as curvas através de um <número deslizante> ou conjunto numérico entre zero e um, e não se preocupar que os parâmetros podem ir além do domínio numérico da curva em si. Há outros componentes úteis para o espaço de parâmetros em Curve> Análise / divisão da qual falaremos mais tarde

5_4_2 uma Avaliação área Se para a avaliação de uma curva que precisa de um número como um parâmetro (porque a curva tem espaço unidimensional) para as superfícies que precisa de um par de números de parâmetros (u, v), através da qual podemos avaliar um ponto específico sobre uma superfície. Podemos usar o componente <avaliar superfície> (Surface> Análise> Analysis) para avaliar um ponto sobre uma superfície com um parâmetro específico. Podemos usar um componente <ponto> para avaliar usando superfície como entrada para o componente de UV <avaliar superfície> (ignorar a dimensão Z), e que vai ser possíveis pontos de fluxo na superfície única com a parte X e Y do ponto, cujos parâmetros de U e V.

Fig. 5.9 Um ponto nominal sobre uma superfície, com base em U e V, a partir de parâmetros <Número> deslizante, com um componente <ponto> que cria um par de números. Mais uma vez, como acontece com as curvas é possível escolher o 'reparameterize' no menu de contexto da superfície e definir o domínio de superfície entre zero e um em ambas as direções U e V. Mudança U e V através de um <número deslizante> e observado como estes pontos avaliadas movimento sobre a superfície (I renomeado o X, Y, Z de entrada, dos componentes no U e V)

Fig. 5.10 porque precisamos <pontos> para avaliar um <superfície> como você pode ver, podemos usar todos os métodos que têm tratado de gerar. Nossas opções não estão limitados a um par de parâmetros de um <número deslizante>, e podemos percorrer uma área de muitas maneiras.

Fig. 5.11 dividir uma superfície (como no exemplo anterior) em algumas linhas e colunas, que também pode utilizar o <superfície divide> ou, se houver necessidade de alguns planos que se intersectam algumas linhas e colunas de uma superfície que pode usar < quadro superfície> tanto do menu Surface, sob o painel de Util. 82

5_4_3_ mais perto da curva e o ponto de superfície Mas nós nem sempre usar os parâmetros de pesquisa para pontos, às vezes, temos o ponto e nós queremos saber seus parâmetros para outros usos. Isso acontece quando a questão entra em jogo para encontrar o ponto mais próximo. Os componentes <curva CP> e <superfície CP> (ponto mais próximo da curva / superfície) são dois componentes que nos ajudam a fazer isso.

Fig. 5:12 <Curve Cp> e <Superfície Cp> ajudar-nos a encontrar o parâmetro de um ponto em uma curva ou sobre uma superfície. Há outros componentes que devem ser fornecidos com outros parâmetros.

5_5 Proliferação de objetos no espaço de parâmetro Por várias razões de design, designers utilizam superfícies para reproduzir rapidamente acima, outras geometrias. As superfícies são objectos bidimensionais e flexíveis contínuas que representam bases adequadas para este propósito. Existem muitos métodos que interagem com a superfície como a telha. Em qualquer caso, eu quero começar com um dos métodos mais simples, enquanto outros vão discutir mais tarde. Temos uma superfície de forma livre e uma geometria simples, como uma caixa. A questão é agora: Como preencher a superfície com um certo número de paralelepípedos, a fim de ter superfícies diferenciadas (tal como, por exemplo, um revestimento), para o qual é preciso ter o controlo macro escala (superfície) e o micro-escala ( cubóide) separadamente, mas associativamente? Aqui está o método: a fim de completar a operação, teremos que dividir a superfície nas partes desejadas e criar o nosso paralelepípedo nesses locais específicos da superfície e rimodificarle para ter manipulação local desses objetos. Localizar os canais desejados na superfície é simples. Podemos dividir a área ou podemos gerar alguns pontos com base em uma dados numéricos juntos. Quanto à manipulação local da geometria, ainda precisamos do conjunto de dados que pode ser usado para transformações, como rotação, movimento local, downsizing, correções etc.

Fig. 05:13 Uma superfície de forma livre reparametrizada, avaliada por meio de um intervalo numérico que começa a partir de zero a um, dividido por 30 elementos por meio de uma <número deslizante> em ambas as direções U e V (aqui usamos <divide a superfície>, mas preferi usar o componente <ponto> lembrar que todas as técnicas para gerar pontos do capítulo 2 são opções possíveis para a nossa experiência).

Fig. 05:14 Como você pode ver o componente <avaliar> retorna um 'normal' (normal) e um 'plano' (piso) para cada ponto da superfície avaliados. Eu usei esses planos ou quadros para gerar série de rectangular (<caixa>) na superfície até que seu tamanho era controlada por <número deslizante>. O componente <caixa> (Superfície> primitivo> caixa centro) requer um foco para a caixa e o seu comprimento na direcção X, Y, Z. A fim de editá-los localmente as caixas, decidi girá-las. Quero definir ll'asse de rotação paralelo ao sentido L da superfície e de acordo com a situação desta superfície simples, vai escolher o plano XZ, como a base para a sua rotação (Fig. 5.15)

Fig. 05:15 rotação local de um paralelepípedo

A Fig. 5.16 O componente <rodar> requer três entradas. O primeiro é a geometria, ou seja, os paralelepípedos. O segundo elemento é o ângulo de rotação. Eu quero que eles giram com valores aleatórios (você pode gradualmente girá-los ou de qualquer forma). Então, eu quero classificar um monte de números aleatórios (<random>) cujo número é igual ao de rectangular. Então eu usei um componente <lista de comprimento> para descobrir quantos retangular e eu conectá-lo à porta do componente N <random> e conectado aos valores aleatórios como um ângulos de racionamento para <rotate> componente. Finalmente, para definir o plano de eixo, que criou um <XZ> em cada ponto que eu avaliada na superfície e ligado ao componente I <gire> Para melhorar o desempenho do processo, antes de gerar objetos, não se esqueça de desmarcar a pré-visualização ( 'preview')

Fig. 05:17 geometria final

Fig. 05,18 Tente combinar diferentes conceitos em seus projetos. Aqui, em vez de usar valores aleatórios para as rotações das caixas, eu usei um atrator ponto e eu definir a sua distância de cada bloco como o fator de rotação, e como você pode ver, os resultados são mostrados na Fig. Estas são as técnicas locais para lidar com caixas, mas você sabe que você também pode aplicar as alterações na escala global. 86

Use a avaliação desigual Durante um projeto que veio à minha mente que não há nenhuma razão para usar uma distribuição uniforme de seus pontos de uma superfície. Gostaria de saber se você pode definir certos critérios e avaliar a área de acordo com isso e selecionar locais específicos na superfície. Desde que nós usamos os U e V parâmetros, o espaço e o conjunto de dados incrementais (ou ciclo incremental no scripting), eu também perguntou se nós são sempre limitados a uma divisão rectangular de uma superfície. Há várias perguntas sobre a identificação das faixas em uma superfície, mas aqui eu vou tentar a minha mão a um exemplo simples para mostrar como, em determinadas situações, podemos usar alguns dos parâmetros U e V de uma superfície para criar para nós mesmos em uma grade retangular não uniforme. O exemplo das colunas Eu tenho duas superfícies de forma livre para cobrir um espaço e estou pensando em criar um espaço social aberto no meio. Quero acrescentar algumas colunas entre as superfícies, mas uma vez que eles são livres forma ee não quero criar uma grade de colunas, decidi limitar o comprimento das colunas e adicionar tanto quanto possível em determinados locais com limites de altura específicas. Eu quero entrar neste espaço dois cones como colunas, invertido e cruzou para criar um formulário simples.

Fig. 5.19 entrei duas superfícies genéricos no Grasshopper, através <srf _top> e <srf_bottom> como um espaço coberto I reparametrizada. Eu também têm gerado um intervalo numérico entre zero e um, divididos por meio de um <número deslizante> e usando o componente <ponto> I avaliou estas superfícies aos pontos.

Fig. 05:20 Como resultado, I têm gerado uma série de <linha> entre todos estes pontos, e que também mediram a distância entre cada par de pontos.

Fig. 5.21 Agora eu preciso puxar minhas linhas que você quer da lista. Eu usei um componente <expedição> (Sets> Lista> Despacho) para selecionar linhas a partir da lista. Um componente <expedição> precisa de dados booleanos associados com os dados da lista, para enviar aqueles associados com TRUE para a saída A e aqueles associados com FALSE, para a saída de dados B. O booleana vem de uma função de comparação simples. Nesta função eu comparei o comprimento das linhas com números de dados como o comprimento máximo de linha (x> y, x = <número deslizante>, y = <> a distância). Cada comprimento da linha inferior do <número deslizante> criar um valor TRUE, através da sua função e passá-los através do componente <expedição> saída A. Então, se você usar as linhas que vêm de uma produção de A <

Fig. 5.22 geometria das colunas é constituída por dois cones invertidos um em relação ao outro, que se intersectam na cimeira. Porque aqui eu tenho o eixo das colunas, eu quero desenhar duas circunferências nos pontos terminais dos eixos e expulsar-los para os pontos nas curvas, de modo a tornar a interseção possível.

Fig. 05:23 Usando o componente <endpoint> eu posso ter ambas as extremidades das colunas. Então, eu posso ligar estes pontos e usá-los como base para criar pontos dos círculos com um determinado raio. Você já aprendeu que essas circunferências são planas, enquanto nossas superfícies não são. Eu, então, precisa projetar-los através do componente <project> (Curve> Util> Project) por este motivo. A parte B do <projecto> vai ser ligado à superfície inferior e superior. 89

Fig. 05:24 A última etapa é a extrusão destes circunferências projectadas no sentido de pontos específicos no eixo da coluna (Fig. 5,23). Eu usei o componente <ponto de extrusão> e eu, em seguida, conectar-se as circunferências projetadas como curvas de base. Para a extrusão de um ponto, que conectado a todos os eixos das colunas para o componente <curvo>, eu reparametrizada-los, e então avaliadas em dois parâmetros específicos distantes 0,6 e 0,4 a partir do topo da parte inferior.

Fig. 05:25 Embora neste exemplo, eu ainda usou o rastreamento com base na grelha sobre uma superfície, tenho usado critérios adicionais para a escolha de alguns pontos e não todos de uma maneira uniforme.

Fig. 05:26 modelo final A idéia de usar os espaços paramétricas de curvas e superfícies a proliferar objetos sobre as mesmas superfícies, envolve diferentes opções e métodos. Não parar em apenas um, mas tente de vários. Ainda vemos outra coisa.

dados 5_6_Alberi Falando de usar o espaço paramétrico e componentes relacionados, é hora de abrir um novo capítulo com a administração de dados sobre Grasshopper, chamado de 'data árvore' (árvore de dados), que, pouco a pouco, pode atendê-lo quando se trabalha com modelos complexos, especialmente no espaço paramétrico de curvas e superfícies. O grande potencial de algoritmos generativos são usados para criar e governar centenas de associações entre os objetos. Trabalhando com um grande número de objetos, às vezes é preciso aplicar o comando para todos os objetos simultaneamente, e às vezes precisamos para extrair um elemento para aplicar um comando. Precisamos, portanto, de ter acesso aos nossos objetos e gerenciar nossos dados (objetos) de diferentes maneiras. Digamos que você tenha 5 curvas em nosso espaço de design e ter que ser dividida em 10 partes. Agora queremos extrair todos os segundos pontos sobre essas curvas e conectá-los em conjunto com uma curva interpolada.

Fig. 05:27 A <curva> componente de matia 5 curvas no interior do gafanhoto, toda dividida em 10 partes. Se selecionar o índice numérico 1 através do componente <item> por pontos de divisão, você vai ver que não será selecionado apenas o segundo ponto da primeira curva, mas todos aqueles que têm índice 1 (ou seja, todos os segundos de todos os pontos de curvas) Bem ! Mas se conectar esses pontos a um componente <interpolar> para desenhar uma curva, você vai ver que o componente irá exibir um erro e não vai chamar qualquer coisa. Para entender o problema, nós introduzimos um componente muito útil e observar a situação. Este componente é o <param visualizador> a partir Params> Especial. Nós comparar os resultados

Fig. 5.28 componente <param espectador> mostra dentro do componente de informação interessante sobre os dados, eles fazem erro capirela por causa do componente. O que você vê em <espectador param> é o conceito da árvore dada em gafanhoto. Como pode ser visto na Figura 5.28 a <curva> componente contém 5 elementos, mas enquanto estas curvas são divididos e gerar alguns pontos para cada curva, os pontos são listados em uma lista de dados diferentes, chamados 'ramos' (ramos). Isto significa que o resultado do <componentes> não é apenas uma lista de dados contendo 55 pontos, mas agora temos cinco listas de dados, cada um com 11 pontos no interior. Isto significa que a árvore (árvore) foi dividido em ramos (ramos), a fim de facilitar o uso futuro e torná-los acessíveis de forma mais simples em nossos projetos. Portanto, quando nós selecionamos <item> índice 1, os elementos índice 1 de cada lista são selecionados 92

Fig. 5.29 <param espectador> por opção 'data de árvore' ativado a partir do menu de contexto, cuja tarefa é mostrar a diferença entre os ramos de dados em cada componente. Vamos perguntar por que o componente <interpolar> não desenhar uma curva: onde está o problema? Vamos dar uma olhada em informações retiradas de nossa situação.

A Fig. 5:30 <Param espectador> e <Painel> A: curvas e B: As selecções de pontos de índice 1 93

Na primeira imagem da figura 5.30 <param Visualizador> componente <curvo> mostra um dos principais ramos. Se você olhar para o seu painel, você verá que há uma lista de curvas sob o título {0}. Aqui Gafanhoto em uma {} representa o símbolo árvore dos dados e mostrar os ramos em que os objetos são colocados. Assim, todas as curvas na primeira imagem abaixo {0} está localizado no ramo principal. Se você voltar a Fig. 05:28 você vai ver que o <param espectador> para as curvas indicam (Caminhos = 1) o que significa que temos um ramo de dados neste ramo {0} (N = 5) temos 5 elementos. Mas na segunda imagem da Fig. 5.30, podemos ver que os dados no componente <item> adicionado à lista em 5 ramos diferentes e quando transferidos dentro de uma <interpolate>, Eles são separados um do outro e o componente <interpolado> não é possível desenhar o polígono por 5 pontos separados. Como podemos resolver o problema?

Fig. 5.31 Para resolver o problema eu usei o componente <achatam> (Sets> Tree) que, como o nome indica, converte os dados de várias ramificações em um único ramo, visto em <param espectador>. Como você pode ver na segunda <painel> agora temos 5 pontos abaixo do ramo {0} e o componente <interpolate> pode desenhar um polígono através destes cinco pontos.

Para resumir, devemos entender que, trabalhando com diferentes níveis de vários objetos, os dados são organizados em uma estrutura hierárquica galhos de árvores, e cada ramo de dados tem o seu próprio caminho e índice numérico que mostra o seu endereço exclusivo do ramo (por exemplo { 0; 1}). É importante saber que trabalhar com componentes que gerenciam as listas, devem submeter-se às regras de trabalho em cada ramo como se fossem listas separadas. Vamos precisar, além disso, é gerar dados em nome de nossas agências é reunir as ramificações de dados em um único fluxo, ou outro processamento de dados. Em experimentos subseqüentes eu tentei colocar em prática estas situações.

Fig. 5.32 dados Antler em uma 'árvore date' Para concluir esta questão, vemos outro exemplo. O nosso objectivo é o de conceber uma superfície perfurada, tal como a esquematizada na fig. 5:33 com base em uma determinada superfície. O processo será tratada com rapidez para ver imediatamente o resultado final.

Fig. 05:33 Esboço da superfície desejada. Para chamar a esta superfície perfurada, que deseja gerar muitas pequenas linhas na borda superior e na parte inferior da superfície e uni-los por meio de um loft. Isto irá criar muitas pequenas superfícies, todos

juntos, eles vão dar a idéia da minha superfície perfurada. Devo prestar atenção à direção das linhas, a fim de controlar as mudanças graduais das superfícies, e então o resultado final.

Fig. 5:34 Eu apresentei um genérico <superfície> na tela e eu explodi através <BREP Componentes> (Surface> Análise> BREP Componentes) para ter acesso a suas bordas. Então, eu selecionei as bordas superior e inferior com <item> através do índice 0 e 2.

Fig. 05:35. Eu apliquei uma distância de deslocamento para a borda inferior e eu também mudou a direção da borda superior com <flip> (Curve> Util> Flip) porque eu sei que as duas bordas não têm a mesma direção. Neste ponto, eu usei o componente <divisão> dividindo essas bordas e têm um conjunto de pontos de gerir (Podemos também usar um único componente <splits> mas agora preferem não torná-lo mais complexo).

Fig. 05:36 O componente <A linha> foi usado para ligar os pontos da parte inferior para os pontos que estão espaçados entre si na curva a partir da borda inferior. Outro componente <line> é usado para conectar todos os pontos pertencentes à borda superior com o seu próximo ponto na lista (shift offset = 1)

Fig. 05:37 Se você agora usar os componentes <linha> para fazer um loft, veremos que gera uma superfície, mas não o que eu quero. O uso do componente <Aceno> não ajuda. 97

Fig. 05:38 Se olharmos para o <param espectador> de <componentes da linha>, veremos que ambos têm um único ramo de dados e, em seguida, o loft não foi aplicada a pares separados de linhas, mas a um único bloco. Claramente eu quero que as linhas são inseridas em diferentes listas para ser tratado como dados individuais e, quando utilizado para o loft, tornar-se pares de linhas.

Fig. 05:39 Para resolver este problema eu usei um componente muito útil, os <Graft> (Sets> Tree> Graft Árvore>. Como você pode ver, como resultado, temos que as listas de dados em ambas as <componentes da linha> foram divididos em ramos, um ramo para cada elemento da lista. Agora o componente <sótão> pode criar a superfície de cada linha da primeira lista de dados para uma linha associada na segunda lista de dados. neste ponto, podemos ver que o resultado é espirrado geometria anteriormente. Aqui, ao contrário do primeiro exemplo, encomendar os nossos dados em diferentes ramos para resultado geometrias múltipla, caso contrário, vamos ter tido uma única superfície contínua.

Fig. 05:40 Gostaria de lembrar que se você quiser desenhar uma curva interpolada loop para pontos específicos, a partir de uma superfície estimada, temos que a lista de dados 'suave' com o componente <achatar>, criando um ramo de dados para pontos e passá-las para a curva interpolados. Isso ocorre porque todas estas superfícies são inseridos em diferentes ramos, bem como os pontos avaliadas. Devemos, portanto, entender que em vários componentes e situação de projecto, precisamos processar os dados em um ou mais ramos. Os componentes que podem nos ajudar, vamos encontrá-los na Sets> Árvore

Fig. 05:41 modelo final da superfície. 99

CAPITOLO_ 6_Deformazioni e Morphing

100

6_1_Deformazioni e Morphing A geometria nem sempre é feito de objetos puros. A fim de realizar certos tipos de projectos, é preciso mudar as porções e condições gerais de volumes geométricos e outros produtos. A deformação e morphing estão entre as características mais poderosas do campo do design de forma livre. Através das deformações, podemos torcer, inclinação, geometrias de curvatura e através do morphing pode transformar geometrias de uma condição para outra limite. Vamos olhar para uma deformação simples. Se tivermos um objeto, tal como Sphere, sabemos que há uma caixa delimitadora (gaiola) em torno de cuja manipulação distorce toda a geometria.

Fig. 6.1 Deformação de um objecto através da caixa delimitadora. Dependendo do tipo de transformação (se feito através de um ângulo, o deslocamento, etc), pode-se chamar inclinação, flexão ou deformação livre. Para cada função deformação, podemos exigir toda a caixa delimitadora, ou apenas um de seus lados, como piso ou um dos seus pontos. Se você verificar os vários componentes para as deformações, você pode facilmente encontrar as construções geométricas básicas, a fim de obter a deformação. No campo animação Morphing termo indica o processo de transição a partir de uma imagem para outra em uma leve e suave. Os componentes de Morphing em Grasshopper, funcionam da mesma maneira. Por exemplo, aqui o componente <Box Morph> (Xform> Morph> Box Morph) deforma um objeto através de um paralelepípedo de referência (limite Parallelepipedo), em um paralelepípedo de destino (destino caixa), enquanto o <Superfície Morph> componente funciona com uma superfície com base no qual é possível, no domínio especificado, deforme sua geometria e altura do objeto. Na guia Xform você vai encontrar <Box Morph>, <Superfície Morph> e outro add-ons que pode fornecer para a recolha de dados. Dado que tem vários comandos que se deformam de um paralelepípedo, se usarmos estes paralelepípedos deformada em paralelepípedos alvo, em seguida, que pode deformar-se cada geometria em Gafanhoto através da combinação da Caixa componente Morph. Como você pode ver na Figura 6.2, temos um objeto importado através do Grasshopper 101

componente <geometria>. Este item está inscrito em uma caixa delimitadora que eu projetei apenas para melhorar a exibição. Eu também desenhou uma outra caixa com a entrada manual.

A Fig. 6.2 O objecto inicial (esfera) e o paralelepípedo definido manualmente.

A Fig. 6.3 Um componente <Caixa transformar> (Xform> Morph> Caixa Morph) deforma-se um objecto a partir de uma referência paralelepípedo para um paralelepípedo alvo. Desde que eu tenho apenas um objeto, eu conectado tanto como geometria que como uma caixa de referência (no caso de várias geometrias pode usar o <Caixa delimitadora> componente (Surface> Primitive> Caixa delimitadora>)). Eu desmarcada a estréia de <caixa> para ver mais da geometria transformada.

102

Fig. 6.4 Agora, a alteração do tamanho do paralelepípedo alvo pode ver a geometria modificada.

Fig. 6.5 Aqui podemos ver que em vez de uma caixa, se eu produzir uma série de rectangular posso começar a editar meus artigos com Morph mais de uma vez. Como você pode ver, os paralelepípedos diferenciar através do componente <series> em sua dimensão Y, causando diferenças nos objetos modificados.

6_2_ panelization Uma das aplicações mais comuns de morphing é a painéis. Esta idéia vem da divisão de uma forma livre de superfície em pequenas partes, especialmente para fins produtivos. Embora as superfícies de forma livre são amplamente utilizados na indústria automobilística, não é fácil para transferilos na arquitetura para uso em maior escala. As vantagens de pannallizzazione são aqueles para dividir uma área em pequenas partes (componentes chamadas) tornando mais fácil o processo de fabricação e transporte, tornando-os também mais controlável em termos de precisão do produto final. É também possível', por vezes, para dividir uma superfície curva em pequenas peças planas e, em seguida obter a curvatura total do conjunto das geometrias planas que podem ser produzidos a partir de folhas de material. 103

Começamos com uma superfície simples e um componente como um módulo para panelize a superfície.

Fig. 6.6 Uma superfície de curva dupla genérico pronto para ladrilhos.

Fig. 6.7 A componente que eu quero usar para preencher a área .... nada de especial, apenas um exemplo.

Fig.6.8 Primeiro de tudo o que preciso para importar a superfície e o objecto a ser repetido como o componente do gafanhoto. Referindo-se aos componentes disponíveis no gafanhoto, que pode gerar diferentes paralelepípedo na superfície e utilizadas como objectos alvo, e applicargli forma transformada. Então eu importou um <caixa de metamorfose> e eu usei a forma como geometria e como uma caixa delimitadora. Agora eu preciso para gerar o cubóide alvo para fazer componente Morph.

104

Figura 6.9 O componente eu preciso para criar o alvo retangular é <Caixa de superfície> (Xform> Morph> Caixa de Superfície). Este componente gera paralelepípedos sobre uma superfície, de acordo com o intervalo indicado pelo domínio de superfície e a altura do paralelepípedo. Eu, então, conectado à superfície e o resultado será o alvo para o componente <caixa de metamorfose>. Preciso para definir o domínio de paralelepípedos, ou dividir o intervalo numérico da superfície nas suas direções U e V, para criar os paralelepípedos.

Fig. 06:10 A fim de dividir o domínio da superfície, eu usei <divide interval2> que conta a <Caixa de superfície>, quantas divisões em U e V são necessárias. Outra <número deslizante>, define a altura do alvo paralelepípedo, isto é, os componentes processados. Então, basicamente, a idéia é simples. Criamos um módulo (um componente) e chamar a nossa área. Por isso, gerar a quantidade de paralelepípedos acima desta superfície (tal como paralelepípedo alvo), e, em seguida, morfizziamo o módulo em paralelepípedos. Após esta etapa, será possível alterar o número de elementos em ambas as direções U e V, e também mudar a forma e ter sempre uma actualização dinâmica sobre a superfície.

105

Fig. 6.11 superfície final criada com a forma.

nível micro 6_3_Manipolazioni Embora seja grande para gerenciar uma forma em uma superfície, pode parecer que esta é uma forma genérica de design. Sabemos que podemos mudar o número de módulos, ou alterar o próprio módulo, mas o resultado será uma área geral e não teremos controle local do nosso sistema. Então, eu estou pensando sobre a criação de um sistema baseado em componentes que nos permitam ter mais controle e lhe permitem projetar superfícies genéricos que não cumprem todos os critérios para micro-escala. A fim de introduzir o conceito, antes de começar com um exemplo simples, e, em seguida, avançar para uma forma mais prática. Nós usamos a idéia de atratores para aplicar manipulações locais a um grupo de objetos. Estou pensando em aplicar o mesmo método para projetar um sistema baseado em componentes com manipulações datas locais de um atrator. A ideia é a de mudar o tamanho do componente (neste caso, a altura) de acordo com os efeitos de um ponto atractor.

106

A Fig. 06:12 Vamos olhar para os ingredientes: uma superfície de dupla curvatura importado através de um <base_srf>, um cone importados como <component> no Grasshopper, um <divide interval2> para a divisão da superfície, e uma <caixa delimitadora> como referência paralelepípedo. Mais tarde, alterar o tamanho da caixa delimitadora, eu posso mudar o tamanho de todos os meus componentes em <base_Srf> graças à mudança de caixa de referência. A altura de entrada de componente <Caixa de superfície> o exige a altura do paralelepípedo no intervalo dado. A idéia é usar alturas relativas em vez da constante. Assim, em vez de números, podemos criar as relações entre as posições de cada bloco e os pontos atratores e gerar números diferentes como alturas associativos.

O que eu preciso agora é medir a distância entre cada bloco e o atrator. O problema técnico é que não há ainda nenhum cubóide gerado, então eu preciso de um ponto na superfície, o que viria a se tornar o centro de cada bloco, para medir a distância.

Fig. 6.13 Aqui eu usei a mesma <divide interval2> eu quero usar para <Caixa de superfície>, para um componente <isotrim> (Surface> Util> Isotrim). Este componente divide a superfície em subsuperfícies. Através destes sub-superfícies pode utilizar outro componente <BREP Área> (Superfície> Análise> área BREP) para usar o subproduto deste componente, isto é, o 'Centróide' para cada sub-superfície. I medida a distância entre estes pontos (centróides) de <atractor> para uso como um factor de referência para a altura paralelepípedo alvo no componente <caixa de superfície> 107

Fig. 06:14 Agora dividida pela distância medida com um número feita a partir de uma <número deslizante> para controlar o efeito do atractor e I utilizado o resultado como entrada para a altura, de modo a gerar alvo rectangular com componente <a superfície caixa>. A superfície vem <base_Srf>, o <divide_interval2> retorna o domínio da superfície, enquanto que a altura é dada pela relação entre a posição do paralelepípedo e o atractor. Como você pode ver, as alturas dos paralelepípedos são diferentes, dependendo das posições de ponto <atrator>.

Fig. 06:15 Para a parte restante, ligar o <componente>, paralelepípedos e dimensionado <caixa de superfície> componente <caixa de metamorfose> que produzem os componentes sobre a superfície. Ao alterar o fator de escala, você pode alterar o tamanho de todos os componentes e como sempre, a posição dos atratores, será controlado manualmente.

108

Fig. 06:16 modelo final Como você pode ver, o tamanho dos componentes vai começar a aceitar manipulações locais com base em propriedades externas que são os pontos de atracção. Embora o conceito é baseado em um atrator simples, o resultado poderia ser interessante e a ideia é mostrar que podemos diferenciar entre retangular e obter resultados diferentes. Sabemos agora que o conceito de morphing e painéis não são necessariamente genérico. Tendo provado o conceito, continuamos com outro experimento prático.

6_4_ Modulação reactivo Para nosso experimento design, a ideia é para modular uma determinada superfície com um controle em cada módulo, o que significa que cada módulo deste sistema deve atender a certos critérios específicos. Então, ainda mais da diferenciação local dos módulos, aqui eu quero ter uma verificação específica no meu sistema, através dos dados critérios que podem ser ambientais, funcional, visual ou qualquer outro comportamento associativa à qual queremos que o nosso formulário de resposta. No próximo exemplo, a fim de fazer o envelope de um edifício, o ambiente reativo em que está localizado, eu quero usar um sistema que responde de acordo com a luz solar. Em seus experimentos, a variável pode ser o vento, a chuva ou as funções internas, ou quaisquer outros critérios que você precisa, bem como a combinação destes. Tenho aqui uma superfície simples como a casca de um edifício que eu quero cobrir com dois tipos diferentes de componentes. O primeiro é fechado e não permite a penetração de luz solar, enquanto que a outra das aberturas. Estes componentes devem proliferar sobre o invólucro de acordo com a direcção principal de 109

luz solar no site. Eu usei um ângulo definido pelo usuário para dizer o algoritmo que um certo grau de incidência de luz solar, temos de ter um componente fechado, e para outros, uma aberta. A definição Grasshopper não contém nada de novo, mas o conceito me permite criar as variações sobre o revestimento em vez de criar uma superfície genérica. Basicamente, quando a superfície livre é de tipo de formulário, move-se e tem diferentes orientações, os ataques a luz solar de ambas as direcções para diferentes graus de incidência. Dependendo da diferença angular entre a superfície e a luz solar, esta variação no componente toma lugar no sistema

Fig. 6:17 primeiros esboços da forma reactiva de um sistema de cortina ingredientes:

Fig. 06:18 a superfície exterior de um edifício como um embrulho que panelize

110

Fig. 06:19 Os dois tipos diferentes de componentes para panelizing

Fig. 6.20 O primeiro passo é similar ao anterior. I introduziu uma <superfície> e eu usei <dividir interval2> dividi-lo nas direções U e V. I criados através de <Caixa de superfície> o alvo retangular. Eu também usei <isotrim> com o mesmo período do bar retangular para encontrar a localização do mesmo na superfície, e eu inserido um <BREP área> para encontrar o centróide desta área (selecionado em verde). Ao mesmo tempo que eu usei uma <curva> componente principal para importar o ângulo da luz solar do local e os seus pontos finais <> I criado um <vector 2pt> que especifica a direcção da luz solar. Você pode manipular e alterar esta curva para ver o efeito da luz solar sobre os componentes em diferentes direções. Como você pode ver na primeira imagem, há uma superfície - o invólucro - dividido em partes para gerar os componentes e há também um portador para a luz do sol. Eu quero saber o ângulo entre esse vetor ea superfície na posição de cada componente. Eu tenho que ter um único resultado para o cálculo do ângulo ea melhor maneira é usar a superfície normal que é único para cada ponto. Um normal é um vector perpendicular à superfície de um determinado ponto, então pode usá-lo para controlar o ângulo de cada componente.

111

A Fig. 06:21 A fim de avaliar o ângulo entre a luz solar e a superfície, que deseja medir esta ancol entre a luz solar e a normal à superfície na posição de cada componente. I pode então decidir para cada variedade de ângulos, que tipo de componente pode ser bom. Então, depois de gerar os pontos principais, eu preciso do normal à superfície e usar esses parâmetros para <avaliar> superfície nestes pontos, a fim de ter o normal da superfície nestes pontos.

Fig. 6.22 Agora eu tenho usado um componente <ângulo> (Vector>> ângulo) para avaliar o ângulo entre a direção do sol e da fachada. Eu, então, convertido este ângulo em graus e eu usei um <function> para ver se este ângulo é maior do que <ângulo max> ou não. Esta função (x> y) retorna dados booleano: TRUE para ângulos menores, e FALSE para os grandes

112

A Fig. 6.23 Com base em dados Booleanas da comparação dos cantos, que criou um <expedição> componente que envia os dados que são o alvo rectangular (I têm vários rectangular alvo, tais como centrais eléctricas e pontos normais, de modo que pode usar rectangular em vez de pontos). Então eu dividi meu alvo retangular em dois grupos diferentes, onde a diferença é o ângulo que recebem da fonte de luz. O resto do algoritmo é simples e semelhante ao anterior. Eu só preciso transformar meus componentes em um alvo cubóide retangular, aqui estão dois.

113

Fig. 06:24 Aqui eu introduziram dois componentes diferentes geometria única e usou dois dos componentes <caixa de metamorfose> como, cada um dados enviados (com <expedição>) associado a uma peça gerando componentes <c_close> ou para <c_Abra> na fachada.

Fig. 06:25 Se agora olhar mais de perto, podemos ver que as diferentes partes da fachada, e de acordo com a sua curvatura e direção, gera diferentes tipos de componentes. Fig. 06:26 modelo final. A bifurcação do alvo paralelepípedo (e componentes) pode ser mais complexo e não constituída por apenas dois algoritmos. Depende de nosso projeto e os critérios utilizados.

114

Podemos pensar em uma fachada com base nos componentes, em que alguns deles estão fechados e outros abertos. Aqueles aberta tem peças ajustáveis dos quais são orientados em relação às forças externas e também refletem as funções internas do edifício e assim por diante. Você pode ver que a idéia é ter um controle sobre a micro escala no sistema e permite designs genéricos. E também é claro que ainda temos um controle global (na superfície) e local (componentes).

115

CAPÍTULO 7 Superfícies NURBS e malha

116

7_1 superfícies NURBS paramétricos No capítulo anterior, fizemos várias experiências com superfícies tratando a ferramenta Loft para criá-los. Nós também utilizados NURBS superfícies de forma livre. Em muitos casos, a geração das superfícies depende de outras geometrias de base, tais como curvas ou pontos. Dentro Grasshopper, existem vários componentes para criar essas geometrias, e para aqueles de vocês que têm um pouco de experiência em modelagem tradicional com Rhinoceros, estes devem ser conhecidos. As superfícies geométricas parecem ser o produto final do nosso projeto, pois representam fachadas, paredes, etc., e é por isso que precisamos de um monte de trabalho para gerar dados como pontos e curvas que servem como as geometrias básicas. Aqui eu decidi projetar um edifício de uma forma esquemática e muito simples, apenas para indicar que os inúmeros componentes do Grasshopper têm o potencial para desenhar objetos diferentes com construção simples. Eu sei que o processo de design por si só pode ser insatisfatória, mas aqui eu só quero concentrar-se no uso dos novos componentes. Torre paramétrico Na porta do Tamisa em Londres, perto de canário warf, onde os edifícios podem ser construídos muito elevada, há o potencial para construir torres. Suponha que você crie um conjunto, maneira realmente simples e esquemático apenas para testar algumas das ideias básicas para trabalhar com superfícies de forma livre. Vamos olhar para a área

Fig 7.1 Vista da área, Canary Warf, Londres (Image: www.maps.live.com, Microsoft Virtual Earth).. O site I escolheu para o projeto é na margem do Tamisa, com um grande prestígio com vista para o rio e perto da área praça da entrada de Canary Warf Central (Westferry Road). Eu não quero ser muito específico sobre o site, então vamos apenas olhar para o lugar onde eu vou propor o projeto e continuar com temas geométricos.

117

Fig. 7.2 Área para a torre proposta. desenho da mão Existem várias formas de iniciar este projecto. Posso desenhar o piso térreo e copiá-lo para o topo, começar a manipulá-lo e adicionar detalhes. Eu decidi usar alguns componentes para a superfície, de modo que a técnica pode não ser apropriada, mas o objectivo é expandir nossos experimentos, também porque eu tenho certeza que você já procurou na web e já tinha em mente várias idéias para trabalhar na torre associativamente. A idéia que tenho em mente não está bem definida, mas eu sei que minha torre terá uma superfície de vidro em geral, coberto por alguns elementos lineares na fachada. Desde que eu não gosto de projetar uma torre convencional, ele também tem alguns espaços ocos em sua camada externa, espalhadas ao longo da fachada. Estes volumes devem se cruzam com os elementos lineares, a fim de cortá-los. Eu também quero desenhar um espaço público perto do rio e se conectar a torre com os mesmos elementos de fachada, de modo a criar uma continuidade da torre na curva do rio. Como você pode ver na Figura 7.3 que eu desenhei minhas curvas básicas manualmente no rinoceronte. Estas curvas correspondem a um sítio específico, para limitação na altura e a forma e as arestas. O primeiro canto foi concebido e, em seguida, espelhado na próxima esquina e novamente espelhado pela próxima e assim por diante. Duas outras curvas foram desenhadas como as bordas do espaço público, que partem do chão e depois se levantam para ser paralelo às bordas da torre. Tenha em mente que estas são curvas experimentais e ou pode desenhar o que quiser e ir para a parte que falta.

118

Fig. 7.3 As linhas de base para o local da torre elementos básicos para a fachada

Fig. 7.4 como um primeiro passo, que importou estes quatro curvas em Gafanhoto através de um <curva> componente I e em seguida dividida com <divide curvas> em 40 partes como os andares da torre. Como você pode ver, os pontos resultantes da divisão são dispostos em diferentes ramos de dados.

Fig. 7.5 Agora tenho de desenhar as curvas de base com esses pontos de divisão, para obter os mesmos elementos da fachada. Quero desenhar linhas por pontos de divisão para cada curva para o ponto correspondente da curva seguinte. Para fazer isso, eu usei um <explodir árvore> renomeando <golpe!> (Sets> Tree> Explode árvore) para acessar a estadia diferente separadamente. Eu adicionei 119

linhas de todos os pontos dos ramos para os subsequentes.

Fig. 7.6 Neste passo eu adicionados os espaços ocos para a fachada, com uma distribuição aleatória. Eles são elipsóides importantes Grasshopper juntamente com o componente <geometria>. Eu também ter combinado todas as linhas geradas anteriormente, através do componente <merge>.

Fig. 7.7 Neste passo eu corte (componente <aparar>), e (<>) de intercalação linhas combinadas com essas geometrias. O componente <aparar> retorna as peças cortadas dentro e fora da área de corte. Aqui eu usei a parte externa. I extrudido peças, tais como os elementos lineares de fachada.

120

A Fig. 7.8 Este é uma curva fechada que liga todos os quatro lados da planta torre. Desde que preciso para criar superfícies diferentes, eu explodida da curva (<explodir>) para obter os segmentos e I também utilizado <enxerto> para gerar um ramo para cada curva. Desde que eu tenho uma seção plana e duas curvas de ponta que definem o imite da fachada de cada lado, eu quero usar o componente <varrer 2> para criar a superfície fachada com a varredura de 2 faixas.

Fig. 7.9 I inserido um componente <varrer 2> para gerar as superfícies de fachada. I utilizados plana curvada enxertados <enxerto> como secções transversais para a varredura. As faixas vão ser os bordos de curvas. O componente <receiver> está ligado às curvas de ponta. I depois enxertado (<enxerto>) uma vez e movimento (<mudança>) e ainda enxertado (<enxerto>) para gerar todas as primeiras e segundas curvas de carril associado com as curvas de secção plana. !! Nota: Se você não obter o mesmo resultado que a imagem, a ordem das curvas de borda (binário) não está corretamente associado ao pedido de curvas planas (curvas de seção) e, em seguida, você tem que mudar a ordem das curvas de ponta na lista, ou manualmente para riassegnandole

121

componente <curva> em uma ordem diferente ou movendo a lista no Grasshopper

A Fig. 7.10 Nesta etapa queremos subtrair os espaços ocos <Geo> da fachada gerado anteriormente. Uma vez que a direcção das normais das superfícies é crítico para este comando, eu invertido (<flip>) normal das superfícies e o resultado é a superfície principal com o <Geo> que foi removido.

Fig. 07:11 Com o mesmo procedimento, eu importados ambas as curvas do espaço público, ele uniformes, explodiu e traçada entre suas outras linhas. Posso conectar esses componentes <line> ao mesmo componente <extrusão> qual elemento fachada para gerar geometrias idênticas.

Fig. 07:12 Após a geração das geometrias, preparados (bake) os componentes <diferenca> e <extrusão>. 122

Fig. 07:13 versĂŁo final do modelo.

123

7_2_ Topologia e Geometria Até agora usamos componentes diferentes e trabalhou com superfícies NURBS. Mas, como já mencionado, existem outros tipos de superfícies e em outros contextos, são úteis. Nem sempre quer alcançar a beleza ea doçura de NURBS, mas precisamos de um controle mais preciso dos processos mais simples ou equações mais fáceis. Além disso a superfície clássico de revolução, linhas ou tubos, têm diferentes superfícies de forma livre, como de Bezier, ou B-spline. Vamos agora analisar a questão da malha, que representam um outro tipo de superfície. Os malha representar um outro tipo de superfícies de forma livre, composto por pequenas peças (faces) cuja acumulação cria a superfície inteira. Não há, portanto função matemática ou interno escondido que gera a forma da superfície, o que é em vez disso definido pelo conjunto de faces. Observando a malha, vamos focar nos rostos. Estes podem ser triangular, rectangular ou hexagonal. Olhando para eles com mais cuidado, podemos ver a grade de pontos que os cria. Estes pontos são os elementos básicos de superfície da malha. Cada pequeno grupo destes pontos (por exemplo, todos os três na malha triangular) criar uma face, e com o resto da geometria tornase uma superfície. Estes pontos são ligados uns aos outros por linhas rectas. Existem dois conceitos básicos que se relacionam com a malha: a localização desses pontos e sua conexão. A posição dos pontos está ligada à malha da geometria e dos pontos de ligação é ligado à topologia. Geometria vs Topologia Enquanto a geometria tem a ver com a posição dos objetos no espaço, a topologia refere ao seu relacionamento. Matematicamente falando, a topologia representa as propriedades dos objetos que as transformações e deformações não pode mudar. Assim, por exemplo, um círculo e um elipse são topologicamente idênticas, e têm apenas diferenças geométricas. Vamos observar a fig. 7.14. Como você pode ver, existem quatro pontos ligados entre si. Na primeira imagem, tanto A e B têm a mesma topologia porque eles têm a mesma relação entre os seus pontos (mesma conexão). Eles são, no entanto, geometricamente diferente, devido ao deslocamento de um ponto. Na segunda imagem, a geometria dos pontos é a mesma, enquanto a sua ligação é diferente e eles não são topologicamente equivalente.

Fig. 07:14 Topologia e Geometria O conceito de topologia é muito importante para a malha. Cada face de um objecto de malha, tem os pontos angulares e estes pontos são ligados uns aos outros com uma ordem idêntica para todas as faces objecto de malha. Podemos então aplicar cada transformação para um objeto de malha e mover os seus vértices no espaço, mesmo se não uniforme, mas a ligação dos vértices 124

Deve ser preservada a fim de preservar os rostos, caso contrário ele entrará em colapso.

Fig. 07:15 superfície Ambos vermelho e cinza são malha com as mesmas faces e vértices. Em que os vértices de cinza são movidos, criando uma configuração geométrica diferente da malha, mas a conectividade da malha não é alterado e ambas as superfícies são topologicamente idênticos. Então, nós sabemos a importância dos aspectos topológicos na malha, que são geometrias muito poderosas, enquanto temos vários pontos e precisamos para representar um tipo de superfície como um espaço contínuo. Podemos aplicar a malha diferentes tipos de algoritmos que trabalham com os pontos, porque eles preservar a topologia. Por exemplo, utilizando análise de elemento finito, ou aplicações específicas, tais como relaxamento dinâmico, e sistemas de partículas, que é mais fácil de trabalhar com a malha do que com outros tipos de superfícies, porque a função pode trabalhar com os vértices de malha. As malhas são fáceis de melhorar e mais rápido para trabalhar, mas eles podem conter buracos e descontinuidades na sua geometria. Existem vários algoritmos para refinar a malha e criam as superfícies mais lisas. Porque diferentes faces podem inicialmente ter cores diferentes, as malhas são bons para a representação para fins de análise (por cor). Na aba 'malha', podemos encontrar diferentes componentes que trabalham com este tipo de geometria.

7_3_Mesh Eu tenho um monte de pontos e eu quero criar, através da mesma, uma superfície. Neste exemplo, o grupo de pontos é simplificada em uma estrutura de grade. Estou pensando em uma grade vertical que representa os parâmetros básicos de uma superfície, que é enviado para o efeito de um vento imaginário. Quero então mover esses pontos de acordo com o factor de vento (ou em relação a qualquer força que pode ser representada por um vector), e representam a superfície deformada resultante. Então, mudando o fator vento, podemos ver como o resultado deste a superfície vai reagir em conformidade.

125

Fig. 7.16 O primeiro passo é simples. Usando um componente <series> com um número de pontos geridos pelo controle deslizante <N_pt> e uma distância entre eles definido por <distance_pt> (ainda um controle deslizante), eu criei uma grade de pontos criados com a referência cruzada. Pressionando este vento imaginário, afeta todos os pontos da grade. No entanto Vamos fingir que a força dos aumentos de vento quando vamos para cima, então a pressão do vento aumenta com maiores valores de Z. Ao mesmo tempo, a força do vento, influenciar os pontos internos de mais pontos perto das bordas. Os pontos da extremidade da secção plana não se mover em todos os pontos fixos ().

Fig. 07:17 diagrama de vento que influencia a superfície. A: seção; efeito vertical da força, B: planta; efeito horizontal. Basicamente preciso de dois mecanismos diferentes para modelar estes efeitos, uma para o diagrama em corte, e uma outra para a planta. Eu simplificaram as equações apenas para imitar a forma como queremos que o ato forças. Para este primeiro mecanismo montamos uma equação matemática simples; I utilizado (X ^ 2), onde X é o valor de Z do ponto submetido a 126

força. Assim, para cada ponto que eu preciso extrair as coordenadas de Z. Para simplificar as coisas, eu fingi que a direção da força é a do Y, em relação ao sistema global de coordenadas. Assim, para cada ponto da grelha, preciso gerar um vector na direcção Y e a força que definida através do número que recebeu a partir das coordenadas do ponto Z. Para o segundo diagrama precisamos de algo mais do que uma equação. Vejamos a primeira parte.

Fig. Coordenadas 07:18 Z de pontos extraídos através do componente <decompor> e, em seguida, activado por uma função X ^ 2 e dividido por um número passado por um <número deslizante> para controlar a circulação geral. O resultado é um factor que multiplica (<multiplicar>) o vector de força (Vector>> Multiplicar), que é um vector simples <unidade Y> em comparação com o sistema global.

Fig. 19.7 Movendo os pontos com estes vectores pode ver a grelha de pontos resultante que satisfaz o primeiro passo do presente processo.

Vejamos agora a segunda parte das forças descritas na seção planar dos pontos nas bordas permanecem fixas, enquanto os pontos no meio de mover-se mais do que os outros. A Fig. 07:20 mostra esta mudança para cada linha dos pontos de quadriculado. 127

Fig. 7:20 movimentos em pontos fileira (vista em planta). Uma vez que para cada ponto eu tenho os vetores de força, eu tenho de controlá-los, e defina o valor de novo, para se certificar de que a sua deslocação na seção planar satisfazer o segundo critério. Então, para cada linha de pontos na grade eu quero gerar um fator que controla a magnitude do vetor. Aqui presumi que, para os pontos no meio, os vectores de força irá ser, no máximo, enquanto que para os pontos das bordas tornar-se zero, isto é, um deslocamento zero. Os outros pontos de um valor de força, e, em seguida, o intermediário de deslocamento.

Fig. 07:21 Para o segundo mecanismo, que precisa de um <gama> e entre 0 e 1 a ser aplicada a cada ponto. 0 para a borda e uma para o centro. Então eu preciso de uma escala de 0 a 1 awfull a partir da borda para o centro e que varia de 1 a 0 do centro para a borda. Eu preciso desse componente <range> gerar valores em quantidades iguais ao número de pontos para cada linha. I definir as <N_pt> para gerar apenas números pares e dividi-los por 2, então eu subtraído 1 (porque o componente <range> leva o número destas divisões e não os valores dos números). Você vê que a primeira <painel> Nossos quatro números entre 0 e 1 para a primeira metade dos pontos. Eu, então, reverteu uma lista e eu ter ligado ao outro. Como você pode ver no segundo painel, eu ter gerado uma lista de 0 a 1 a 0, e os números dos valores na lista é o mesmo que o número de pontos em cada linha. O último passo é gerar esses itens para todos os pontos do grid. Eu, então, duplicar (<duplicar>) pontos em uma quantidade igual a <N_pt> (os números das linhas e colunas são os mesmos). Agora tenho um fator em todos os pontos da rede, com base em sua posição na sua linha.

128

Fig. 7.22 Agora eu preciso multiplicar (<multiplicam>) ainda vetores de força para novos fatores. Se eu mover os pontos com estes novos vetores, podemos ver como dois mecanismos diferentes agir em toda a grade de pontos. Na verdade, esta parte da amostra precisa de uma análise mais detalhada. Os métodos que os de Sistemas de Partículas Primavera (Sistemas de partículas primavera) ou Análise de Elementos Finitos (Finite Element Analysis) usam o conceito de que todas as transportadoras afetam pontos e definir pontos de influência com o outro. Então, quando forças aplicadas todos os pontos são afetados e esses pontos vão influenciar uns aos outros ao mesmo tempo. Este processo deve ser calculada em loops iterativos, de modo a calcular a totalidade da posição resto do sistema. Aqui eu só quero tomar um exemplo simples, sem estes efeitos, e eu só quero te mostrar uma representação simples de um tipo de sistema que se comunica com múltiplas forças. Eu costumava equações matemáticas muito simples, A idéia diz respeito à representação malha do processo, em seguida, vemos a parte relativa à geração de malha malha

Fig. 07:23 Geração de malha. Agora você pode simplesmente adicionar um componente <malha> (Mesh> Primitive> Mesh) na tela e se conectar todos os pontos que foram movidos para seu topo você vai ver que no cenário, nada acontece. Precisamos definir as faces da geometria da malha a ser gerado. As faces da malha são uma série de números que definem a forma em que os pontos 129

Eles estão interligados para criar rostos para cada superfície. Em seguida, os vértices são partes geométricas da malha, mas agora precisamos da definição de malha topológico, a fim de ser capaz de gerar. A cada 4 pontos de canto da grade, definindo uma face do disco para a objeto de malha. Se olharmos para os pontos de grade, veremos que existem índices numéricos para cada ponto de grade. Sabemos que cada ponto através de seu índice, e sabemos que este substitui as coordenadas de modo a ser capaz de conversar com sua topologia.

Fig. 07:24 índice numérico dos pontos na grade Para definir as faces da malha, é preciso rotular os 4 pontos de canto acreditamos ser um rosto, mettergli juntos e passar o componente <malha>, a fim de criar a superfície.

Fig. 07:25 Em uma determinada rede de pontos, um simples quadrante é definida por uma sequência de pontos que são ligados através de uma curva, criando uma cara. A curva começa a partir de um ponto da grelha, move-se para o ponto seguinte, e, em seguida, em que a próxima linha, para trás uma coluna remanescente na mesma linha, e fecha de volta para o primeiro ponto. Vemos que o primeiro rosto, em sua definição consiste de itens [0,1,6,5]. A segunda face é [1,2,7,6] e assim por diante.

130

Para definir os rostos de toda a malha, vamos encontrar a relação entre estes pontos e, em seguida, criar um algoritmo que gera a regra para a criação de rostos. Se olharmos para a face da matriz, vemos que para cada primeiro primeiro ponto, podemos definir o segundo como o próximo na grade. Em seguida, para cada ponto (n) na grade, o próximo ponto sobre a face é (n + 1). Simples! Daqui para frente, nós sabemos que sempre se move uma linha: em seguida, se acrescentarmos o ponto, podemos chegar ao ponto na segunda linha o número de colunas (c) índice (n) (n + c). Assim, por exemplo, no exercício acima, temos 5 colunas (c = 5) e através do ponto (1) o próximo ponto sobre a face da malha é (N + c) ou seja, o ponto (6). Em seguida, para cada ponto (n) como o primeiro ponto, o terceiro será (n + 1 + c). Não estamos! O último ponto, é sempre uma localizada uma coluna atrás do terceiro ponto. Em seguida, para cada ponto (n + 1 + c) como um terceiro ponto, o próximo ponto será (n + 1 + c-1) que significa que (n + c). Assim, por exemplo, para o ponto (6) como um terceiro ponto, o próximo ponto tornase (5) Resumindo: para cada ponto (n) na grade, a face que começa a partir deste único ponto terá como pontos na lista de vértice a seguinte combinação: [N, N + 1, n + 1 + c, n + c] onde (c ) é o número de colunas na grelha.

Fig. 07:26 Depois de definir todas as faces da tela, a superfície pode ser gerado. Olhando para os vértices de malha, vemos que ainda há algo a considerar. Se você se lembrar o exemplo do 'triângulo' do Capítulo 3, que lidou com o problema da seleção dos pontos que poderiam ser considerados 'primeiro passo' do grid. Se olharmos para o exemplo grade acabamos de discutir, vamos ver que os pontos da última coluna e última linha não pode ser pontos de partida para os rostos. Assim, além do algoritmo para gerar rostos, precisamos também de um pouco 'para manipular os dados para gerar os primeiros pontos de toda a grade e passar estes primeiros pontos do algoritmo, e em seguida, gerar as faces da malha. Basicamente, na lista de pontos, omitimos os pontos da última fila ea última coluna e, em seguida, começar a gerar a matriz de face.

131

Fig. 07:27 Geração de um índice numérico dos primeiros pontos na grade com um componente <series>. O número dos valores da série, derivada de TNP> como o número de colunas (alguns como filas) através da utilização da função de <x * (x-1)> I quer para gerar uma série de números, tal como <colunas * (1 rows- ) para gerar o índice para todos os pontos da rede eléctrica, omitindo a última linha. O próximo passo é selecionar (<abate>) a lista do índice pelo número de colunas (<N_pt>) para excluir o índice também aponta na última coluna.

Fig. 07:28 índice numérico final do primeiro ponto possível da face em malha de grade (com 8 pontos em cada coluna).

132

Fig. 07:29 O componente <malha quad> (malha> primitivo> malha quad) tem a função de gerar as faces. Anexei a lista de números primos para o primeiro ponto do <quad> Agora é o tempo para gerar a lista de índices para rostos.

Fig. 07:30 Enquanto (n) é o primeiro ponto do índice, e (c) é o número de colunas, o segundo ponto será (n + 1), o terceiro ((n + 1) + c) (o índice de segundo ponto mais o número de colunas), e o último ponto vai ser ((n + 1 + c) -1) (o terceiro ponto de índice menos 1).

133

Fig. 07:31 A malha resultante.

7_4 Análise cromática Para completar o exemplo, vamos olhar como podemos representar a nossa malha final, através do uso da cor como uma ferramenta de análise. Há vários componentes em Grasshopper que nos dão uma representação de cores, e estas cores são apropriadas para os nossos fins de análise. No exemplo, para mostrar ainda melhor deste, presumi que, no final, ver o valor do desvio do nosso superfície final a partir do ponto de partida (superfície vertical). Quero aplicar um gradiente de cor que começa a partir os pontos que permanecem fixas para o fundo da própria coloração até os pontos que têm o valor máximo de desvio da posição vertical com o maior entre o gradiente de cor. Simplesmente, para encontrar a quantidade de desvio, eu preciso medir o status final de cada ponto ao seu estado original. Então eu posso usar esses valores para atribuir a cor às faces da malha de acordo com a sua distância.

Fig. 07:32 Voltando que o ponto de partida da grelha gerada na primeira etapa I e também o deslocamento final, que I utilizado para gerar os vértices de malha. Posso usar um componente <distância> para medir a distância entre a posição inicial dos pontos e sua posição final para ver o desvio. 134

A Fig. 07:33 Para os nossos propósitos analíticos, eu quero usar um componente <gradiente> (Params> especial> Gradiente) para atribuir um gradiente de cor para a malha. Eu ligado os valores <distância> de entrada (t) <Gradiente> e I ligado ao cor de entrada (c) da malha. Mas, para completar o processo, que preciso para definir o limite inferior e superior do intervalo de gradiente (L0 e L1). O limite mais baixo é o valor mínimo na lista, enquanto o limite superior é o valor máximo: os outros valores são divididos em gradientes intermédios. Para obter os valores mais baixos e mais altos da lista de desvios, eu preciso para classificar os dados e obter o primeiro eo último valor do intervalo numérico.

Fig. 07:34 Usando um <espécie> componente para classificar as distâncias, fico com o primeiro elemento da lista de dados (Índice = 0) como o limite inferior e o último (Índice = <lista comprimento> -1) como o limite superior do conjunto de dados (valores de desvio) para ligar o componente <> gradiente para atribuir cores com base na sua gama.

135

Fig. 7:35 Clicando no ícone colorido pequeno no componente <gradiente> podemos mudar as cores do gradiente.

Fig. Direita 07:36 Clicando sobre o componente, o menu de contexto terá mais opções para manipular o objeto e os gradientes de cores diferentes resultantes para atender os métodos gráficos para a análise.

136

Fig. 7:37 limiares diferentes gradientes.

7_5 Manipulando malha como um método de criação. De acordo com os objectos e fins de modelagem, pessoalmente, preferem obter a malha através da manipulação de geometrias simples, em vez de gerar a malha a partir de um esboço, até à definição do conjunto de pontos e a face matriz que nem sempre são simples simples. Através da manipulação, podemos usar um objeto de malha simples, extrair seus componentes e modificálos, e depois ainda fazer uma malha com uma variedade de vértices e faces. Por isso, não precisa gerar pontos como vértices e faces matrizes. Vejamos este exemplo simples.

Fig.7.38 Neste exemplo, I utilizado um <malha plano> componente I e extrair os seus dados usando um <malha componente> para ter acesso aos seus vértices e faces. Em seguida, deslocado ao longo dos vértices da direcção Z com valores aleatórios activados por um <número deslizante> para ter ainda ligado a um componente <malha> para gerar outra malha. Eu também utilizado um componente <abate pattern> (selecione padrões) e eu ter omitido algumas das faces da malha original e, em seguida, usado como caras novas para criar outra malha. A malha resultante tem diferenças geométricas e topológicas da sua malha inicial e pode ser utilizado para outros fins de concepção. A idéia de manipular geometricamente os vértices e mudar rostos topologicamente apresenta muitas possibilidades diferentes que podem ser utilizados nos experimentos de design. Desde a malha podem negligenciar alguns dos seus rostos sempre restantes uma superfície, a idéia de criar uma superfície permeável pode ser perseguido de várias maneiras. 137

Fig. 07:39 Resultado da malha manipulado (apenas uma situação aleatória)

Fig. 7:40 esboços de malha manipulado. triangulações

138

Fig. Os componentes da amostra 7:41 triangulada Existem tantos componentes sob o painel de 'triangulação' no separador mesh, contendo algoritmos úteis, tais como Delaunay ou de Voronoi ou convexa casco. Esses algoritmos internos pode ser útil para desenhar objetos complexos e, mais importante, pode usar esses conjuntos de pontos para criar suas geometrias. Não vou insistir no assunto, também porque esses componentes são fáceis de explorar e você pode encontrar muitos exemplos online.

139

CAPITOLO_8_ Fabricação

140

Capitolo_8_ Fabricação Hoje em dia há um interesse crescente na prática de fabricação assistida por computador e fabricação digital. Por causa das mudanças e novas tendências no processo de design, parece ter se tornado uma escolha crucial e um dos 'must', para viajar no território de fabricação digital. Cada decisão de projeto no espaço digital, pode ser testado em diferentes escalas para mostrar as habilidades de fabricação e montagem. Uma vez que é óbvio que este novo processo de design e os algoritmos não cair nas técnicas de construção tradicionais, os designers tentar agora a utilizar as tecnologias modernas de fabricação e design de adaptar seus produtos para atender a essas necessidades. A partir do momento em que as máquinas CNC começaram a servir o ' indústria da construção civil até agora, ele estabeleceu uma grande relação entre o design digital e fabricação física. muitas máquinas e desenvolvidas muitas tecnologias foram inventadas a fim de realizar este tipo de operação. A fim de concepção e fabrico de elementos de construção, precisamos ter uma compreensão concisa do processo de fabricação de diferentes tipos de materiais e ser capaz de preparar os nossos projectos de propósito. De acordo com os objetos que projetar, os materiais utilizados, a montagem lógica, transporte, escala etc, precisamos de dados apropriados de nossos projetos e obter os resultados desejados ao funcionamento da máquina. Se os métodos tradicionais na implementação de projetos que necessitam de planos, seções e detalhes, hoje, precisamos de dados e códigos para ser transferido para as máquinas para executar os projectos. O ponto é, portanto, que o designer deve estar envolvida na 'oferta' dos dados solicitados, uma vez que esta fase está intimamente ligada com o objeto de projeto. Designers, por vezes, deve ter em conta as conclusões da preparação de dados para efectuar correcções para o projeto. Às vezes o objetivo do designer deve mudar para refletir as limitações da máquina ou montagem. Até agora, nós já sabemos os diferentes potenciais que propõe Grasshopper em projectos de edição, e essas mudanças de design pode facilitar a fabricação, como outros critérios utilizados. Eu quero abrir o tópico e tocar alguns pontos em relação à fase de preparação de dados, a olhar para a possibilidade de projetos de mineração de dados do projeto e manufatura. Sabemos que este tópico está aberto a diferentes técnicas, equipamentos, materiais etc.

8_1_ Folha de dados A fim de preparar os dados para criar um objeto, às vezes nós simplesmente precisa de uma série de medições, ângulos, coordenadas ou genericamente, dados numéricos. Existem vários componentes dentro Grasshopper para calcular medidas, distâncias, ângulos, etc. O ponto importante é a seleção correta e precisa dos pontos que temos de encaminhá-los para um propósito específico. Vamos estar atentos a qualquer complexidade geométrica que o nosso projeto tem, para escolher a posição desejada para a medição. O próximo passo é encontrar a posição que nos dar as informações corretas para a nossa produção e evitar números geradoras que possam ser de nenhuma utilidade come tempo. 141

Projeto feito com tiras de papel Para continuar a investigar estas questões, as tiras de papel parece uma boa solução. Para entender a montagem lógica, eu comecei com uma combinação simples para o primeiro nível e eu tentei adicionar combinações simples junto com o segundo nível de montagem. Na primeira, foi interessante, mas rapidamente se tornou evidente que eu não obter os resultados esperados. No final eu tentei ser mais preciso para enfrentar a geometria complexa.

A Fig. 8.1 Tiras de papel: primeiro exemplo Na próxima etapa, eu tentei começar com uma situação simples de entender a lógica geométrica e usá-lo como base para a modelagem digital. Presumi que, através do uso do modelo digital não seria capaz de fazer um modelo físico e eu tinha certeza de que eu precisava fazer testes com o papel para os primeiros passos. O meu objectivo era utilizar três tiras de papel e ligá-los em conjunto: um no centro e as outras duas em ambos os lados em relação ao centro de um, mas com um comprimento maior e estreito na parte final. Este poderia ser o módulo básico de repetir e criar montagens maiores.

Fig. 8.2 simples combinação de tiras de papel para entender as conexões e lógica.

142

modelagem digital Quero modelar as tiras de papel digitalmente depois de compreender os conceitos básicos do modelo tributário. Desde o ponto de partida, eu preciso de uma curva média simples, servindo como base do projeto. Este deve ser capaz de ser divididos e os pontos divididos deve ser capaz de ser selecionado (via booleana valores de dados TRUE / FALSE de um <abate padrão>): os pontos que respondem o valor TRUE deve ser movido perpendicularmente à curva central e deve ser utilizado (tanto aqueles que se movia aqueles correspondendo a FALSO) como vértices de duas curvas interpolados que pode moldar de um modo semelhante às que já descrito com as tiras de papel.

Fig. 8.3 Primeiro método de modelagem com a faixa central e as curvas interpolados como tiras laterais. Mas parece muito simples e direta. Então eu decidi adicionar uma dimensão de diferenciação gradual nos pontos de conexão de modo a mostrar uma geometria um pouco mais complexa. Agora vamos em Grasshopper e continuar a nossa discussão sobre modelagem. Quero tentar descrever sucintamente a definição e vá para a seção em dados.

A Fig. 8.4 O componente <curvado> é a faixa central, representado em Rhinocerosda uma curva simples. I reparametrizada e agora eu quero avaliá-lo em diminuir intervalos. I utilizado um componente <gama>, e I ligado para um componente <mapeador gráfico> (Parâmetros> especial> mapeador Gráfico) para gerar as bitolas. Um <gráfico mapeador> (mapeador gráfica) remaps um conjunto de números de formas diferentes, por meio da escolha de um determinado tipo de gráfico. Como você pode ver, eu tenho avaliado a curva com <gráfico mapeador> com a parábola gráfica e os pontos resultantes da curva são claras. Você pode alterar o tipo de gráfico para alterar o intervalo de mapeamento

143

Numérico (para mais informações consulte a ajuda do componente). Depois disto, estes parâmetros avaliados na curva inicial (I ligado <receptor> com <curvo>).

Fig. 8.5 Após os dados numéricos remapeadas e avaliou os pontos, eu quero encontrar os pontos centrais a cada dois pontos do conjunto anterior. Devo, portanto, encontrar os parâmetros das curvas, entre cada ponto base e o próximo, a ser avaliada. Desde que eu tenho os parâmetros de cada primeiro ponto, eu me mudei (<Shift>) os dados para encontrar os próximos pontos. Eu também usei um <abate> com a frequência determinada pelo comprimento da lista (<lista de comprimento>) para excluir o último item da lista principal, a fim de ter os mesmos elementos que a lista mudou. A <função> componente é o parâmetro intermediário (f (x) = (x + y) / 2). Você pode ver os parâmetros resultantes sendo avaliado (a <receiver> conectado <crv>).

Fig. 8.6 vértices Agora o ponto médio e create desviados da faixa lateral quer movido. Estes pontos devem sempre mover-se numa direcção perpendicular à curva central. Assim, para ser capaz de se mover, que preciso para vectores, perpendiculares à curva central na posição de cada ponto. Com o componente <avaliar> Também eu recebo um vector tangente em cada ponto, mas precisamos perpendicular. Sabemos que o produto do vetor de dois vectores é ainda um vector, sempre perpendicular a ambos (Fig. 8,7). Por exemplo, o vector de unidade Z, pode ser o produto de cruz 144

vectores unitários X e Y. A curva central é uma curva plana, em seguida, sabemos que o vector de Z em cada ponto da curva será sempre perpendicular ao plano da curva. O vector tangente em cada ponto da curva, também está situada no plano da curva. Assim, se encontrar o produto vector do vector tangente e o vector Z unidade de cada ponto, o resultado deve ser um vector perpendicular à curva intermédia que pertence sempre ao plano da curva. I utilizado o ponto de tangente do componente <avaliar> e o vector <unidade Z> para encontrar o seu <Xprod> (produto cruzado) que Sei é perpendicular à curva mesmo que mudá-lo manualmente. Outros make-up! I utilizados os valores de <mapeador gráfico> como factores de potência desses vectores Z, a fim de aumentar o movimento dos pontos. Assim, quanto maior a distância entre os pontos, maior o seu deslocamento.

Fig. 8.7 Vector de Produto. O portador A e B estão no plano de base. O transportador C é o produto do vetor de A e B e é perpendicular ao plano de base e, consequentemente, para a vectores A e B.

Fig. 8.8 Agora que têm os pontos de base (os primeiros pontos de medição) e movido pontos. Eu torcido (<tecer>) juntos para ter uma lista ordenada de dados. Agora, se eu usar esses pontos para gerar uma curva interpolada, você vai ver a curva de base da listra lateral. 145

Fig. 8.9 Usando um <curvas espelho componente> (Xform> Morph> curvas espelho) pode espelhar a curva interpolado usando a curva intermédia ligado ao <receptor>. Desta forma, portanto, terei ambos os lados com tiras de papel modulados no mesmo conceito

A Fig. 08:10 Se agora ligar-se a curva intermédia e curvas laterais de um componente <extrusão> I pode ver a primeira combinação de tiras de papel, com uma folga decrescente entre os pontos.

Fig. 08:11 I pode começar a editar as tiras intermédias e ver como Gafanhoto actualiza os três tiras de papel que estão ligados uns com os outros, ou pode modificar os valores dos cursores e verificar a geometria resultante para seleccionar o mais próximo do modelo física.

146

Depois de encontrar a configuração para minhas tiras de papel, eu preciso extrair o tamanho e posicionamento para construir meu modelo com base nesses dados. Embora seja fácil de moldar todas estas tiras em folhas de papel e cortar com o laser, aqui eu quero criar um processo mais geral e obter os dados iniciais necessários de modo a não limitar-se a uma máquina específica e um método de fabricação específico. Você pode usar esses dados como genérico para os códigos de produção. Tomando um modelo simples papel Eu sei que preciso a localização dos pontos de conexão nas tiras e é óbvio que estes pontos de conexão terá um comprimento diferente na faixa do lado esquerdo com relação à parte direita da faixa, bem como em relação ao intermediário. Então, se eu obter o comprimento divisória Grasshopper, eles podem marcá-lo nas tiras.

Porque as tiras são curvas componente <distância> não me ajuda para esta medida. Preciso de uma distância entre um ponto para outro ou a partir do ponto da tira de partida mas com respeito à curva, de modo que quando o uso no rolo de papel pode dar-me a posição correcta. Para atingir este fim, eu preciso encontrar pontos de parâmetros de conexão nas tiras (curvas) e avaliar a sua posição. Os mesmos componentes que voltará a distância entre estes pontos a partir de um ponto inicial da curva.

Fig. 08:12 Como se pode ver I utilizado o primeiro grupo de pontos avaliadas que têm chamado os principais pontos da curva (pontos principais curvas) na tira central (curva inicial). A saída L do componente me retorna a distância dos pontos (pontos de conexão) da tira a partir do ponto de partida para a faixa intermédia. Eu também usei esses pontos para encontrar os seus parâmetros de um lado da curva. Então, usei um componente <curva cp> para encontrar os parâmetros de cada ponto na curva (t). Estes parâmetros foram utilizados para avaliar a curva e encontrar a sua distância a partir do ponto inicial. Eu faria o mesmo para a próxima parte da tira. Certifique-se de que a direção de todas as curvas é o mesmo e controlado, onde o ponto da curva de medição (origem) de partida.

147

exportação de dados

Fig. 8.13 Clique no botão direito do mouse sobre o componente <painel> e selecione 'fluxo de conteúdo'. Com esta opção, você será capaz de salvar seus dados em formatos diferentes e usálos como dados numéricos genéricos. Aqui eu salvou com um formato .txt simples para que você possa usar em Microsoft Excel.

Fig. 08:14 Em uma planilha do Excel, clique em uma célula vazia e a data selecionada cartão em 'Obter dados externos'. Seleccione aqui 'do texto'. Selecione o arquivo salvo em txt a partir do local onde eu tenho posição e siga as instruções do Excel. Estas medidas irão permitir que você para administrar diferentes tipos de dados relativos, por exemplo, como dividir seus dados em diferentes células e colunas etc. 148

A Fig. 8.15 Agora você pode ver seus dados localizados em uma planilha excel. Você pode fazer o mesmo para as tiras restantes

Fig. 08:16 Tabela da distância dos pontos de ligação ao longo da tira.

Se você tem uma lista de coordenadas 3D de pontos e você deseja exportar para Excel, você tem várias opções disponíveis. Se você exportar as coordenadas 3D pelo método descrito acima, você vai ver que há tantas parênteses e vírgulas não é necessário que você deve excluir. Você também pode adicionar colunas, clicando no botão de texto na importação excel e colocar em outros vírgulas colunas e parênteses e, em seguida, excluí-los novamente. 149

Em alguns casos eu recomendo a decompor-se em seus pontos de componentes e importá-los separadamente. Não é um grande problema para exportar três listas de dados em vez de um.

Fig. 08:17 Usando o componente <decompor> para obter as coordenadas X, Y e Z de uma forma seperable para, em seguida, exportá-los neste caminho para uma folha de cálculo. Eu recomendo fortemente a trabalhar profissionalmente com Excel ou outras planilhas, porque eles nos ajudam no gerenciamento de dados.

Com modelagem estamos! Eu usei os dados obtidos, a fim de marcar minhas tiras de papel e conectá-los juntos e criar padrões simples. Para provar também a mim mesmo, eu fiz este processo artesanal, para demonstrar que a produção não significa necessariamente máquinas de corte a laser, mas, como ele disse uma vez Achim Menges (Tutor AA EmTech), por vezes, o CAM pode ser substituída por HAM ou seja Fábrica manual (mão Aided Manufacturing !!! Só para rir). Passei uma hora para cortar todas as faixas, enquanto o processo de montagem levou um pouco de mais tempo, mas ele ainda foi feito à mão. 150

Fig. 8:18 Final Draft tiras de papel.

151

8_2 cortes a laser e manifatturazione com base no corte Para fabricar geometrias complexas comumente usados hoje em dia é a idéia de cortar folhas de material através do laser. Existem várias maneiras em que podemos usar essa capacidade para fabricar objetos. Os cortes a laser são bons para objetos construídos com superfícies evolutivas ou dobrados. E 'pode colocar sobre uma geometria plana e um conversor digital simplesmente cortar a partir de uma folha e dobrar o material para o construir. Para geometrias complexas, que também podem ser apropriadas para reduzi-las em pedaços separados de superfícies planas: todo o modelo pode ser desmontado em várias partes separadas, aninhado em folhas planas e podem ser adicionados às partes sobrepostas para conexão (colagem, por exemplo) e para o corte na extremidade de um conjunto física. E ' também possível fabricar um duplo objetos curvatura com este método. Houve vários experimentos para encontrar as diferentes secções de um objeto em forma de 'blob'. Estas secções cortadas do objecto em pelo menos duas direcções e uma vez montada, elas são unidas (geralmente aproveitado) para criar a forma da gaiola modelo. Uma vez que os gravadores laser são ferramentas genéricas, existem vários métodos, mas para toda a coisa importante é encontrar maneiras de reduzir o alto geometria plana elementos de modo a cortar a partir de uma folha de material (não importa se papel ou metal, papelão ou madeira) e eventualmente montá-los em conjunto. Das diferentes maneiras discutidas aqui, eu quero testar um dos Grasshopper. Tenho certeza que você pode facilmente experimentar com os outros em seu nome Fabrico de superfícies de forma livre Eu decidi fazer uma superfície de forma livre para fazer experiências, preparando e abrigar os pedaços de objetos a ser cortada de forma livre e todas as outras coisas que precisamos.

Fig. 08:19 Aqui temos a superfície que importou Grasshopper através do componente <geometria>. Isso é para mostrar que é possível introduzir qualquer geometria que você planejou, ou usar qualquer objeto que você criou Grasshopper. Costelas das seções Para produzir estas formas forma genérica livre, eu quero criar seções desta superfície, ninho los em uma folha e preparar arquivos para ser cortado com uma gravadora laser. Se o objeto que você está trabalhando tem uma determinada espessura que pode ser cortado, o modelo é plano, então você precisa adicionar uma espessura cortar partes.

152

A Fig. 8.20 Na primeira etapa eu usei um componente <caixa delimitadora> (caixa delimitadora) para encontrar a área que eu quero trabalhar. Eu também utilizado um componente <cantos Box> (Surface> Análise> canto Box) para encontrar os cantos opostos da caixa e usá-los como final do intervalo que você deseja gerar as costelas ao longo da geometria. Assim, graças ao cálculo do comprimento e da altura da caixa, eu poderia usar esses valores como os domínios que você deseja compartilhar através de um <range> componente. Basicamente, usando um <número deslizante>, eu posso dividir o comprimento, a altura da caixa nas partes desejadas.

Fig. 08:21 Meu objetivo é criar planos ao lado do comprimento e largura da caixa em quantidades iguais ao das costelas que eu preciso. Primeiro de tudo o que gerou dois andares, um <plano xy> e o outro <XZ>: o primeiro perpendiculares ao comprimento do paralelepípedo e o segundo perpendiculares à largura. Eu criei tanto no primeiro canto do cubóide ligando a saída de A <canto> caixa. Agora eu posso gerar vetores <unidade X> e <unidade Y> ao lado do comprimento e largura da caixa e através da conexão do componente <range>, posso criar vetores para todos os pontos divididos. I pode então mover-se (<>) movimento os planos XZ e YZ com estes vectores e gerar séries de armadura ao longo do comprimento da caixa delimitadora. 153

Fig. 08:22 Armação gerado ao longo da direcção do comprimento e da largura da caixa de delimitação do objecto, perpendicular ao bordo.

Fig. 08:23 Ora, se eu encontrar as intersecções desses planos com a superfície, eu posso realmente gerar as costelas próximos metade das nossas superfícies do processo de fabricação. Aqui eu usei o componente <BREP | Plane> (Intersect> Matemática> BREP | Plane) para resolver o problema. Eu costumava <Geometry> (meu superfície inicial) como BREP e planos das etapas anteriores, tais como planos para alimentar os componentes da seção.

154

Fig. 8:24 intersecções entre as placas e as superfícies, que criam uma série de curvas na superfície. nidificação O próximo passo é para ninho estas curvas de seção sobre uma folha plana para prepará-los para o processo de corte. Eu desenhei um retângulo Rhinoceroscon minha folha. Copiei este retângulo para gerar muitas folhas sobrepostas umas às outras e eu desenhei uma superfície que cobre todos esses retângulos.

Fig. 8:25 folhas de papel e as superfícies subjacentes a representá-los em Gafanhoto Vou usar o componente <orient> (Xform> euclidiana> Orient) para aninhar minhas curvas em uma superfície que representa as folhas para os cortes. Olhando para o componente <orient> você pode ver que precisamos do plano de referência objeto eo plano de destino que deve ser na folha. Então eu deveria criar esses planos para meu ninho objetos de corte. Desde que eu usei esses planos para cruzar a superfície inicial e gerar as curvas de seção, eles ainda podem usá-los como planos de referência, então eu só preciso para gerar os níveis-alvo.

155

Fig. 08:26 I importado a superfície de corte de gafanhoto e I utilizado um <quadro superfície> componente (Superfície quadros> Util> de superfície) para gerar série de estruturas transversais à superfície. Podemos gerar planos, quantos ele precisa da geometria.

Fig. 08:27 orientação. Liguei as curvas de seção como geometrias básicas e os planos que eu tenho usado para este tipo seção como geometria de referência para o componente <orient>. Mas ainda necessário uma pequena alteração ao plano de destino. Se você olhar para os resultados do <frame superfície>, você vai ver que dividindo a direção U para 1, 2 colunas serão gerados para dividir a superfície. Tenho, portanto, um número de andares acima minhas necessidades. E é por isso que dividiu a lista (<Split>) do plano de destino com os números que vêm do número de curvas de referência. I depois utilizada andares em uma quantidade igual às curvas e presentes I transferida-los para uma unidade na direcção X, para permitir a sobreposição com as extremidades das folhas. Agora eles podem se conectar esses planos para o <orient> componente.

156

Fig. 8:28 curvas aninhados na folha cortada

Geração das costelas

Fig. 08:29 Depois de curvas aninhadas em folhas de corte, visto que os nossos objetos não têm espessura, precisamos prever este requisito para ser capaz de cortar. Para esta finalidade, Criei um <offset> das curvas com o valor da altura desejada e também adicionou algumas linhas em ambas as extremidades destas curvas e os '' offsettate de modo a fechar todo o desenho e para obter a nervura completa para o corte. Geram as articulações (imbrigliatura) O próximo passo é para gerar as nervuras na outra direcção e criar as articulações para montar após o corte. Embora seja usado o método de divisão mesma altura 157

caixa delimitadora para gerar planos e, em seguida, seções, posso gerá-los manualmente em qualquer posição desejada. Então, se você não quer dividir ambos os sentidos e criar seções, você pode usar outros métodos.

Fig. 08:30 Como você pode ver, neste caso, em vez dos planos gerados anteriormente, eu usei planos definidos manualmente para a seção na outra das direções superfícies. Um plano é statp gerado por meio de um valor de X directamente a partir de uma <número deslizante> e outra proveniene plano por um espelho plano do outro lado da superfície (o comprimento da superfície (Y) - número deslizante (x)). A secção de estes dois planos e superfícies são calculados para os passos seguintes. Agora eu posso orientar estas novas curvas em outra folha a ser cortado, usando o mesmo processo acima. Então vamos criar as articulações para a montagem de peças.

Fig. 8:31 Porque não temos as curvas em ambas as direções, podemos encontrar o seu ponto de intersecção para desenhar as articulações no lugar. Para este fim, eu usei o componente <CCX> (Intersect> Física> Curve | Curve) para encontrar as posições de intersecção entre essas curvas que as posições conjuntas (O componente <CCX> está definido no modo de referência cruzada (referência)) . 158

Eu preciso para desenhar desenhar algo mais para preparar as articulações para o corte. Estou pensando em usar un'imbrigliatura e, em seguida, eu preciso cortar metade de cada costela na posição conjunta para se juntar a eles no final. Primeiro eu preciso encontrar essas interseções em costelas aninhados e, em seguida, chamar a linha de corte.

Fig. 08:32 Se você olhar para a porta do componente de saída <CCX> você vai ver que retorna o parâmetro no qual cada curva cruza com a outra. Posso, então, avaliar as curvas aninhadas ou orientados com esses parâmetros para encontrar a posição de costura sobre as folhas cortadas.

Fig. 08:33 Agora que temos a posição das juntas, temos de desenhá-los. Para uma coisa que atraiu as linhas com o componente <A linha SDL> com o ponto de junção como o ponto de partida, em direcção <unidade Y> e eu usei uma meia-altura da nervura como o valor para o comprimento. Agora podemos ver que ponto na curva tem aninhados uma linha fina associado. 159

Fig. 08:34 próximo passo, desenhar uma linha na direcção X a partir do ponto final da linha anterior com o comprimento de <sheet_thikness> (espessura da folha, o que depende do material).

Fig. 08:35 Para desenhar a terceira linha eu preciso encontrar o ponto onde a linha conecta-se a curva de base, porque eu não sei exatamente o comprimento. Neste passo, I adicionado um outro <linha SDL> direcção Y, mas com um sinal negativo para extrair a terceira linha, mas mais do que o necessário, para intersectar a curva de base em um ponto. O <receiver> está ligado à curva orientada. Então, usei <CLX> (Intersect> Matemática> Curves | line) para encontrar a intersecção com a curva de base. Eu 'achatada' (<achatar>) e adicionado as linhas, mesmo do ponto final da segunda linha nesta intersecção. Como resultado, agora as conexões sejam concluídas. Eu tenho que concluir o trabalho de ambos os lados da junção.

160

Fig.8.36 Usando um componente <join curvas> (curva> Util> Junte curvas), como você pode ver eu tenho uma ranhura (chamado <juntar curvas>) que pode ser usada para cortar, como imbrigliatura dentro da estrutura. Nós aplicar o mesmo método para a outra extremidade da curva (segunda série de junções do outro lado da curva orientado).

Fig. 8:37 Reforços com o ponto de junção desenhados em ambos os extremos. Eu posso cortar a parte mais fina da curva base na articulação, mas uma vez que não alterar a geometria, eu posso sair. rotulagem Enquanto nós estamos trabalhando na fase de fabrico, pode não ser uma ótima idéia para cortar centenas de pequenas peças e deixá-los sem nome e direções. Desde que nós estamos indo para 161

montá-los, seria apropriado para indicar o fim de saber qual vai primeiro. É óbvio que uma vez que todas as partes são diferentes, precisamos classificá-los para que eles possam ser facilmente montado. A etiqueta pode ser simplesmente representado por um número ou uma combinação de números e textos úteis em colocar as peças. Se o objeto é composto de uma série de pequenos pedaços divis somos capazes de citar as principais partes e usar o seu nome ou iniciais com números para colocar as peças (por exemplo left_ wing_01 - ala_sinistra_01). Podemos também usar a lógica hierárquica para também nomear partes (por exemplo layer_01_p_45). Então eu preciso de um conjunto de números para mostrar a posição das costelas na lista. Posso usar o componente <text> tag para adicionar texto ao meu geometria e para fazer isso, eu preciso especificar a posição e altura do texto.

A Fig. 08:38 Como você deve se lembrar, eu tenho uma série de planos que se usaram como os pisos de destino para orientar as curvas de seção na folha. Então irei usar os planos para criar a posição para o texto. Porque os planos são exatamente os cantos dellenervature, primeiro tenho de movê-los.

Fig. 08:39 Mudei os ângulos dos planos de uma unidade na direção X e metade de uma unidade na direção Y (como a soma (<soma>) de vetores) e ter usado esses planos para a colocação dos rótulos de texto. Aqui eu usei <texto 3D tag> e geraram um número de elementos igual ao número das costelas e usá-lo como texto. Para converter 12.0 em 12 eu usei o componente <inteiro>, mas você também pode fazê-lo com uma função. Como resultado, você pode ver todos os elementos que têm um número único no seu canto esquerdo. 162

Fig. 08:40 Agora você pode alterar os factores de divisão das superfícies de corte para comprimir as costelas, de modo a evitar o desperdício de material. Como você pode ver no exemplo anterior, a partir do ponto da folha 3 (sheet_3) de partida, as costelas começam a ser mais plana e isso permite ter mais espaço entre eles. Aqui você pode quebrar suas costelas em duas superfícies diferentes para cortar e mudar os pontos divididos, comprimi-los de acordo com sua forma. Mas se você não está levando em conta algumas partes que você pode fazer esse tipo de coisa rinoceronte manualmente: nenhum è necessário que todas as partes são feitas associativamente! Agora eu tenho as costelas em uma direção e eu posso fazer a mesma coisa na outra direção. A única coisa a considerar é a direção das articulações invertidos, por isso, enquanto eu estava trabalhando com geometria orientada na parte anterior, aqui eu tenho que trabalhar com o que foi criado por '<offset>

corte Quando todas as geometrias tornar-se pronto para ser cortado, eu preciso 'cozinhar' (assar) e alterá-las um pouco mais 'nas folhas. Como você pode ver na Fig. 8:41 objetos são aninhados em todas as três folhas. Eu criei três formas diferentes para as costelas na direção da largura do objeto para verificar-los. O material está agora pronto para ser cortado.

Fig. 8:41 nervuras aninhados, pronto para ser cortado. 163

Fig. 8:42 Exemplos de nervuras, pronto para ser montado. montagem

No nosso caso, a montagem é relativamente simples. Às vezes, você precisará verificar novamente os arquivos para ajudar na montagem das peças com diferentes métodos de fabricação. Aqui nós todas as superfícies feitas com folhas de papel.

164

Fig. 08:43 modelo final A fabricação é um assunto de muito extensa discussão. Depende principalmente sobre o que você quiser produzir, o material, o que é que a máquina seja usada como peças fabricadas devem ser montados, e assim por diante. Como mencionado acima, dependendo do projeto que você deseja trabalhar, você vai precisar de recuperar dados para as etapas de fabricação. Alguns vão ser mais importante que o conjunto de lógica, por exemplo, quando você está trabalhando com componentes simples que criam uma posição de geometria complexa, como resultado da montagem.

165

Fig 8,44 Lógica montagem:. Os materiais e as articulações são simples. Posso trabalhar na lógica da montagem e usar os dados para fazer meus modelos.

166

CAPITOLO_9_ estratĂŠgia de design

167

9_Strategia projeto Os algoritmos generativos são algoritmos e representam modo associativo / paramétrico para operar na geometria nos problemas de design. Com o método algorítmica, com melhor do que com objectos geométricos convencionais, que podem ter todas as possibilidades oferecidas pela geometria computacional, e, ao mesmo tempo que pode administrar uma quantidade enorme de dados, a partir dos números e cálculos. A questão não é a de limitar a configuração padrão em experimentos, e explorar o potencial infinito; Há sempre maneiras alternativas para definir os algoritmos de design. Embora pareça que a aplicação dos controlos de modelagem paramétrica pode restringir determinadas operações, ou pode impor métodos, soluções alternativas estão sempre presentes: Deixe sua imaginação voar e subir ao longo dos limites! Para ser capaz de projetar algo, ele sempre ajuda a ter uma estratégia de design. Isso permitirá que você para definir o melhor algoritmo para encontrar a solução para o nosso problema. Pensando sobre as propriedades gerais dos objetos de design, desenhar peças e fazer modelos físicos, pode ajudar a compreender melhor os algoritmos a fim de escolher os melhores componentes para modelagem digital. Pensando nos parâmetros fixos, estas podem ser alterados durante o projeto: os dados numéricos e os objetos geométricos necessários, sempre ajudar a melhorar o algoritmo. Seria muito útil entender analiticamente problemas de design, schizzarle e, em seguida, iniciar um algoritmo que pode resolver o problema. A fim de projetar algoritmos, temos que pensar algorithmically!

168

Fig. Weaving 9,1 Projeto, de compreensĂŁo analĂtica a modelagem associativa.

169

Fig. 9.2 Projeto de uma parede perfurada, de compreensĂŁo analĂtica a modelagem associativa.

170

bibliografia Pottman, Helmut e Asperl, e Andreas Hofer, e Michael Kilian, Axel, 2007: 'Geometria Arquitetural', Bently Institute Press. Hensel, Michael e Menges, Achim, 2008: 'Morpho-Ecologies', Architectural Association. Rutten, David, 2007: 'RhinocerosScript 101', versão digital por David Rutten e Robert McNeel e de Associação.

Flake, Gary William, 1998: 'A beleza computacional da natureza, explorações computador de fractais, caos, sistemas complexos, e adaptação', The MIT Press. De Berg e Mark Van Kreveld, e Marc Overmars, Mark, 2000: 'Computational Geometry', Springer. gafanhoto tutoriais em Robert McNeel e Associates http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryExamples.html

wiki:

Axel Kilian e Stylianos Dritsas: 'Tooling Projeto - Esboçando por Computação',

http://www.designexplorer.net/designtooling/inetpub/wwwroot/components/sketching/index.ht ml

Wolfram Mathworld: http://mathworld.wolfram.com/ Stylianos Dritsas, http://jeneratiff.com/ Principal página web Grasshopper: http://Grasshopper3d.com

171