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
Mặc dù ta tạo ra những vòng tròn cơ bản này, tất cả như nhau, nhưng chúng ta biết rằng tất cả các tầng không có cùng kích thước, vì vậy chúng ta cần rescale chúng; Nếu chúng ta nhìn vào các phần của tháp, chúng ta sẽ thấy rằng từ một vòng tròn trênđất, chúng trở nên lớn hơn lên đến độ cao nào đó, sau đó trở nên nhỏ hơn và nhỏ hơn lên đến điểm cao nhất của tháp.Vì vậy, ta cần phải rescale các tầng mẫu, có nghĩa là ta phải cung cấp một danh sách các hệ số scale. Ở đây một lần nữa ta sẽ sử dụng một giả định về các hệ số scale của các tầng mẫu. Bạn có thể thay đổi những con số này để xem nếu project của bạn trông giống như thiết kế ban đầu, nhiều hơn hoặc ít hơn.
62
GENERATIVE ALGORITHMS
Hình.4.15. Ta cần một component (XForm > 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).
