Grasshopper 3d Vietnamese Edition

GENERATIVE ALGORITHMS

GENERATIVE ALGORITHMS using GRASSHOPPER (bản tiếng Việt)

ZUBIN KHABAZI 1

GENERATIVE ALGORITHMS

GENERATIVE ALGORITHMS using GRASSHOPPER (bản tiếng Việt )

ZUBIN KHABAZI

© 2010 Zubin Mohamad Khabazi This book produced and published digitally for public use. No part of this book may be reproduced in any manner whatsoever without permission from the author, except in the context of reviews. To see the latest updates visit my website or for enquiries contact me at:

www.MORPHOGENESISM.com [email protected]

2

GENERATIVE ALGORITHMS

Contents Introduction ...

5

Acknowledgements ...

5

Lời của nhóm dịch ...

6

Chapter_1_Generative Algorithms ... ........................................................................................................................ 7 1_1_ Generative Algorithms ... .............................................................................................................................. 8 Chapter_2_The very Beginning ................................................................................................................................. 11 2_1_Method ... ....................................................................................................................................................... 12 2_2_Basics of Grasshopper ... ................................................................................................................................ 12 2_2_1_Interface, Workplace ... ......................................................................................................................... 12 2_2_2_Components ... ...................................................................................................................................... 13 2_2_3_Data matching ....................................................................................................................................... 21 2_2_4_Component’s Help (Context pop-up menu)... ...................................................................................... 23 2_2_5_Type-In Component Search / Add ........................................................................................................ 23 Chapter_3_Data Sets and Math ................................................................................................................................ 24 3_1_Numerical Data Sets ...................................................................................................................................... 25 3_2_On Points and Point Grids ... .......................................................................................................................... 27 3_3_Other Numerical Sets ... ................................................................................................................................. 29 3_4_Functions ... .................................................................................................................................................... 30 3_5_Boolean Data types ... .................................................................................................................................... 34 3_6_Cull Lists ... ...................................................................................................................................................... 35 3_7_ Data Lists ... ................................................................................................................................................... 37 3_8_On Planar Geometrical Patterns ................................................................................................................... 41 Chapter_4_Transformations ... .................................................................................................................................. 52 4_1_Vectors and Planes ........................................................................................................................................ 54 4_2_On Curves and Linear Geometries ................................................................................................................ 55 4_3_Combined Experiment: Swiss Re ... ............................................................................................................... 61 4_4_On Attractors ................................................................................................................................................. 70

3

GENERATIVE ALGORITHMS

Chapter_ 5_Parametric Space ... ............................................................................................................................... 81 5_1_One Dimensional (1D) Parametric Space ... .................................................................................................. 82 5_2_Two Dimensional (2D) Parametric Space ... .................................................................................................. 83 5_3_Transition between spaces ... ........................................................................................................................ 85 5_4_Basic Parametric Components ... .................................................................................................................. 86 5_4_1_Curve Evaluation ... ................................................................................................................................ 86 5_4_2_Surface Evaluation ... ............................................................................................................................. 87 5_4_3_Curve and Surface Closest Point ... ....................................................................................................... 89 5_5_On Object Proliferation in Parametric Space ... ............................................................................................ 89 5_6_On Data Trees ................................................................................................................................................ 98 Chapter_6_ Deformations and Morphing ... ............................................................................................................. 107 6_1_Deformations and Morphing ... ..................................................................................................................... 108 6_2_On Panelization ... .......................................................................................................................................... 111 6_3_Micro Level Manipulations ... ........................................................................................................................ 114 6_4_On Responsive Modulation ... ....................................................................................................................... 117 Chapter 7_NURBS Surfaces and Meshes ... ............................................................................................................... 123 7_1_Parametric NURBS Surfaces .......................................................................................................................... 124 7_2_Geometry and Topology ... ............................................................................................................................ 132 Chapter_8_Fabrication .............................................................................................................................................. 134 8_1_Datasheets ..................................................................................................................................................... 136 8_2_Laser Cutting and Cutting based Manufacturing ... ...................................................................................... 149 Chapter_9_Design Strategy ... ................................................................................................................................... 166

Bibliography ...

170

4

GENERATIVE ALGORITHMS

Introduction Have you ever played with LEGO Mindstorms NXT robotic set? Associative modelling is something like that! While it seems that everything tends to be Algorithmic and Parametric why notarchitecture? During my Emergent Technologies and Design (EmTech) master course at the Architectural Association (AA), I decided to share my experience in realm of Generative Algorithms and Parametric-Associative Modelling with Grasshopper as I found it a powerful platform for design in this way. In this second edition, as I changed the name ‘Algorithmic Modelling’ to ‘Generative Algorithms’, I tried to update some of the experiments and subjects due to the changes happening to the work-in-progress project of Grasshopper. I hope this tutorial helps you to understand Generative Algorithms and delicate Grasshopper as well. I would try to keep updating whenever needed but consider that most of experiments and examples were established by previous versions of plug-in, so if you faced some differences it might be because of that. Although I still believe that the book needs editorial review, since this is a non-profit, noncommercial product, please forgive me about that. I am very pleased that since publishing this book, I have found great friends worldwide, so feel free to contact me for any queries and technical issues. Enjoy and Good luck!

Acknowledgements First of all I would like to thank Bob McNeel for his support in Grasshopper3D and David Rutten for his inspiration and support as well. I also like to thank AA/EmTech directors and tutors Mike Weinstock, Michael Hensel and also Achim Menges who established my parametric and computational concepts. Many thanks to Stylianos Dritsas (AA/KPF) and Dr.Toni Kotnik (AA/ETH) for their computation, scripting and advance geometry courses. I am extremely grateful to the students, architects and designers who contacted me and shared their knowledge and let me know short comes and errors of the work.

Zubin M Khabazi March 2010

5

GENERATIVE ALGORITHMS

Lời của nhóm dịch : Grasshopper là một plugin của phần mềm Rhino3d được giới thiết kế trên toàn thế giới sử dụng một cách rộng rãi. Tuy nhiên ở Việt Nam, Grasshopper chỉ mới được sử dụng trong các đồ án của số ít sinh viên. Đây là một công cụ mạnh mẽ cho tất cả các đối tượng là người thiết kế đang tìm hiểu về thiết kế dựa trên thuật toán toán học. Không giống như rhinoscript (visual basic) chúng ta không cần biết về ngôn ngữ lập trình cũng có thể thực hiện được các thiết kế. Tuy nhiên tài liệu về plugin này hầu hết là tiếng Anh;phần nào hạn chế sự tiếp cận của chúng ta đối với công cụ hữu ích này. Điều đó đã thôi thúc chúng tôi chuyển ngữ cuốn sách này sang tiếng Việt với mong muốn phát triển cộng đồng sử dụng Grasshopper ở Việt Nam. Chúng tôi chân thành cảm ơn Zubin M Khabazi – tác giả của cuốn GENERATIVE ALGORITHMS-using GRASSHOPPER về những kiến thức mà ông đã chia sẻ trong cuốn sách. Và đặc biệt cảm ơn các bạn sinh viên trường Đại học Kiến Trúc TP.HCM có tên dưới đây đã nhiệt tình tham gia thực hiện chuyển ngữ cuốn sách này. Nhóm dịch:

Đậu Sỹ Nghĩa - [email protected] Nguyễn Nhật Anh - [email protected] Trần Ngọc Hoàng Thảo - [email protected] Đoàn Thế Phương - [email protected] Nguyên Thị Phương Dung - [email protected] Võ Duy Kim - [email protected] Nguyễn Phúc Nguyên - [email protected] Lê Minh Hoàng - [email protected] Đồng Viết Ngọc Bảo - [email protected] Đỗ Thị Vành Khuyên - [email protected] Phạm Tấn Đạt - [email protected]

Nhóm chỉnh sửa:

Lý Thanh Hoàng Phúc - [email protected] Nguyễn Trọng Thụy - [email protected] Đồng Viết Ngọc Bảo - [email protected]

Mọi ý kiến đóng góp bổ xung xin các bạn gửi về địa chỉ: [email protected]

Trân trọng cảm ơn và chúc các bạn thành công! 6

GENERATIVE ALGORITHMS

CHƯƠNG_1_Algorithmic Modelling

7

GENERATIVE ALGORITHMS

1_1_Algorithmic Modelling

Nếu ta xem kiến trúc như là một đối tượng đại diện trong không gian, ta phải luôn luôn xử lý hình học và sử dụng một phần của toán học để hiểu và thiết kế đối tượng này. Trong Lịch sử kiến trúc,nhiều phong cách kiến trúc khác nhau đã trình bày nhiều loại hình học và logic rõ ràng trong từng thời kỳ đã tìm ra cách để giải quyết các vấn đề hình học. Kể từ khi bắt đầu sử dụng máy tính nó giúp các kiến trúc sư, mô phỏng không gian và hình học cấu âm, nó đã trở thành một công cụ không thể thiếu trong quá trình thiết kế. Tính toán hình học đã trở thành một chủ đề thú vị để nghiên cứu và kết hợp các thuật toán lập trình với hình học mang lại những thuật toán hình học được gọi là thuật toán có thể sản sinh.Mặc dù các phần mềm 3D mô phỏng gần như bất kỳ không gian nào, đó là khái niệm thuật toán có thể sinh sản mang lại các khả năng hiện tại của thiết kế, như 'parametricdesign' trong lĩnh vực kiến trúc.

Kiến trúc sư sử dụng các đường cong và bề mặt để thiết kế và khảo sát các không gian vượt ra ngoài những hạn chế của hình học thông thường - "không gian Ơclít". Nó là sự kết hợp của kiến trúc và kỹ thuật số đã mang các dấu ấn đặc biệt và đưa nó đi xa hơn. Mặc dù sự tiến bộ của tính toán là cực kỳ nhanh,song kiến trúc đã và vẫn cố gắng để theo kịp sự phát triển đó.

Thiết kế kiến trúc ảnh hưởng bởi tiềm năng của thuật toán hình học, tính toán với hệ thống phân cấp nhiều và mức độ phức tạp cao. Thiết kế và mô hình hóa bề mặt và đường cong dạng tự do như xây dựng các yếu tố có liên quan với các component khác nhau và có nhiều họa tiết không phải là một công việc dễ dàng để làm với các phương pháp truyền thống. Đây là sức mạnh của các thuật toán và đẩy các giới hạn thiết kế ngày càng đi xa hơn. Rõ ràng rằng ngay cả suy nghĩ về một hình học phức tạp, chúng ta cần các công cụ thích hợp, đặc biệt là các phần mềm, có khả năng mô phỏng những hình học và kiểm soát tài sản của mình. Kết quả là, kiến trúc sư cảm thấy quan tâm tới việc sử dụng các thuật toán di truyền để tạo ra thiết kế thuật toán và đi xa hơn các pallet hiện tại của các hình thức có sẵn và không gian. Chân trời là một danh mục đầy đủ phức tạp và đa dạng của sự kết hợp sáng tạo và tham vọng.

8

GENERATIVE ALGORITHMS

Hình.1.1. Mô hình tham số để tính toán tiến hóa và di truyền Thuật toán, Zubin Mohamad khabazi, AA, được thực hiện bởi Michael Weinstock, mùa thu năm 2008.

Một bước chuyển tiếp, các thuộc tính của hệ thống vật liệu trong các thuật toán thiết kế dường như có thể có trong khái niệm tham số này, bây giờ tiềm năng vốn có của các component và hệ thống nên được áp dụng các mô hình tham số của thiết kế. Các thuật toán không chỉ có thể tạo ra đáp ứng với hình thức, mà còn có một tiềm năng lớn để đạt được sự hệ thống logic các dữ liệu trong nó.

"Logic cơ bản của thiết kế tham số có thể được giới thiệu ở đây như là một phương pháp thiết kế thay thế, trong đó tính chính xác hình học của mô hình tham số có thể được triển khai đầu tiên tích hợp với sản xuất, lắp ráp logic và đặc điểm vật chất trong các component đơn giản, và sau đó để sinh sôi nảy nở các component vào các hệ thống lớn hơn. Phương pháp này sử dụng việc thăm dò của các biến tham số để hiểu được hành vi của hệ thống và sử dụng sự thăm dò này vào mục đích thiết kế của mình "(Hensel, Menges, 2008).

Để làm việc với các đối tượng phức tạp, một quá trình thiết kế thường bắt đầu từ một mức độ rất đơn giản và sau đó các layer khác được thêm vào, hình thức phức tạp bao gồm hệ thống thứ bậc khác nhau, kết hợp logic và các chi tiết của nó. Các mức này cũng được kết nối với nhau và component của nó ảnh hưởng lẫn nhau, như vậy phương pháp này được gọi là 'liên tưởng'.

Nói chung, liên tưởng Mô hình liên quan đến một phương pháp trong đó các yếu tố của thiết kế được xây dựng dần dần trong hệ thống phân cấp nhiều và ở mỗi cấp, một số thông số của các yếu tố này được chiết xuất tạo tiền đề cho các yếu tố khác trong các cấp độ tiếp theo, từng bước để tạo ra hình học toàn bộ. Vì vậy, về cơ bản là điểm cuối của một đường cong có thể là điểm trung tâm của vòng tròn khác và bất kỳ thay đổi trong đường cong sẽ thay đổi vòng tròn cho phù hợp. Về cơ bản phương pháp thiết kế này sử dụng với số lượng lớn các dữ liệu và tính toán xảy ra thông qua dòng chảy của các thuật toán. 9

GENERATIVE ALGORITHMS

Điều quan trọng là tất cả các dạng hình học này đều có thể dễ dàng điều chỉnh sau khi thực hiện xong quá trình tính toán. Các nhà thiết kế luôn luôn có thể truy cập vào các yếu tố của sản phẩm thiết kế từ điểm bắt đầu lên chi tiết. Trên thực tế, kể từ khi thiết kế sản phẩm là kết quả của một thuật toán, đầu vào của thuật toán có thể được thay đổi và kết quả cũng sẽ được cập nhật cho phù hợp.Bây giờ có thể phác thảo một mô hình và tạo ra hàng trăm biến thể của dự án bằng cách điều chỉnh các thông số hình học. Đó là khả thi để nhúng các thuộc tính của hệ thống vật chất, chế tạo và logic các thông số. Nó cũng có thể đáp ứng với môi trường và được kết hợp trong ý nghĩa lớn hơn. "... Tham số thiết kế cho phép công nhận các mô hình về hành vi hình học và năng lực biểu hiện liên quan và các xu hướng của hệ thống. Trong thông tin phản hồi tiếp tục với môi trường bên ngoài, những xu hướng hành vi có thể thông báo sự phát triển ontogenetic của một hệ thống cụ thể thông qua sự khác biệt tham số của tiểu địa điểm "(Hensel, Menges, 2008).

Hình.1.2. A. hình thức tìm hiểu trong hệ màng căng và bề mặt tối thiểu, mô hình vật lý, B. màng mô hình của phong trào với Grasshopper, Khabazi Zubin Mohamad, EmTech Core-Studio, AA, Thực hiện bởi Michael Hensel, Achim Menges, mùa thu năm 2008.

Grasshopper là một nền tảng trong Rhino để tạo ra những thuật toán và các kỹ thuật tạo các mô hình liên tưởng. Các chương sau đây được thiết kế để kết hợp các đối tượng hình học với các thuật toán để giải quyết một số vấn đề thiết kế trong kiến trúc với phương pháp thuật toán. Mục đích là mở rộng đối tượng hình học và sử dụng các câu lệnh trong grasshopper.

10

GENERATIVE ALGORITHMS

CHƯƠNG_2_The very begining

11

GENERATIVE ALGORITHMS

2_1_Giải pháp

" Algorithmic Modelling " và bây giờ chuyển thành " Generative Algorithms " và hai từ này có thể thay đổi cho nhau. Bạn nên xem các ví dụ đã được thực hiện trong các phiên bản trước đây, tôi cũng đã cố gắng cập nhật những gì cần thiết nhất và tôi chắc chắn rằng nếu bạn gặp phải bất kỳ sự khác biệt nào, bạn đều có thể giải quyết chúng theo cách của bạn. Khái niệm chính của cuốn sách là tập trung vào một số vấn đề hình học, kiến trúc, các dự án và phát triển sự hiểu biết về thuật toán, mô hình tham số, dựa trên các ví dụ thiết kế thay vì mô tả toán học thuần túy hoặc hình học. Để làm như vậy, trong nhiều trường hợp, tôi giả định rằng bạn đã có những hiểu biết cơ bản về cáccomponent. Grasshopper nhanh chóng phát triển và trở thành một nền tảng phù hợp giúp các kiến trúc sư trong việc thiết kế. Nhiều hơn một công cụ hoặc phần mềm, nó trình bày một cách suy nghĩ về các vấn đề thiết kế, một phương pháp gọi là tham số hoặc liên tưởng. Phương pháp này được phát triển bởi tất cả những người dùng trên khắp thế giới. sự phát triển của phương pháp này vẫn đang tiếp tục và luôn có những phiên bản mới, và luôn có các buổi thảo luận thú vị về các phiên bản được nâng cấp, tôi khuyên bạn nên thỉnh thoảng kiểm tra trang web Grasshopper. Trong chương này, tôi sẽ thảo luận về các vấn đề cơ bản mà chúng ta nên biết trước.

http://www.grasshopper3d.com/

2_2_Basics of Grasshopper

2_2_1_Interface, Workplace Bên cạnh các menu của Windows thông thường khác, có hai phần quan trọng trong giao diện Grasshopper: Panels Component và Canvas. Panels Component cung cấp tất cả các yếu tố cần cho thiết kế và Canvas là nơi làm việc, nơi chúng ta đặt các component và thiết lập các thuật toán. Bạn có thể click vào bất kỳ object từ Panels và kích một lần nữa vào Canvas để mang nó đến nơi làm việc hoặc bạn có thể kéo nó vào nơi làm việc. Các phần khác của giao diện dễ dàng để khám phá và bạn sẽ quen thuộc với nó thông qua việc sử dụng chúng sau này. Để biết thêm thông tin về chủ đề này,nó có sẵn tại:

12

GENERATIVE ALGORITHMS

http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryPluginInterfaceExplained.html

Hình.2.1. Grasshopper Component Tabs/Panels and Canvas

2_2_2_Components Có nhiều loại khác nhau của các object trong Grasshopper mà chúng ta sử dụng để thiết kế. Bạn có thể tìm thấy chúng theo các tab khác nhau được gọi là: Params, Logic, Primitive, Vector, Curve, Surface, Mesh, Intersect, Xform và Complex.

Mỗi tab có nhiều bảng và các object khác nhau, và các lệnh được sắp xếp giữa các bảng. Có các object để vẽ hình học như đường cong, vòng tròn và cũng có rất nhiều lệnh để di chuyển, rescale, chia, làm biến dạng hình học. Các thông số là các object đại diện cho dữ liệu, giống như là một điểm hoặc đường. Bạn có thể vẽ chúng bằng tham số có liên quan hoặc có thể xác định chúng từ các object trong Rhino. 13

GENERATIVE ALGORITHMS

Chúng ta thường cần phải cung cấp dữ liệu liên quan cho các component nó để làm việc. Trong hướng dẫn này, tôi đã sử dụng component .tôi luôn luôn sử dụng văn bản trong dấu để giải quyết chúng một cách rõ ràng, như . component

Nếu bạn nhấp chuột phải vào một component, một menu sẽ pop-up có chứa một số khía cạnh cơ bản của component. Menu này được gọi là " Context pop-up menu". “Context pop-up menu” Từ bây giờ, bạn cần tìm các component liên quan từ các bảng và thiết lập kết nối giữa các component này để tạo ra thuật toán thiết kế của bạn và xem kết quả trong Rhino.

14

GENERATIVE ALGORITHMS

Hình.2.2. Flowchart vs. Grasshopper Algorithm Defining External Geometries Chúng ta có thể sử dụng object trong Rhino hoặc có thể tạo ra các object trong Rhino từ Grasshopper.Chúng ta có thể nhìn vào tab Params dưới bảng điều khiển Gometry có một danh sách các loại khác nhau của hình học mà bạn có thể sử dụng để xác định object của bạn từ nơi làm việc Rhino.

15

GENERATIVE ALGORITHMS

Hình.2.3. Different geometry types in the Params > Geometry panel

Chúng ta có một ví dụ đơn giản. Chúng tôi có ba điểm trong khung nhìn Rhino và chúng ta muốn vẽ một hình tam giác bởi những điểm này trong Grasshopper. Trước tiên, chúng ta cần phải giới thiệu những điểm này trong Grasshopper. Chúng ta cần ba component từ Params > Point và đi vào menu ngữ cHình (kích chuột phải) và chọn và sau đó chọn điểm từ khung nhìn rhino (Hình.2.4).

Hình.2.4. Set point from Rhino in Grasshopper component

Hình.2.5. Grasshopper canvas và ba điểm được xác định đã chuyển sang màu đỏ (x) trong Rhino. Tôi đổi tên các component để nhận ra chúng dễ dàng hơn. 16

GENERATIVE ALGORITHMS

Components Connectivity

Chúng ta cần phải kết nối các component bao gồm các dữ liệu input cho các component xử lý và kết nối kết quả cho các component khác. Tôi chọn component (Curve>primitive>line). Kéo nó vào canvas. Sau đó kết nối và .

Bây giờ thêm component khác, làm điều đó một lần nữa cho và với component thứ ba. Có một hình tam giác trong khung nhìn Rhino.

Hình.2.7. các component được vẽ giữa các component . Như bạn thấy bất kỳ component nào cũng có thể được sử dụng nhiều hơn một lần.

17

GENERATIVE ALGORITHMS

Hình.2.8. Bây giờ nếu bạn thay đổi vị trí của các điểm bằng tay trong Rhino, vị trí của các điểm trong Grasshopper (X) và hình tam giác sẽ thay đổi cho phù hợp nhưng ranh giới giữa các điểm (hình tam giác) sẽ vẫn còn.

Như bạn có thể nhìn thấy trong ví dụ trên, đầu tiên, kết hợp kỹ thuật làm cho nó có thể thao tác các điểm và vẫn còn có hình tam giác giữa các điểm. mà không cần tiếp tục điều chỉnh.

Input / Output Như đã đề cập trước đây, bất cứ component nào trong Grasshopper đều có input và output có nghĩa là nó xử lý dữ liệu vào và xử lý dữ liệu trở ra. Input là phần trái của các component và output ở bên phải. Dữ liệu đến từ bất cứ nguồn nào thuộc phần input của các component và output của component là kết quả của chức năng cụ thể của từng component đó. Có một số tính năng về chủ đề này mà bạn có thể tìm hiểu thêm tại: http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryVolatileDataInheritance.html Bạn phải biết rằng những gì sắp xếp của các input bạn cần cho bất kỳ chức năng cụ thể và những gì bạn nhận được sau đó. Chúng ta sẽ nói thêm về loại khác nhau của dữ liệu chúng ta cần phải cung cấp cho mỗi component sau này. Chúng ta nên giữ chuột hoặc "di chuột" trên bất kỳ cổng input/ output của các component và bạn sẽ thấy tên, các dữ liệu bạn cần để cung cấp cho các component.

18

GENERATIVE ALGORITHMS

Hình.2.9. Pop-up công cụ đi kèm nếu bạn giữ chuột qua cổng input /output của component. Multiple connections Đôi khi bạn cần để gắn một component nhiều hơn một nguồn dữ liệu. Hãy tưởng tượng trong ví dụ trên, bạn muốn vẽ hai dòng từ và . Bạn có thể sử dụng hai component khác nhau hoặc bạn có thể sử dụng một component và đính kèm điểm B và C là điểm thứ hai của các component . Để làm được điều này, bạn cần phải giữ phím Shift khi bạn muốn kết nối các nguồn dữ liệu thứ hai của một component. Khi bạn giữ shift, mũi tên của con chuột xuất hiện trong một vòng tròn màu xanh lá cây với một biểu tượng nhỏ (+) trong khi bình thường nó có màu xám. Bạn cũng có thể sử dụng phím Ctrl để ngắt kết nối một component khác (thông thường bạn có thể ngắt kết nối một component từ một số khác bằng cách sử dụng menu ngữ cHình). Trong trường hợp này, các vòng tròn xung quanh con chuột xuất hiện trong màu đỏ với một biểu tượng nhỏ (-).

Hình.2.10. Multiple connections for one component by holding shift key. Colour Coding Có một hệ thống mã hóa màu sắc của Grasshopper, cho thấy các component trạng thái làm việc như thế nào.

19

GENERATIVE ALGORITHMS

Hình.2.11. Colour Coding. Component màu xám có nghĩa là không có vấn đề và các dữ liệu định nghĩa một cách chính xác / component hoạt động chính xác. Màu da cam cho thấy cHình báo và nó có nghĩa là có ít nhất một vấn đề cần được giải quyết, nhưng component này vẫn hoạt động. Các component màu đỏ có nghĩa là bị lỗi và các component không hoạt động trong tình huống này. Các nguồn gốc của lỗi được tìm thấy và giải quyết để làm cho công việc component đúng. Bạn có thể tìm thấy sự giúp đỡ đầu tiên về nguồn gốc của lỗi trong component menu ngữ cHình (context menu> runtime warning/ error) và sau đó tìm kiếm các dữ liệu input để tìm ra nguyên nhân của lỗi. Màu xanh có nghĩa là component này được lựa chọn. Hình học có liên quan với các component này cũng biến thành màu xanh lá cây trong khung nhìn Rhino (nếu không tất cả các hình học được tạo bởi Grasshopper đều màu đỏ). Preview Có thể sử dụng nó để ẩn hoặc bỏ ẩn các hình học trong khung nhìn rhino. Chúng ta thường sử dụng nó để ẩn các hình học không mong muốn,ví dụ như là các điểm cơ sở trong các mô hình phức tạp để tránh mất tập trung. Tùy chọn này được sử dụng trong các mô hình phức tạp để xử lý dữ liệu nhanh hơn, vì vậy bạn nên ẩn các hình học cơ sở khi bạn không cần nó.

20

GENERATIVE ALGORITHMS

2_2_3_Data matching Đối với nhiều component trong Grasshopper, nó luôn luôn có thể cung cấp một danh sách các dữ liệu thay vì chỉ một input. Vì vậy, trong bản chất, bạn có thể cung cấp một danh sách các điểm và một component có thể thu hút hàng trăm object nếu chúng ta cung cấp thông tin cần thiết. Look at this example: Tôi có hai bộ điểm khác nhau, với bảy điểm. Tôi sử dụng hai component và tôi đã sử dụng để giới thiệu tất cả các điểm trên trong một component. Như bạn thấy, bằng cách kết nối hai bộ của các điểm đến một component , bảy đoạn thẳng được tạo ra giữa chúng. Vì vậy, chúng ta có thể tạo ra nhiều hơn một object với mỗi component.

Hình.2.12. Nhiều bộ điểm và đoạn thẳng được tạo ra bởi chúng. Nhưng những gì sẽ xảy ra nếu số lượng điểm không giống nhau trong hai bộ điểm Trong ví dụ dưới đây, tôi có 7 điểm trong hàng đầu và 10 điểm ở phía dưới. Trong quản lý dữ liệu của Grasshopper được gọi là ''data matching". tại context pop-up menu của component, bạn thấy có ba tùy chọn gọi là: Shortest list Longest list Cross reference Xem sự khác biệt ở Hình 2.13. http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryDataStreamMatchingAlgorithms.html

21

GENERATIVE ALGORITHMS

A: shortest list,

B: longest list and

C: cross reference Hình.2.13. Data matching

22

GENERATIVE ALGORITHMS

2_2_4_Component’s Help (Context pop-up menu) Chúng ta dùng nó để xem các component làm việc như thế nào và sắp xếp dữ liệu cần thiết của input và output. Có những tính năng hữu ích khác trong context menu này mà chúng ta sẽ thảo luận về chúng sau này.

Hình.2.14. Context pop-up menu and Help part of the component

2_2_5_Type-In Component Search / Add

Hình.2.15. Tìm kiếm các component (ở đây tôi tìm component ) bằng cách nhấp đúp chuột trên canva (background của giao diện) và gõ tên "line". Component sẽ được đưa ra.

23

GENERATIVE ALGORITHMS

CHƯƠNG_3_Data Sets and Math

24

GENERATIVE ALGORITHMS

Mặc dù trong phần mềm 3D chúng ta có thể chọn hình học từ các trình đơn và vẽ một cách rõ ràng bằng cách nhấn vào mà không cần suy nghĩ những khía cạnh của toán học, để làm việc với các thuật toán có thể được tạo ra, chúng ta cần phải suy nghĩ một chút về dữ liệu và toán học để làmyếu tố đầu vào của thuật toán và tạo ra nhiều đối tượng. Vì chúng ta không muốn vẽ tất cả mọi thứ bằng tay, chúng ta cần một số nguồn dữ liệu là component cơ bản để có thể phát triển các thuật toán,nó có thể được sử dụng nhiều hơn một lần và có nhiều kết quả hơn trong một đối tượng. Cách thức mà thuật toán làm việc rất đơn giản. Nó bao gồm các đầu vào của dữ liệu, xử lý dữ liệu và đầu ra. Quá trình này xảy ra toàn bộ trong các thuật toán. Vì vậy, thay vì phương pháp truyền thống, chúng tôi cung cấp thông tin, thông tin này sẽ xử lý thuật toán và kết quả là đối tượng sẽ được tạo ra. Như tôi đã nói, thay vì sao chép một đối tượng bằng cách nhấp vào 100 lần trong màn hình, chúng ta có thể xác nhận với các thuật toán là sao chép đối tượng đó 100 lần. Hình học cóliên quan đến toán học,vì vậy chúng ta có thể sử dụng các chức năng toán học đơn giản trong các thuật toán các con số và các đối tượng để tạo ra những sự kết hợp vô hạn trong hình học.

3_1_Numerical Data Sets

Toán học và các thuật toán bắt đầu với những con số, chúng ta có thể tạo ra các bộ dữ liệu số khác nhau trong Grasshopper và sau đó chúng ta có thể sử dụng chúng để làm công cụ thiết kế.

One numerical value

Component (Params>special>number slider) có thể điều chỉnh bằng tay. Nó có thể là số nguyên, số thực, ngay cả với các giá trị giới hạn trên và dưới. Để thiết lập một giá trị số cố định là bạn có thể đi đến các Params> Primitive> Integer / Number to set on integer/ real value through context menu of / . 25

GENERATIVE ALGORITHMS

Series of numbers

(logic> Sets>Series). Component này tạo ra một list các số mà chúng ta có thể điều chỉnh các số và số lượng các giá trị. 0, 1, 2, 3, … , 100 0, 2, 4, 6, … , 100 10, 20, 30, 40, … , 1000000

Range of numbers

(logic> Sets> Range). Bất kỳ một khoảng số (ví dụ [1-10]) có thể được chia thành các phần vô hạn: 1, 2, 3, … , 10 1, 2.5, 5, … , 10 26

GENERATIVE ALGORITHMS

1, 5, 10

Domains (Intervals)

Params> Primitive> Domain/Domain2 Nó cung cấp một loạt các tất cả các số thực sự giữa một giới hạn trên và dưới, chúng ta có thể xác định một miền cố định bằng cách sử dụng component này để làm việc một cách linh hoạt.

3_2_On Points and Point Grids

Điểm là một trong những yếu tố cơ bản cho hình học và giải thuật có thể sinh sản. Điểm đánh dấu một vị trí cụ thể trong không gian, có thể bắt đầu từ điểm của đường cong, trung tâm của vòng tròn và rất nhiều vai trò khác, chúng ta có thể tạo ra các điểm theo nhiều cách: - (Params> Geometry>Point) :những điểm này có thể được điều chỉnh và di chuyển bằng tay trong Rhino. - (vector >point>point xyz) : tọa độ của điểm. - và : lưới điểm. - Chúng ta có thể trích xuất điểm từ hình học bằng nhiều cách khác nhau khác như điểm đầu, cuối, trung điểm, vv.. 27

GENERATIVE ALGORITHMS

Chúng ta có thể sản xuất các điểm và các bộ điểm bằng component , .

Hình.3.1. feeding a or component by three to generate a point by manually feeding the X,Y and Z coordinates.

Hình.3.2. Tạo ra một mạng lưới các điểm bằng component và . Các kiểm soát khoảng cách và số lượng các điểm.

Hình.3.3.Bạn có thể thay đổi giới hạn trên và dưới của để thay đổi tọa độ của các điểm, kích chuột phải vào phần D (domain) và thay đổi tên miền.

28

GENERATIVE ALGORITHMS

3_3_Other Numerical Sets

Random Data Sets Component ()cung cấp một list các số ngẫu nhiên và chúng ta có thể kiểm soát số lượng các giá trị của nó .

Hình.3.4. Tạo ra một tập hợp điểm ngẫu nhiên. component tạo ra 10 số ngẫu nhiên được điều khiển bởi và sau đó list này được xáo trộn bởi các component (logic> Sets> Jitter) cho Y tọa độ, và một lần nữa cho Z tọa độ. Trong hình 3.4, tất cả các điểm được phân phối trong không gian giữa 0 và . Để thay đổi khu vực phân phối của các điểm, chúng ta nên thay đổi tên miền số trong component .

Hình.3.5. Thiết lập một miền bằng component (vào Scalar> Domain> Domain)

Fibonacci series 29

GENERATIVE ALGORITHMS

Fibonacci là một dãy số với hai số đầu tiên được định nghĩa (0 và 1) và các số tiếp theo là tổng của hai số trước đó. 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) Dưới đây là một số các con số: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, … Ở đây tôi sử dụng series (logic> Sets> Fibonacci) để tăng số lượng của một component .

Hình.3.6. Số điểm có thể được kiểm soát với một .

3_4_Functions

Các component được xác định trước trong Grasshopper có thể không phải luôn luôn là công cụ thiết kế tốt nhất của bạn. Bạn có thể cần phải tạo ra bộ dữ liệu của riêng bạn hoặc ít nhất là thao tác dữ liệu của các component hiện có. Để làm như vậy, bạn cần sử dụng các chức năng toán học và thay đổi độ mạnh, khoảng cách, ... của các con số. Các chức năng là những component có thể thực hiện các chức năng toán học trong Grasshopper, có chức năng với các biến số khác nhau (Logic > script). Bạn cần để cung cấp một chức năng với các dữ liệu liên quan (không phải luôn luôn là số mà cũng là Boolean và String) và nó thực hiện chức năng trên các dữ liệu đầu vào mà ta xác nhận. Để xác định chức năng, bạn có thể phải bấm vào một phần (F) của các component và gõ vào sửa đổi biểu thức (expression editor). Sửa đổi biểu thức có rất nhiều chức năng được xác định trước và một thư viện các chức năng toán học. Chú ý đến tên của các biến mà bạn sử dụng trong biểu thức và các dữ liệu liên quan phù hợp với chức năng các component! Math functions Một ví dụ đơn giản là chức năng toán học của một vòng tròn có nghĩa là X = Sin (t) và Y = Cos (t) với (t) chạy từ 0 đến 2Pi sẽ hình thành một vòng tròn.

30

GENERATIVE ALGORITHMS

Hình.3.7. Parametric circle by mathematical functions. You have and functions in the (Scalar > Trig). (F(x) = x * 2Pi).

Hình.3.8. (x: F (x) = x/100, y: F (x) = x/10). (F (x) = x +2).Chúng ta có thể thao tác các tập hợp dữ liệu và tạo ra các hình học khác nhau.

Hình.3.9.Nguồn cấp dữ liệu component bởi các chức năng toán học sau đây: X = t * Sin (t), Y = t * Cos (t) Để áp dụng t * sin/ cos tôi đã sử dụng component từ (scalar>anylay). Ở đó bạn có thể tìm thấy các component cho các hoạt động toán học đơn giản.

31

GENERATIVE ALGORITHMS

Hình.3.10. Hình xoắn ốc liên tiếp từ hai điểm xoắn ốc đảo ngược thứ nhất : X: F (x) = x * Sin (x * 2 Pi), Y: F (x) = x * Cos (x * 2 Pi) thứ hai có chức năng tương tự nhưng ngược lại.

Hình.3.11 và là những component đã được đổi tên thành. X = Sin (u) * (-2 + v * sin (u / 2)) Y = Cos (u) * (-2 + v * sin (u / 2)) Z = v * Cos (u / 2) (u = 0 đến 8Pi và v =- 2 đến 2 )

32

GENERATIVE ALGORITHMS

Thực hiện các biểu thức toán bằng các chức năng toán học có thể không bao giờ kết thúc. Bạn có thể tìm thấy rất nhiều yếu tố toán học để phù hợp với dữ liệu của bạn. Điểm quan trọng là bạn có thể thao tác các bộ dữ liệu ban đầu và tạo ra các giá trị số khác nhau và component khác nhau. Vì vậy, bằng cách tập hợp của dữ liệu số, chúng ta có thể tạo ra hình học và vấn đề là làm thế nào cho các thuật toán làm việc. chúng ta dựa vào phương pháp thuật toán để đáp ứng với các vấn đề về thiết kế hình học, giống như bề mặt rất đẹp Enneper.

33

GENERATIVE ALGORITHMS

3_5_Boolean Data types

Dữ liệu không giới hạn chỉ có số. Có những loại dữ liệu khác có ích cho các mục đích khác nhau trong lập trình và các thuật toán. Vì chúng ta đang xử lý với các thuật toán, chúng ta cần biết rằng sự phát triển của một thuật toán không phải là tuyến tính. Đôi khi chúng ta muốn quyết định có làm điều gì đó hay không. Lập trình viên gọi nó có câu lệnh điều kiện. Đáp ứng của một câu hỏi điều kiện đơn giản là có hoặc không. trong các thuật toán, chúng tôi sử dụng dữ liệu Boolean để đại diện cho những phản ứng. Các kiểu dữ liệu Boolean đại diện cho giá trị chỉ True (có) hoặc False (không có). Nếu câu lệnh đáp ứng các tiêu chuẩn, phản ứng là True, nếu không thì là False. Như bạn thấy, kiểu dữ liệu này rất hữu ích trong trường hợp khác nhau khi bạn muốn quyết định về một điều gì đó, chọn một số các đối tượng theo 1 tiêu chí nhất định,và sắp xếp các đối tượng đó, v v

Hình.3.12. Ở đây tôi tạo ra mười giá trị và một component (scalar>operator),tôi sử dụng component ( Params>special) để hiển thị nội dung của và kết quả của các component .

34

GENERATIVE ALGORITHMS

Hình.3.13. Tạo ra 30 giá trị với một component và sử dụng một component (scalar> operator> Modulus) để tìm phần dư của phép chia các số cho 3 và tôi đã thông qua kết quả . kết quả là một có giá trị True / False. Trong tab Logic và trong bảng điều khiển Boolean có các component khác nhau làm việc với kiểu dữ liệu Boolean.

Hình.3.14.Sử dụng component (logic> Boolean> gate and). Kết quả là True khi cả hai đầu vào có giá trị Boolean là True, nếu không nó sẽ là False. Có nhiều component Boolean trong bảng điều khiển của tab Logic mà bạn có thể sử dụng và kết hợp chúng để tạo ra các tiêu chí của bạn, Chúng ta sẽ thảo luận làm thế nào để sử dụng các giá trị Boolean.

3_6_Cull Lists

Chúng tôi cần phải lựa chọn một số nội dung cụ thể từ một list hoặc bỏ qua các list khác. Có nhiều cách khác nhau để đạt được điều này, nhưng chúng ta hãy bắt đầu với việc bỏ qua hoặc chọn lọc list các dữ liệu. Có ba component để chọn lọc một list các dữ liệu trong Grasshopper. bỏ qua tất cả các mục N của một list dữ liệu, có các giá trị Boolean(True / False) và chọn lọc một list các dữ liệu, dựa trên mô hình này, chỉ chọn list dữ liệu số. Nếu số lượng các giá trị trong list dữ liệu và list Boolean là như nhau, mỗi mục của list dữ liệu được đánh giá bởi cùng một mục trong list Boolean. Nhưng bạn có thể xác định một mô hình đơn giản của các giá trị Boolean (như False / False / True / True là được xác định trước trong component) và component 35

GENERATIVE ALGORITHMS

sẽ lặp lại cùng một khuôn mẫu cho tất cả các mục của list dữ liệu. Để hiểu rõ hơn, ở đây tôi muốn giới thiệu một trong những cách chúng ta có thể chọn dữ liệu mà chúng ta mong muốn từ một tập hợp dữ liệu.

Distance example Tôi đang nghĩ đến việc lựa chọn một số điểm từ một điểm thiết lập dựa trên khoảng cách của chúng đến một điểm khác, những gì tôi cần là một component (Vector> Poin> Distance). Tôi so sánh các khoảng cách này bởi () với một component (logic> Script> F2 / function with two variable). So sánh này tạo ra các giá trị Boolean ở đầu ra (True / False) so với giới hạn F = x> y (giống như component ). Tôi sẽ sử dụng các giá trị Boolean cho component . có một list các dữ liệu chung và một list các dữ liệu Boolean và bỏ qua các dữ liệu liên kết với giá trị "False" của list Boolean.Để hiển thị chúng tốt hơn tôi chỉ kết nối chúng với các điểm tham chiếu bởi một đơn giản.

Hình.3.15. Lựa chọn các điểm từ một điểm được thiết lập bởi khoảng cách của nó đến một điểm tham khảo bằng cách sử dụng component .

Topography example Sau khi kiểm tra khoảng cách, tôi nghĩ đến việc lựa chọn một số điểm có liên quan với các đường cong trên một địa hình, dựa trên chiều cao của nó.

36

GENERATIVE ALGORITHMS

Hình.3.16. Topography with points associated with contour lines.

Những gì tôi có là một tập hợp điểm được tạo bởi một component (đặt tên theo địa hình). Tôi cần chiều cao của các điểm, ở đây tôi sử dụng một component (Vector>Point >Decompose) để có được tọa độ Z (chiều cao) của những điểm này. mang lại cho tôi tọa độ X, Y và Z của mỗi điểm đầu vào của nó. Tôi so sánh các giá trị này với một component để sản xuất một list các giá trị Boolean nhằm lựa chọn một số điểm có liên quan với các đường cong trên một địa hình, dựa trên chiều cao của nó.

Hình.3.17. Điểm được lựa chọn cao hơn 4,7550 (Một giá trị mà người dùng đưa ra).

3_7_ Data Lists

Những vấn đề cơ bản của mô hình thuật toán là list dữ liệu. List dữ liệu có thể là bất kỳ cacs loại dữ liệu như số, điểm, hình học,...chúng ta có thể trích xuất một phần của một list các con số, giúp chúng ta đạt được một list dữ liệu mong muốn cho các mục đích thiết kế. Nghiên cứu một số ví dụ:

37

GENERATIVE ALGORITHMS

Hình.3.18.Component cho chúng ta tọa độ của điểm. Về cơ bản component sắp xếp một list (hoặc nhiều list) của dữ liệu dựa trên một list dữ liệu số để phân loại. Vì vậy, ở đây tôi sắp xếp tất cả các điểm có tọa độ X như là các dữ liệu chính. Những gì tôi cần là chọn mục đầu tiên của list này. Để làm điều này, tôi cần một component .

Các ví dụ : Triangles

Hãy phát triển các thử nghiệm của chúng ta với quản lý dữ liệu. Hãy tưởng tượng chúng ta có một mạng lưới các điểm và chúng ta muốn vẽ những đuờng thực hiện hình tam giác với một mô hình như con số 3,19. quan niệm này rất hữu ích trong các vấn đề hệ mắt lưới, nhưng thời điểm này, quan trọng để có thể tạo ra khái niệm cơ bản này. Hình.3.19. Tạo hình tam giác bởi một mạng lưới các điểm. Bước đầu tiên là tạo ra một mạng lưới các điểm bởi component và . Bước tiếp theo là tìm các điểm thích hợp để vẽ đường ở giữa. Mỗi lần chúng ta cần một dòng bắt đầu từ một điểm và kết thúc tại điểm tiếp theo trên cùng một hàng cột. chúng ta cho ba list các điểm khác nhau, một cho tất cả các điểm đầu tiên, một cho tất cả các điểm thứ hai và một cho tất cả các điểm thứ ba và sau đó vẽ đường thẳng giữa chúng. Tôi có thể sử dụng các điểm ban đầu là list cho tất cả các 'start point', để chọn điểm thứ hai tôi chỉ chuyển list ban đầu bằng component (logic>list>shift list) , điểm thứ ba của tam giác là điểm đầu tiên của tam giác tiếp theo.

38

GENERATIVE ALGORITHMS

Hình.3.21. Sử dụng bỏ qua cột cuối cùng của list điểm đầu tiên, thứ hai và thứ ba. Bước cuối cùng là dùng ba component để kết nối các điểm đầu tiên với điểm thứ hai và điểm thứ hai với điểm thứ ba và điểm thứ ba với điểm đầu tiên một lần nữa.

39

GENERATIVE ALGORITHMS

Hình.3.22.Kết nối list chọn lọc của các điểm bởi component . Các component set to Cross reference và các component set to Longest List.

Hình.3.23. Bây giờ bạn có thể thay đổi cho phù hợp. Mặc dù vẫn còn một số vấn đề với thiết kế của chúng ta và chúng ta biết rằng chúng ta không nên bắt đầu bất kỳ hình tam giác từ điểm của các dòng cuối cùng (và chúng ta nên bỏ qua chúng từ list các điểm đầu tiên), nhưng khái niệm này là rõ ràng rồi. Chúng ta sẽ quay trở lại ý tưởng này trong khi nói chuyện về các lưới hình học và sau đó tôi sẽ cố gắng để tinh chỉnh chúng. Ý tưởng chính là để xem làm thế nào dữ liệu được tạo ra và cách quản lý chúng. Hãy phát triển sự hiểu biết của chúng ta thông qua nhiều thử nghiệm hơn.

40

GENERATIVE ALGORITHMS

3_8_On Planar Geometrical Patterns

Mô hình hình học là một trong những vấn đề có thể thiết kế với các thuật toán có thể sinh sản trong Grasshopper. Chúng tôi thiết kế một motif và sau đó sinh sôi nảy nở nó và có thể sử dụng nó như là cơ sở của các sản phẩm thiết kế khác, bằng cách vẽ hình học cơ bản, chúng ta có thể sao chép nó để sản xuất các mô hình lớn hơn mà chúng ta cần (Hình.3.22).

Hình.3.24. Khái niệm về một mô hình hình học đơn giản. Bằng cách tập hợp dữ liệu và các chức năng toán học đơn giản, chúng có tiềm năng to lớn để tạo ra các hình dạng hình học, có thể là các hình học cổ điển.

41

GENERATIVE ALGORITHMS

Hình.3.25. Hình học phức tạp của mái nhà thờ Hồi giáo Sheikh Lotfollah -Iran, bao gồm các mô hình đơn giản được tạo ra bởi các tính toán toán học, hình học.

Simple Linear Pattern Ở đây tôi quyết định thiết kế một mô hình với một số điểm cơ bản, mục tiêu của tôi là sử dụng các khái niệm.

Hình.3.26. Khái niệm cơ bản để tạo ra các mô hình. Tôi muốn tạo ra một số điểm cơ bản như điểm cơ sở và sau đó vẽ các đoạn thẳng giữa chúng. Tôi bắt đầu bởi một làm cho nó có thể kiểm soát số lượng các giá trị (ở đây là số điểm) và khoảng cách giữa các điểm. Ttôi tạo ra một tập hợp các điểm chỉ với mục X (Y và Z = 0).

42

GENERATIVE ALGORITHMS

Hình.3.27. Ở đây tôi tạo ra thiết lập điểm đầu tiên của tôi với component và . Thủ thuật mới là một component từ (Params> Primitive>Receiver). Ở đây các component nhận dữ liệu từ .

Hình.3.28. Để tạo ra một hình thức "zig-zag" tôi cần hai hàng của các điểm như là cơ sở. Tôi sử dụng khác để có được dữ liệu từ và với khác tôi tạo ra dòng thứ hai với các giá trị Y đến từ một .

Hình.3.29. Trong bước tiếp theo, tôi cần phải bỏ một số điểm từ mỗi list để cung cấp các điểm cơ bản cho mô hình zig-zag. Ở đây tôi bỏ qua những điểm với . 43

GENERATIVE ALGORITHMS

Hình 3.30. Bây giờ nếu bạn kết nối cả hai component bởi một component , bạn sẽ thấy kết quả là một hình dạng Z.

Hình.3.31. Các điểm được mô tả là (logic>List). khi bạn kết nối nó với dòng đầu tiên của zig-zag sẽ được tạo ra.

Hình.3.32. Tương tự, tôi tạo ra hàng điểm thứ ba, với và tôi đã có dòng zig-zag thứ hai của mô hình. 44

GENERATIVE ALGORITHMS

Hình.3.33. Mặc dù có nhiều cách ngắn hơn để tạo ra những dòng này, tương tự cho các điểm và pline của hàng thứ ba. Preview component , và để ẩn tất cả các điểm chỉ để lại component Plines.

Hình.3.34.Sử dụng cùng một với chức năng của f (x) =-x, bạn sẽ có một của component đối xứng của Plines, bạn có thể tạo ra các quy mô và hình dạng khác nhau..

Hình.3.35. Bạn có thể thay đổi cách bạn tạo ra các điểm cơ sở hoặc chọn lọc list dữ liệu để sản xuất các mô hình phức tạp hơn..

45

GENERATIVE ALGORITHMS

Hình.3.36. Đây là kết quả đầu tiên của thiết kế. Motif được lặp đi lặp lại và kết quả có thể được sử dụng trong nhiều mục đích của bạn.

Hình.3.37. Điều này chỉ là một trong những ví dụ trong số hàng trăm khả năng sử dụng các mô hình cơ bản để phát triển một sản phẩm thiết kế.

46

GENERATIVE ALGORITHMS

Circular patterns Tôi sẽ mô tả một phần của thuật toán và phần còn lại dành cho bạn.

Hình.3.38. Circular geometrical patterns. Điểm bắt đầu của mô hình này là một tập hợp dữ liệu tạo ra một loạt các điểm dọc theo một vòng tròn, giống như ví dụ chúng tôi đã làm trước đây. Tập hợp dữ liệu có thể được thay đổi tỷ lệ từ các center để cung cấp nhiều hơn và nhiều hơn nữa đường tròn xung quanh trung tâm. Tôi sẽ huỷ các bộ điểm với cùng một cách như là các ví dụ cuối. Sau đó, tôi sẽ tạo ra một mô hình lặp đi lặp lại 'zig-zag "của các điểm thay đổi tỷ lệ vòng tròn và kết nối chúng với nhau, làm thành một đường có hình dạng ngôi sao. sự chồng chéo của những ngôi sao này có thể là một phần của mô típ.

Hình.3.39. Sử dụng component Sin / Cos để tập hợp các điểm trong một hình học tròn.

47

GENERATIVE ALGORITHMS

Hình.3.40. Tăng kết quả của chức năng Sin / Cos, trong khi nhân với một < number slider >, thiết lập thứ hai các điểm có bán kính lớn hơn. Như bạn thấy kết quả của phần này là hai điểm. Tôi đổi tên component .

Hình.3.41. Đường tròn tròn điểm đầu tiên và thứ hai. Để đến các điểm bị loại (cull point) , chúng ta chỉ đơn giản sử dụng cho các điểm và sử dụng True / False giống như ví dụ cuối cùng. Có thể một lần nữa để sử dụng component . Nhưng ở đây tôi muốn sử dụng một khái niệm phân loại mà tôi nghĩ sẽ là hữu ích sau này. Tôi muốn sắp xếp các điểm dựa trên số chỉ mục của chúng trong thiết lập này. Trước hết tôi cần phải tạo ra các con số chỉ số. Bởi vì tôi tạo ra điểm bởi một component với số thực, ở đây tôi cần một component để cung cấp các số nguyên là chỉ số của các điểm trong list. Tham số N của xác định số lượng các bước hoặc bộ phận, do đó component tạo ra N +1 số. Đó là lý do tại sao tôi cần một với N +1 giá trị là chỉ số của các điểm.

48

GENERATIVE ALGORITHMS

Hình.3.42. Tạo chỉ số của các điểm (một list các số nguyên bắt đầu từ 0)

Hình.3.43. Bây giờ tôi cần đến các điểm bị loại và các thông số cả những ví dụ trước. Sau đó, tôi sử dụng component (Logic> Tree) để tạo ra một list những dữ liệu từ cả hai list .

49

GENERATIVE ALGORITHMS

Hình.3.44. Điểm được sắp xếp với một component . Một polyline được vẽ bởi các điểm sắp xếp.

Hình.3.45. Tạo ra một hình sao. Tương tự như vậy,chúng ta có thể sử dụng để tạo ra các dạng hình học phức tạp hơn bằng cách là tạo ra các bộ điểm khác, chọn lọc và kết nối chúng lại với nhau để sản xuất các đối tượng mà chúng ta mong muốn.

50

GENERATIVE ALGORITHMS

Hình.3.46. Bạn có thể nghĩ về những khả năng khác của mô hình và hình học tuyến tính, ứng dụng của chúng như chiếu (project) lên 1 đối tượng hình học khác.

Hình.3.47. Final model.

51

GENERATIVE ALGORITHMS

CHƯƠNG_4_Transformations

52

GENERATIVE ALGORITHMS

Sự biến đổi là việc làm cần thiết trong việc model và tạo ra các hình học. Chúng cho phép chúng ta có được các biến thể từ các đối tượng đơn giản ban đầu. Biến đổi giúp chúng ta thay đổi tỉ lệ và định hướng của đối tượng :di chuyển, sao chép, nhân bản, hoặc có thể dẫn đến tổng hợp của các đối tượng. Có nhiều loại biến đổi khác nhau , nhưng để phân loại chúng, chúng ta có thể phân chia thành các nhánh chính, và sự phân chia đầu tiên là biến đổi tuyến tính (linear) và không gian (spatial). Biến đổi tuyến tính thực hiện trong không gian 2D, trong khi biến đổi không gian hiện trong không gian 3D Cách khác, chúng ta có thể phân loại chuyển đổi theo tình trạng của đối tượng ban đầu, biến đổi như translation, rotation, và reflection giữ hình dạng ban đầu nhưng thay đổi tỉ lệ và làm biến dạng tình trạng ban đầu của đối tượng. Ngoài ra còn có các biến đổi phi tuyến tính. Ngoài translation, rotation, và reflection, chúng ta có các loại biến đổi ti lệ và biến dạng khác nhau và không thống nhất trong không gian 3D như xoắn ốc spiral và xoắn ốc helical . Để chuyển đổi các đối tượng, chúng ta cần di chuyển và định hướng đối tượng (hoặc một phần của các đối tượng) trong không gian và để làm điều này, chúng ta cần phải sử dụng vector và mặt phẳng là vấn đề cơ bản của các toán học / hình học. Chúng ta sẽ không thảo luận các vấn đề cơ bản của hình học và logic toán học của chúng ở đây, nhưng trước tiên hãy có một cái nhìn sơ lược về vectơ và mặt phẳng vì chúng ta cần chúng để làm việc.

Hình 4.1 Biến đổi có khả năng để tạo ra các hình thức phức tạp từ các cá thể. Thiên nhiên có một số ví dụ tuyệt vời về biến đổi.

53

GENERATIVE ALGORITHMS

4_1_Vector và Mặt phẳng _Vectors and Planes

Vector là một đối tượng toán học / hình học có độ lớn (chiều dài), hướng và chiều. Nó bắt đầu từ một điểm, hướng tới một điểm khác với độ dài nhất định và hướng cụ thể. Vectoc được sử dụng rộng rãi trong các lĩnh vực khác nhau của khoa học và hình học cung như là torng các biến đổi.

Hình.4.2.A: các component cơ bản của một vector, B: điểm chuyển vị của một vector. Chỉ đơn giản là nếu chúng ta có một điểm và vector, vector này có thể chuyển vị với khoảng cách bằng độ lớn của vector và theo hướng của nó để tạo ra một vị trí mới cho vector. Chúng ta sử dụng khái niệm này đơn giản để tạo ra, di chuyển, đổi tỉ lệ và định hướng hình học Mặt phẳng (plane) có thể mô tả chúng như là các bề mặt phẳng vô hạn trong đó có một điểm gốc. Cấu trúc của các mặt phẳng trong Rhino là các loại phẳng này. Chúng ta có thể sử dụng những mặt phẳng này để đưa hình học của chúng ta vào chúng và làm một số biến đổi trên cơ sở định hướng và gốc toạ độ. Ví dụ trong không gian 3D, chúng ta không thể định hướng cho 1 vector! và chúng ta cần hai vectơ để tạo ra một mặt phẳng để có thể đưa các đối tượng hình học đặt trên nó. Vectơ có hướng và độ lớn trong khi mặt phẳng có định hướng và toạ độ. Vì vậy, chúng là hai loại khác nhau của các cấu trúc có thể giúp chúng ta tạo ra, sửa đổi, biến đổi và làm rõ các model của chúng ta trong không gian. Grasshopper có một số của các vector và mặt phẳng cơ bản như các component được mặc định trước. Bao gồm vector đơn vị X,Y,Z và các mặt phẳng XY, XZ, YZ. Có vài component khác để tạo ra hiệu chỉnh chúng mà chúng ta sẽ nói về chúng trong các ví dụ sau. Vì vậy, hãy bắt đầu thiết kế với một số cách sử dụng đơn giản của vectơ . 54

GENERATIVE ALGORITHMS

4_2_On Curves and Linear Geometries

Như chúng ta đã thử nghiệm với điểm như là hình học 0 chiều , bây giờ chúng ta có thể bắt đầu suy nghĩ về các đường cong như các đối tượng 1 chiều.Giống như điểm, đường cong có thể là cơ sở xây dựng rất nhiều đối tượng khác nhau.Chúng ta có thể extrude một đường cong cùng nhau và tạo ra một bề mặt, chúng ta có thể kết nối các đường cong khác nhau lại với nhau và tạo ra mặt và khối , chúng ta có thể sắp xếp bất kỳ đối tượng dọc theo một đường cong với những khoảng cụ thể và rất nhiều cách khác để sử dụng một đường cong như là một hình học cơ sở tạo ra các đối tượng khác. Chuyển vị/ Displacements Chúng ta tạo ra lưới điểm trong chương 3 bởi các component và . Nhưng có một component được gọi (Vector> Point> Grid rectangular) tạo ra một mạng lưới các điểm. Chúng ta có thể kiểm soát số lượng các điểm theo hướng X, Yvà khoảng cách giữa các điểm (tương đương ở cả hai chiều) trong component này.

Hình.4.3. một component các giá trị mặc định sẵn của nó Bạn có thể thay đổi kích thước của lưới bằng ở đầu vào (S) của component . Bạn cũng có thể thay đổi định hướng của điểm. Để làm điều này, bạn cần một mặt phẳng dính lưới của bạn trên đó. Ở đây, ta giới thiệu một component (Vector> Constants> XY plane) là một phẳng được xác định trước bằng trục X và Y và ta chuyển vị theo trục Z bằng component (Vector > Constants > Z unit) là một vector dọc theo trục Z với chiều dài (độ lớn) bằng 1. Ta có thể thay đổi chiều cao của sự chuyển vị này bởi kích thước của vector thông qua một

55

GENERATIVE ALGORITHMS

mà ta kết nối với các đầu vào của các component , thay đổi vị trí của dọc theo trục Z sẽ thay đổi vị trí của lưới điểm.

Hình.4.4.điều khiển lưới (lưới được chọn hiện màu xanh lá cây ) với một để thay đổi lưới (khoảng cách giữa các điểm) và và khác để thay đổi tọa độ Z của lưới điểm. Bây giờ nếu bạn nhìn vào out put của bạn có thể thấy rằng chúng ta có thể truy cập toàn bộ các điểm cũng như các tế bào lưới và các tế bào trung tâm. Trong ví dụ này, ta đang tìm kiếm một nhóm line bắt đầu từ các điểm trung tâm của các tế bào lưới và mở rộng ra không gian, bằng cách chỉ sử dụng các lưới. Ta chỉ đơn giản là kết nối điểm từ 2 phần M của hai component cho một component , và tạo ra một nhóm line . Sau đó, thay đổi kích thước của lưới thứ hai sẽ cho kết quả ở hướng của tất cả các line. Ở đây vấn đề là chiều dài của line trong trường hợp này sẽ là khác nhau, nhưng ta muốn vẽ đường có cùng độ dài, và ta cần một chiến lược và đó là lý do tại sao ta sẽ sử dụng một component . Component vẽ một line với điểm bắt đầu (S), Hướng (D), và Dài (L).Vì vậy, chiều dài của line là điều khiển được.Chính xác những gì ta cần, ta có những điểm bắt đầu (trung điểm của tế bào), và chiều dài line. Hướng?Ta muốn sử dụng lưới tế bào trung điểm thứ hai là điểm thứ hai của line để hướng line của ta là theo hướng của các đường kết nối các điểm giữa lưới tế bào. Để xác định các hướng ở đây ta cần một số vectơ thay vì line.Đó là lý do tại sao ta sẽ tạo ra một tập các vectơ bởi hai bộ điểm này để tạo ra hướng cho component .

Hình.4.5. Tạo vectơ từ các điểm của lưới đầu tiên hướng tới các điểm của lưới thứ hai của component (Vector> Vector> vector 2pt). Component này tạo ra vectơ bằng điểm bắt đầu và điểm cuối của vectơ. 56

GENERATIVE ALGORITHMS

hình.4.6. tạo ra loạt các line từ lưới điểm thứ nhất trải ra vào không gian bởi vì kích thước lớn hơn của lưới thứ hai. Ta có thể thay đổi chiều dài của line bằng và ta có thể thay đổi hướng của chúng bằng cách thay đổi kích thước của lưới thứ hai. Bước tiếp theo, ta muốn thêm một đa giác ở phần cuối của mỗi đường và extrude nó đến điểm bắt đầu của line để cảm nhận tiềm năng sinh ra của các component đường cong.Để tạo ra các đa giác, ta có thêm một mặt phẳng tại điểm cuối của line là mặt phẳng cơ sở để có thể tạo ra các đa giác.

Hình.4.7.bằng cách dung component (Curve > Analysis> end points) và dung như là gốc toạ độ cho tập hợp các mặt phẳng, ta có thể tạo ra các mặt phẳng cơ sở. Ở đây ta dùng component (Vector> Plane) tạo ra các mặt phẳng bằng một điểm gốc và mộ vector theo trục Z cho mặt phẳng(vector pháp tuyến là vector vuông góc với mặt phẳng). ở đây ta dùng những vector của line như là vector pháp tuyến của mặt phẳng.

57

GENERATIVE ALGORITHMS

Hình .4.8. thêm vào component và dùng các mặt phẳng đã được tạo ra như là mặt phẳng cơ sở cho các lục giác, chúng ta có một tập hợp các lục giác ở điểm cuối và vuông góc với các line đã tạo ra.như các bạn đã thấy, nhưng lục giác này có chung một kích thước nhưng ta muốn có sự thay đổi về kích thước tạo ra một hình dáng mượt mà hơn.

hình.4.9. Với component ta nhận được số lượng line và các component tiếp theo đó là căn bậc hai của các đầu vào (F (x) = Sqrt (x)), tính toán số lượng line ở mỗi hàng. Ta sử dụng một component với điểm bắt đầu và kích thước bước (step) = 0,1. Vì vậy, ta tạo ra một danh sách các số từ lớn dần lên bằng số lượng các đa giác ở mỗi hàng. Để có thể sử dụng các giá trị cho tất cả các đa giác, ta nhân đôi các danh sách dữ liệu với số lượng cột (ở đây bằng số lượng hàng) và gắn nó vào 58

GENERATIVE ALGORITHMS

đầu vào (R) của đa giác. Như bạn có thể nhìn thấy trong model, mỗi hàng, kích thước của đa giác dần dần thay đổi và mô hình này lặp đi lặp lại đến người cuối cùng.

Hình4.10. trong bước cuối cùng, ta dùng component (Surface>Freeform) và ta đã gán điểm bắt đầu của line như là điểm mà ta muốn các luc giác extrude.

Hình.4.11. Bây giờ sử dụng ‘Remote Control Panel’ từ View menu, bạn có thể thay đổi các giá trị của number slider một cách dễ dàng và chọn cái tốt nhất. Đừng quên bỏ chọn Preview của nhưng d9oi61 tượng không cần thiết đi. 59

GENERATIVE ALGORITHMS

Hình.4.12. Final model

60

GENERATIVE ALGORITHMS

4_3_Combined Experiment: Swiss Re

Ngày nay nó để thiết kế concept tòa tháp với các phương pháp mô hình hóa kết hợp là rất phổ biến.Nó cho phép các nhà thiết kế tạo ra các mô hình khác biệt, đơn giản và nhanh chóng. Có tiềm năng rất lớn để thay đổi thiết kế sản phẩm và tìm các concept khá nhanh chóng.Ở đây ta quyết định để mô hình một tháp và ta nghĩ rằng tháp "Swiss Re" của Foster có vẻ là đủ cho thích hợp nhất. đầu tiên, hãy có một cái nhìn sơ qua về công trình:

Hình.4.13. Swiss Re HQ, 30 St Mary Axe, London, UK, 1997-2004, Photos from Foster and Partners website, http://www.fosterandpartners.com.

Hãy để ta nói cho bạn về concept. Ta sẽ vẽ một vòng tròn như là phác thảo của tháp và sao chép nó để làm cho một số tầng mà mặt tiền sẽ thay đổi độ cong của nó. Sau đó, ta sẽ thay đổi tỉ lệ các tầng để phù hợp với hình dạng, ta sẽ làm vỏ bao của tháp. Cuối cùng, để tạo ra cấu trúc cá thể đơn lẻ của mặt tiền ta sẽ thêm phần đa giác. Để thực hiện quá trình này, ta giả định kích thước, tỉ lệ và ta sẽ giải quyết model bằng hình học rất đơn giản để làm cho quá trình đơn giản.

61

GENERATIVE ALGORITHMS

Hãy bắt đầu với sàn. Ta biết rằng tầng của Swiss Re là vòng tròn có một số vết cắt hình chữ V-xung quanh chúng, nhưng ta chỉ sử dụng một vòng tròn đơn giản để làm cho các phác thảo của tháp. Ta muốn sao chép những tầng ở độ cao nhất định làm cho nó có thể chay thay đổi tỷ lệ tháp một cách trực quan. Như ta đã nói, những điểm này được đặt ở các vị trí thay đổi độ cong ở mặt tiền

Hình.4.14.component với đóng vai trò như bán kinh là phác thảo của tháp. Vòng tròn được sao chép 6 lần bởi component theo hướng Z bằng component Affine > Scale) để rescale tầng mẫu. Các component cần geometry, tâm điểm scale,hệ số scale.Vì vậy, ta cung cấp một phần hình học của nó bởi các tầng hoặc vòng tròn đó là output của các component .Tâm điểm được xác định trước rộng là điểm gốc toạ độ, nhưng nếu ta scale tầng bằng gốc toạ độ như là tâ, điểm, chúng sẽ dịch chuyển trong không gian bởi vì chiều cao của chúng cũng bị scale. Ta cần những tâm scale ở tầng tương tự tại mỗi tầng. Đó là nguyên nhân ta dùng component (Curve > Analysis > Centre) đễ tạo ra tâm của đường tròn. Bằng việc nối nó vào bạn có thể nhận ra rằng nhưng đường tròn đó sẽ được thay đổi tỉ lệ mà không cần chuyển vị Một lần nữa ta phải nói rằng các hệ số scale đó là giả định trong các độ cao mẫu mà ta đã từng thực hiện trước đó. Những giá trị này có thể được thay đổi để kết hợp tốt nhất phù hợp với tổng thể. Tất cả chúng được thiết lập trong component

Hình.4.16. Bây giờ nếu ta loft các tầng bằng component (surface > freeform > loft) hình Hình đầu tiên của tháp xuất hiện. Từng chút một, ta nên bỏ chọn tùy chọn preview của các điểm và đường cong tạo ra trước đây để làm sạch.

63

GENERATIVE ALGORITHMS

Ok! Bây giờ đến các yếu tố mặt đứng. Mặt đứng các yếu tố cấu trúc có hình dạng xoắn ốc có mặt cắt ngang như hai hình tam giác kết nối, nhưng một lần nữa để làm cho nó đơn giản, ta chỉ model một phần có thể nhìn thấy của nó là gần giống như một hình tam giác. Ta cần những phần để loft tạo ra khối tích của chúng. Ta muốn tạo ra những phần hình tam giác trên mặt đứng. Để làm được điều đó, trước tiên ta cần phải tìm vị trí của những hình tam giác trên mặt đứng. Ta nghĩ rằng nếu ta tạo ra một đường cong trên bề mặt mặt tiền và chia nó, nó sẽ là một nơi chấp nhận được để thừa nhận tất cả các hình tam giác trước khi biến đổi .

Hình .4.17. ta dung component để lấy điểm đầu/ cuối của tầng điển hình. Bằng cách gắng những điểm này như là nhưng điểm thẳng đứng cho component (curve > spline > interpolate) sẽ tạo ra một đường cong nằm trên mặt đứng

Hình .4.18. ở đây ta chia đường cong thành 40 phần. số lượng của số chia giúp các component trên mặt đứng mềm mại hơn.

64

GENERATIVE ALGORITHMS

Hình.4.19. Bây giờ , các điểm chia trở thành các điểm cơ sở để hình thành các trên mặt đứng. ta giá trị cho“slide” là 3 để tao ra tam giác và “R” -kích thước của các component –được kiểm soát bằng

Hình .4.20. các component cấu trúc mặt đứng là các vòng xoắn quay quanh bề mặt tới đỉnh của công trình. Để đạt được điều này, ta phải xoay tất cả các phần tam giác dần dần. Ta muốn sử dụng component và ta cần phải cung cấp các góc quay. Như ta đã nói, góc quay phải là một danh sách các số ngày càng tăng từ từ. Các component ở đây tạo ra các góc quay và nó có nhiều đối tượng như các component (điểm tam giác). Vì vậy, kết quả, tất cả phần hình tam giác xoay xung quanh mặt tiền.

65

GENERATIVE ALGORITHMS

Hình.4.21. Bây giờ, nếu ta tất cả các tam giác lại với nhau, bạn sẽ thấy một component đơn giản của mặt đứng xuất hiện. Góc quay và kích thước của các component hoàn toàn được kiểm soát nên chúng ta cần phoi61 hợp để tạo ra một mặt đứng tốt nhất

Domains Như ta đã đề cập trước đây, các Domain (miền)( hoặc khoảng) là các dãy số học. chúng là những số thực từ giớ hạn dưới và giới hạn trên. Từ nay khi ta nói “ số thực” có nghĩa là chúng ta có nhưng con số vô hạn ở giữa, có nghĩa là chúng ta cần những loại khác nhau trong việc sử dụng những miền số học này. chúng ta có thể phân chia một loạt số và được phân chia như số phân bố đều giữa hai thái cực Ở đây ta muốn phân bố các yếu tố mặt đứng xung quanh vòng tròn cơ sở. Để làm được điều đó, ta cần một khoảng để bao toàn bộ vòng tròn cơ sở.

66

GENERATIVE ALGORITHMS

Hình .4.22. Một component (Scalar > domain > domain) được sử dụng để xác định miền số từ 0-360. Phạm vi số được phân chia bởi một component thành 10 phần và kết quả được sử dụng như là giá trị góc cho component .Vì vậy, như nó được hiển thị trong hình Hình ở dưới ,tất cả các yếu tố mặt đứng được phân bo xung quanh vòng tròn cơ sở.

Hình.4.23. bây giờ, nếu ta (XForm > Euclidian > Mirror) những hình đã xoay bằng (Vector > Constants > YZ plane) ta sẽ có các yếu tố mặt đứng trong một hình dạng xoắn ốc được nhân đôi. Vì vậy, cuối cùng ta có một hình học hình dạng mạng tinh thể xung quanh tháp.

67

GENERATIVE ALGORITHMS

Hình.4.24. xem lại mặt đứng một lần nữa, chúng ta có một diện thô của “Swiss Re”.

Hình.4.25.Để tạo ra đối tượng hình học trong Rhino, chọn những component muốn thể hiện trên màn hình, chọn “bake selected objects” từ thanh công cụ trong canvas

68

GENERATIVE ALGORITHMS

Hình 4.26. Mô hình hoàn thiện. Mặc dù nó có thể không chính xác với cái gốc, nhưng để phác thảo một mô hình trong thời gian ngắn thì nó thực sự hữu ích

Hình.4.27. giữa các component cấu trúc chính còn có các cấu trúc với tỉ lệ nhỏ hơn và ta chắc rằng các bạn có thể tự mình model chúng.

69

GENERATIVE ALGORITHMS

4_4_On Attractors

“Attractor một tập hợp các trạng thái của một hệ thống năng lượng vật lý có xu hướng phát triển, bất kể các điều kiện bắt đầu nào của hệ thống. Một điểm hút (point attractor) là một attractor tồn tại ở trạng thái đơn lẻ. Ví dụ, một hòn đá lăn trong một cái tô tròn trơn luôn có xu hướng lăn về điểm thấp nhất là đáy tô, vậy trạng thái cuối cùng và sự bất động là một điểm hút (point attractor).” (Dictionary.com/Science Dictionary)

Hình.4.28. Strange Attractor (Illustration from: http://www.cs.swan.ac.uk/~cstony/research/star/)

70

GENERATIVE ALGORITHMS

Trong thiết kế và hình học, những điểm hút sẽ là các component (thường là điểm, đường hoặc bất kỳ dạng hình học nào) ảnh hưởng đến các hình học khác trong không gian, thay đổi trạng thái và làm chúng dịch chuyển, xoay, hay thay đổi kích thước vv.vv… Chúng có thể biểu lộ rõ không gian quanh chúng, và xác định được vùng hoạt động với bán kính ảnh hưởng. Điểm hút có ứng dụng khác nhau trong thiết kế tham số vì chúng có khả năng thay đổi toàn bộ các hình khối thiết kế. Khi xác định được vùng ảnh hưởng, các điểm hút cũng có thể tác động đến hệ thống những tác nhân (agent). Cái cách và độ lớn lực mà những điểm hút tác động lên vật thể khác thì đều có thể điều chỉnh được. Chúng ta sẽ xem xét khái niệm vể điểm hút trong những trường hợp khác nhau, nên trước tiên ta sẽ có một vài ví dụ đơn giản.

Point Attractors Ta có một hệ những điểm mà tại đó sẽ tạo ra các đa giác. Ta cũng có một điểm đặt tên là và vẽ một đường tròn quanh nó để dễ nhận biết. Điểm này sẽ tác động lên tất cả các đa giác trong vùng hoạt động của nó. Điều đó có nghĩa là dựa vào khoảng cách giữa mỗi đa giác và điểm , và trong phạm vi ảnh hưởng của điểm hút mỗi đa giác sẽ thay đổi kích thước của nó.

Hình.4.29. Các điểm gốc , các đa giác và điểm hút

Ta có một hệ những điểm mà tại đó sẽ tạo ra các đa giác. Ta cũng có một điểm đặt tên là và vẽ một đường tròn quanh nó để dễ nhận biết. Điểm này sẽ tác động lên tất cả các đa giác trong vùng hoạt động của nó. Điều đó có nghĩa là dựa vào khoảng cách giữa mỗi đa giác và điểm , và trong phạm vi ảnh hưởng của điểm hút mỗi đa giác sẽ thay đổi kích thước của nó. .

71

GENERATIVE ALGORITHMS

Hình.4.30. Khoảng cách được chia nhỏ để kiểm soát “lực” của . Ta cũng đã tạo ra một nhóm “cluster” gồm và để tạo thành điểm hút. Bạn có thể biến đổi bất kì nhóm hình học nào thành nhóm “cluster” bằng cách chọn chúng và dùng lệnh “ make cluster from selection” từ thanh toolbar của canvas (hoặc Arrange menu hoặc Ctrl+G) Bây giờ nếu kết nối component với bán kính R của ta có thể thấy rằng bán kính của các đa giác tăng lên khi chúng càng xa điểm hút . Mặc dù điều này có vẻ ổn nhưng chúng ta vẫn cần kiểm soát bán kính tối đa của các đa giác. Mặt khác nếu chúng càng ra xa, chúng sẽ rất lớn và cắt nhau một cách chồng chéo (điều này cũng xảy ra nếu lực hút của quá lớn). Vì vậy ta phải tự kiểm soát bán kính tối đa của các đa giác.

Hình 4.31 Dùng component (Scalar > Util > Minimum) vơi một số xác định, ta sẽ có thuật toán chọn ra một giá trị từ component làm bán kính lớn nhất của , sao cho giá trị này nhỏ hơn con số ta xác định bởi . Như ta thấy trong hình, có những đa giác trong vùng ảnh hưởng của điểm hút thì thay đổi bán kính, trong khi những đa giác khác thì không. Bây giờ nếu di chuyển vị trí của trong mặt phẳng làm việc của Rhino, ta có thể thấy rằng các đa giác sẽ thay đổi bán kính tùy theo vị tri của . 72

GENERATIVE ALGORITHMS

Hình 4.32 Tác động của lên các đa giác. Khi thay đổi vị trí điểm hút thì các đa giác cũng thay đổi theo. .

HÌnh 4.33 Với khái niệm tương tự, ta có thể thay đổi các đa giác trong trục Z dựa vào giá trị lấy từ component hoặc thay đổi nó bằng một hàm số toán học khác.

Ta có thể thực hiện bất kì thuật toán nào với các đa giác này như xoay, thay đổi màu sắc, vv.vv. Nhưng điều gì sẽ xảy ra nếu ta có 2 điểm hút trong cùng một vùng. Ta tạo một nhóm “cluster” khác, tức là một điểm khác trong Rhino đã được gán với nhóm và trong Grasshopper.

73

GENERATIVE ALGORITHMS

Phần đầu tiên của thuật toán thì gần như giống nhau. Ta lại đo khoảng cách giữa điểm này với tâm của các đa giác hay các điểm lưới , sau đó tìm của các khoảng cách này và xác định bán kính lớn nhất của đa giác.

Hình 4.34 Thuật toán tương tự đối với điểm hút Bây giờ ta đã có 2 bảng dữ liệu khác nhau là khoảng cách từ các đa giác đến mỗi điểm hút. Vì càng gần điểm hút thì các đa giác càng chịu tác động nhiều, nên ta sẽ tìm điểm hút nào gần hơn và dùng nó làm nguồn tác động. Ta sử dụng component để tìm khoảng cách nhỏ nhất hay điểm gần nhất.

Hình 4.35. Tìm điểm hút gần hơn. Sau khi tìm được thì các bước còn lại tương tự như trên. Bây giờ các đa giác đều đã chịu tác động của các điểm hút.

74

GENERATIVE ALGORITHMS

Hình 4.36 Thay đổi vị trí điểm hút để thấy tác động của nó đối với các đa giác.

Ta có thể có nhiều điểm hút hơn nữa. Khái niệm này là để tìm điểm hút nào gần với đa giác hơn thì tác động lên đa giác đó. Việc chọn ra cái nào gần hơn được thực hiện bởi component, và chúng ta cũng có những cách chọn khác sẽ được giới thiệu sau. Có những cách khác để xử lý với các điểm hút như component (chọn lọc). Với phương pháp này bạn cần có bảng dữ liệu khoảng cách giữa các đa giác và các điểm hút, sau đó lựa chọn khoảng cách ngắn nhất bằng hàm Boolean a>b. Có rất nhiều ví dụ về chủ đề này trên mạng nên ta hi vọng các bạn có thể tự tìm hiểu thêm.

Curve Attractors: Wall project Chúng ta sẽ hoàn thành cuộc thảo luận này với một ví dụ khác nhưng là về Đường hút vì trong nhiều trường hợp bạn phải xác định rõ trường vật thể bằng đường hút thay vì điểm. Ở đây mục tiêu của ta là tạo ra một bức tường xốp, lỗ rỗ cho một không gian nội thất để có thể nhìn xuyên sang bên kia. Việc này có thể được cắt từ tấm vật liệu. Trong không gian thiết kế, ta có một tấm phẳng (bức tường), 2 đường cong và những điểm được phân bố tự do. Ta sẽ tạo ra các hình chữ nhật từ những điểm này, dùng nó cắt tấm tường để tạo ra bức tường bị đục lỗ. Ta tổ chức các hình chữ nhật theo 2 đường cong đã cho, để các hình chữ nhật này không lộn xộn mà được phân bố ngẫu nhiên dựa theo những đường cong này.

75

GENERATIVE ALGORITHMS

Điều ta cần là tạo ra là một nhóm các điểm ngẫu nhiên và dời chúng đến gần các đường cong dựa vào lực hút của các đường này. Ta sẽ tịnh tiến các điểm này đến cả 2 đường cong nên không cần chọn đường nào gần hơn, ta tịnh tiến các điểm này dựa vào khoảng cách của chúng với các đường cong. Sau đó ta sẽ tạo ra hình chữ nhật từ 3 điểm, cuối cùng ta xác định được kích thước của các hình chữa nhật dựa vào khoảng cách của chúng đến các đường hút.

Hình 4.37 Tạo lập một bảng những điểm phân bố ngẫu nhiên và đường hút bằng 2 component (Params > Geometry > Curve). Ta dùng component (khoảng, quãng) để xác định số khoảng giữa 0 và giá trị của để tìm phạm vi những điểm ngẫu nhiên. Ta sẽ tạo một cluster gồm , , , and để dễ quản lý.

Hình 4.38 Với điểm hút, ta có thể tịnh tiến các hình học khác đến nó một cách đơn giản. Nhưng với đường hút, ta cần tìm một điểm relative và tịnh tiến các điểm khác đến điểm đó. Và điểm này phải là duy nhất đối với mỗi điểm vì đó là mối quan hệ 1-1 giữa đường hút với bất kì hình học nào trong phạm vi ảnh hưởng của nó. Nếu ta xem đường hút (attractor) là một nam châm thì nó sẽ kéo tất cả các điểm các vật về phía nó. Vì vậy về căn bản điều đầu tiên ta cần làm là tìm điểm gần nhất của trên cả 2 đường hút. Đó là những điểm gần nhất trên đường hút đối vối mỗi điểm của < Rnd_pt_grid>. Ta dùng component (Curve >Analysis >Curve CP) để có được điểm gần nhất tr6en 2 đường hút đối với . 76

GENERATIVE ALGORITHMS

Hình 4.39 Để tịnh tiến các điểm đến các đường hút, ta cần xác định một vector cho mỗi điểm trong , từ điểm đó đến điểm gần nhất của nó trên đường hút. Vì ta đã có điểm bắt đầu và kết thúc của vector nên ta dùng component để tạo vector. Điểm thứ 2 của vector < cổng B của component> là điểm gần nhất trên đường hút.

Hình 4.40 Bây giờ ta sẽ liên kết tất cả các điểm với 2 component để dời chúng đến các đường hút. Nhưng nếu ta sử dụng vector đã tạo ở bước trước, tất cả các điểm sẽ bị tịnh tiến đến đường hút và đó không phải điều chúng ta muốn. Ta sẽ dời các điểm liên quan đến khoảng cách của chúng đối với các đường hút. Ta thấy component có một cổng ra (D) cho ta khoảng cách giữa các điểm và điểm gần nhất tương ứng trên đường cong. Chúng ta sẽ không cần phải đo khoảng cách đó bằng một component khác. Ta dùng một component và gán khoảng cách (D) vào cổng X và một vào Y để được hàm X/log(Y) để kiểm soát việc tịnh tiến các điểm (Hàm log thay đổi mối quan hệ dạng tuyến giữa khoảng cách và hệ số kết quả của việc tịnh tiến).

77

GENERATIVE ALGORITHMS

Ta sử dụng component (Vector > Vector > multiply), gán vector làm vector cơ sở và đổi kích thước của nó bằng hệ số tạo bởi khoảng cách, và ta gàn vector kết quả với component để dời đến các đường hút tùy theo khoảng cách của nó đối với các đường hút.

Hình 4.41 component thay đổi độ lớn lực mà các đường hút tác động lên các điểm xung quanh để kéo chúng lại gần.

78

GENERATIVE ALGORITHMS

Hình 4.42 Ta dùng component (tạo ra các hình chữ nhật) và gán các điểm đã tịnh tiến (G) với cổng P của để làm điểm cơ sở. Ta sẽ thay đổi kích thước của các dựa vào khoảng cách của chúng đối với các đường hút. Vì vậy ta sẽ dùng giá trị số tương tự như dùng cho vector độ lớn và thay đổi chúng dựa vào 2 hàm. Ta chia giá trị X của những hình chữ nhật cho 5 và chia giá trị Y cho 25. Bạn có thể thấy, các hình chữ nhật có kích thước khác nhau dựa vào khoảng cách ban đầu của chúng đối với đường hút.

Hình 4.43 Thay đổi các biến số sẽ cho kết quả khác nhau.

79

GENERATIVE ALGORITHMS

Hình 4.44. Hiệu ứng sau cùng là bức tường bị đục lỗ rỗ. 80

GENERATIVE ALGORITHMS

CHƯƠNG_5_Parametric Space

81

GENERATIVE ALGORITHMS

Khảo sát của chúng ta trong quan sát các đối tượng trong không gian, những hình thức kĩ thuật số, sự khác nhau trong việc kết nối các thành tố và nhiều qui trình của các thế hệ hình thái, từ những ý tưởng cổ điển về đối xứng và mô hình khối đến NURBS, Meshes. Chúng ta đang xoay trở với các đối tượng. Những đối tượng này có thể là hình boxes, hình cầu, hình nón, curve,mặt phẳng hoắc bất cứ point nối nào của chúng. Sự xuất hiện của chúng trong không gian được chia thành point như là chiều 0, curve như 1D, mặt phẳng như là 2D và khối là đối tượng 3D. Chúng ta xây dựng không gian của các hệ thống phối hợp để xác định một số đặc tính cơ bản như vị trí,hướng và đo lường. Hệ đề các là một không gian 3 chiều trong đó có một point gốc là O = (0,0,0) và ba trục giao nhau tại point này tạo thành trục X, Y và Z. Nhưng chúng ta nên xem xét rằng hệ thống cũng bao gồm các không gian hai chiều (phẳng (x, y)) và hệ thống một chiều (không gian tuyến tính (x)) . Trong khi tham số thiết kế thay đổi giữa các không gian, chúng ta cần phải hiểu chúng như là không gian tham số.

5_1_Một chiều (1D )trong không gian tham số Trục X là một đường vô hạn mà có một vài con số liên quan đến vị trí khác nhau trên đó. Đơn giản x = 0 là gốc và x = 2,35 một point trên hướng xác định của trục X là 2,35 đơn vị từ gốc. Nói đơn giản,hệ thống một chiều có thể được (qui đổi tham số)parameterised trên bất kỳ curve trong không gian. Vì vậy, về cơ bản không chỉ các trục X có một số con số thực liên quan đến vị trí khác nhau trên nó, mà còn bất kỳ curve trong không gian có thể xác định bởi 1 dãy các số thực cho thấy các vị trí khác nhau trên curve. Vì vậy, trong không gian tham số 1D của chúng ta khi chúng ta nói về một point, nó có thể được mô tả bởi một số thực mà có liên quan với một point cụ thể trên một curve chúng ta đang chú ý tới. Điều quan trọng là kể từ khi chúng ta không làm việc trên các trục X nữa,bất kỳ curve đều có không gian tham số riêng của mình và các thông số này không chính xác phù hợp với hệ thống đo lường quốc tế. Bất kỳ curve trong Grasshopper có một không gian tham số bắt đầu từ số không và kết thúc trong một số thực dương (Hình 5.1).

Hình 5.1. Tham số 1 chiều không gian của một curve. Bất kỳ giá trị 't' là một số thực liên quan đến một vị trí trên curve.

82

GENERATIVE ALGORITHMS

Vì vậy, nói về một curve và làm việc, tham khảo một số point cụ thể về nó, với các point trong không gian 3D với p = (X, Y, Z) chúng ta có thể gọi lại một point trên một curve p = t như một tham số cụ thể. Và rõ ràng rằng chúng ta luôn luôn có thể chuyển đổi không gian tham số này đến một point trong hệ thống điều phôi. (Hình 5.2)

Hình 5.2. 1D tham số không gian và chuyển đổi trong trục tọa độ 3D.

5_2_Hai Chiều (2D) tham số không gian

Hai trục, X và Y của trục tọa độ, các point trên một bề mặt phẳng vô hạn mà trong đó, mỗi point trên không gian này được kết hợp với một cặp số p = (X, Y). Hoàn toàn giống như không gian 1D, ở đây chúng ta có thể tưởng tượng rằng tất cả các giá trị của không gian 2D có thể được tìm trên bất kỳ bề mặt không gian nào. Vì vậy, về cơ bản chúng ta có thể tham số một trục tọa độ trên một bề mặt cong trong không gian, và gọi các point khác nhau của nó bởi một cặp số ở đây được gọi là không gian UV, trong đó bất kỳ point P trên bề mặt là P = (U, V). Một lần nữa chúng ta không cần phải làm việc với 3 giá trị của P = (X, Y, Z) là không gian 3D để tìm thấy những point và thay vào đó, chúng ta có thể làm việc với UV "tham số" của bề mặt. (Hình 5.3)

83

GENERATIVE ALGORITHMS

Hình 5.3. UV và không gian tham số 2D. Những "Tham số" là cụ thể cho mỗi bề mặt của chính nó và chúng không phải là dữ liệu chung chung như hệ thống tọa độ thế giới và đó là lý do tại sao chúng ta gọi tham số! Một lần nữa chúng ta có thể truy cập tới trục tương đương 3D của bất kỳ point nào trên bề mặt. (Hình 5.4)

Hình 5.4. Tương đương với point P = (U, V) trên hệ thống trục thế giới p = (X, Y, Z).

84

GENERATIVE ALGORITHMS

5_3_Sự chuyển đổi giữa không gian

Nó là một phần rất quan trọng của thiết kế tham số để biết chính xác mà phối hợp hệ thống hoặc không gian tham số mà chúng ta cần làm việc, để thiết kế. Làm việc với những curve và bề mặt tự do, chúng ta cần phải cung cấp dữ liệu cho không gian tham số, nhưng chúng ta luôn luôn cần phải quay trở lại kiểm tra hoặc thay đổi để cho ra một hình thức mới. Nó phức tạp hơn trong scripting, nhưng kể từ khi Grasshopper có một giao diện trực quan hơn là mã code, bạn chỉ cần xác định loại dữ liệu mà bạn cần phải cung cấp cho mục đích thiết kế của bạn. Ở đây lưu ý rằng nó không phải là một tham số hoặc giá trị trong một hệ thống tọa độ được nhắc đến trong Generative Algorithms và Grasshopper, đôi khi chúng ta cần chỉ cần một số chỉ số để làm điều đó. Nếu chúng ta làm việc với loạt các point, đường hoặc bất cứ điều gì, và chúng được tạo ra như một nhóm đối tượng, giống như những đám mây point, vì mỗi đối tượng có liên quan với một số tự nhiên cho thấy vị trí của nó trong một list tất cả các đối tượng, chúng ta chỉ cần gọi số điện thoại của đối tượng là "chỉ số" của nó thay vì bất kỳ hệ thống trục. Chỉ số như các mảng biến( array) trong lập trình là một hệ thống đếm bắt đầu từ 0 (Hình 5.5).

Hình 5.5. Chỉ số số trong một nhóm đối tượng là một cách đơn giản để xác định một đối tượng. Đây là một hệ thống đếm dựa trên 0 - có nghĩa là số bắt đầu từ 0.

Vì vậy, như đã đề cập trước đó, trong mô hình liên tưởng chúng ta tạo ra hình học của chúng ta từng bước như một vài đối tượng liên quan và vì lý do này, chúng ta đi vào không gian tham số của từng đối tượng và trích xuất thông tin cụ thể của nó và sử dụng nó như là các dữ liệu cơ sở cho các bước tiếp theo. Điều này có thể được bắt đầu từ một vùng đơn giản của các point như tổng hợp cơ bản và kết thúc ở các chi tiết nhỏ kết quả của mô hình, trong khác nhau hệ thống thứ bậc.

85

GENERATIVE ALGORITHMS

5_4_Components tham số cơ bản

5_4_1_ Evaluation Curve

Các component là chức năng tìm thấy point trên một curve hoặc bề mặt, dựa trên các tham số chúng ta cung cấp. Các component (Curve> Analysis> Evalution Curve) có một curve và một tham số (một số) và cung cấp cho trở lại một point trên curve tham số đó.

Hình 5.6. Point evaluation trên trên tham số cụ thể mà xuất phát từ slider> Geometry và trong menu của nó, kiểm tra Reparameterize option(clik phải vào component). Nó thiết lập miền của curve 0-1. Vì vậy, về cơ bản tôi có thể theo dõi tất cả các dài bởi một hoặc thiết lập số bất kỳ giữa 0 và 1 và không lo lắng rằng các thông số có thể đi vượt ra ngoài miền số của curve.

Có những components hữu ích khác cho parametric space trên curve trong Curves> Analysis / Division mà chúng ta sẽ nói về chúng sau này.

5_4_2_ Evaluation bề mặt Trong khi evaluation một curve, chúng ta cần một số như một tham số (vì curve là không gian 1D) cho các bề mặt chúng ta cần một cặp số như các thông số (U, V), với chúng, chúng ta có thể evaluation một point cụ thể trên một bề mặt. Chúng ta sử dụng components (Surface> Analysis> Analysis) để evaluation một point trên một bề mặt thông số cụ thể.Chúng ta chỉ đơn giản là có thể sử dụng các components để evaluation một bề mặt bằng cách sử dụng nó như là đầu vào UV của (bỏ qua Z) và bạn có thể theo dõi số point của bạn trên bề mặt chỉ bằng X và Y của như các thông số U và V

87

GENERATIVE ALGORITHMS

Hình 5.9. Một point d các dựa trên U, V các thông số đến từ các với một components mà làm thành một cặp số. Một lần nữa như curve, bạn có thể kiểm tra 'Reparameterize' trên menu của các và thiết lập các miền của bề mặt 0-1 trong cả hai hướng U và V. Thay đổi U và V và xem di chuyển point d như thế nào trên bề mặt (tôi đổi tên X, Y, Z đầu vào của các component thành U, V, bằng tay).

Hình 5.10. Chúng ta cần để evaluation một như bạn thấy, chúng ta có thể sử dụng bất kỳ phương pháp mà chúng ta sử dụng để tạo ra point để evaluation trên và lựa chọn của chúng ta là không giới hạn chỉ nỗi một cặp các thông số từ , và chúng ta có thể theo dõi một bề mặt point với rất nhiều cách khác nhau.

Hình 5.11. Để phân chia một bề mặt (như ví dụ trên) trong các hàng và cột nhất định chúng ta có thể sử dụng hoặc nếu chúng ta cần một số plane trên các hàng và cột của một bề mặt, chúng ta có thể sử dụng cả hai đều từ surface tab dưới util panel .

88

GENERATIVE ALGORITHMS

5_4_3_Curve và bề mặt point gần nhất Chúng ta luôn luôn không có tham số để tìm point, một số lần chúng ta đã point và chúng ta muốn biết tham số của nó sử dụng hơn nữa. Điều này là khi việc tìm kiếm point gần nhất đến chơi. và components (curve / bề mặt gần nhất point) là hai components giúp chúng ta để làm điều đó.

Hình 5.12. and giúp chúng ta tìm thấy những tham số của một point trên một curve hoặc bề mặt. Có các components khác mà bạn cần phải cung cấp các thông số này.

5_5_ Đối tượng phổ biến trong tham số không gian Vì rất nhiều lý do thiết kế, các nhà thiết kế sử dụng bề mặt để phát triển một số hình học khác dựa trên chúng. Có nhiều phương pháp để xử lý với các bề mặt như Penalisation, nhưng ở đây tôi sẽ bắt đầu với một trong những thứ đơn giản nhất và chúng ta sẽ nói về những phương pháp khác sau này.

Chúng ta có một bề mặt tự do hình thức tự do và hình học đơn giản như một boxes. Câu hỏi đặt ra là, làm thế nào chúng ta có thể phát triển boxes này trên bề mặt, và vậy ta có một bề mặt đa dạng như một cái vỏ, trong đó chúng ta có quyền kiểm soát (bề mặt) và (boxes) của thiết kế , nhưng bằng cách kết hợp.

Để làm được điều này, chúng ta nên phân chia bề mặt thành các phần mong muốn và tạo ra cái boxes của chúng ta từ những point cụ thể trên bề mặt và điều chỉnh lại nếu chúng ta muốn có thao tác chính xác vị trí của các đối tượng này.

89

GENERATIVE ALGORITHMS

Tạo vị trí mong muốn trên bề mặt rất dễ dàng. Chúng ta có thể phân chia bề mặt hoặc chúng ta có thể tạo ra một số point bất kỳ dựa trên dữ liệu số mà chúng ta muốn.

Về các thao tác vị trí hình học, một lần nữa chúng ta cần một số tập hợp dữ liệu số có thể được sử dụng cho biến đổi như xoay, di chuyển cục bộ, thay đổi kích thước, điều chỉnh, v.v…

Hình 5.13. Một hình thức tự do, reparameterized, >> bởi từ 0-1, chia cho 30 bước trong cả U và V. (Ở đây bạn có thể sử dụng nhưng tôi đã sử dụng components để nhắc lại các kỹ thuật tạo point từ chương hai là lựa chọn có thể chèn vào thử nghiệm).

Hình 5.14. Như bạn thấy các components cho ‘normal’' và 'plane’ của bất kỳ point evaluation trên bề mặt. Tôi đã sử dụng những plane hoặc frames để tạo ra hàng loạt trên trong khi kích thước của nó được kiểm soát bởi . các components (surface>primitive> center boxes) cần trung tâm của boxes và chiều dài của nó (X, Y và Z) 90

GENERATIVE ALGORITHMS

Để thao tác các boxes ở từng vị trí, tôi chỉ quyết định xoay chúng .Tôi muốn thiết lập song song với trục quay song song với hướng U của bề mặt và dựa vào tình trạng của bề mặt đơn giản này, tôi sẽ chọn mặt phẳng XZ là mặt phẳng cơ sở cho việc quay của chúng (Hình 5.15).

Hình 5.15. Xoay tại chỗ của boxes.

Hình 5.16. Các component cần ba yếu tố đầu vào. Đầu tiên là hình học đó có nghĩa là . Mục thứ hai là góc quay. Tôi muốn xoay chúng bằng giá trị ngẫu nhiên (bạn có thể xoay chúng dần đều hay bằng bất kỳ cách nào khác) vì vậy tôi muốn tạo ra một tập hợp các số và thiết lập các giá trị ngẫu nhiên vào từng boxes. Vì vậy, tôi chỉ được sử dụng một components để thực hiện gán vào các tôi có và gắn nó vào đầu vào 'N' của component và kèm theo các giá trị ngẫu nhiên như các góc quay để các components . Cuối cùng để xác định plane của trục, tôi đã tạo ra trên bất kỳ point nào mà component trên component và gắn nó vào components . 91

GENERATIVE ALGORITHMS

Đừng quên bỏ chọn Preview của các đối tượng trước đây được tạo ra để tăng cường hiệu suất của máy tính

Hình 5.17. kết quả cuối cùng.

Hình 5.18. Hãy thử kết hợp các khái niệm khác nhau trong project của bạn. Ở đây thay vì các giá trị ngẫu nhiên cho vòng quay của boxes, tôi sử dụng một point attractor và thiết lập khoảng cách của nó từ mỗi 92

GENERATIVE ALGORITHMS

boxes là yếu tố quay và như bạn thấy, kết quả mới được thể hiện trong thí nghiệm. Đây là những kỹ thuật để thao tác vị trí của các boxes, nhưng bạn biết rằng bạn có thể áp dụng các thay đổi với quy mô chung.

Sử dụng không thống nhất evaluation Trong một project, ý tưởng này đến tâm trí của tôi rằng tại sao tôi luôn luôn sử dụng phân phối thống nhất của các point trên bề mặt và thêm các components vào nó? Có thể thiết lập một số tiêu chí và đánh giá bề mặt của tôi trên cơ sở đó và chọn vị trí cụ thể trên bề mặt? Hoặc vì chúng ta sử dụng U, không gian tham số V và tập hợp dữ liệu gia tăng (hoặc gia tăng vòng trong scripting) là chúng ta luôn luôn giới hạn cho một bộ phận hình chữ nhật trên bề mặt? Có vài câu hỏi liên quan đến theo dõi thông số của một bề mặt, nhưng ở đây tôi sẽ chú ý tới một ví dụ đơn giản để hiển thị như thế nào trong các tình huống cụ thể chúng ta có thể sử dụng một số các thông số U, V của một bề mặt và không phải một mạng lưới hình chữ nhật thống nhất

Columns Example Tôi có hai bề mặt hình thức tự do như một lớp bao che cho không gian và tôi đang nghĩ đến việc tạo ra một không gian cộng đồng mở ở giữa. Tôi muốn thêm một số cột giữa các bề mặt này, nhưng vì chúng là hình thức bề mặt tự do và tôi không muốn tạo ra một mạng lưới các cột, tôi quyết định giới hạn chiều dài của cột và thêm nhiều nơi càng tốt ở các vị trí nhất định với chiều cao giới hạn . Tôi muốn thêm vào hai hình nón ngược và giao nhau như các cột trong không gian này, chỉ là một hình dạng đơn giản.

Hình 5.19. Tôi giới thiệu hai bề mặt chung Grasshopper và như bao gồm không gian và tôi Reparameterized chúng. Tôi cũng tạo ra một 0 và 1, chia , và bằng cách sử dụng một components và d các bề mặt này tại .

93

GENERATIVE ALGORITHMS

Hình 5.20. Tiếp theo, tôi tạo ra giữa tất cả những point này, nhưng tôi cũng đo khoảng cách giữa hai point bất kỳ

.Hình 5.21. Bây giờ tôi cần trích xuất các dòng tôi muốn từ list. Ở đây tôi sử dụng một components (logic> Llist> dispatch) để chọn đường của tôi từ list. Một components cần dữ liệu Boolean mà liên kết với các dữ liệu từ list, để gửi những dữ liệu liên quan với Đúng là đầu ra A và sai đầu ra B. Các dữ liệu Boolean đến từ một chức năng so sánh đơn giản. Trong component này sẽ so sánh độ dài với một số nhất định (coi như là chiều dài tối đa) (x>y, x = , y = ). Bất kỳ chiều dài nào ít hơn tạo ra một giá trị thật theo chức năng và cho phép nó thông qua các components với giá trị A. Vì vậy, nếu tôi sử dụng line được cho qua thì tôi chắc chắn rằng chúng đều nhỏ hơn so với độ dài chọn từ slider.

94

GENERATIVE ALGORITHMS

Hình 5.22. Hình dạng của các cột là hai hình nón ngược được giao nhau ở góc nhọn của chúng. Ở đây tôi có trục của cột, tôi muốn vẽ hai vòng tròn tại các point cuối của trục và sau đó extrude theo các point on curve và làm cho chúng giao nhau.

Hình 5.23. Bằng cách sử dụng một components tôi có thể nhận được cả hai đầu của cột. Vì vậy, tôi kèm theo những point này như các point cơ sở để làm cho với bán kính tự cho. Bạn đã biết rằng những vòng tròn được bằng phẳng nhưng bề mặt của chúng ta là không phẳng. Vì vậy, tôi cần phải vòng tròn của tôi trên các bề mặt chính để tìm thấy hình dạng khớp theo bề mặt. Tôi sử dụng một components (Curve> util > Project). B là một phần của kết nối với bề mặt trên và dưới. 95

GENERATIVE ALGORITHMS

Hình 5.24. Bước cuối cùng là extrude những vòng tròn này theo các point quy định trên trục cột (Hình 5.23). Tôi sử dụng components và sau đó tôi gắn đường tròn vào . Cho các extrusion point, tôi đính kèm 'trục vào một components và tôi Reparameterized' chúng, sau đó tôi d chúng trong tham số cụ thể là 0,6 cho hình nón hàng trên và 0,4 đối với tế bào hình nón hàng dưới.

Hình 5.25. Mặc dù trong ví dụ này, một lần nữa tôi sử dụng lưới dựa trên một bề mặt, tôi đã sử dụng các tiêu chuẩn khác để chọn một số point và không phải tất cả trong số chúng đều thống nhất.

96

GENERATIVE ALGORITHMS

Hình 5.26. Mô hình cuối cùng Ý tưởng dùng tham số không gian cho curve và các mặt phẳng để sản sinh ra các khối, đã có rất nhiều lựa chọn và giải pháp. Đừng suy nghĩ vào 1 cách duy nhất, hãy cố gắng khai phá nhiều hơn. Chúng ta sẽ thấy ngay sau đây.

97

GENERATIVE ALGORITHMS

5_6_ Cây dữ liệu

Bây giờ là lúc mở ra một chủ đề mới về quản lý dữ liệu trong Grasshopper được gọi là cây dữ liệu để nói về tham số không gian và việc sử dụng các component liên quan, bạn thực sự cần Cây dữ liệu này khi làm việc với các model phức tạp, đặc biệt là đối với những tham số không gian của đường cong và bề mặt. Một trong những tiềm năng to lớn của các thuật toán tạo ra tham số là chúng cho phép ta thiết kế và quản lý hàng trăm component liên kết chặt chẽ với nhau . Để làm việc với một số lượng lớn component, đôi khi cần phải áp dụng lệnh cho tất cả và thỉnh thoảng chỉ cần chọn một mục và áp dụng một lệnh để nó. Vì vậy, chúng ta cần phải có quyền truy cập vào các component và quản lý dữ liệu (các component ) theo nhiều cách khác nhau . Hãy tưởng tượng chúng ta có 5 đường cong trong không gian thiết kế và chúng ta chia nó thành 10 phần. Bây giờ chúng ta muốn chọn tất cả các điểm thứ hai của những đường cong này và kết nối chúng lại với nhau với một đường cong nội suy mới.

Hình.5.27. Một component với 5 đường cong, tất cả đều d 10. Nếu bạn chọn số chỉ số là 1 với component từ điểm phân chia, bạn sẽ thấy rằng tất cả các điểm thứ hai của đường cong được lựa chọn, không chỉ là điểm thứ hai của dòng đầu tiên. Nhưng nếu bạn nối những điểm này với một component để vẽ một đường cong, bạn sẽ thấy cho thấy lỗi và không rút ra bất cứ điều gì! Ở đây để hiểu được vấn đề chúng ta hãy giới thiệu một component hữu ích và quan sát tình hình. Đây là component từ Params> Special. Hãy so sánh kết quả:

98

GENERATIVE ALGORITHMS

Hình .5.28. Component cho thấy một số thông tin dữ liệu khác bên trong các component chỉ ra lý do các lỗi trong . Những gì bạn nhìn thấy trong là khái niệm của cây dữ liệu trong Grasshopper. Như bạn có thể nhìn thấy trong Hình.5.28 component có 5 đường nhưng khi d những đường cong và tạo ra một số điểm cho mỗi đường cong, những điểm đã được sắp xếp vào danh sách dữ liệu khác nhau được gọi là nhánh. Điều này có nghĩa rằng kết quả của component là không chỉ có một danh sách các dữ liệu bao gồm 55 điểm,mà bây giờ chúng ta có năm danh sách các dữ liệu đều có 11 điểm bên trong. Vì vậy, các dữ liệu chính của "Cây" đã được chia thành các nhánh để tạo điều kiện thuận lợi hơn nữa trong việc sử dụng và truy cập dễ dàng hơn khi thiết kế.Đó là lý do tại sao khi chúng ta chọn với chỉ số là 1,thì tức là chọn mục có chỉ số 1 trong mỗi danh sách.

HÌnh.5.29. với tùy chọn kiểm tra Draw Tree trong context menu để chỉ ra sự khác biệt giữa các nhánh dữ liệu trong mỗi component. Bây giờ, tại sao component không thể vẽ một đường cong ? Vấn đề là gì ? Hãy có một cách nhìn gần hơn vào các thông tin mà chúng ta thu thập được : 99

GENERATIVE ALGORITHMS

Hình.5.30. và A: đường cong và B: lựa chọn chỉ số 1 điểm. Trong hình Hình đầu tiên của Hìnhure.5.30 của component cho thấy một trong những nhánh dữ liệu chính .Nếu bạn nhìn tại của nó, bạn thấy có một danh sách các đường cong dưới tiêu đề của {0}. Trong Grasshopper {} là biểu tượng cho cây dữ liệu và hiển thị các nhánh mà đối tượng đó được định vị. Vì vậy, tất cả các đường cong trong hình Hình đầu tiên bên dưới biểu tượng {0} nằm trong các nhánh chính. Nếu bạn quay trở lại Hình.5.28 bạn thấy rằng của các , (đường dẫn = 1) có nghĩa là chúng ta chỉ có một nhánh của dữ liệu và nhánh {0} này (N = 5), chúng ta có 5 mục . Nhưng trong bức Hình thứ hai của Hình.5.30 chúng ta có thể thấy rằng dữ liệu trong các component được liệt kê dưới năm nhánh khác nhau: {00:00} {00:01}, ... {00:04} và đó là một trong những điểm ở mỗi danh sách. Nếu bạn kiểm tra Hình.5.28 một lần nữa bạn thấy rằng có 5 nhánh (đường dẫn = 5) và mỗi nhánh của dữ liệu có một mục (N = 1 cho 100

GENERATIVE ALGORITHMS

tất cả các nhánh). Điều này có nghĩa rằng dữ liệu đã được chia thành những nhánh khác nhau và khi chuyển vào component , chúng là riêng biệt với nhau và component không thể vẽ polyline từ năm điểm riêng biệt. Vậy chúng ta giải quyết vấn đề này như thế nào ?

Hình.5.31. Để giải quyết vấn đề này, ta sử dụng một component (Logic> Tree)mà âm thanh, chuyển đổi dữ liệu từ nhiều nhánh tới một nhánh có thể thấy trong . Như bạn có thể thấy trong thứ hai, bây giờ chúng ta có năm điểm dưới các nhánh của {0} và component có thểvẽ một polyline với năm điểm này. Để tóm tắt và nắm được các khái niệm, chúng ta nên hiểu rằng trong khi làm việc với nhiều đối tượng ở những mức độ khác nhau, dữ liệu có cấu trúc thứ bậc trong các nhánh và mỗi nhánh của dữ liệu có đường dẫn riêng của mình như một số chỉ số trong đó cho thấy các địa chỉ duy nhất của nhánh (tức là {00:01}). Đây là điều quan trọng để biết rằng làm việc với danh sách các component quản lí bị ảnh hưởng bởi các khái niệm này và những component làm việc trên từng nhánh là một danh sách riêng biệt. Chúng ta có thể cần phải tạo ra các nhánh dữ liệu của chính chúng ta hoặc gom dữ liệu phân nhánh thành một nhánh, hoặc những loại dữ liệu quản lí khác mà ta có thể sử dụng trong các thí nghiệm sau đó .

101

GENERATIVE ALGORITHMS

Hình .5.32 Những nhánh dữ liệu của cây dữ liệu Hãy đưa ra một ví dụ khác để làm rõ thêm các chủ đề: Tôi muốn thiết kế một surface giống như những phác thảo trong hình.5.33 dựa trên một mặt sử dụng. Tôi có thể mô tả quá trình một cách nhanh chóng và xem kết quả cuối cùng .

Hình.5.33. Phác thảo của surface mong muốn.

102

GENERATIVE ALGORITHMS

Để thiết kế surface này, ta tạo ra hai line ở cạnh trên và dưới của một surface và loft chúng lại với nhau. Điều này sẽ tạo ra một số surface nhỏ mà tất cả liên kết với nhau tạo ra surface cần dựng . Ta nên điều chỉnh hướng của các line để có thể kiểm soát sự khác biệt trên surface.

Hình.5.34. Tôi giới thiệu một cơ bản trong khung làm việc và tôi explode nó bằng .(Surface> Analysis) để có thể chọn các cạnh của nó. Sau đó, tôi chọn phía dưới và cạnh trên với có chỉ số là 0 và 2.

Hình.5.35. Tôi sử dụng cạnh dưới để (Curve> Util), và tôi cũng thay đổi hướng của cạnh đầu với (Curve> Util) bởi vì tôi biết rằng các đường cong cạnh dưới và cạnh trên là không cùng một hướng. Tôi sử dụng component để phân chia các đường cong cạnh và tạo ra nhiều điểm. (Chúng ta có thể sử dụng một component nhưng tôi không muốn làm cho nó phức tạp).

103

GENERATIVE ALGORITHMS

HÌnh.5.36. Một component được sử dụng để kết nối tất cả các điểm phân chia với tất cả các điểm được offset ở đường dưới . Khác được sử dụng để kết nối tất cả các điểm phân chia đầu tiên với các điểm tiếp theo của chúng trong danh sách (thay đổi bù đắp = 1).

Hình.5.37. bây giờ nếu tôi sử dụng các component , bạn sẽ thấy rằng một surface được tạo ra mà không như thiết kế của tôi, thậm chí sử dụng component cũng không giúp đỡ được trong tình huống này. 104

GENERATIVE ALGORITHMS

HÌnh.5.38. tìm kiếm tại của các component , chúng ta có thể thấy rằng cả hai component chỉ có một nhánh dữ liệu và khi loft , nó nối tất cả chúng lại với nhau mà không tách ra thành nhiều line. Nhưng ở đây chúng tôi muốn những line nằm trong danh sách dữ liệu khác để được coi là dữ liệu duy nhất để khi loft, chúng trở thành những cặp line.

Hình.5.39. Để giải quyết vấn đề này ở đây tôi sử dụng một component hữu ích đó là (Logic> Tree> Graft Tree). Bạn có thể thấy, kết quả của component này là danh sách dữ liệu trong cả hai component được chia thành các nhánh, một nhánh cho mỗi mục trong danh sách. Bây giờ component nối mỗi line từ danh sách các dữ liệu đầu tiên với một line liên kết trong danh sách dữ liệu thứ hai. Và chúng ta thấy rằng kết quả là một surface hình học giống với phác thảo. 105

GENERATIVE ALGORITHMS

Ở đây, với ví dụ đầu tiên, chúng ta phải sắp xếp dữ liệu trong các nhánh khác nhau để có được kết quả là nhiều đường hình học nếu như nó không chỉ có một surface liên tục.

Hình .5.40. Ở đây tôi phải nhắc nhở bạn một lần nữa rằng nếu bạn muốn vẽ một đường cong nội suy trên từ các điểm cụ thể mà bạn chọn ra trên các surface như thế này, vì tất cả các surface này nằm trong các nhánh khác nhau nên dữ liệu và kết quả đánh giá các điểm sẽ là nhánh khác nhau của dữ liệu thì để vẽ một đường cong tốt , bạn cần phải danh sách dữ liệu một lần nữa, tạo ra một nhánh dữ liệu điểm và nội suy vẽ ra đường cong bạn cần . Vấn đề là nhận ra rằng trong các component khác nhau và các tình huống thiết kế, chúng ta phải cung cấp dữ liệu cho các nhánh hoặc cho một nhánh, có vài component trong Logic> Tree giúp chúng ta làm như vậy.

Hình.5.41. Mô hình cuối . 106

GENERATIVE ALGORITHMS

Chương_6_ Biến hình và biến dạng (Deformation and Morphing)

107

GENERATIVE ALGORITHMS

6_1_Deformation and Morphing (Biến dạng và biến hình) Deformation (biến dạng) và Morphing (biến hình) nằm trong số những chức năng mạnh mẽ trong lĩnh vực thiết kế free-form (hình khối tự do). Với deformation, ta có thể twist, shear, blend, … geometry (hình học) và với Morphing, ta có thể deform geometry (biến dạng hình học) từ một hình thái này sang hình thái khác Hãy xét đến một ví dụ về sự biến dạng đơn giản. Nếu chúng ta có một vật thể như là một quả cầu chẳng hạn, chúng ta sẽ có một bounding‐box (cage) bao quanh nó và nếu ta điều chỉnh bounding-box này thì ta có thể biến dạng toàn bộ geometry (trong ví dụ này là quả cầu).

Hình.6.1. Biến dạng bởi Bounding‐box (cage). Tuỳ theo sự điều chỉnh của chúng ta, chúng ta có thể gọi nó là shear hoặc blend hoặc free deformation. Đối với bất kỳ chức năng deformation nào, chúng ta có thể cần toàn bộ bounding‐box, hoặc chỉ một mặt phẳng của nó hay thậm chí chỉ là một điểm để deform (biến dạng). Nếu bạn xem xét kỹ những component (đối tượng) đã biến dạng theo nhiều cách khác nhau trong Grasshopper bạn vẫn có thể dễ dàng nhận thấy hình dạng hình học cơ bản của đối tượng đó trước khi nó biến dạng. Morphing (biến hình) trong lĩnh vực phim hoạt hình có nghĩa là sự chuyển tiếp từ một bức tranh này đến một bức tranh khác một cách mượt mà và liên tục. Ở đây trong không gian 3D nó có nghĩa là sự biến dạng từ trạng thái hoặc điều kiện này sang một trạng thái hoặc điều kiện khác. Morph (biến hình) một component (đối tượng) trong Grasshopper cũng hoạt động theo cách đó. Có 2 components, một cái biến dạng vật thể từ một reference box (Bounding Box) sang một target box, cái còn lại hoạt động với một bề mặt cơ bản mà trên đó bạn có thể deform geometry của bạn, trong domain cụ thể của bề mặt và chiều cao của vật thể. 108

GENERATIVE ALGORITHMS

Cái đầu tiên là và cái tiếp theo là cả hai đều nằm trong tab Xform dưới section Morph. Với cặp lệnh này, nếu chúng ta sử dụng những box đã biến dạng như là những target boxes thì chúng ta có thể deform bất kỳ geometry nào trong Grasshopper bằng cách kết hợp với component Box Morph. Như bạn thấy trong hình.6.2 chúng ta có một vật thể được gán vào Grasshopper bằng component . Vật thể này có một bounding‐box xung quanh nó mà tôi vẽ ở đây chỉ để minh hoạ. Tôi cũng có thể vẽ một box khác bằng cách liên kết với các giá trị mà ta có thể chủ động điều chỉnh.

Hình.6.2. Vật thể và box chứa đựng

Hình.6.3. Componet (XForm > Morph > Box morph) biến dạng một vật thể từ một reference box sang một target box. Bởi vì tôi chỉ có một geometry tôi gắn nó vào như là một bounding box hoặc reference box và vật thể, nhưng trong trường hợp này, bạn cũng có thể sử dụng component (Surface > Primitive > Bounding box) để sử dụng làm source box. Tôi tắt chế độ preview của component để thấy hình dạng sau khi biến hình rõ hơn.

109

GENERATIVE ALGORITHMS

Hình.6.4. Bây giờ nếu bạn chỉ đơn giản thay đổi kích thước của target box bạn có thể thấy rằng morphed geometry sẽ thay đổi theo.

Hình.6.5. Ở đây bạn thấy thay vì một box, nếu tôi sản xuất hàng loạt box, chúng tôi có thể bắt đầu morph vật thể nhiều hơn nữa. Như bạn thấy các box được tạo bởi component khác nhau theo trục Y, cũng sẽ tạo ra các vật thể biến hình khác nhau.

110

GENERATIVE ALGORITHMS

6_2_On Panelization Một trong những ứng dụng thường dùng nhất của chức năng Morphing là Panelization. Ý tưởng của panelization là chia nhỏ một free‐form surface (bề mặt cong tự do) thành nhiều phần nhỏ especially for fabrication issues. Mặc dù những free‐form surfaces (bề mặt cong tự do) được sử dụng rộng rãi trong công nghiệp chế tạo xe hơi, nhưng đó không phải là một công việc dễ dàng cho kiến trúc bởi ta phải xử lý chúng trong tỉ lệ lớn. Ý tưởng của panelization là chia một bề mặt thành nhiều phần nhỏ which are easier to fabricate and transport và có thể điều chỉnh sản phẩm cuối cùng dễ dàng hơn. Đôi khi nguyên nhân là chia một bề mặt cong thành nhiều mặt phẳng nhỏ và tận dụng những đường cong được tạo bởi các mặt phẳng đó which could be then fabricated from sheet materials. Có nhiều vấn đề cần được quan tâm, kích thước, đường cong, sự điều chỉnh, v..v... mà chúng ta sẽ thảo luận về một số trong số đó. Hãy bắt đầu với một mặt phẳng đơn giản và một component sẽ được sử dụng làm module cho mặt phẳng này.

Hình.6.6. Một bề mặt cong 2 chiều mà ta sẽ sử dụng để thử nghiệm ứng dụng panelization.

Hình.6.7. Component mà tôi muốn ốp lên mặt phẳng…….Không đặc biệt lắm, chỉ để ví dụ thôi !!!

111

GENERATIVE ALGORITHMS

Hình.6.8. Trước tiên, chúng ta cần gán mặt phẳng và module của chúng ta thành các component trong Grasshopper. Dựa trên những component có thể sử dụng trong Grasshopper, ý tưởng là tạo ra một cặp hình hộp trên bề mặt và sử dụng những hình hộp này làm target boxes và morph các module vào chúng. Vì vậy tôi sử dụng và tôi sử dụng bản thân vật thể làm bounding‐box. Bây giờ chúng ta cần tạo ra target box để morph các component vào chúng.

Hình.6.9. Component mà chúng ta cần để tạo target box là (XForm > Morph > Surface box). Component này sẽ tạo ra nhiều hình hộp trên một mặt phẳng dựa trên intervals trên surface domain và chiều cao hình hộp. Vì vậy tôi gắn bề mặt với nó và kết quả là các target box cho component . Ở đây tôi cần xác định domain interval của các hình hộp, hoặc số lượng chính xác của hình hộp theo mỗi hướng U và V của bề mặt.

112

GENERATIVE ALGORITHMS

Hình.6.10. Bây giờ tôi kết nối với để xác định bao nhiêu khoảng chia mà tôi cần trên hai hướng U và V. Một xác định chiều cao của target box, cũng tức sẽ là chiều cao của các component sau khi morph. Về cơ bản, toàn bộ ý tưởng là đơn giản. Chúng ta tạo ra một module (một component) và chúng ta thiết kế một bề mặt. Sau đó chúng ta tạo ra một số lượng hình hộp nhất định trên bề mặt này (gọi là target box) và rồi chúng ta morph module vào trong những hình hộp này. Cuối cùng chúng ta thay đổi số lượng component trong hai hướng U và V và cũng thay đổi module để update tự động lên bề mặt surface.

Hình.6.11. Mặt phẳng cuối cùng được tạo từ module cơ bản của chúng ta

113

GENERATIVE ALGORITHMS

6_3_Điều khiển cấp độ vi mô Mặc dù việc tạo ra hàng loạt module trên một bề mặt là rất tuyệt vời, nhưng dương như đó vẫn là một cách thiết kế rất chung chung. Bề mặt được tạo ra vẫn còn “mấp mô”. Chúng ta đã biết rằng chúng ta có thể thay đổi số lượng module, hoặc thay đổi chính bản thân module, nhưng kết quả vẫn là một bề mặt rất khái quát và chúng ta không thể điều khiển cục bộ hệ thống của chúng ta. Bây giờ tôi đang suy nghĩ về việc thiết kế một hệ thống trên cơ sở là các component mà chúng ta có thể thiết lập nhiều hơn sự điều khiển cục bộ trên hệ thống và tránh việc thiết kế những bề mặt chung chung mà không có sự phản ứng nào trong quy mô vi mô, cục bộ.

Chapter 6

Để giới thiệu về khái niệm này, chúng ta hãy bắt đầu với một ví dụ đơn giản và thực hành thêm một bài tập nữa. Chúng tôi sử dụng ý tưởng về những attractor để thiết lập điều khiển cục bộ cho một nhóm vật thể. Bây giờ tôi đang nghĩ về việc sử dụng phương pháp tương tự để thiết kế một hệ thống trên cơ sở là các component với chế độ điều khiển cục bộ. Ý tưởng là thay đổi kích thước component (trong trường hợp này, là chiều cao của chúng) dựa trên hiệu ứng của một attractor dạng điểm.

Hình.6.12. Một bề mặt cong 2 chiều được gán là và một hình nón được gán là trong Grasshopper, một để chia bề mặt, và một đóng vai trò là reference box của . Ở đây tôi sử dụng component cho bounding box. Bây giờ nếu tôi thay đổi kích thước của bounding box, tôi có thể thay đổi kích thước của tất cả các component trên bởi bounding box thay đổi tức là reference box đã thay đổi. Như bạn có thể thấy, component có một input chiều cao để xác định chiều cao của hình hộp. Ý tưởng là sử dụng những chiều cao tương đối thay vì là một hằng số. Vì vậy thay vì gán một hằng số cho chiều cao của hình hộp, chúng ta có thể thiết lập mối quan hệ giữa vị trí của mỗi hình hộp hộp với vị trí của attractor. 114

GENERATIVE ALGORITHMS

Hình.6.13. Ở đây tôi sử dụng cùng cho component (Surface > Util > Isotrim). Component chia bề mặt thành các bề mặt con nhỏ hơn. Với các bề mặt con này tôi có thể sử dụng một component khác gọi là (Surface > Analysis > BRep area) để sử dụng một sản phẩm của component này đó là ‘Area Centroid’ cho mỗi bề mặt con. Tôi đo khoảng cách của các điểm này (area centroids) với để sử dụng nó như là reference cho chiều cao của các target box trong component .

Hình.6.14. Tôi chia khoảng cách bởi một hệ số nhất định để điều khiển hiệu ứng của attractor và tôi đã sử dụng kết quả làm chiều cao cho target boxes là component . Bề mặt mà ta đã gán là , sử dụng như là surface domain và chiều cao được xác định dựa theo vị trí

của hình hộp và attractor. Như bạn thấy, chiều cao của các hình hộp bây giờ là khác nhau,tuỳ theo vị trí của attractor.

115

Chapter 6

Điều tôi cần là đo khoảng cách giữa mỗi hình hộp và attractor. Vì chưa có một hình hộp nào, tôi cần một điểm trên bề mặt tại trung tâm của mỗi hình hộp để đo khoảng cách.

GENERATIVE ALGORITHMS

Chapter 6

Hình.6.15. Chỉ có phần còn lại, kết nối với , bounding box và vào component và tạo ra các component trên bề mặt. Bằng cách thay đổi tỉ lệ scale, bạn có thể thay đổi kích thước của tất cả các component và dĩ nhiên, vị trí của attractor cũng có thể điều chỉnh.

Hình.6.16. Kết quả cuối cùng. Như bạn thấy, kích thước của component đã bước đầu được điều khiển cục bộ, dựa trên những đặc tính bên ngoài tác động, mà ở đây là attractor dạng điểm. Mặc dù ý tưởng là một attractor đơn giản, kết quả có thể rất thú vị và bạn có thể phân biệt các reference box theo nhiều cách khác nhau. Bây giờ chúng ta biết rằng khái niệm morphing và panelization không phải lúc nào cũng chung chung khái quát. Chúng ta đã kiểm tra khái niệm, bạn hãy thực hành một bài tập khác. 116

GENERATIVE ALGORITHMS

6_4_On Responsive Modulation Ý tưởng cho bước tiếp theo là điều chỉnh một bề mặt cho trước bằng cách điều chỉnh từng module của bề mặt đó, có nghĩa là mỗi module phải có sự tương tác với một vài tiêu chuẩn nào đó. Không đơn giản là một vài sự khác biệt của các module ở những vùng khác nhau, ở đây ta muốn có một sự điều khiển rõ ràng trên cả hệ thống module theo một tiêu chuẩn được cho trước. Những tiêu chuẩn này có thể là sự tương tác với môi trường, công năng, tầm nhìn…của các module ở vị trí khác nhau trên bề mặt. Trong ví dụ sau đây, với mục đích là làm cho vỏ bao công trình tương tác nhiều hơn với môi trường xung quanh, ta sẽ tạo ra một hệ thống phản ứng theo ánh nắng mặt trời. Ngoài ra, bạn có thể tự tìm tòi thêm về gió, mưa hoặc những công năng bên trong công trình hoặc bất kì tiêu chuẩn nào khác mà bạn đang quan tâm. Ở đây ta có một bề mặt, có thể nó là lớp vỏ của một công trình mà ta sẽ phủ lên nó với hai loại module khác nhau. Một loại hoàn toàn đóng kín, ngăn cản sự xâm nhập của ánh sáng mặt trời và loại còn lại có một lỗ mở. Những module này cần được lắp lên bề mặt lớp vỏ dựa vào hướng nắng tại nơi xây dựng công trình. Ta sẽ xác định góc nắng để hình thành thuật toán xác định với góc nắng bao nhiêu độ trên bề mặt ta sẽ lắp module kín và số còn lại là module hở. Definition của Grasshopper không có gì mới ngoài những concept giúp ta tạo nên sự thay đổi đa dạng trên lớp vỏ thay vì chỉ là dựng nên một bề mặt chung chung nào đó. Cơ bản khi bề mặt cong tự do và có nhiều hướng khác nhau thì chắc chắn góc nắng sẽ khác nhau ở từng phần của bề mặt. Đó là ý tưởng, dựa trên sự khác nhau của các góc hợp bởi pháp tuyến của từng phần trên bề mặt lớp vỏ với tia nắng để tạo nên một component điều chỉnh cho hệ thống module.

Hình 6.17: Phác thảo đầu tiên của các module tương tác tia nắng trên hệ thống façade 117

GENERATIVE ALGORITHMS

Chapter 6

Nguyên Liệu :

Hình 6.18: Bề mặt của công trình như một lớp vỏ.

Hình 6.19: Hai loại module khác nhau dùng cho lớp vỏ của công trình.

118

Hình 6.20: Bước đầu tiên tương tự như những ví dụ trước. Ta áp và sử dụng để chia nhỏ surface theo từng hướng U, V và tạo ra các Target Box bằng . Ta cũng dùng với cùng interval U, V và sử dụng để tìm trọng tâm của từng area (component được chọn màu xanh trên hình). Cùng lúc đó ta dùng một được định nghĩa như góc mặt trời ở nơi xây dựng công trình, dùng tạo để chỉ rõ hướng nắng. Bạn có thể lôi, kéo curve này để thấy hiệu ứng của ánh sáng mặt trời theo nhiều hướng tác động lên các module sau này.

Hình 6.21: Để tính toán góc giữa tia nắng và bề mặt lớp vỏ công trình, ta sẽ đo góc giữa tia nắng và pháp tuyến của bề mặt ở từng vị trí đặt module vào. Thế ta có thể quyết định loại module nào sẽ phù hợp trong một dãy các số đo góc này.Nên sau khi tạo ra tâm điểm của từng area, ta cần vector pháp tuyến của bề mặt lớp vỏ tại những điểm này. Đó là lý do tại sao ta sử dụng để tìm điểm gần nhất từ các tâm điểm này đến bề mặt lớp vỏ, có được thông số UV và sử dụng những thông số này để bề mặt ở các điểm đó để chắc chắc lấy được pháp tuyến.

119

Chapter 6

GENERATIVE ALGORITHMS

GENERATIVE ALGORITHMS

Hình 6.22: Ta sử dụng (vector > Vector > Angle) để tính góc giữa hướng nắng và bề mặt façade. Sau đó đổi giá trị góc sang độ và sử dụng để xem liệu các góc này có lớn hơn hay không. Hàm số này (x>y) sẽ cho ta giá trị Boolean: True cho các góc nhỏ hơn, False cho góc lớn hơn.

Hình 6.23: Dựa trên giá trị Boolean từ dữ liệu so sánh các góc, ta (tách?) những dữ liệu là Target Box (ta có số lượng target box, tâm điểm và pháp tuyến là như nhau). Vậy cơ bản ta chia chia các target box thành 2 nhóm khác nhau về góc nắng khi chúng nhận ánh sáng mặt trời. Việc còn lại của thuật toán đơn giản và giống những gì ta làm trước đây. Ta chỉ cần morph các module vào target box, chỉ có điều ở đây là làm cho 2 loại khác nhau. 120

Hình 6.24: Ở đây ta áp 2 loại module khác nhau này như những khối đơn lẻ và sử dụng cho từng loại kết hợp với một phần của dữ liệu để tạo hay module trên cả bề mặt façade.

Hình 6.25: Bây giờ nếu ta nhìn gần hơn có thể thấy trong những phần khác nhau của bề mặt façade, dựa vào độ công và hướng của từng phần đó mà các module khác nhau được tạo ra.

121

Chapter 6

GENERATIVE ALGORITHMS

Chapter 6

GENERATIVE ALGORITHMS

Hình 6.26: Model cuối cùng. Chổ chia đôi của target box (và dĩ nhiên cả module) có thể nhiều hơn 2 loại. Bao nhiêu là tùy thuộc vào thiết kế và các tiêu chuẩn chúng ta sử dụng. Chúng ta có thể nghĩ về các module hình thành nên façade, trong đó một vài cái là đóng kín, một vài cái mở ra; trong những cái mở ra đó ta có thể điều chỉnh một vài bộ phận giúp hướng về và hứng các luồng gió bên ngoài, và có những lổ hở tự điều chỉnh để phù hợp với chức năng bên trong công trình và cứ như thế tiếp tục. Bạn có thể thấy ý tưởng là tạo nên những module được điều khiển trong cả một hệ thống. Ta vẫn có những kết quả của điều khiển trên tổng thể facade (form) và từng vùng khác nhau trên façade (chiều cao, dầy hoặc kích thước lổ mở) trong cả hệ thống.

122

GENERATIVE ALGORITHMS

CHƯƠNG_7_NURBS AND MESHES

123

GENERATIVE ALGORITHMS

7_1 Bề mặt NURBS tham số (Parametric NURSB surfaces)

Trong các chương trước,chúng ta đã có một vài trải nghiệm với những bề mặt(Surfaces).Chúng ta đã sử dụng các lệnh Loft(Tạo bề mặt bằng việc nối các tiết diện) và lệnh Pipe (tạo bề mặt dạng ống từ 1 đường dẫn) để tạo ra chúng.Chúng ta cũng đã sử dụng những bề mặt tự do (Freeform surface) và những lệnh phân tích bề mặt (Surfaces analysis) tương ứng.Thông thường chúng ta sử dụng thuật ngữ “bề mặt” (surfaces) với ý nghĩa “những bề mặt tự do”(free form surfaces) ,chính là những bề mặt được tạo ra từ các đường cong (curvels) hay đôi khi là tập hợp(bunch) các điểm. Cho nên thông thường thì việc tạo ra các bề mặt phụ thuộc vào những đường cong (curvels) mà chúng ta cung cấp cho công cụ hình học bề mặt (surfaces geometries).Có rất nhiều những công cụ(component) trong Grasshopper và nếu bạn đã có đôi chút kinh nghiệm trong việc sử dụng Rhino thì bạn nên biết bằng cách nào ,thông qua những công cụ này,có thể sản sinh ra các bề mặt. Có thể xem những bề mặt như những sản phẩm cuối cùng trong thiết kế của chúng ta,giống như là bề mặt công trình(facades),tường .,.v..v.Và đó chính là lí do tại sao chúng ta cần rât nhiều phương án để có thể tạo ra các dữ liệu đóng vai trò nền tảng hình học như điểm hay tuyến(curvels) và nền những bề mặt cuối cùng.Ở đây tôi quyết định thiết kế một công trình hết sức đơn giản nhằm chỉ rõ rằng những công cụ bề mặt (surfaces component) đa dạng của Grasshopper có khả năng tạo ra những sản phẩm thiết kế khác biệt bằng những phương pháp hết sức cơ bản. Tháp Parametric Trong khu vực Docklands of Thames ở Luân Đôn,gần Canary Wharf,nơi mà những những công trình cao tầng sẽ có cơ hội xuất hiện,có tiếm năng xây dựng một số cao ốc.Và tôi nghĩ rằng chúng ta có thể cùng nhau đề xuất một phương án ở đây và thiết kế này sẽ một phác thảo đơn giản,chỉ là để thử sử dụng một vài ý tưởng cơ bản khi làm việc với các bề mặt tự do(Free form surfaces).Hãy quan sát khu vực xây dựng trong hình dưới đây.

Hình 7.1.Không Hình, Canary Wharf, London (image: www.maps.live.com, Microsoft Virtual Earth). Khu đất mà tôi chọn để thiết kế dự án này là trên bờ của sông Thames,,với một tầm nhìn tốt ra sông và gần lối vào quảng trường khu vực trung tâm của Canary Warf(đường Westferry).Tôi ko muốn trình bày quá nhiều về khu đât vì vậy chúng ta chỉ hãy có một quan sát nơi tôi dự định đặt cao ốc của mình và tiếp tục với những ý định về hình học.

124

GENERATIVE ALGORITHMS

Hình 7.2 : Khu đất dánh cho tòa tháp dự kiến

Phác thảo ban đầu (Manual drawings) Có rất nhiều cách để bắt đầu phác thảo này.Tôi có thể vẽ tầng trệt và sao chép nó lên trên rồi bắt đầu thao tác với chúng và thêm vào những chi tiết giống như những gì chúng ta đã làm với cao ốc Swiss Re.Một cách khác là vẽ những đường bao của cao ốc và sử dụng chúng như một nền tảng hình học hình thành khối tích công trình,sau đó bổ sung chi tiết để hoàn thành phác thảo.Tôi sẽ thích cách thứ 2 hơn một phần vì chúng ta cũng đã từng làm qua cách 1 ở các chương trước. Tôi sẽ vẽ những đường bao trong Rhino.Tôi cũng có thể vẽ những đường này trong Grasshopper nhưng vì tôi muốn lồng ghép các yếu tố hình học của khu đất vì vậy cũng cần một số dữ liệu khu vực và tôi có thể lây được theo cách này. Một ý tưởng lóe lên trong đầu tôi.Cao ốc này sẽ có một vài yếu tố dạng tuyến lập lại trên bề mặt và tôi cũng muốn đặt trên đó một dạng không gian rổng giữa ngoại thất và nội thất. Tôi cũng muốn đề xuất một không gian công cộng và được kết nôi với công trình thông qua cùng những yếu tố trên bề mặt,liên tục từ cao ốc đến bờ sông.

125

GENERATIVE ALGORITHMS

Hình 7.3.Những đường nét cơ bản của cao ốc kết hợp với khu đất Như bạn thấy ở hình &,3 tôi đã vẽ những đường nét cơ bản trong Rhino.Những đường nét này sẽ tương ứng với các đặc trưng khu đất,như giới hạn chiều cao,hình dáng và đường bao ..v..v.. bốn đường nét diễn tả công trình và hai đường còn lại là đường bao không gian công cộng xuất phát từ mặt đất và tiếp xúc với đường nét công trình.Mọi cái đều được vẽ hết sức tổng quát.Bạn có thể tạo ra bất cứ điều gì bạn thích và đi đến phần tiếp theo của công việc Tạo những component cơ bản trên bề mặt cao ốc

Hình 7.4. Đối với bước đầu tiên, tôi nhập đường cong 4 góc thành Grasshopper bằng component và sau đó tôi sử dụng phân chia những đường cong này thành 40 phần như các tầng của tháp. Như bạn thấy, các điểm phân chia được sắp xếp trong bốn chi nhánh dữ liệu khác nhau.

126

GENERATIVE ALGORITHMS

Hình 7.5. Bây giờ tôi có vẽ các đường cơ bản các điểm phân trên mặt tiền để sử dụng chúng cho các yếu tố mặt tiền. Ở đây tôi muốn vẽ đường từ điểm phân chia của mỗi đường cong với cùng một điểm của đường cong tiếp theo. Để làm được điều đó, tôi sử dụng gọi là component (Logic > Tree > Explore Tree ) để có quyền truy cập đến các chi nhánh khác nhau của dữ liệu một cách riêng biệt. Tôi thêm từ mỗi điểm nhánh với những điểm tiếp theo.

Hình 7.6. Trong bước này, tôi thêm vào những không gian rỗng của tôi cho mặt tiền với phân phối ngẫu nhiên. Chúng là ellipsoids, đã giới thiệu tất cả trong Grasshopper bằng component . Tôi cũng đã tất cả trước đó tạo ra các đường.

127

GENERATIVE ALGORITHMS

Hình 7.7. Trong bước này, tôi ed tất cả d các đường thẳng với những này .

Component mang lại cho tôi các phần bị cắt nhỏ trong và bên ngoài của khu vực, ở đây tôi sử dụng hần bên ngoài. Tôi nâng các phần như các yếu tố tuyến tính mặt tiền.

Hình 7.8. Đây là đóng kết nối với bốn góc tháp. Ở đây bởi vì tôi cần chúng để tạo ra các bề mặt khác nhau, tôi đường cong để có được các phân đoạn của nó và tôi cũng sử dụng để tạo ra một nhánh dữ liệu cho mỗi đường cong. Kể từ khi tôi có mặt cắt phần đường cong và hai đường cong cạnh để xác định ranh giới của mặt tiền trên từng mp, tôi sử dụng component để tạo ra mặt tiền bề mặt quét bằng sweep 2 rail.

128

GENERATIVE ALGORITHMS

Hình 7.9. Tôi giới thiệu một component để tạo ra bề mặt mặt tiền chung. Tôi sử dụng các đường cong kế hoạch ed như đường cong Mục lệnh quét. Rails là đường cong cạnh. Các component kết nối với các đường cong cạnh. Tôi ed nó một lần và tôi cũng ed và ed nó một lần nữa để tạo ra tất cả các đường cong đường sắt đầu tiên và thứ hai liên quan với những đường cong Mục kế hoạch. ! ! Lưu ý: nếu bạn không có được kết quả tương tự như minh họa, thứ tự của các đường cong cạnh của bạn (Rails) không liên quan với thứ tự của các đường cong kế hoạch của bạn (Phần đường cong) và bạn cần phải thay đổi thứ tự của các đường cong cạnh của bạn trong danh sách hoặc bằng tay bằng cách lại giao cho họ để component bằng cách trật tự khác nhau hoặc bằng cách chuyển danh sách Grasshopper.một component khi nó đã kết nối với những cái khác)

Hình 7.10. Trong bước này, tôi muốn trừ đi không gian rỗng từ bề mặt mặt tiền tạo ra trước đây. Kể từ khi hướng bình thường của bề mặt là quan trọng trong lệnh này, tôi ed hướng bề mặt bình thường, và sau đó sử dụng một component Difference> Boolean> Solid Difference) và kết quả là bề mặt chính trong khi s đã được xóa bỏ .

129

GENERATIVE ALGORITHMS

Hình 7.11. Với cùng một phương pháp, tôi giới thiệu cả hai đường cong của không gian công cộng, chia chúng, phá chúng ra và vẽ đường giữa chúng. Tôi có thể kết nối component này để component tương tự như các yếu tố mặt tiền để tạo ra hình học giống hệt nhau.

Hình 7.12. Sau khi thế hệ của tất cả các hình học, bake và các component .

130

GENERATIVE ALGORITHMS

Hình 7.13 Mô hình phác thảo sau khi hoàn tất 131

GENERATIVE ALGORITHMS

7_2_ Hình khối và cấu trúc liên kết (Geometry and Topology)

Đến nay chúng ta đã sử dụng các component khác nhau và làm việc với bề mặt NURBS. Nhưng như đã đề cập trước khi có các loại bề mặt rất hữu ích trong các ngữ cHình khác. Nó không phải là vẻ đẹp mịn màng của NURBS mà chúng ta nhằm cho, nhưng chúng ta có thể cần điều khiển chính xác hơn, chế biến dễ dàng hơn hoặc các phương trình đơn giản. Bên cạnh các loại bề mặt cổ điển của cuộc cách mạng, cai trị hoặc ống dẫn, chúng ta có bề mặt hình thức khác nhau miễn phí như Besier hoặc B-splines. Nhưng ở đây tôi sẽ nói một chút về mắt mesh có nhiều loại khác nhau của bề mặt. Mesh là một dạng khác của hình thức bề mặt tự do, nhưng các bộ phận nhỏ ( mặt) và tích lũy của các bộ phận nhỏ làm cho toàn bộ bề mặt. Vì vậy, có là không, nội bộ chức năng toán học ẩn mà tạo ra hình dạng của bề mặt, nhưng những mặt này xác định hình dạng của bề mặt tất cả cùng nhau. Nếu chúng ta nhìn vào một mắt mesh, đầu tiên chúng ta nhìn thấy mặt của nó. mặt có thể là hình tam giác, góc phần tư hoặc hình lục giác. Bằng cách nhìn gần gũi hơn, chúng ta có thể thấy một mạng mesh các điểm mà làm cho các mặt. Những điểm này là những yếu tố cơ bản của một mesh bề mặt. Bất kỳ nhóm nhỏ của những điểm này (ví dụ như bất kỳ ba trong mesh tam giác) làm cho một mặt hình học trở thành bề mặt. Những điểm này được kết nối với nhau bởi thẳng dòng. Có hai vấn đề quan trọng về mắt mesh: vị trí của những điểm này và kết nối giữa các điểm này. Vị trí của điểm liên quan đến hình học của mesh và kết nối các điểm liên quan đến cấu trúc liên kết.

Hình khối và cấu trúc liên kết. Trong khi khối hình học xử lý với vị trí của các object trong không gian, thì cấu trúc liên kết xử lý với các mối quan hệ của chúng. Trong toán học, cấu trúc liên kết là một thuộc tính của object mà sự chuyển đổi và biến dạng không thể thay đổi được.Chẳng hạn như hình tròn và hình elip đều có sự liên kết như nhau nhưng chúng khác biệt vê hình học. Hình 7,14 Như bạn thấy, có bốn điểm được kết nối với nhau. Trong hình đầu tiên, cả A và B có cùng một cấu trúc liên kết bởi vì chúng có cùng một mối quan hệ giữa các điểm (cùng một kết nối), nhưng hình dạng của hai hình khác nhau, do sự dịch chuyển của một điểm. Nhưng trong hình thứ hai, vị trí của các điểm là như nhau nhưng kết nối của các điểm khác nhau và chúng không giống nhau về cấu trúc liên kết.

132

GENERATIVE ALGORITHMS

Hình 7.14 Cấu trúc liên kết và Hình học. Ý tưởng về cấu trúc liên kết rất quan trọng trong mặt mesh. Bất kỳ mặt nào trong một mesh object đều có số điểm góc như nhau và các điểm góc này được liên kết với nhau theo một trật tự giống nhau cho tất cả các mặt của mesh object. Vì vậy, chúng ta có thể áp dụng bất kỳ biến đổi một mesh object và dịch chuyển các đỉnh(góc của 1 tứ giác) của mesh trong không gian thậm chí không-thống nhất với nhau, nhưng các kết nối tại các góc mesh cần được giữ nguyên để bảo vệ bề mặt nếu không sẽ hỏng bề mặt.

Hình 7.15. Cả hai bề mặt màu đỏ và màu xám là các mắt mesh với mặt và góc, trong mặt màu xám, các đỉnh được dịch chuyển, thực hiện một cấu hình hình học của mesh, nhưng kết nối của mesh object không thay đổi và cả hai bề mặt đều có cấu trúc liên kết giống nhau.

Tầm quan trọng các khía cạnh cấu trúc liên kết của các mesh object được hiểu như sau, chúng là một dạng hình học mạnh mẽ, khi ta có một loạt các điểm và ta cần một loại bề mặt chứa các điểm đó trong không gian. Các thuật toán khác nhau mà có thể làm việc với các điểm đều có thể được áp dụng cho dạng hình học mesh khi cấu trúc liên kết của mesh được sử dụng. Ví dụ, bằng cách sử dụng phân tích phần tử hữu hạn hoặc các ứng dụng cụ thể như dynamic relaxion, và các hệ thống phân tử, dễ dàng để làm việc với các mesh hơn so với các loại khác của các bề mặt khác kể từ khi có thể làm việc với đỉnh mesh. Mesh object đơn giản để tiến bộ hơn và nhanh hơn để xử lý, chúng có khả năng có lỗ bên trong và không liên tục về hình dạng. Ngoài ra còn có nhiều thuật toán để tinh chỉnh mesh và làm cho bề mặt mượt mà hơn. Kể từ khi các mặt khác nhau có thể có màu sắc ban đầu khác nhau, mesh object đáp ứng tốt cho mục đích phân tích màu sắc. Có nhiều component để xử lý với các mesh object trong tab 'mesh' trên giao diện Grasshopper.

133

GENERATIVE ALGORITHMS

CHƯƠNG_8_ Sự chế tạo (Fabrication)

134

GENERATIVE ALGORITHMS

Ngày nay, có một lợi ích rất lớn trong sự kết hợp với quá trình sản xuất có hỗ trợ của máy tính và việc chế tạo vật liệu. Với những thay đổi và các xu hướng mới trong quá trình thiết kế, dường như sự kết hợp này là một điều cốt yếu “phải có” trong mảng thiết kế, chuyển biến vào trong lĩnh vực của chế tạo kỹ thuật số. Bất kỳ quyết định thiết kế nào trong lĩnh vực kỹ thuật số cũng nên được kiểm tra dưới nhiều tỉ lệ khác nhau để cho thấy khả năng của việc chế tạo và lắp ráp. Rõ ràng những quá trình thiết kế mới và những thuật toán không thích hợp với những công đoạn thiết kế truyền thống, vì vậy các nhà thiết kế đang cố gắng sử dụng những công nghệ hiện đại trong chế tạo để làm ra sản phẩm của họ. Từ khi máy cắt CNC bắt đầu phục vụ công nghiệp xây dựng cho đến nay, một mối quan hệ lớn được tạo ra giữa thiết kế số hóa và chế tạo, theo sau đó nhiều máy móc và công nghệ khác nhau cũng được phát minh và cải tiến để phục vụ những loại hình thiết kếnày. Để thiết kế các yếu tố trong công trình và chế tạo chúng, chúng ta cần có khái niệm về quá trình chế tạo áp dụng cho nhiều loại vật liệu khác nhau và phải hiểu cách chuẩn bị khâu thiết kế thành phẩm. Dựa trên vật thể chúng ta thiết kế và vật liệu chúng ta dùng, những tính toán lắp ráp hợp lý, sự vận chuyển và quy mô kích thước, v.v.. chúng ta cần cung cấp số liệu thích hợp từ bản thiết kế và lấy những thông tin xuất ra mong muốn, để cung cấp cho máy.Nếu như xưa kia, để thực hiện 1 đồ án cần có mặt bằng, mặt cắt chi tiết , v..vv. Thì ngày nay tất cả những gì chúng ta cần đến chỉ là dữ liệu máy tính và các con số để chuyển đến máy để chế tạo. Vấn đề ở đây là nhà thiết kế nên cung cấp vài dữ liệu bắt buộc, bởi vì đó là sự liên kết cấp cao với đối tượng thiết kế. Và đôi khi nhà thiết kế cũng nên sử dụng những phản hồi từ sự chuẩn bị dữ liệu chế tạo cho việc tái cải tiến hay điều chỉnh đối tượng thiết kế. Đôi khi những đối tượng thiết kế nên được thay đổi để phù hợp với khả năng của máy móc và kỹ thuật lắp ráp. Liên quan đến vấn đề chúng ta đã biết, những khả năng tiềm ẩn khác nhau của Grassshopper có thể thay đổi thiết kế và những thiết kế đa dạng này có thể tồn tại trong một của quá trình chế tạo như những tiêu chuẩn khác. Tôi chỉ muốn mở ra một chủ đề và nói đến vài điểm liên quan đến giai đoạn chuẩn bị dữ liệu để có một cái nhìn vào những khả năng khác nhau mà chúng ta có thể trích dữ liệu từ đồ án thiết kế cho việc chế tạo chúng và đôi khai điều chỉnh để phù hợp những giới hạn trong chế tạo những đối tượng đó.

135

GENERATIVE ALGORITHMS

8_1_Datasheets

Để tạo ra một đối tượng, đôi khi chúng ta chỉ cần một chuỗi các số đo, góc, toạ độ và các số dữ liệu khác. Có nhiều component (multiple component) trong Grasshopper để tính toán các số đo, khoảng cách, góc, v.v… vấn đề là chúng ta cần lựa chọn đúng đắn và chính xác đối tượng cho các mục đích khác nhau. Chúng ta nên để ý đến độ phức tạp về hình học trong từng thiết kế và sau đó chọn điểm cần thiết cho từng mục đích đo đạc riêng. Tiếp theo là tìm những vị trí có thể đưa cho chúng ta những dữ liệu thích hợp cho mục đích chế tạo đối tượng, việc này để tránh tạo ra quá nhiều bảng dữ liệu tốn nhiều thời gian trong các đồ án lớn nhưng lại vô dụng vào giai đoạn kết thúc đồ án. Cuối cùng, chúng ta cần xuất dữ liệu từ phần mềm 3D sang dạng bảng tính và dữ liệu cho các công việc sau này. Paper_strip_project (Đồ án sử dụng các dải băng giấy để tạo hình) Ý tưởng về sử dụng những dải băng giấy để tạo hình đã hấp dẫn tôi vào vài cuộc nghiên cứu, dù nó đã được thử nghiệm trước đó (như trong đồ án Morpho-Ecolokgies bởi Hensel và Menges, 2008). Để hiểu rõ cách lắp ráp các dải băng, chúng ta bắt đầu với những kết hợp đơn giản trước cho cấp độ 1 và sau đó liên kết các kết cấu này với nhau như một cấp độ 2 cho việc lắp ráp. Ban đầu việc này rất thú vị, nhưng dần dần bị hỏng và không như tôi mong đợi. Vì vậy tôi cố gắng làm chính xác hơn để có được cấu trúc tinh xảo hơn.

Hình 8.1 Paper strips, thử nghiệm đầu tiên.

Bước tiếp theo, tôi cố gắng tạo một cấu trúc rất đơn giản và cố hiểu về mặt hình học và dùng nó như một nền tảng cho việc thiết kế mô hình trên máy tính. Tôi cho rằng việc tiếp cận ngay vào 136

GENERATIVE ALGORITHMS

thiết kế mô hình trên máy tôi sẽ không thể tạo ra được mô hình thực tế, và tôi nghĩ tôi cần thử nghiệm trên giấy trước. Mục tiêu của tôi là dùng ba mẫu băng giấy và liên kết chúng lại, một cái ở giữa và hai cái kia hai bên với độ dài lớn hơn cái ở giữa, và được ép lại rồi đính ở cuối với dải băng ở giữa. Đây có thể là một module cơ bản.

Hình 8.2 – Liên kết đơn giản của ba băng dấy ,để hiểu sự kết hợp trước khi đưa vào mô hình trên máy.

Khởi tạo mô hình trên máy tính Lúc này, tôi muốn tạo mô hình trên máy cho các dải băng sau khi hiểu được cấu trúc vật lí của nó. Để bắt đầu chúng ta cần một đường cong đơn giản ở giữa như một đường làm nền và chia nó ra bằng cách chọn các điểm chia (true, false) và di chuyển (điểm false) vuông góc với đường ở giữa và dùng tất cả những điểm này (điểm di chuyển và điểm false) như là những đỉnh cho 2 đường cong nội suy (interpolated curve) như tôi đã diễn tả

Hình 8.3 – Cách dựng mô hình đầu tiên với những đường cong nội suy

137

GENERATIVE ALGORITHMS

Nhưng nó dường như quá đơn giản và thẳng đuột, nên tôi muốn cho thêm những điểm liên kết với kích thước nhỏ dần, và nó sẽ tạo ra một dạng hình học phức tạp hơn. Giờ thì mở Grasshopper và tiếp tục làm việc với mô hình này. Tôi sẽ cố gắng giải thích các định nghĩa 1 cách ngắn gọn và đi vào phần dữ liệu.

Hình 8.4 - Component (Component) đường cong là dải băng ở giữa được dựng trong Rhino. Tôi tham số hoá (reparameterized) nó và tôi muốn định lượng nó trong một khoảng giảm dần. Tôi dùng component gọi là (khoảng/ dải/ hàng) và tôi đính/dán nó vào component (Params > Special > Graph Mapper). Component này vạch ra một bộ các số theo nhiều cách khác nhau và miền giá trị chọn bởi một dạng đồ thị đặc biệt (ở đây là dạng đường cong parabol) để tạo ra những điểm chéo màu đỏ như trên hình. Bạn có thể thay đổi dạng đường đồ thị để thay đổi cách phân bố các điểm trên đường cong (có thể tìm hiểu thêm trong bảng help). Tiếp tục tôi định hình đường ở giữa ( nối với ). Chú thích Reparameterized intial curve as middle strip: Đường cong ban đầu được tham số hoá như là dải băng ở giữa. Parameters alongside a reparameterized curve: Tham số dọc theo đường cong được tham số hoá. Changing the distribution of the parameters (parabola graph type): Thay đổi sự phân bố của các tham số (dạng đồ thị parabol – dùng cho việc nhỏ dần khoảng cách giữa các điểm) 138

GENERATIVE ALGORITHMS

Hình 8.5 - Sau khi phân bố các điểm dữ liệu và các điểm định trước, tôi muốn tìm trung điểm cho mỗi hai điểm đã hiết lập trước đó. Ở đây tôi phải tìm tham số đường curve, ở giữa mỗi điểm ban đầu và điểm kế nó, đểxác định.Khi có những tahm số của mỗi điểm đầu tiên này, tôi dùng di chuyển () dữ liệu để tìm điểm kế tiếp. Và tôi dùng component với để loại điểm/component (item) cuối trong danh sách để có thêm danh sách đã được di chuyển (ed). Component (f(x)=(x+y)/2) để tìm ra tham số ở giữa (ở đây là trung điểm). ( nối với ). Chú thích Finding the parameters of the midpoints on curve (between each point and the next one): Tìm tham số của trung điểm (tức là tìm giá trị của điểm) trên đường cong (ở giữa mỗi điểm và điểm kế nó) excluding 1 from list: Loại 1 điểm trong danh sách.

139

GENERATIVE ALGORITHMS

Hình 8.6 – Bây giờ tôi muốn di chuyển trung điểm và tạo những điểm chóp/điểm cực đại (deviated vertices) của 2 dải băng ở biên. Những điểm này phải luôn luôn vuông góc với đường ở giữa.Vì vậy để di chuyển chúng ta cần những vector vuông góc với đường giữa ở từng điểm cần di chuyển. Tôi đã sẵn có các các vector tiếp tuyến tại mỗi điểm bằng component nhưng tôi lại cần vector vuông góc. Chúng ta biết rằng Vector tích của 2 vector thì luôn luôn là một vector vuông góc với cả 2 (xem thêm ở hình 8.7). Ví dụ: vector đơn vị Z có thể là vector tích của 2 vector đơn vị X và Y. Đường curve ở giữa là đường thuộc mặt phẳng vì vậy vector Z tại mỗi điểm của đường curve này sẽ luôn vuông góc với mặt phẳng chứa đường curve. Vì vậy nếu chúng ta tìm được vector tích của vector tiếp tuyến và vector Z tại mỗi điểm , kết quả sẽ là một vector vuông góc với đường curve ở giữa ( đường middle curve này luôn nằm trên mặt phẳng). Vì vậy tôi dùng tiếp tuyến tại một điểm từ component và vector để tìm (Cross product), Xprod luôn luôn vuông góc với đường curve ở giữa. Thêm 1 mẹo nhỏ ! Tôi dùng các thông số của như một luỹ thừa của những vector Z để có những thừa số tăng dần cho sự di chuyển của các điểm, vì vậy khoảng cách (distance) giữa các điểm càng dài, độ di chuyển của chúng (displacement) càng lớn. Chú thích Increasing the power of Z vector: Tăng luỹ thừa của vector Z. Perpendicular vector to the curve at the parameter: Vector vuông góc với đường cong (curve) tại mỗi điểm tham số. Midpoint deviation: Độ lệch trung điểm 140

GENERATIVE ALGORITHMS

Hình 8.7 - Vector tích. Vector A và B thuộc mặt phẳng nền. Vector C là vector tích của A và B và nó vuông góc với mặt phẳng nền vì vậy nó vuông góc với vector A và B.

Hình 8.8 – Bây giờ tôi có cả những điểm cơ bản và những điểm đã được di chuyển. Tôi nhập chúng lại nhau bằng component , để có danh sách dữ liệu các điểm. Bây giờ tôi dùng những điểm này tạo ra đường cong nội suy ( curve), bạn sẽ thấy đường cong đầu tiên ở 1 bên băng giấy. 141

GENERATIVE ALGORITHMS

Chú thích Sorting points alongside Y direction: Sắp xếp các điểm dọc theo hướng Y

Hình 8.9 – Dùng component (theo đường dẫn XForm > Morph > Mirror Curve) tôi có thể lấy đối xứng đường cong nội suy qua trục là đường ở giữa (middle ) được kết nối với và chúng ta có 2 bên của băng giấy. Chú thích Interpolated curves as side strips: 2 đường cong nội suy sẽ là 2 dải băng ở biên.

Hình 8.10 - Bây giờ nếu tôi liên kết băng giấy ở giữa và 2 bên vào trong component , tôi có thể thấy bộ liên kết với những khoảng khác nhau giữa những điểm liên kết.

142

GENERATIVE ALGORITHMS

Hình 8.11 - Tôi có thể bắt đầu kéo/ thao tác dải băng ở giữa và nhận thấy Grasshopper cập nhật 3 dải băng được liên kết với nhau, hoặc tôi có thể thay đổi giá trí trên slider và kiểm tra xem có được kết quả như mô hình thực tế hay không. Sau khi tôi tìm ra hình dạng tôi muốn để tạo ra mô hình dải băng, tôi cần xuất ra kích thước, số đo để có thể xây dựng mô hình thật với những dữ liệu đó. Mặc dù nó khá dễ để tạo tất cả các đoạn băng trên tấm giấy và cắt chúng với máy laser, nhưng ở đây tôi thích quá trình thêm tổng quát và lấy dữ liệu ban đầu để tạo mô hình, nên tôi không muốn giới hạn mình vào cái máy cắt laser hay một cách thức đặc thù nào khác. Bạn có thể dùng dữ liệu để tạo mô hình bằng bất kỳ cách nào, thậm chí bằng tay như cách tao muốn làm trong trường hợp này để chắc rằng tôi không bị phụ thuộc máy tính. Bằng cách tạo ra mô hình đơn giản ban đầu của dải băng, tôi biết là tôi cần biết vị trí của các điểm liên kết trên dải băng và rõ ràng những điểm này khác nhau về độ dài giữa dải bên trái, bên phải và ở giữa. Vì vậy tôi lấy khoảng chia từ Grasshopper, tôi có thể đánh dấu chúng trên dải băng và ráp chúng lại. Dải băng là một đường cong, component không giúp tôi tìm được những số đo. Tôi cần độ dài của đường cong giữa 2 điểm bất kỳ trên mỗi dải băng. Khi tôi định tham số trên đường curve, nó chỉ đưa cho tôi khoảng cách từ điểm bắt đầu. Vì vậy tôi cần tìm tham số của điểm liên kết trên đường curve và định vị trí của chúng cho mỗi đường curve và component sẽ đưa ra khoảng cách của những điểm từ điểm bắt đầu của đường curve (dải băng), tức là vị trí của các điểm liên kết.

143

GENERATIVE ALGORITHMS

Hình 8.12 –Như bạn thấy tôi dùng bộ đầu tiên của các điểm mà tôi gọi là “main curve points” (điểm chính) trên đường cong ở giữa (đường cong đầu tiên initial curve). Giá trị xuất ra (L) của component (component) chỉ cho tôi khoảng cách của các điểm liên kết từ điểm khởi đầu của dải băng ở giữa. Tôi cũng dùng những điểm này để tìm tham số của chúng trên mỗi dải băng biên. Tôi dùng component để tìm tham số các điểm trên đường cong. Tôi dùng những tham số này để định những điểm liên kết (hay là tham số - parameter) cho đoạn băng ở biên và tìm khoảng cách của chúng với điểm khởi đầu. Tôi cũng có thể làm cách tương tự để tìm khoảng cách của các điểm liên kết trên đoạn băng ở biên còn lại (dùng component ). Khi kết thúc, tôi có vị trí của tất cả các điểm trên mỗi dải băng.

Nên chắc chắn các hướng của tất cả các đường curve đồng hướng và kiểm tra khởi đầu của đường curve (dựa trên đo đạc).

144

GENERATIVE ALGORITHMS

Xuất dữ liệu

Hình 8.13 – Nhấp chuột phải trên component và chọn ‘stream contents’. Bằng lệnh này bạn có thể lưu dữ liệu của bạn dưới nhiều định dạng và sử dụng chúng như dữ liệu tổng quát. Ở đây bạn sẽ lưu với dạng .txt và tôi muốn dùng chúng trong Microsoft Excel.

145

GENERATIVE ALGORITHMS

Hình 8.14 – Trên bảng tính Excel, chọn một ô trống và vào thẻ ‘Data’ và bên trong phần ‘Get External Data’ bạn chọn ‘From Text’. Sau đó chọn đường dẫn tới file .txt lúc nãy và làm theo hướng dẫn của Excel. Những bước này cho phép bạn quản lý những dạng khác nhau của dữ liệu và chia dữ liệu của bạn trong những cột và ô khác nhau.

Hình 8.15 – Bây giờ bạn sẽ thấy dữ liệu của bạn được đặt trong bảng tính của Excel. Bạn có thể làm tương tự cho các dữ liệu của các dải băng còn lại.

Hình 8.16 – Bảng thống kê của các điểm liên kết dọc dải băng. 146

GENERATIVE ALGORITHMS

Nếu bạn có một danh sách của các toạ độ 3D của các điểm và bạn muốn xuất chúng qua Excel, có nhiều lựa chọn khác nhau ngoài ví dụ ở trên. Nếu bạn xuất toạ độ 3 chiều (3D coordinates) với phương pháp trên bạn sẽ thấy nhiều ‘dấu ngoặc’ và ‘dấu phẩy’ không cần thiết và bạn sẽ muốn xoá nó. Bạn cũng có thể thêm cột vào bằng cách chọn hộp thoại import text trong Excel và chia những dấu ngoặc và dấu phẩy đó theo nhiều cột khác nhau và xoá chúng, nhưng vì kích thước độ dài của các con số khác nhau, nên bạn sẽ tìm các ký tự ở các cột khác nhau, và bạn sẽ không dễ dàng canh chia cột. Trong trường hợp như vậy, tôi khuyến khích bạn phân tích các điểm vào các component và xuất chúng riêng ra. Đó không phải là vấn đề lớn khi xuất 3 danh sách dữ liệu thay vì một danh sách.

Hình 8.17 – Dùng component để tạo toạ độ X, Y và Z của các điểm riêng ra để xuất sang bảng tính. Tôi nhấn mạnh giới thiệu bạn làm việc 1 cách chuyện nghiệp với Excel và các phầm mềm sắp xếp dữ liệu khác bởi vì chúng giúp chúng ta nhiều trong quản lí dữ liệu trong nhìu cách khác nhau, ở nhìu trường hợp khác nhau.

Như vậy là đủ cho việc tạo mô hình! Tôi dùng dữ liệu để đánh dấu các dải băng và liên kết chúng. Thậm chí để chứng minh,tôi tự làm mọi thứ bằng tay!!!!!!! Để chứng minh rằng việc chế tạo mô hình không nhất thiết phải dùng máy cắt laser (hoặc đôi khi là HAM, Achim Menges có lần dùng như từ viết tắt của Hand Aided Manufacturing). Tôi chỉ tốn 1 giờ để cắt và đánh dấu tất cả các dải băng, nhưng khi ráp thì lâu hơn và dĩ nhiên quá trình này phải ráp bằng tay.

147

GENERATIVE ALGORITHMS

Hình 8.18 (a,b,c) - Dự án dải băng khi hoàn thiện.

148

GENERATIVE ALGORITHMS

8_2_Việc cắt bằng laser and Cutting based Manufacturing

Ngày nay, ý tưởng cắt laser trên các tấm vật liệu để chế tạo các dạng hình học phức tạp là rất phổ biến. Chúng ta có nhiều cách khác nhau để chế tạo các vật thể. Phương pháp cắt laser phù hợp với các đối tượng được tạo lập với các bề mặt hoặc trải những bề mặt được gấp lại. Người ta có thể trải các hình học kỹ thuật số trên mặt phẳng và chỉ đơn giản là cắt nó thành 1 mHình và gấp lại để tạo ra vật thể. Nó cũng thích hợp để làm các dạng hình học phức tạp mà có thể được giảm phần riêng biệt của các bề mặt phẳng và người ta có thể tháo rời toàn bộ mô hình kỹ thuật số thành những phần riêng biệt, làm tổ trên các tấm phẳng, thêm các bộ phận chồng chéo cho các mục đích kết nối (giống như dán) và cắt nó và lắp ráp vật lý. Nó cũng có thể chế tạo hai đường cong đối tượng bằng phương pháp này. Nó cũng đã được thử nghiệm để tìm các phần khác nhau của đối tượng hình bất kỳ 'Blob’, cắt giảm ít nhất là trong hai hướng và lắp ráp các phần này lại với nhau thường là với các khớp kiềm chế và làm cho các mô hình hình lồng xương sườn. Kể từ khi máy cắt laser là một công cụ phổ biến, và cũng có nhiều phương pháp khác, nhưng tất cả cùng tìm một cách giải quyết, giảm hình học thành miếng phẳng để cắt chúng từ một tấm vật liệu, giấy, kim loại, cardboard hoặc gỗ và cuối cùng là lắp ráp chúng lại với nhau (nếu bạn có cánh tay robot và bạn có thể cắt hình học 3D, nó là một sự khác biệt) Trong số các cách khác nhau thảo luận ở đây, tôi muốn thử nghiệm một trong số chúng trong Grasshopper và tôi chắc chắn rằng bạn có thể làm các phương pháp khác dựa trên các thí nghiệm này một cách dễ dàng. Bề mặt chế tạo dạng tự do. Tôi định chế tạo một bề mặt dạng tự do để nêu lên vài kinh nghiệm với việc chuẩn bị và gắn kết các phần của một đối tượng để cắt tạo, và với các vấn đề khác mà chúng ta cần tránh.

Hình.8.19. Ở đây tôi có 1 bề mặt và giới thiệu nó trong Grasshoper như là 1 vật thể, bạn có thể giới thiệu bất kỳ bề mặt nào mà bạn thiết kế hoặc sử dụng bất kỳ vật thể Grasshoper khác Sections as ribs 149

GENERATIVE ALGORITHMS

Để chế tạo bề mặt tự do điển hình này, tôi muốn tạo ra các phần của bề mặt này, lồng chúng trên tờ và chuẩn bị các tập tin được cắt bằng máy cắt laser. Nếu đối tượng mà bạn đang làm việc có một độ dày nhất định thì bạn có thể cắt nó, nhưng nếu như bề mặt này không có độ dày bất kỳ thì bạn cần thêm độ dày cho các phần được cắt.

Hình .8.20. Bước 1, tôi dùng một component để xác định vùng làm việc. Tôi cũng dung 1 phần < Box corners> (Surface > Analysis > Box corners) để tìm các góc khác. để tìm các góc đối diện của hộp và sử dụng chúng như là giới hạn của phạm vi mà tôi muốn tạo ra các xương sườn cùng với hình học. Vì vậy, bằng cách tính toán chiều dài và chiều rộng của hộp, tôi sử dụng những con số như là địa chỉ mà tôi muốn chia cho component . Về cơ bản bằng sử dụng tôi chỉ đơn giản là có thể phân chia chiều dài và chiều rộng của hộp trong các phần mong muốn.

150

GENERATIVE ALGORITHMS

Hình .8.21. Mục tiêu của tôi là để tạo ra các mặt phẳng cùng với chiều dài và chiều rộng của hộp như các dải xương sườn tôi cần. Đầu tiên tôi tạo ra hai mặt phẳng, một và một , mặt phẳng đầu tiên vuông góc với chiều dài của hộp và mặt phẳng thứ hai vuông góc với chiều rộng. Tôi tạo ra cả hai mp trên các góc đầu tiên của hộp bằng cách kết nối đầu A ra . Bây giờ tôi có thể tạo ra và cùng với chiều dài và chiều rộng của hộp, và bằng cách kết nối các component với họ, tôi có thể làm cho vector cho tất cả các điểm phân chia. Sau đó, tôi có thể mặt phẳng XZ và YZ bởi những vectơ và tạo ra hàng loạt các khung hình cùng với chiều dài và chiều rộng của hộp ranh giới của đối tượng.

Hình .8.22. Các khung hình được tạo ra cùng với chiều dài và chiều rộng của hộp ranh giới của đối tượng, tiếp tuyến với cạnh. Như bạn thấy, tôi có thể bắt đầu cắt bề mặt với những khung này.

151

GENERATIVE ALGORITHMS

Hình .8.23. Bây giờ nếu tôi tìm thấy các giao điểm của những khung và bề mặt (main geometry), tôi thực sự tạo ra cấu trúc cơ sở xương sườn. Ở đây tôi sử dụng một section component (Intersect> Mathematical > Brep / Plane) để giải quyết vấn đề này. Tôi sử dụng (bề mặt ban đầu của tôi) như là BRep và tạo ra các khung, các mặt để cung cấp cho component.

Hình .8.24. Sự cắt nhau của các khung và bề mặt, kết quả là tạo ra các đường cong trên bề mặt.

152

GENERATIVE ALGORITHMS

Làm tổ (Nesting) Bước tiếp theo là tổ các đoạn đường cong trên một tấm phẳng để chuẩn bị cho quá trình cắt. Ở đây tôi đã vẽ một hình chữ nhật trong Rhino với kích thước của tôi. Tôi đã sao chép hình chữ nhật để tạo ra nhiều tấm chồng chéo nhau và tôi đã vẽ một bề mặt bao gồm tất cả các hình chữ nhật

Hình .8.25. Những tờ giấy và một bề mặt cơ bản để đại diện chúng trong Grasshoper. Tôi sẽ sử dụng component (xform> Euclidian> Orient) tổ đường cong của tôi vào bề mặt đại diện cho các tấm để cắt. Nếu bạn nhìn vào component bạn thấy rằng chúng ta cần các mặt phẳng như mặt phẳng tham chiếu và mặt phẳng mục tiêu cần được trên bề mặt. Kể từ khi tôi sử dụng những mặt phẳng giao với bề mặt ban đầu và tạo ra các đường cong, tôi có thể sử dụng chúng một lần nữa như những mặt phẳng tham chiếu, vì vậy tôi cần phải tạo ra những mặt phẳng mục tiêu.

Hình .8.26. Tôi giới thiệu bề mặt được cắt trong Grasshopper và tôi sử dụng component (Surface > Util > Surface frames) để tạo ra hàng loạt khung ngang qua bề mặt. Nó thực sự hoạt động như nhưng nó tạo ra các mặt phẳng đầu ra, đó là điều tôi cần. 153

GENERATIVE ALGORITHMS

Hình .8.27. Định hướng. Tôi đã kết nối các đường cong dựa trên hình học cơ sở, và những mặt phẳng mà tôi sử dụng để tạo ra các phần hình học tham chiếu đến các component . Tuy nhiên, vẫn còn một chút thao tác xử lý cần thiết cho những mặt phẳng mục tiêu. Nếu bạn nhìn vào kết quả component bạn thấy rằng nếu bạn chia U hướng thậm chí bằng 1, bạn thấy nó sẽ tạo ra 2 cột để phân chia bề mặt. Vì vậy, tôi cần có các mặt nhiều hơn. Vì thế, tôi danh sách các mặt phẳng mục tiêu bằng con số xuất phát từ số lượng các đường cong tham chiếu. Nên tôi chỉ sử dụng mặt phẳng nhiều đường cong mà tôi có. Sau đó, tôi di chuyển các mặt 1 đơn vị trong hướng X để tránh chồng chéo với các cạnh của tấm. Bây giờ tôi có thể kết nối các mặt phẳng này tới component và bạn có thể thấy rằng bây giờ tất cả các đường cong lồng nhau trên bảng cắt.

Hình .8.28. Các đường cong lồng vào nhau trên bảng cắt. 154

GENERATIVE ALGORITHMS

Tạo Generating ribs

Hinh 8.29. Sau khi lồng các đường cong trên bảng cắt, vì vật thể chưa có độ dày nên chúng ta cần làm độ dày cho nó. Đó là lý do tại sao tôi các đường cong với độ cao mong muốn và thêm vào cả điểm cuối của đường cong để khép kín đường vẽ mà tôi hoàn thành để cắt

Tạo Khớp (khớp bridle) Bước tiếp theo là tạo ra khung sườn theo hướng khác và làm các khớp nối để lắp ráp sau khi cắt. Mặc dù tôi sử dụng cùng một phương pháp phân chia chiều dài Bounding Box để tạo ra các mặt phẳng và mặt cắt, nhưng tôi có thể tạo ra mặt phẳng bằng tay ở bất kỳ vị trí mong muốn. Vì vậy, nếu bạn không muốn phân chia theo cả hai hướng và tạo ra các phần đồng đều, bạn có thể sử dụng các phương pháp khác tạo ra các mặt phẳng và thậm chí làm cho chúng bằng tay.

155

GENERATIVE ALGORITHMS

Hình .8.30.Như bạn thấy, thay vì mặt phẳng tạo ra trước đây, tôi dùng các mặt phẳng bằng tay được xác định cho các phần theo một hướng khác của bề mặt. Một mặt phẳng được tạo ra bởi giá trị X trực tiếp từ và mặt phẳng khác xuất phát từ mặt phẳng được nhân đôi ở phía bên kia của bề mặt (surface length – number slider). Phần của hai mặt phẳng và bề mặt được tính toán cho các bước tiếp theo. Bây giờ tôi có thể định hướng những đường cong trên một tờ để cắt .Vì vậy, chúng ta hãy tạo ra khớp nối cho việc lắp ráp, là điều quan trọng.

Hình .8.31. Khi có các đường cong theo hai hướng, chúng ta có thể xác định các điểm giao nhau. Đó là lý do tại sao tôi sử dụng các component (Intersect > Physical > Curve | Curve) để tìm các vị trí giao nhau của những đường cong này, đó là những vị trí khớp nối ( Component trong chế độ tham chiếu chéo). 156

GENERATIVE ALGORITHMS

Tôi cần các bản vẽ để chuẩn bị cho các khớp để cắt.Tôi nghĩ đến việc chuẩn bị các vị trí khớp nối, nên tôi phải giảm một nửa mỗi xương sườn để có thể nối chúng ở vị trí cuối. Trước tiên, tôi cần phải tìm những vị trí giao nhau trên các xương sườn lồng nhau và sau đó vẽ các đường để cắt.

Hình .8.32. Nếu bạn nhìn thấy những kết quả xuất ra của component, bạn có thể nhận ra rằng nó cho chúng ta tham biến giữa đường cong này với các khác. Vì vậy tôi có thể cái tổ hoặc đường cong với những tham biến để tìm ra các vị trí khớp nối.

157

GENERATIVE ALGORITHMS

Hình .8.33. Bây giờ chúng ta có các vị trí khớp nối, chúng ta cần phải vẽ nó ra.Trước tiên tôi vẽ những dòng component với các vị trí khớp nối là điểm bắt đầu, định hướng và tôi đã sử dụng một nửa chiều cao của khung sườn như chiều cao của dòng. Vì vậy, mỗi điểm trên đường cong lồng nhau bây giờ có một dòng nhỏ liên kết với nó.

Hình .8.34. Bước tiếp theo, vẽ 1 dòng trên trục X từ điểm cuối của dòng trước đó với độ dài của (tùy thuộc vào loại vật liệu)

158

GENERATIVE ALGORITHMS

Hình .8.35. Để vẽ đường thứ ba, tôi cần phải tìm điểm mà dòng này kết nối với các đường cong cơ sở bởi vì tôi không biết chính xác chiều dài của nó. Trong bước này, tôi thêm vào với trục Y và giá trị âm để thu hút các dòng thứ ba, nhưng một chút còn hơn cần thiết, để băng qua đường cong cơ sở, để tìm điểm giao nhau. Các kết nối với các đường cong định hướng. Vì vậy, tôi sử dụng (Intersect> Mathematical > Curve | line>) để tìm vị trí giao nhau với đường cong cơ bản. Tôi ed những điểm này và s, một lần nữa từ điểm cuối của dòng thứ hai điểm giao nhau này. Kết quả là, các khớp xương được hoàn thành. Tôi hoàn tất cho cả hai khớp bên.

Hình .8.36. Sử dụng (Curve > Util > Join curves) bây giờ bạn có thể thấy tôi có một ô khe cắm hình mà tôi có thể sử dụng để cắt khớp bridle bên trong xương sườn. Tôi đang áp dụng cùng một phương pháp cho đầu kia của đường cong (Dãy thứ hai các khớp ở phía bên kia của đường cong theo định hướng )..

159

GENERATIVE ALGORITHMS

Hình .8.37. Khung sườn với những đường khớp nối ở 2 đầu. Tôi có thể rút ngắn đoạn nhỏ xíu ở phầngốc đường cong nhưng bởi vì nó không ảnh hưởng đến hình dáng nên ta có thể bỏ qua

Ghi nhãn

Khi làm việc giai đoạn chế tạo, sẽ một thảm họa nếu cắt hàng trăm các bộ phận nhỏ mà không có bất kỳ manh mối hoặc địa chỉ nào đó để chúng ta lắp ráp chúng lại với nhau, trật tự là gì và cái nào làm trước cái nào sau . Chắc chắn 1 điều là các phần đều khác nhau và chúng ta phải ghi nhãn cho chúng để thiết lập trật tự 1 cách dễ dàng. Đơn giản là một số hoặc một sự kết hợp của ký tự và số lượng để giải quyết một phần. Nếu đối tượng bao gồm các bộ phận khác nhau, chúng ta có thể đặt tên chúng. Chúng ta có thể sử dụng hệ thống thứ bậc khác nhau của dự án để đặt tên cho các bộ phận. Ở đây tôi sẽ đánh dãy số các bộ phận lắp ráp để chỉ ra vị trí của từng đoạn trong danh sách. Ta có thể dung thè để thêm chữ vào trong hình học và thể hiện vị trí cũng như độ cao .

160

GENERATIVE ALGORITHMS

Hình .8.38. Nếu bạn nhớ, tôi có 1 dãy các mặt phẳng mà tôi dùng như là mặt phẳng mục tiêu để định hương các đường cong. Tôi sẽ sử dụng mặt phẳng tương tự để định vị trí của ghi chú. Khi mặt phẳng này ở vị trí góc của khung sườn, tôi muốn thay thế nó trước tiên.

Hình .8.39.Tôi di chuyển các mặt phẳng góc 1 đơn vị trong hướng X và 0,5 đơn vị trong hướng Y (như của các vector) và tôi sử dụng các mặt phẳng để định vị các thẻ văn bản. Ở đây tôi sử dụng và tôi tạo ra một loạt các con số nhiều như khung sườn. component mà tôi sử dụng ở đây chỉ đơn giản là chuyển đổi từ 12,0 đến 12. Kết quả là, bạn có thể nhìn thấy tất cả các phần có một số duy nhất ở góc trái của nó.

161

GENERATIVE ALGORITHMS

Hình . 8.40. tôi có thể thay đổi cách phân chia các component của bề mặt được cắt 1 cách tối ưu để tránh lãng phí vật liệu. Ví dụ trên cho thấy, từ điểm bắt đầu của tờ 3, khung sườn được trải phẳng hơn và có nhiều khoảng trống ở giữa. Tôi cần cắt các khung sườn thành 2 phần và thay đổi điểm phân chia để gom gọn chúng lại. Tuy nhiên, tôi không xử lý quá nhiều phần tôi có thể làm bằng tay công cụ này trong Rhino, mọi phần không cần thiết để kết hợp! Bây giờ tôi có những khung sườn cùng hướng, và tôi sẽ làm tương tự cho các hướng khác có thể. Có 1 điều mà bạn phải xem xét ở đây là hướng của các khớp nối lật xung quanh, vì vậy về cơ bản trong khi làm việc với geometry ở phần trước bạn nên làm việc với phần Cutting Khi các geometry sẵn sàng để cắt, tôi cần sắp xếp và quản lý 1 chút trên tờ giấy. Như hình 8.42 tất cả được xếp gọn vào 3 tờ. Tôi đã tạo ra 3 hình dáng khác nhau của khung sườn theo chiều rộng của đối tượng. File sẵn sàng để cắt.

Hình .8.41. Nested ribs, đã chuẩn bị xong để cắt 162

GENERATIVE ALGORITHMS

Hình .8.43. Cắt khung sườn, sẵn sàng ráp nối.

Ráp nối Trong trường hợp của chúng tôi, việc ráp nối là đơn giản. Đôi khi bạn cần phải kiểm tra lại file hoặc file hỗ trợ hoặc excel sheet để ráp nối theo nhiều cách khác nhau.

163

GENERATIVE ALGORITHMS

Hình.8.43 Mô hình cuối cùng

164

GENERATIVE ALGORITHMS

Chế tạo là một chủ đề rộng để thảo luận. Nó phụ thuộc rất cao vào những gì bạn muốn chế tạo, vật liệu gì, máy tính nào và làm thế nào các bộ phận chế tạo sẽ được lắp ráp với nhau. Như tôi đã nói với bạn trước, phụ thuộc vào các dự án bạn làm, bạn cần cung cấp dữ liệu của bạn cho các giai đoạn tiếp theo. Đôi khi nó là quan trọng hơn để có được những cách lắp ráp logic, ví dụ như khi bạn đang làm việc với các component đơn giản nhưng hình học phức tạp khi lắp ráp thứ tự.

Hinh.8.44.Lắp ráp 1 cách logic; Vật liệu và điểm nối đơn giản, tôi có thể làm lắp ráp logic và sử dụng dữ liệu để làm mô hình của tôi.

165

GENERATIVE ALGORITHMS

CHƯƠNG_9_ Design Strategy

166

GENERATIVE ALGORITHMS

Design Strategy

Generative Algorithms là thuật toán và tham số liên tưởng đối xử lý hình học trong vấn đề thiết kế. Vượt xa các đối tượng hình học thông thường, với phương pháp thuật toán này, bây giờ chúng tôi có tất cả các khả năng của hình học tính toán cũng như quản lý số lượng lớn các dữ liệu, con số. Ở đây đối số không hạn chế thiết kế trong bất kỳ thử nghiệm nào được xác định trước, ta sẽ khám phá tiềm năng vô hạn; luôn luôn có những cách khác nhau để thiết lập các thuật toán. Mặc dù có vẻ như là các lệnh trong phần mềm mô hình tham số có thể giới hạn một số hành động hay chi phối các phương pháp, nhưng giải pháp thay thế luôn luôn có thể được đưa ra bàn luận, cho phép sáng tạo thoát khỏi những hạn chế. Để thiết kế một cái gì đó, cần có một chiến lược thiết kế giúp thiết lập các thuật toán tốt nhất có thể để tìm ra giải pháp thiết kế. Suy nghĩ về các thuộc tính chung của đối tượng thiết kế, vẽ một số bộ phận, thậm chí tạo ra một số mô hình vật lý, sẽ giúp chúng ta hiểu tốt hơn về các thuật toán, cũng như lựa chọn tốt hơn khi tạo một mô hình số hóa. Thông số có thể thay đổi trong quá trình thiết kế, dữ liệu số và các đối tượng hình học cần thiết, luôn luôn giúp đỡ để cải thiện các thuật toán. Rất có ích khi ta đã hiểu được vấn đề, hãy phác thảo và sau đó bắt đầu viết 1 thuật toán có thể giải quyết vấn đề đó. Và cuối cùng là...

Chúng ta nên suy nghĩ như đang giải thuật toán để thiết kế thuật toán!

167

GENERATIVE ALGORITHMS

Hình 9.1. Đồ án tạo vãi dệt ; Từ sự hiểu biết phân tích mô hình liên tưởng. 168

GENERATIVE ALGORITHMS

Hình 9.2. Đồ án tường xốp; Từ sự hiểu biết phân tích mô hình liên tưởng.

169

GENERATIVE ALGORITHMS

Tài liệu tham khảo Pottman, Helmut and Asperl, Andreas and Hofer, Michael and Kilian, Axel, 2007: ‘Architectural Geometry’, Bently Institute Press. Hensel, Michael and Menges, Achim, 2008: ‘Morpho-Ecologies’, Architectural Association. Rutten, David, 2007: ‘Rhino Script 101’, digital version by David Rutten and Robert McNeel and Association. Flake, Gary William, 1998: ‘The computational beauty of nature, computer explorations of fractals, chaos, complex systems, and adaptation’, The MIT Press. De Berg, Mark and Van Kreveld, Marc and Overmars, Mark, 2000: ‘Computational Geometry’, Springer. Grasshopper tutorials on Robert McNeel and http://en.wiki.mcneel.com/default.aspx/McNeel/ExplicitHistoryExamples.html

Associates

wiki:

Axel Kilian and Stylianos Dritsas: ‘Design Tooling - Sketching by Computation’, http://www.designexplorer.net/designtooling/inetpub/wwwroot/components/sketching/index.html Wolfram Mathworld: http://mathworld.wolfram.com/ Stylianos Dritsas, http://jeneratiff.com/ Main Grasshopper web page: http://grasshopper3d.com/

170

GENERATIVE ALGORITHMS

Ghi chú

171