The Percy Project
ryanpennings_thesis_final_005.indd 1
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 2
27/10/2015 10:53 PM
Ryan Pennings Bachelor of Industrial Design (Honours) RMIT University 2015 s3378565@student.rmit.edu.au design@ryanpennings.com www.ryanpennings.com Supervisor: Dr. Scott Mayson
All photography and graphics by Ryan Pennings Š 2015 unless otherwise stated.
ryanpennings_thesis_final_005.indd 3
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 4
27/10/2015 10:53 PM
A special thank you to: The RMIT School of Architecture and Design workshop staff. - For their continued support in setting up the Robotic 3D printer. Scott Mayson - For his ongoing assistance, supervision and banter over the year.
ryanpennings_thesis_final_005.indd 5
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 6
27/10/2015 10:53 PM
Abstract Keywords: algorithmic design, parametric design, robotic fabrication, additive manufacturing
Algorithmic Design is an area of designpractice where an object’s form and function with in the built environment is generated by a computational system. Project Percy explores how algorithms can be applied to a product design, and exemplifies how designers can work with these methods and techniques; through the lens of furniture and home-wares via additive manufacturing (3D Printing).
of an algorithmic design process, where material and machine properties are built into the algorithm. The novel process provides an emergent visual behaviour and functionality to archetypal furniture, and utilises the unique relationship that results from the combination of robotic fabrication and algorithmic design.
The Percy project includes the development of a robotic 3D printing system, which enables the integration of large scale robotic printing and fabrication into the algorithmic design process. Explorative digital prototyping is used to examine the possibilities of algorithmic design in a product design context. These prototypes are then evaluated against a set of specific criteria; this informs an iterative design method that is applied to develop a furniture series. This series includes the ‘Percy Stool, Dining Chair, and Dining Table’ and showcases an in-depth examination
The Percy Project
ryanpennings_thesis_final_005.indd 7
27/10/2015 10:53 PM
Contents Abstract Contents Introduction What is algorithmic design? Understanding Algorithmic Design Project Overview Why use algorithmic design? Product Concept
1 2 5 6 8
Context & Field 3D Printed Furniture Algorithmic design in products Furniture & Home-wares Robotic 3D Printing Introduction to software
15 16 18 20 20
Current Theories Biomimicry 29 Digital Materiality 30 Are we actually designing? 32
Methods Intro: The use of multiple methods 39 Parallel Prototyping 40 Sketching 40 Digital Sketching 40 Matrix 42 Algorithmic Design Environments 42 Robot 3D Printing - Setup & Testing 42 Robotic Programming 45 Extruders, Plastics & Environments 46
ryanpennings_thesis_final_005.indd 8
27/10/2015 10:53 PM
Methods of Evaluation & Validation Introduction 51 Artefact Analysis 51 Affinity Diagram 54
Objects Introduction 61 Potato Masher 62 Contour Bowl 66 Physics Spoon 70 Cellular Automata Bowl 74 Pasta Scoop 78
Algorithmic Furniture: Percy Series Introduction 87
Pre-Algorithmic Stools Introduction 89 1st Stool 90 2nd Stool 92 3rd Stool 92
Algorithmic Stools Explaining the Algorithm Used 97 Stool_001 100 Stool_002 104 Stool_003a 108 Stool_003b 112 Stool_003c 116 Stool_003d 120
ryanpennings_thesis_final_005.indd 9
27/10/2015 10:53 PM
Algorithmic Dining Chairs Chair_003 126 Chair_004 132 Chair_005 138
Synthesis Introduction 145 Grasshopper vs Processing 146 Why digital sketching works 146 Emergent Behaviour 149 Outsourcing form giving 149 Providing Function with form. 150 Maintaining product topology 150 Pushing away from Archetypical Topologies 153 Integration of Environments 153 Applying Algorithmic Design 153
Conclusion 157 Reflection
159
References 161 List of Figures
163
Glossary of Terms
164
ryanpennings_thesis_final_005.indd 10
27/10/2015 10:53 PM
Appendix A: Matrix
167
Appendix B: Grasshopper Scripts Stool_001 170 Stool_002 174 Stool_003a 178 Stool_003b 182 Stool_003c 186 Stool_003d 190 Chair_003 194 Chair_004 198 Chair_005 202 Python Script 207
Appendix C: Processing Scripts Introduction 217 Main_Code 218 Agent_Code 220
ryanpennings_thesis_final_005.indd 11
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 12
27/10/2015 10:53 PM
Introduction What is algorithmic design? What I call Algorithmic Design within this project refers to a collection of terms used loosely within various design disciplines. The terms ‘Parametric Design’, ‘Algorithmic Design’, ‘Generative Design’ and ‘Computational Design’ are all used by various researchers and designers within the field. A simple way to view the distinction between these terms is seeing them in an order of raising complexity, beginning at Parametric Design, through Algorithmic Design and into Generative Design. Computational Design can be seen as an umbrella term for the other three terms. There is no standardised definition of these terms, various researchers and designers have different opinions on what each means and what they encompass. Here I seek to define each of the terms individually to help with understanding the issues and fields involved. Computational design, as used by designers such as Francis Bitonti(Bitonti, n.d.) and
Ross Lovegrove(Howarth, 2015) is the use of computers within design that extends beyond typical CAD (Computer Aided Design) and CAM (Computer Aid Manufacture) processes, and begins to use more advanced tools and processing that Parametric, Algorithmic and Generative Design methods afford. Parametric Design in it’s simplest form is the direct and adjustable manipulation of a form. Dassault SolidWorks, a popular CAD program within Industrial Design and Engineering, is an excellent example of a parametric software. This involves the ability to change parameters of the computer model at any time during the process, as opposed to more typical surface modelling programs (such as Rhinoceros 3D or Autodesk Alias) where the relevant part of the model would need to be rebuilt if a change was desired. The use of parametric design techniques within SolidWorks is a simple version of what others call parametric design. One of
The Percy Project
ryanpennings_thesis_final_005.indd 1
1
27/10/2015 10:53 PM
these other’s is Patrik Schumacher, his work from Zaha Hadid, which he calls Parametric Design(Patrik Schumacher, 2010), could hardly be placed in the same category of work typically produced in SolidWorks. While Patrik Schumacher’s parametric design methodology is heavily focused on complexity and variance of form, the parametric parameters of SolidWorks are more suitable to mainstream design practices. This shows the variance that is possible within parametric design. Algorithmic Design as a term can be applied to the utilisation of existing algorithmic processes (algorithms) to generate form and function. The key difference from parametric design is the inclusion of multiple steps as opposed to a single step in parametric design (where when a parameter is changed the model updates). The definition of an algorithm is a series of steps that is followed to create an outcome, thus algorithmic design is a collection of steps followed [by the computer] to create a designed form. The term algorithmic is also used within the art field by Frieder Nake and Jon McCormack(McCormack et al., 2014; Nake, 2014), who talk about the more metaphysical and philosophical nature of algorithmic art. Their work also ventures into what could be called generative design. Generative design has two majorly different potential meanings. Schumacher and Krish (Peter Schumacher & Krish, 2014) talk about the use of generative design as a process where a model is defined and a computer is used to generate a variety of possible outcomes. This type of generative design is also explored by the Autodesk Dreamcatcher project(Autodesk, n.d.). Other people see generative design as a process iterative within itself, where the process “grows” the form, as is in the work of Nervous System (Nervous System, n.d.). For this project, I use Algorithmic Design as a board term, to cover the areas of parametric design that includes the work of
2
ryanpennings_thesis_final_005.indd 2
Patrik Schumacher, through the generative and algorithmic work of Nervous System, to the computational products and processes of Francis Bitonti and Ross Lovegrove. I leave out the approach to generative design that is followed by the Schumacher and Krish and the Dreamcatcher project, as this constitutes an entirely different design methodology that falls outside the framework this project provides.
Understanding Algorithmic Design To understand the approaches and thinking behind this project I propose a framework of understanding that is based around the materialisation of algorithmically designed objects. This framework enables designers to understand the complexity involved in the possible methods and approaches that can be taken when designing with algorithms. The framework is based on the ideas of digital materiality as proposed by Gramazio and Kohler(Gramazio & Kohler, 2008), and is reinforced by the discussion on materiality within fashion by Woodward and Fisher(Woodward & Fisher, 2014). “Digital Materiality” is a term used by Gramazio and Kohler, which refers to the connection between between material and digital processes(Gramazio & Kohler, 2008). While they’re specifically discussing the topic within the field of Architecture, this idea of a “Digital Materiality” is appropriate to this project. Gramazio and Kohler attribute a large amount of the connection between the digital and physical to digital fabrication techniques. These techniques, such as Additive Manufacturing or Robotic Fabrication give a designer a high level of control over the materialisation [manufacturing and fabrication] process. It is this level of control that Gramazio and Kohler suggest lets materials be “…
The Percy Project
27/10/2015 10:53 PM
The Percy Project
ryanpennings_thesis_final_005.indd 3
3
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 4
27/10/2015 10:53 PM
enriched by information…”(Gramazio & Kohler, 2008, pp?). They discuss the architectural specifics of the concept of ‘digital materiality’, eventually moving on to an essential change that ‘digital materiality’ provides us. This change is the move from designing objects that are unchanging and static in their form, to designing a process that in turn designs the object. By designing an algorithmic process and an object as one, we have the ability to materialise a board range of functions, contextual agencies, information and data. As Schumacher and Krish(Schumacher, 2010) have pointed out, teaching these design methods and processes is difficult. By using ‘digital materiality’ as a framework, it is possible to provide designers with the a method of understanding to navigate the complexity of algorithmic design. To add to this framework, we can look at the ideas of materialisation within fashion presented by Woodward and Fisher in their article for ‘Critical Studies in Fashion & Beauty(Woodward & Fisher, 2014)’. Woodward and Fisher discuss the idea of materialisation within fashion consisting of a wide variety of elements, which include “…images on a screen, the way clothing in a fashion show catches the lights of the cameras, as well as an item of clothing”. They contend “… in the context of fashion, an appropriate position on materiality must treat both the cultural and the material elements present in fashion.”(Woodward & Fisher, 2014) As such, in the context of algorithmic design, we must consider that the materiality of an algorithmically designed object to extend beyond it’s physical form and function to include the digital process alongside it’s cultural and contextual elements. As fashion is considered largely immaterial(Woodward & Fisher, 2014), the same way in which digital design [algorithmic design] is considered immaterial, we can apply the ideas discussed by Woodward and Fisher to algorithmic design alongside
the ideas of ‘digital materiality’. The application of these ideas suggests methods and approaches to help guide designers through the complex conceptual thinking required to work with the algorithmic design process. A strong technical understanding of the algorithmic design process and the tools used within it is also required.
Project Overview Both the technical and process approaches are explored in this project through object experiments where digital and physical materiality are combined. These object experiments, conducted through the lens of the home-wares & furniture field, probe the different methods made possible by the previously discussed framework. The objects will be analysed against each other, and against their function. Additive Manufacturing was selected as the preferred digital manufacturing technique for a variety of reasons. The versatility of additive manufacturing in terms of forms it can produce make it an ideal candidate for the manufacturing and production of algorithmically design objects which are often complex in form and are not designed/created with manufacturability in mind. Proximity to additive manufacturing technologies across scales such as large format robotic 3D printing, small format FDM/SLA/SLS, ceramic and metal printing, is another factor that led to the choice of additive manufacturing. Furniture and home-wares was chosen as a lens through which to shape these objects as they are simple enough to not complicate the already complex topic of algorithmic design (both in design and manufacturing), while retaining a wide range of options with which to explore a broad range of techniques and methods. From the users perspective furniture and home-wares are a familiar and
The Percy Project
ryanpennings_thesis_final_005.indd 5
5
27/10/2015 10:53 PM
common occurrence, that when presented with algorithmically designed variants of objects, they have more chance of being able to decipher the intended use, function and context of the object. This field also accommodates a broad range of options that support the scalability that is afforded by the use of additive manufacturing.
Why use algorithmic design?
Existing projects and practitioners in the fields of 3D printed furniture, algorithmic product design, furniture and home-wares, robotic architecture and robotic 3D printing are examined. These precedents provide guidance and inspiration as well as criticisms which help to differentiate this project and identify areas which remain un- or underexplored. Alongside this, the techniques and theories of these current practitioners are analysed, to decipher their usefulness. These theories and practices include biomimicry, ‘generative design’ and ‘digital materiality’. The technical requirements of the elements involved in this project are discussed, which includes a variety of algorithmic design environments, which a strong focus on the Grasshopper plugin for Rhinoceros 3D. The programming and development of a robotic 3D printing platform is also discussed, its integration into the algorithmic design environment is a key factor . Following this, the topic of discussion turns towards additive manufacturing techniques. Key components of the requirements for user understanding of created artefacts are examined and areas in which further study will be identified. The results are split into two major sections, the first covers the algorithmic artefacts generated in the first part of this project, and the second covers the iterative Percy series of furniture, which is informed by the previous stage. Following the results, the findings are discussed and synthesised.
6
ryanpennings_thesis_final_005.indd 6
An opportunity exists for designers when it comes to algorithmic design, the topic has typically been the domain of artists and architects. Now that the complex forms created by algorithmic design are produceable through increased adaption of additive manufacturing, the practicality of designers using algorithmic design to create products is acceptable. Nordin, Hopf and Motte (Nordin, Hopf, & Motte, 2014) present two case studies that utilise algorithmic design in combination with ‘mass-production’ techniques as “a step towards enabling industrial designers the same level of form articulation as has been available to artists and architects, even though the constraints on the design activity are much different.” (Nordin et al., 2014) This idea of form articulation is one of the major opportunities becoming available to industrial designers. The ability to generate more complex forms, or to generate forms from a variety of inputs, as well as the ability to create optimisations (or rough optimisations) offers a plethora of design opportunities. This under explored area has potential to provide uniqueness to products, to include the consumer in the design process of their product and to offer a degree of freedom to designing products that has previously been heavily limited by manufacturing processes. These advantages of algorithmic design are touched upon during this project, though ultimately the focus is on the development of the algorithms to generate products.
The Percy Project
27/10/2015 10:53 PM
DIGITAL
PHYSICAL
DATA + INFORMATION
MATERIALISTION
INPUT + PARAMETERS
ALGORITHM
OBJECT
Figure 1: Framework Diagram Figure 1 - Framework Chart
DESIGN INTENTION
The Percy Project
ryanpennings_thesis_final_005.indd 7
7
27/10/2015 10:53 PM
Product Concept The cumulation of the Percy project is the Percy series of furniture. This includes the the Percy Stools, and Chairs. These products are presented as an example of algorithmic design applied to a specific product design. They show how algorithmic design can produce both functional and visual elements, and how algorithmic design can be used in conjunction with additive manufacturing and robotic fabrication. The Percy Stools and Chairs are uniquely generated through a novel process, and manufactured with a robotic 3D printing system. A combination of strict and loose algorithmic rules combine to create tool paths for this 3D printing system. The strict rules help maintain the product topology while the loose rules create both striking visuals and functional support to the furniture. The Percy series is produced from PLA (Polylatic Acid), with the stools weighing approximately 5-6kg and the chairs 12kg. A number of research components come together within these products, each adding their own novel element. The first half of this project informs the algorithmic design methods used in the design of the stools and chairs. The iterative research into robotic fabrication and large scale 3D printing is incorporated through ‘digital materiality’; and precedents in 3D printed products and furniture inform decisions across the project, and push it in new directions. Both the Percy Stools and Chairs showcase a novel process in which algorithmic design processes have been applied to a product design, and where these processes have been used to create a product with new and unique topologies. The Chairs at the time of publishing are in progress iterations, which include some errors.
8
ryanpennings_thesis_final_005.indd 8
The Percy Project
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 9
27/10/2015 10:53 PM
Chair_003 - Side Detail
Stool_003c - Close Detail
ryanpennings_thesis_final_005.indd 10
27/10/2015 10:53 PM
Algorithmic design: The use of algorithms (rules) to generate [usually] complex geometries, not humanly possible.
This project: An exploration of algorithmic design techniques within Product Design. Specifically with a Furniture and Additive Manufacturing focus.
ryanpennings_thesis_final_005.indd 11
27/10/2015 10:53 PM
Why algorithmic design? Algorithmic design is an emerging field [especially within Industrial Design] and presents an opportunity for designers. Additive Manufacturing allows designers to realise the complex morphologies that are created by algorithmic design. Robotic Fabrication provides a manufacturing method which joins the algorithmic design and robot programming environments.
ryanpennings_thesis_final_005.indd 12
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 13
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 14
27/10/2015 10:53 PM
Context & Field 3D Printed Furniture A field that this project focuses on is additively manufactured furniture. Numerous designers in this field approach the task of 3D printing furniture with similar methods. Many of these methods also relate to the project in that they are algorithmic. The prevailing algorithmic focus in 3D printed furniture is on the minimisation of material while maintaining appropriate strength. While this method is common, at least one designer does not use the method. Dirk Vander Kooij, a product designer from the Netherlands, created a series of 3D printed chairs. This series of chairs, won a Dutch Design Award in 2011 (Vander Kooij, n.d.). Kooij uses a robot to print his chairs using recycled plastic from refrigerators as his material. Kooij’s process is as equally focused on procedures as it is on the final product (“Dutch Profiles: Dirk van der Kooij,” n.d.). In-fact Kooij refers to himself as an inventor and a craftsmen more than a designer. Dirk describes his process
as building machines that produce furniture rather than him designing the end product. In this case, the machine that Dirk built was a robot 3D printer, with a self designed and made extruder. The size of the extrusion requires a continuous flow of plastic, unlike conventionally size 3D printers, where the flow of plastic can easily be broken, this constraint informs the design language of Dirk’s products. Joris Laarman, a designer from? is another designer who utilises robotic fabrication. Joris has built a number of robotic 3D printers. His MX3D-Metal and MX3D-Resin projects allow for more freeform printing applications(Laarman, n.d.). Laarman’s design practice is heavily experimental based, and includes a wide range of disciplines working together to explore the possibilities of new technologies (Rubinstein, 2014). Laarman is one designer that believes there is a link between craftsmanship and the digital world. In an article in ‘Architectural Digest’
The Percy Project
ryanpennings_thesis_final_005.indd 15
15
27/10/2015 10:53 PM
when talking about his projects, Laarman is quoted as saying “There is a symbiosis between craftsmanship and digital tools,” and “It's not industrial, it's not handmade, but something in between.” (Rubinstein, 2014). Laarman’s Bone chair, which was cast using 3D printed moulds (Laarman, n.d.), utilises algorithmic design to generate it’s form. The aim being to minimise material use while maintaining strength. This method of minimising material is also explored by Janne Kyttanen with his 3D printed sofa. This Sofa, in contrast to the methods of Kooij and Laarman, was 3D printed with a conventional SLA 3D printer(Howarth, 2015), making the build time several days. In contrast Dirk Vander Kooij claims the build time of his printer (hours at the most) as a benefit of his process (“Dutch Profiles: Dirk van der Kooij,” n.d.). The costs associated 3D printing a chair with SLA would be prohibitive for any sort of manufacturing. Something which is backed up by (Nordin, Hopf, & Motte, 2014). One misguided (perhaps just premature) justification of 3D printed furniture comes from Kyttanen. He post processes his printed sofa with copper and chrome platting. He aims to, by minimising use of material and by printing locally, to reduce the costs of transportation and energy consumption associated with furniture production. Lilian Van Daal’s biomimicry soft seat also shares the biomimicry inspiration of Janne Kyttanen, alongside the method of reducing material while maintaining strength, shared with both Joris Laarman and Janne Kyttanen. Daal does not however, utilise algorithmic design methods to create her chairs, but instead models them manually, although she does note that there is software to complete this task. Daal’s process involves experimentation of forms to discover what function they give (van Daal, n.d.). While the individual processes and methods of designers in the field of
16
ryanpennings_thesis_final_005.indd 16
additively manufactured furniture differ it is clear that certain benefits and uses for the technology can bn identified. Benefits such as reduction in waste and material usage during manufacture are clear. It is also clear that there is a divide between those that are inspired by biomimicry and those that are inspired by the process itself. Both avenues however allow for a large variety of exploration. The current selection of products in this field leave a large gap for exploration.
Algorithmic design in products Algorithmic design is being used by a number of designers in the product, object and fashion design fields. These designers include: Nervous System, a generative design studio based in the United Sates; Francis Bitonti, a trained architect turned fashion/object designer, Jonathan Keep, a pottery artist based in the UK and Ross Lovegrove, also based in the UK. (Bitonti, n.d.; Han, 2014; Howarth, 2015a) The range of products produced by these designers vary in their context, Nervous System for example create unique art, jewellery and home-wares. Nervous System are attracted to “complex and unconventional” forms(Nervous System, n.d.). They draw their inspiration from a biomimicry process, where they code programs that represent the complex systems that underpin nature. These programs are placed online, which allows the customer to interact with the product, and produce their own unique object. This unique object can then be digitally fabricated through methods such as 3D printing and laser cutting. One of these programs is the Kinematics series of products. The online app lets the customer design their own necklace,
The Percy Project
27/10/2015 10:53 PM
Percy Chair_004
The Percy Project
ryanpennings_thesis_final_005.indd 17
17
27/10/2015 10:53 PM
bracelet or earrings. The Kinematics concept uses algorithmic design to create foldable forms, allowing for products such as necklaces and bracelets to be 3D printed in hard materials. (Nervous System, n.d.) Jonathan Keep uses algorithmic design to create ceramic pottery, he does this through the use of digital fabrication(Han, 2014). A self built ceramic 3D printer allows Jonathan Keep to create his digital pots in ceramic. His inspiration for the use of algorithmic design is also based on biomimicry. An interest in “hidden numerical code that underpins all nature” drives Keep to write code that generates forms. Two examples of his pots are titled: Icebergs, based on the form of icebergs, and Sound-Surfaces, based on soundwaves. Francis Bitonti is a designer working within algorithmic design that does not see biomimicry as an inspiration, in-fact he speaks out against the use of biomimicry on his personnel blog, stating that there is no truth in the mathematical models used within biomimicry(Bitonti, n.d.). He is instead interested in humanity and draws the observation that biomimicry is a human perception of nature and that he is interested in the poetry of these systems in relation to humanity. Francis Bitonti’s work includes a 3D printed dress for Dita Von Teese (worked on with Michael Schmidt Studios) (Bitonti, n.d.) and the new luxury series of 3D printed home-wares called ‘Cloud Collection’ (Bitonti, n.d.). Dita Von Teese’s dress is an excellent example of algorithmic design used to create function, while the ‘Cloud Collection’ is a good example more cost effective algorithmic products. The Cloud Collection is a series of serving ware objects that utilise an algorithm based on entropy, they are customisable and are manufactured with a decentralised method provided by 3DHubs (a collection/ community of 3D Printers around the world). Ross Lovegrove has been using
18
ryanpennings_thesis_final_005.indd 18
computational design methods for the past 17 years (at time of writing: 2015) (Howarth, 2015a). He has been a champion of these methods the entire time and has recently spoken out against the lack of digital design taught in design education. Recent products include the Ilabo shoes for United Nude (Howarth, 2015b). These shoes were created with the help of Grasshopper expert Arturo Tedeschi and was based on the ideas of de-materialism and minimal material. The broad selection of designers discussed here illustrates the potential for algorithmic design within product design related fields, and highlights the methods and inspirations that motivate designers in this field. It identifies theories and rationalisations of designers working in the field of algorithmic design, which assists in the clarification of the field
Furniture & Homewares There are few designers working within algorithmic design and 3D printing, that are selling furniture and home-wares with most of these sales being via the designers own websites (Bitonti, n.d.; Vander Kooij, n.d.). Some designers sell their design in other online stores, and less in brick and mortar stores. Products sold in the brick and mortar stores tend to share more similarities with conventional products than those sold in the designers own stores only. Nervous System, Francis Bitonti and Dirk Vander Kooij all sell their products via their own websites(Bitonti, n.d.; Nervous System, n.d.; Vander Kooij, n.d.). Of these three Dirk Vander Kooij is the only one that sells his products through other stores, both online and brick and mortar. Gimmii, an online store based in the Netherlands
The Percy Project
27/10/2015 10:53 PM
Joris Laarman Janne Kyttanen
Furniture & Homwares
Ross Lovegrove
3D Printed Furniture
Robotic 3D Printing
Algorithmic design in Products
Robotic Fabrication
Algorithmic Design
Chris Hardy Additive Manufacturing
Architecture Dirk Vander Kooij
Lilian Van Daal NERVOUS System
PROJECT Francis Bitonti
Gramazio & Kohler Jonathan Keep Figure 2: Field Map
The Percy Project
ryanpennings_thesis_final_005.indd 19
19
27/10/2015 10:53 PM
Introduction to software
sells a range of his products(Gimmii, n.d.), and SCP, an online/brick and mortar store in the UK sell his Fresnel Pendant. Within Australia sale of algorithmic and 3D printed products is very limited. Workshopped, a design store based in Surrey Hills, Sydney, sells a 3D printed light by Chris Hardy (Workshopped, n.d.). Another 3D printed design in the Australia market is Studio Batch’s Diagrid pendant light, a light parametrically design and 3D printed in Nylon, won the Vivid Design competition in 2014(Batch, n.d.; Shead, 2014). 3D printing is also starting to show up as components of furniture, as is evident at recent design exhibitions in Melbourne, such as Fringe Festival and Vivid. Despite these algorithmically designed and 3D printed products starting to emerge in the Australian market place, both areas remain under-explored.
Robotic 3D Printing Robotic 3D Printing is often used in conjunction with algorithmic design, as is the case for Joris Laarman (Rubinstein, 2014). Within Architecture robotic fabrication is heavily linked to algorithmic design practices, as in the ideas of Gramazio and Kohler (Gramazio & Kohler, 2008). Joris Laarman and Dirk Vander Kooij both utilise robotic 3D printing to create products, although they employee substantially different methods. Dirk’s robotic 3D printing process is a lot more simplistic than Joris Laarman’s, the constraints put on the design by this process dictate more connected and continuous forms. Laarman’s process on the other hand is largely freeform and dictates a style vastly different from Kooij’s.
20
ryanpennings_thesis_final_005.indd 20
A knowledge of the software used in algorithmic design is essential to understanding the field. The preference of software has a large effect on the designed object, visual programming environments have limitations and constraints that limit their function that coding in text based environments do not. On the other hand, coding environments lack immediate visual feedback that visual programmings provide and are more complex to use due to a the steep learning curve that typically comes alongside coding, especially to designers. A popular visual programming environment includes the Grasshopper Plugin for Rhinoceros 3D. Grasshopper integrates directly into a CAD program (Rhinoceros 3D), making it ideally suited for creating and working with, products and buildings. The use of a visual environment over coding allows faster iteration and development, an important part of the design process. The flexibility of this software relies on developer support. A large community around Grasshopper that provides numerous plugins that greatly extend the functionality of the software. Text based coding environments such as Processing and Python provide more flexibility, are almost endlessly customisable and are more powerful. The main drawback of text based coding environments is the steep learning curve. Integration of coding into visual programming environments is possible, for example, a plugin for Grasshopper called ‘ghPython’ allows python code to be executed within Grasshopper.
The Percy Project
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 21
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 22
27/10/2015 10:53 PM
These tools are popular among a variety of disciplines. Visual programming environments within CAD programs are typically favoured by designers in Architecture and Industrial Design, but this popularity also extends into Fashion Design. Coding environments are typically the domain of artists, data visualisers and more adventurous Architects. Robotic programming has been bought into the algorithmic environment through the use of the Kuka | PRC plugin for Grasshopper. This plugin allows designers to program a Kuka robotic arm directly with Grasshopper, which gives a great level of control over the manufactured output. This environment is an important aspect of this project. Whereas software for the operation of 3D printers is not generally based within the algorithmic design environment. This software takes a finished model and produces code (called G’Code) which will control the 3D printer. This method means less integration and control over the manufacturing process, but means objects designed for this process will be more likely to suit existing products.
The Percy Project
ryanpennings_thesis_final_005.indd 23
23
27/10/2015 10:53 PM
Robot Printing - Stool_003a
ryanpennings_thesis_final_005.indd 24
27/10/2015 10:53 PM
Precedents exist in the areas of 3D printed furniture and algorithmically generated products. But there is very few [if any] precedents when combining 3D printed furniture and algorithmic design.
ryanpennings_thesis_final_005.indd 25
27/10/2015 10:53 PM
There is also limited research into algorithmic design from an Industrial Design perspective [but there is a large amount of research for both algorithmic design and robotic fabrication within Architecture]. It is necessary to pull together research and precedents from a large number of fields.
ryanpennings_thesis_final_005.indd 26
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 27
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 28
27/10/2015 10:53 PM
Current Theories Biomimicry As evident through the precedents presented so far, biomimicry is a prevailing and popular theory and inspiration for designers working with algorithmic design. A number of reasons exist for this, the obvious being the draw of natures ability to produce complex yet appealing forms, the less obvious is that a large number of algorithms were developed to simulate natural and biological processes. Two examples of this are the L-System algorithm and the Cellular Automata algorithm. The L-System algorithm was developed by Hungarian botanist Aristid Lindenmayer to model growth patterns of plants(Shiffman, 2014a). A common example application of the L-System algorithm is too model a tree. A cellular automata (CA) is typically attributed to Stanisław Ulam and John von Neumann, the study of Stephen Wolfram linked CA’s to biology, chemistry, physics and more. The most common CA would be John Conways ‘Game of Life’, it’s this simple
model that is generally used as a basis for algorithmic modelling, and is very much related to the biology. (Shiffman, 2014b) Of the aforementioned designers, Nervous System, Ross Lovegrove, Jonathon Keep, Lillian Van Daal, Joris Laarman and Janne Kyttanen use biomimicry as a framework or inspiration for their work. Schumacher and Krish (Peter Schumacher & Krish, 2014) suggest the use of biomimicry as a framework for understanding ‘generative design’. Francis Bitonti on the other hand, actively speaks out against biomimicry, stating that there is no absolute truth in mathematical biological models (Bitonti, n.d.). Both Gramazio and Kohler, and Patrik Schumacher propose methods of algorithmic design that differ from biomimicry. Gramazio and Kohler’s method, as discussed in the introduction, focuses on the connection between digital and physical materialities(Gramazio & Kohler,
The Percy Project
ryanpennings_thesis_final_005.indd 29
29
27/10/2015 10:53 PM
2008). Patrik Schumachers manifesto on parametric style emphasises complexity and variation of form(Patrik Schumacher, 2010).
Digital Materiality The idea of digital materiality is first discussed in the introduction in relation to this project. This section gives a brief overview of digital materiality as proposed by Gramazio and Kohler and in the context of architectural design and construction. Gramazio and Kohler describe digital materiality as “an emergent transformation in the expression of architecture” (Gramazio & Kohler, 2008). They attribute the link between the digital world and the physical world to digital fabrication techniques. Which gives an architect the ability to control the manufacturing process with information. This emergent transformation creates a new type of expression that is characterised by the complexity in large numbers of elements,
30
ryanpennings_thesis_final_005.indd 30
arranged with precision, a high level of detail and various scales of formation. Digital materiality, which Gramazio and Kohler say is “generated through the integration of construction and programming in the design process” (Gramazio & Kohler, 2008), does not substitute the architect in the design process, but is a tool within it. The robot is the factor of digital fabrication that allows the connection between the computer and the materiality of architecture. Gramazio and Kohler state that the robot is the prefect tool because it has not been optimised for one application, but is suited for a variety of applications. This gives architects the ability to generate their own forms of expression. (Gramazio & Kohler, 2008) In comparison to the wide variety of practitioners within the fields of this project, Gramazio and Kohler observe that the comparisons of the complexity of digital materiality to nature disguises the truth that digital materiality is not a product of biological systems and is not grounded in them either
The Percy Project
27/10/2015 10:53 PM
BIOMIMICRY
NERVOUS SYSTEM LILIAN VAN DAAL ROSS LOVEGROVE
JONATHAN KEEP
JANNE KYTTANEN
SCHUMACHER & KRISH
JORIS LAARMAN
FRANCIS BITONTI
WOODWARD & FISHER DIRK VANDER KOOIJ GRAMAZIO & KOHLER
MATERIALITY
The Percy Project
ryanpennings_thesis_final_005.indd 31
Figure 3: Theory Map
31
27/10/2015 10:53 PM
(Gramazio & Kohler, 2008). This observation leads to the idea that digital materiality involves designing the process and not the object. Gramazio and Kohler refer to this as a form of rules developed from digital logics that define relationships and intentions.
Are we actually designing? An aspect of algorithmic design that receives criticism is the issue of who is actually designing the object. This question is raised when the generative design approach of using an algorithm to generate a wide variety of options is used, as Autodesk’s Dreamcatcher project (Autodesk, n.d.) uses or the process Schumacher and Krish follow(Schumacher & Krish, 2014). This topic of who is actually doing the designing is discussed by Jon McCormack and Frieder Nake. In ’Ten
32
ryanpennings_thesis_final_005.indd 32
Questions concerning Generative Computer Art’ for the Leonardo journal, McCormack alongside g that as designers designing algorithmic systems to create objects, the computer does what it is told (assuming that it was programmed correctly), when things become more complex, the idea origin of the design can become unclear. In the editorial to the volume of Leonardo containing the article from McCormack and others, Nake suggests that the role of the computer is to run the algorithm and output the result. To him, there is no question that the human is the origin of the design, in-fact states that “Algorithms are concepts in the special form of computability” (Nake, 2014). One valid criticism of this process was bought up by Victoria Slaker, VP of Design at Ammunition in an interview with (Currey, n.d.). Her criticism was that these algorithms give people the ability to design objects that they aren’t capable of validating.
The Percy Project
27/10/2015 10:53 PM
The Percy Project
ryanpennings_thesis_final_005.indd 33
33
27/10/2015 10:53 PM
34
ryanpennings_thesis_final_005.indd 34
The Percy Project
27/10/2015 10:53 PM
Two main trains of thought currently exist within algorithmic design. These are Biomimicry [copying biological organism and processes] and ‘Digital Materiality’ [building material characteristics into the algorithm].
ryanpennings_thesis_final_005.indd 35
27/10/2015 10:53 PM
This project takes a ‘Digital Materiality’ approach.
ryanpennings_thesis_final_005.indd 36
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 37
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 38
27/10/2015 10:53 PM
Methods Intro: The use of multiple methods The intersection of fields that this project sits within provides a convoluted set of obstacles to navigate. Own it’s own algorithmic design is vast and complex. This is further complicated by the introduction of additive manufacturing and robotic 3d printing. These areas are directed through the design of furniture and home-wares in an attempt to simplify. The accompanying concepts that come with these fields, such as ‘digital materiality’ and biomimicry, along with the technical challenges of programming a variety of different algorithms increase the difficulty of conducting research. To minimise this difficulty methods such as parallel prototyping, which address the issues of variance and infinite possibility by providing a framework in which divergent exploration can take place. This exploration is structured through the use of methods such as sketching, digital sketching and a matrix of combinations.
The Percy Project
ryanpennings_thesis_final_005.indd 39
39
27/10/2015 10:53 PM
Parallel Prototyping In order to explore the wide range of artefact outcomes that algorithmic design can generate, a Parallel Prototyping process is used. Parallel Prototyping is beneficial over an iterative prototyping process during the first stage of the project for a number of reasons. Firstly, it explores the design possibilities in a divergent way. This divergent process was chosen in order to develop a varied range of artefacts on which to base future research and design on. Secondly, Parallel Prototyping removes an attachment from a specific design. When coupled with the number of artefacts to be produced, it allows for a less biased review in later research (Martin & Hanington, n.d.). Within this project the Parallel Prototyping process will be structured to result in a consistent flow of artefacts. This provides a balance between the complexity of the algorithmic design and modelling stage, and the number of artefacts produced. It also develops a knowledge base for future artefacts to build on.
Sketching One of the main issues that inhabits the algorithmic design process is the complexity and difficulty (Schumacher & Krish, 2014) of generating forms. While it is quite possible to generate a wide variety of outputs easily, the transformation of these into functional and realistic physical forms can lead the designer down a path where no outcome is reached. To combat this, sketching is used to identify the correct path to explore, which is done in two distinct yet linked areas. The first is the sketching out of the algorithmic process (in this case, the Grasshopper definition). Sketching out the definition in this manner encourages the designer to think about how they will achieve an physical outcome.
40
ryanpennings_thesis_final_005.indd 40
Developing methods of managing data (in Grasshopper, list and trees) visually is included in this area, as is visualisations of changes in form as the definition progresses. The second area is the sketching of forms. Sketching the form’s that could possibly be generated, alongside sketching of the definition eliminates are large portion of time spent on ‘digital sketching’, which in turn means a larger number of options are explored. Sketching form and definitions also serves to keep the modelling on track.
Digital Sketching A large and important portion of algorithmic design is exploration in the digital environment. This exploration serves multiple purposes. It develops understanding and knowledge of the algorithmic programming environment, essential to develop more complex and varied forms. It also provides a platform to experience new and unexpected emergent outcomes that are common in this field (Schumacher & Krish, 2014). Digital sketching is a time consuming process, which can be supplemented through sketching and the creation of a collection of processes, methods and techniques used within the algorithmic programming environment. Digital sketching also serves one other important function, as the entire process is simultaneously a sketching and explorative process and the creation of the final digital product/model itself. This means the digital sketching process is an essential part of the the parallel prototyping method. This project will need to utilise this digital sketching method to create the algorithmic artefacts and to explore the possible uses algorithmic design has within the industrial/product design field.
The Percy Project
27/10/2015 10:53 PM
Figure 4: Digital Sketching
The Percy Project
ryanpennings_thesis_final_005.indd 41
41
27/10/2015 10:53 PM
Matrix To track of all the possible combinations between algorithmic processes, and, furniture and homeware products, a matrix is used. In the matrix, one axis lists furniture and homeware products, while the other lists all the algorithmic processes that can be employed. Algorithmic processes can be inspired by precedents, discovered directly through research or be a collection of smaller processes that were discovered while digital sketching. A matrix used in this manners lists the possible combinations, with each combination assessable for the suitability between process and product. (Martin & Hanington, n.d.)(see Appendix A)
Algorithmic Design Environments The technological requirements for using algorithmic design to create products leads this project to use Grasshopper as the main algorithmic modelling tool. Multiple reasons exist for this, the first being it’s simple integration within Rhinoceros 3D. This integration reduces time spent attempting to obtain a valid 3D model, allows for the use of conventional modelling techniques to supplement the object, and has a high level of compatibility with other CAD programs if needed. The second is that the preferred robotic programming software, Kuka | PRC, is a plugin for Grasshopper. The integration between the algorithmic modelling environment and the robotic control environment opens up possibilities between the algorithm and the robot. While working within a CAD environment is a step towards producing models that are valid and able to be constructed, forms generated in Grasshopper are often impossible to make tangible in the physical
42
ryanpennings_thesis_final_005.indd 42
world. One of the challenges and focuses of this project is on the methods and processes used to create algorithmic designs that are physically possible. The test of this will be the actual creation of these objects. The plugins within Grasshopper will be used to create the objects within this project in order to reduce time developing complex algorithms. These plugins are generally developed with an architectural focus, and have a tendency dictate the formal construction of the design. Active diversification of the plugins, processes and outcomes will be used to limit the effect that the bias of plugins has on the designed objects. Grasshopper uses parts called components, these components each have a simple function, for example one component can move an object and another can divide a curve into segments. These components each have inputs and outputs. Grasshopper definitions are made by connecting components together to generate outcomes and results. Plugins add more components with more functionality. Grasshopper is a suitable algorithmic design environment for designers, and thus for this project due to it’s visual nature, integration into a CAD environment and it’s large collection of plugins that extend it’s functionality.
Robot 3D Printing Setup & Testing Using the Kuka robot as a 3D printer requires a large amount of setup and testing. The setup and testing includes the attachment of the extruder to the robot, cable management, tool and workspace setup, plastic selection, plastic testing, build surface testing, settings calibration and programming.
The Percy Project
27/10/2015 10:53 PM
The Percy Project
ryanpennings_thesis_final_005.indd 43
43
27/10/2015 10:53 PM
44
ryanpennings_thesis_final_005.indd 44
The Percy Project
27/10/2015 10:53 PM
The attachment of the extruder to the robot was straightforward, which was attached to the tool changer with a metal plate. The positioning of the extruder ensures that it is unlikely the robot will reach locations known as singularities, a mathematical impossibility which prevents the robot from operating at very specific axis orientations. The position also suits large sized 3D prints, and proper gravity feeding of plastic granules due to its orientation. One disadvantage of this position is a limited ability to rotate the extruder easily and quickly, something which is important for more complex forms. This setup phase included the specification of safety features such as a heat guard, cable management and operation procedures. Initial plastic selection was PE (Polyethylene) due to it’s lower melting temp, material properties and ease of availability. The plastic chosen was a blow moulding grade PE, and while suitably strong for any furniture applications, has large issues with shrinkage. These issues meant that the intended process of layering plastic to 3D print an object was unachievable. The next plastic selected was PLA. This plastic testing led to the decision to include compressed air for cooling extruded plastic. Programming the robot via Kuka | PRC, required some iterative testing to discover settings that outputted code that provided smooth motion. This was done with the assistance of an architectural researching who is familiar with robot fabrication.
Robotic Programming Programming a robot arm for a 3D printing process is a difficult task, luckily this is simplified by the use of Kuka | PRC. Through the RMIT School of Architecture and Design workshop facilities access to a Kuka KR150 L110 robotic arm on a 3metre linear track, with a Dohle ExOn 8 Granule Extruder attached, is provided. The Kuka KR150 is very adaptable to different 3D printing situations, it’s large working area and ability for highly detailed control means objects can be printed large or small. For this project the robot and extruder will be set up for printing furniture sized objects. The extrusion size of this setup is greater than that of conventional FDM 3D printers, a with a 2-8mm nozzle width compared to around 0.4mm for conventional FDM 3D printers. This extrusion width also puts constraints on how the robot will be programmed, and what objects can be constructed with it. Another characteristic of the robot 3D printer is that inability to easily start and stop the extrusion process due to the large size of the extrusion. This will mean the object has to use a continuous extrusion. Safety issues also affect the programming of the robot. Presently the extruder setup has cords running from the extruder to the control unit, the robot must be programmed so they are not pulled past their length or tangled within the robot and other objects. The design of other safety features such as a heat guard, and functional features such as a hopper for plastic granules, affect the programming of the robot as well. The constraints these place on the object construction can be worked around and designed into the objects in the algorithmic design due to Kuka | PRC’s integration into Grasshopper.
The Percy Project
ryanpennings_thesis_final_005.indd 45
45
27/10/2015 10:53 PM
The requirements of the plastic also affect the robots programming in terms of temperature, and speed. Plastic must be selected that is appropriate to the task of furniture, but suitable for the extruder. Fortunately the extruder has a wide range of temperature and speed options. Currently the extruder controls are separated from the robot controls, down the track the extruder controls will be fully programable and controllable via the robots programming in Kuka | PRC, extending the possibility for automated printing, and allowing a breakaway from continuous extrusion.
Extruders, Plastics & Environments The extruder is currently separate from the robot programming. Programable aspects of the extruder include, extruder temperature, air temperature and extrusion speed. Other requirements for the extruder includes selection of plastics, build surfaces, cooling, heating, plastic management and the integration of safety features. Ideal plastic selection for 3D printing furniture and large objects requires plastic that does not shrink, or is manageable through heating and cooling, and is strong enough to be structurally safe. While air heating for the extruded plastic is provided within the extruder, cooling options via compressed air need to be added. Both heating and cooling gives control over how the plastic sets and forms. Cooling is particularly important considering the thermal mass of extruded plastic between 2-8mm, especially once it has been layered. The build surface is also another important factor, where it must allow for plastic to stick, help prevent shrinkage (with manifests as curling from the bed) and in more advanced cases provide support for more complex forms.
46
ryanpennings_thesis_final_005.indd 46
The Percy Project
27/10/2015 10:53 PM
A range of methods will be used in the algorithmic design process. This includes digital sketching, an explorative technique that helps designers discover emergent behaviour.
ryanpennings_thesis_final_005.indd 47
27/10/2015 10:53 PM
The required methods also include setting up and testing the robotic 3D printer, as well as programming the robot.
ryanpennings_thesis_final_005.indd 48
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 49
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 50
27/10/2015 10:53 PM
Methods of Evaluation & Validation Introduction The methods of evaluation and validation described here are intended to identify if the algorithms used to design the explored artefacts in the first part of this project are suitable for creating functional products with desirable forms. These methods also explore the concern that algorithms can produce artefacts so complex in form that a user cannot identify the intended function of the artefact.
Artefact Analysis Produced artefacts need to be compared to one another, this comparison intends to reveal what makes certain artefacts work over others. It includes an analysis of the aesthetics, material and interactive qualities, as well as the algorithmic process. The analysis for the artefacts produced in this project will look to discover if the artefact addresses the issues of user understanding, visual desirability,
functionality (and perceived functionality), material use, and algorithmic process. The artefact analysis is visualised and compared with the use of radar charts. 7 categories are used that relate to the artefact analysis categories that are suited to analysing the characteristics of the objects. A radar chart is preferred over other methods of chart/graph visualisation because it allows for a level of ambiguity within the results. I.e. As the results are recorded by me, the [visual] comparison method rather than accurate numbers allows for changes in personnel intricacies over the time these results are recorded. Visual comparison also reduces inaccurate recordings affecting the conclusions drawn. The ambiguity of this method is offset with the triangulation method and affinity diagramming. The radar chart has 7 spokes with a circle that represents a neutral measure. Each spoke is less at the centre of the chart and more at the extent of the chart. It is a sliding scale.
The Percy Project
ryanpennings_thesis_final_005.indd 51
51
27/10/2015 10:53 PM
Complexity The complexity of the artefact is measured by visual inspection. This is used to determine against other categories if the perceived complexity has an affect. This category does not refer to the complexity of making the algorithmic design.
Use Recognisability This category is similar to function recognisability but instead refers to the user being able to identify how to use the object. I.e. Where is the handle? Which way is up?
Algorithmic Recognisability Algorithmic Recognisability is a measure of if the algorithm used to create the object is visually recognisable, this category is intended to determine what effect the visual representation of the algorithm has on the perception of the artefact. Materialisation (Meta-objects) Materialisation refers to the level of the data/information (see Understanding Frame on p.2 and Digital Materiality on p.16) that is inserted into the product. This is not a visual inspection, but measure based on being informed of the process used to design the artefact. This category is for comparison of categories and identification of any affects materialisation has the other categories. Function Recognisability This category refers to the ability for the user to identify the intended function of the object. I.e. Is the potato masher a masher or a whisk?
52
ryanpennings_thesis_final_005.indd 52
Producibility Producibility is how many ways it is possible to make the artefact and how difficult it would be. Ie. Inside would relate to one possible method and the outside would relate to the artefact being produceable via numerous methods, including beyond additive manufacturing. Personal Preference for Aesthetics The personal preference category refers to how much I like the visual aesthetics of the artefact produced. As the artefacts are produced through the lens of furniture and home-wares, and this project has the intention of generating products and/or processes for me to use in my own practice, it is only suitable that I agree with the visual styling of the artefact. See figure 5 for an example of this instrument.
The Percy Project
27/10/2015 10:53 PM
Complexity
Pe r
so n
al
rit
Pr ef
ise gn
er en ce
go Al
hm
co Re
Mate rialisa tion
ty cabili Produ
Rec
Use
ni s og
Rec
n tio
og
unc
nis e
eF
Figure 5: Example of Radar Chat
The Percy Project
ryanpennings_thesis_final_005.indd 53
53
27/10/2015 10:53 PM
Affinity Diagram To collate the qualitative research gathered during the design of algorithmic artefacts, an affinity diagramming process will be used. This process will take all the qualitative research from both the artefact analysis and the design process and begin to group them together by issues (these have an affinity). As patterns being to emerge these are noted down. These observations will be distilled through the chapter: Results: Artefacts. An affinity diagram affords the opportunity to look at all the research of artefacts from a variety of angles. An important aspect of affinity diagraming is that it is a bottom-up process (Martin & Hanington, n.d.). Meaning that categories are not defined (or loosely defined in the case of this project).
54
ryanpennings_thesis_final_005.indd 54
The Percy Project
27/10/2015 10:53 PM
The Percy Project
ryanpennings_thesis_final_005.indd 55
55
27/10/2015 10:53 PM
56
ryanpennings_thesis_final_005.indd 56
The Percy Project
27/10/2015 10:53 PM
Methods of evaluation include artefact analysis and affinity diagramming
ryanpennings_thesis_final_005.indd 57
27/10/2015 10:53 PM
The evaluation is separated into two distinct stages. The first is an evaluation of a body of algorithmic artefacts, to determine the characteristics of the algorithmic design process. The second is an iterative evaluation of the algorithmic furniture produce.
ryanpennings_thesis_final_005.indd 58
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 59
27/10/2015 10:53 PM
ryanpennings_thesis_final_005.indd 60
27/10/2015 10:53 PM
Objects Introduction The objects shown here are the result of a divergent exploration into the different possible algorithmic techniques and processes that can be applied to a product design. The aim of each object was to showcase how particular techniques, methods or processes could generate a physically possible and functional artefact. By using the lens of furniture and home-wares, these artefacts were directed towards product design outcomes. These objects also identified areas of difficulty that a designer might face while designing these products. Once identified strategies for working around these were developed for future objects. Two overreaching strategies were developed to avoid these problems and to simplify the algorithmic design process. The first keeping a notebook of basic and specific definitions, which show how to do specific tasks, was developed to counteract the negative effect, that the flexibility and complexity that is afforded by Grasshopper, has on memory. Which such flexibility and complexity, it is a common occurrence to forget how specific outcomes have been achieved before. By storing these definitions in a notebook, the designer can reduce the time spent trying to figure out a method to achieve a result. Storing these digitally allows them to be easily searchable and retrievable. It is also ideal to store the grasshopper definition files as well. The second overreaching strategy was to create clusters (a group of grasshopper components which is displayed
as a single component). By creating clusters for frequently used functions, the designer can save time and effort, as well as avoid the possibility of forgetting different methods. The method of digital sketching became the most frequently used method. This method facilitated exploration of new plugins and algorithms. Two problems existed when using physical sketching as a method, the first was that, without prior experience and knowledge of the algorithm, sketching the result was incredibly difficult. The second was that, due to the complexity and subtly that can be outputted by these algorithms, sketching them is very difficult. Sketches tended towards being explanatory but are abstractions of the process rather than direct visual representations of the object to be produced. The matrix method provided a good volume of algorithm and object combinations to explore. It was a useful tool for identifying object and algorithm combinations that could potentially work, and those that would not work. This relates to both the functional capability of the algorithms, I.e. If it could be shaped into a form that provided the function required, and to the aesthetic qualities that the algorithm imparted onto the object.
The Percy Project
ryanpennings_thesis_final_005.indd 61
61
27/10/2015 10:53 PM
Potato Masher The Potato Masher utilises an algorithm that was created to model the growth branches in nature. Called a L-System, this algorithm is capable of producing both organic looking, and geometric styled objects. The algorithm here explores how an L-System can be used to create strong and functional kitchenware. The algorithmic section is the mashing part that is attached to a handle.
spent doing in two distinct processes. The first, generating an L-System that provided the correct function, and the second, giving form that is physically possible to the algorithmic output. The matrix method identified that the combination of L-System and Potato Masher would work well together, this was because the typical morphologies output by an L-System has similarities between the physical form of archetypal potato mashers.
What An L-System takes a series of symbols that create a set of rules to follow. The L-System follows these rules, I.e. Move forward twice, rotate left, move forward and creates a collection of lines. In the case of the potato masher, the L-System is very geometric. Towards the mashing end of the algorithmic artefact, the lines turn horizontal and cross each other. When given form, this creates a strong structure with which to mash.
Implications There is a large disconnect between programming an L-System and it’s visual output. The typical input for an L-System is a set of characters that each control an output, which is then translated into a series of lines in three dimensional space. This disconnection in the design process is a significant barrier that inhibits the designers process, which is predominantly visual.
To give the algorithm form, a pipping algorithm called ‘exo-skeleton’ is used. Exo-skeleton adds a pipe shaped geometry to each line, joins them together and smooths them all out with mesh sub-division. At this stage the geometry is incorrect as it intersects with itself. To fix this, the model is taken into ‘Magics’ where a tool called ‘shrink wrap’ is used to create a mesh that doesn’t intersect itself and is 3D printable.
Process Digital Sketching was again used to create this artefact. The combination of L-system and potato masher was chosen through the matrix method. The digital sketching time was
62
ryanpennings_thesis_final_005.indd 62
The Percy Project
27/10/2015 10:53 PM
Figure 6: L-System Masher
Complexity
Potato Masher L-System Pe r
so n
al
Pr ef
rit
er en ce
Re
ise gn co
go Al
hm
Mater
bility
ialisat ion
ca Produ
Rec
Use
ni s og unc
og nis e
eF
Rec
n tio
The Percy Project
ryanpennings_thesis_final_005.indd 63
63
27/10/2015 10:53 PM
L - System - Input Rules
L - System - Total output of Applied Rules
64
ryanpennings_thesis_final_005.indd 64
The Percy Project
27/10/2015 10:53 PM
L - System - Process Overview
L - System - Line Output
The Percy Project
ryanpennings_thesis_final_005.indd 65
65
27/10/2015 10:54 PM
Contour Bowl The algorithmic contour bowls utilise a location based on a custom made algorithm (rather than utilising an existing algorithm to generate form as is generally the case with algorithmic design), that takes the contours of a particular location on earth, and turns these into a bowl. The bowl is slip cast in ceramic, with the mould positive being digitally fabrication, either through 3D printing or CNC milling. The idea being that the location can be personalised to the customer.
What This algorithm utilises GIS (Geospatial information systems) plugins for grasshopper, these plugins which are typically used within architecture and landscape architecture. These plugins take a specific location and turn them into curves. An equal amount of curves on either side of the centre are bent towards each other and join to form a loop. Each curve is given its own layer and moved up a specific distance from the last. These curves are smoothly lofted together to form a bowl. This form is then digitally manufactured to create a positive for the mould, the mould for slip-casting is then made from plaster. The lengthy process increases the cost involved in making unique versions of this product, which being a location based personalisation, makes the cost of an individual bowl fairly expensive.
with. In this case, the location was just outside of Casey Station, Antarctica. Contours were imported into Grasshopper as curves, which involved the use of GIS software. This task was laborious and difficult due to the complexity of importing real world data into the GIS software, extracting, and exporting it as a format that the Grasshopper plugins could recognise. Following this, the digital sketching method was used to explore different combinations of grasshopper components to morph contours that didn’t join into a bowl form. The chosen algorithm took a number of points on each end of the contours, and bent them each a different magnitude until they touched, the points were then rebuilt into a new line, trimmed and joined together to form a closed loop. Each curve (apart from the innermost) is moved up 5mm from the last. These are then lofted together with loose settings. If necessary the form is adjusted to suit production in a single part slip-cast mould.
Implications The issue with this design process, is that there was a large number of manual adjustments required to produce desirable forms, and that the GIS part is a difficult, time consuming, and outside the education of most product designers.
Process The method used to design this bowl was Digital Sketching. The idea to use contours was set before the digital sketching began, and a location was chosen to do the sketching
66
ryanpennings_thesis_final_005.indd 66
The Percy Project
27/10/2015 10:54 PM
Figure 7: Contour Bowl
Complexity
Contour Bowls Custom Algorithm based on contours. Pe r
so n
al
Pr ef
rit
er en ce
Re
ise gn co
go Al
hm
Mater
bility
ialisat ion
ca Produ
Rec
Use
ni s og unc
og nis e
eF
Rec
n tio
The Percy Project
ryanpennings_thesis_final_005.indd 67
67
27/10/2015 10:54 PM
Contour Bowls - Connecting Contours and Applying Form
68
ryanpennings_thesis_final_005.indd 68
The Percy Project
27/10/2015 10:54 PM
Contour Bowls - Contours before algorithm applied
Contour Bowls - Algorithm Applied to create loops for bowl
The Percy Project
ryanpennings_thesis_final_005.indd 69
69
27/10/2015 10:54 PM
Physics Spoon This spoon uses a physics simulation algorithm to modify it’s form. This algorithm simulates wind passing over a basic mesh of a spoon. This gives it a rippled appearance.
Process The process behind this artefact was simple and quick. A small amount of digital sketching went into adjusting and defining the inputs of the algorithm and the mesh reconstruction.
What Kangaroo is a physics simulation plugin for Grasshopper, this simulation gives the option to simulate wind over a mesh. The simple mesh of a spoon is divided into a collection of points, with the outer perimeter remaining stationary as anchor points. The simulated wind affects the interior points on the mesh, after the simulation (which runs in real time) the collection of points is rebuilt into a mesh. This simple but powerful simulation creates natural looking effects easily.
70
ryanpennings_thesis_final_005.indd 70
Implications The reconstruction of the form however took a bit of work and resulted in the intended effects of a natural looking output being lost. In order to make the output a valid mesh and thus manufacturable, the algorithmic output had to be taken into another program ‘Maya’ for manual fixing. This manual fixing both caused details to be lost and broke away from the purely algorithm generation of the object.
The Percy Project
27/10/2015 10:54 PM
Figure 8: Physics Spoon
Complexity
Spoon Physics Simulation - Wind Pe r
so n
al
Pr ef
rit
er en ce
Re
ise gn co
go Al
hm
Mater
bility
ialisat ion
ca Produ
Rec
Use
ni s og unc
og nis e
eF
Rec
n tio
The Percy Project
ryanpennings_thesis_final_005.indd 71
71
27/10/2015 10:54 PM
Spoon - Physics Components and Engine
Spoon - Wind Directions
72
ryanpennings_thesis_final_005.indd 72
The Percy Project
27/10/2015 10:54 PM
Spoon - Post Processing Mesh Correction
The Percy Project
ryanpennings_thesis_final_005.indd 73
73
27/10/2015 10:54 PM
Cellular Automata Bowl The CA Bowl, or Cellular Automata Bowl, is based upon the Cellular Automata algorithm (see Biomimicry). A cellular automata, which is a computational representation of life, generates a series of points over time. At one point in time, the points are taken and connected via lines. These lines are then given form in the same way that the potato masher is, via ‘Exo-skeleton’. This artefact also used a Genetic Algorithm (an algorithm that improves each iteration based on the theory of evolution, see glossary for more details) in order to generate a collection of lines that work with Exo-skeleton.
amount of time was spent trying to get valid outputs from various algorithms. Within a design process this is excessive, as well as a waste of time and resources.
Implications The CA bowl showed a dangerous pitfall in the algorithmic design process, the great amount of flexibility and options lets the designer wonder around aimlessly, not producing a robust product outcome.
What This artefact is a collection of 4 different algorithms, it starts with a cellular automata, a custom line giving and sorting algorithm, Exo-skeleton and then a genetic algorithm. The CA bowl applies a 2D cellular automata across a bowl shaped surface, this results in a higher density of points towards the centre of the bowl (which is needed in order to maintain a grid), this causes problems when it comes to giving form with lines. The custom line and sorting algorithm applies lines to the three closest points, and then removes any that overlap. The genetic algorithm works in conjunction with the inputs for the cellular automata, changing them until it finds a solution where Exo-skeleton is able to generate a valid mesh.
Process The process used in the CA bowl was very convoluted and difficult to control. In this case, the digital sketching method did not produce decent results. A large
74
ryanpennings_thesis_final_005.indd 74
The Percy Project
27/10/2015 10:54 PM
Figure 9: CA Bowl
Complexity
Cellular Automata Bowl Cellular Automata Pe r
so n
al
Pr ef
rit
er en ce
Re
ise gn co
go Al
hm
Mater
bility
ialisat ion
ca Produ
Rec
Use
ni s og unc
og nis e
eF
Rec
n tio
The Percy Project
ryanpennings_thesis_final_005.indd 75
75
27/10/2015 10:54 PM
CA - Cellular Automata Algorithm
CA - Cellular Automata Cell Output
76
ryanpennings_thesis_final_005.indd 76
The Percy Project
27/10/2015 10:54 PM
CA Bowl - Sorting Lines, Applying Genetic Algorithm and Form
CA - Output after line algorithm applied
The Percy Project
ryanpennings_thesis_final_005.indd 77
77
27/10/2015 10:55 PM
Pasta Scoop The pasta scoop is created by an agent based algorithm. This agent (see Explaining the Algorithm used for a detailed explanation on agent based algorithms), follows a series of attractor points that guide it within the form of a pasta scoop. A generic block provides an environment for this to happen within. The agents paths are given form that produce the end artefact.
What
The marching cubes algorithm is difficult to control, but it allows you to add form to the complex paths that the agents generate.
Implications This algorithm went on to inform the algorithm used within the Percy series of furniture. The range of options and possibility of emergent behaviour within the algorithm made it the most exciting algorithm out of the artefact prototypes.
The algorithm follows a series of attractor points as it travels down towards the base of the scoop from the top. These points exhibit different amounts of forces and have distance roll offs (i.e. Attraction only applies at full strength between the upper and lower distances). A strong attractor point that rotates around the base coaxes the agents to create prongs, this rotation is timed so it matches the agents travel time. Another alternating attractor point shifts the agents paths towards the left or right side.
Process Once the agent and pasta scoop method was selected, sketching was chosen to determine a rough shape for the scoop, and to decide upon the the location of attractor points and their movements. Following that the agent was developed and the values tuned in order to produce decent results. This tuning process took a heavy majority of the development time. A marching cubes algorithm was used to give form to the agents.
78
ryanpennings_thesis_final_005.indd 78
The Percy Project
27/10/2015 10:55 PM
Figure 10. Pasta Scoop
Complexity
Pasta Scoop Agent Based Modelling Pe r
so n
al
Pr ef
rit
er en ce
Re
ise gn co
go Al
hm
Mater
bility
ialisat ion
ca Produ
Rec
Use
ni s og unc
og nis e
eF
Rec
n tio
The Percy Project
ryanpennings_thesis_final_005.indd 79
79
27/10/2015 10:55 PM
Pasta Scoop - Various Attractors
80
ryanpennings_thesis_final_005.indd 80
The Percy Project
27/10/2015 10:55 PM
Pasta Scoop - Various Attractors
The Percy Project
ryanpennings_thesis_final_005.indd 81
81
27/10/2015 10:56 PM
Pasta Scoop - Attractors in 3D Space
82
ryanpennings_thesis_final_005.indd 82
The Percy Project
27/10/2015 10:56 PM
The algorithmic artefacts revealed a number of issues and advantages of an algorithmic design process
ryanpennings_thesis_final_005.indd 83
27/10/2015 10:56 PM
These discoveries were then used to inform the next stage of the project. [The Percy Stools and Chairs]
ryanpennings_thesis_final_005.indd 84
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 85
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 86
27/10/2015 10:56 PM
Algorithmic Furniture: Percy Series Introduction The second part of this project focused on the iterative development of a furniture series, that applied, through the use of a single algorithm, the findings of the algorithmic artefacts from the first part of the project. The series, which includes the ‘Percy Stool’, ‘ Percy Dining Chair’, and ‘Percy Dining Table’ shows an in-depth examination of the application of an algorithm to a product design. Applying the algorithm across a number of different products in the series examines the ability for an algorithmic design to produce a coherent visual language, and gives a number of different contexts in which to place algorithmically designed products. It also explores how adaptable the functional elements of the algorithm are when size, scale and function are changed. The key focus of the Percy furniture series however, is the in-depth examination of the algorithmic processes used in developing a function product, this is discussed in the chapter: Synthesis.
The Percy series results are broken down into sections, separating the prealgorithmic stools, Percy Stools, Percy Dining Chairs and Percy Dining Table.
The Percy Project
ryanpennings_thesis_final_005.indd 87
87
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 88
27/10/2015 10:56 PM
Pre-Algorithmic Stools Introduction Three versions of stools were produced without algorithmic design in order to test and refine the 3D printing process, in particular in relation to the creation of furniture. These stools, while intended as only a test piece for the robot, ended up being precedents for the algorithmic versions of the stools. They also informed the creation of the algorithmic rules used in the Percy Stools. Alongside this, the pre algorithmic stools also provided inspiration via a number of unexpected artefacts that were created from inconsistencies in the printing process. Another factor that led to the forms continued use was the apparent wide spread fondness of parties exposed to these stools in an informal setting. The desirability and acceptance of algorithmically designed products is an important evaluation to pass, and the reaction to these stools was an indication that this form could help provide that to the algorithmic versions of these stools. In a sense, the iterative part of the project really started with the creation of
these stools, and not with the creation of the algorithmic design. This raises the question, can algorithmic design techniques be applied in different stages of the design process? (This is visited in the chapter: Synthesis)
The Percy Project
ryanpennings_thesis_final_005.indd 89
89
27/10/2015 10:56 PM
1st Stool The first stool was printed with a 6mm nozzle, and in natural PLA. Issues with the extrusion to robot speed ratio caused some uneven layers in the first half of the stool, these were corrected and a rough correct ratio was found. This ratio, of approximately 1.6:1 robot-speed(mm/s):extruder-speed(hrtz) provides a good amount of extrusion when layer height is set to 3mm. A variety of issues were immediately apparent. The first being the weight of the stool. A 6mm nozzle extruded more plastic than was needed to make the stool structurally sound, this also added a lot of extra waste, and cost. A second issue was the structural integrity of the stool in the left to right plane. The open profile meant the stool wobbles when used, this gives the user a feeling of unease. Another issue was that the first layer was too close to the bed, causing the beds mesh tape to get stuck into the bottom layer of the print. Finally, the uneven layering broke the surface continuity of the seating area, leading to discomfort.
90
ryanpennings_thesis_final_005.indd 90
In contrast the stool is very strong and able to handle the weight of a user, it can also handle the wobbling from side to side without snapping or breaking. The form of this stool featured both curved areas and straight areas, to test overhangs and layering accuracy respectively. The straight sections did not come out perfectly layered, this indicated that their was either a problem with the robots positioning, that the extrusion was inconsistent or that the plastic was not cooling quick enough. The issue was resolved with extra cooling later in the project, other inconsistencies from this process were worked into the algorithmic design to create variance and texture (see Explaining the Algorithm used). All the curves design to test overhangs produced results as expected.
The Percy Project
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 91
27/10/2015 10:56 PM
Pre Algorithmic Stool 2
2nd Stool
3rd Stool
The second stool was printed with the same parameters as the first stool, with a change to the extrusion speeds. The changed extruder speeds gave a more consistent print with no areas where too much plastic was extruded. This meant a smooth surface overall on the seating area.
The third stool was printed with a 4mm nozzle, and form had been modified. The new form had a variety of new curves in it, departing away from the straightness of the previous two stools. The form was asymmetrical and had a number of differences on each side. This print also included the introduction of colour. An attempt to touch the middle of the legs to the seat, in order to increase stability and eliminate wobble was made. This touch off did not meet as planned, and the small amount of contact that did happen, broke when tested. Curves that ran down the legs (print orientation)
92
ryanpennings_thesis_final_005.indd 92
The Percy Project
27/10/2015 10:56 PM
Pre Algorithmic Stool 3
were made to further test overhangs and to test the increase in strength. The print quality was improved from the previous two stools, with only a few minor problems in the extrusion. However a major problem with the extruder was leaking plastic. This was caused by the nozzle change from 6mm to 4mm, where plastic got into the threads and occasionally dropped burnt bits of plastic onto the print. These were normally very easy to knock off, although some did get bonded into the print, or got covered over with the next layer of extrusion.
Functionally, the stool is sound, although there are some issues. The legs are flimsy unless direct downward force is applied. Wobble has not been eliminated, due to the touch off not bonding well enough and breaking. It isn’t clear if the added curves added strength to the chair, but an estimated guess suggests that the curves added strength which was lost when the smaller nozzle size was used. The smaller nozzle and extrusion size greatly reduces the weight, material usage and cost of the stools.
The Percy Project
ryanpennings_thesis_final_005.indd 93
93
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 94
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 95
27/10/2015 10:56 PM
ryanpennings_thesis_final_005.indd 96
27/10/2015 10:56 PM
Algorithmic Stools Explaining the Algorithm Used An agent based algorithm, is an algorithm that simulates the moving of an object (an agent) through a system of rules. The agent is capable of making it’s own decisions about what to do next (Shiffman, 2014). A common example of an agent based algorithm, which is widely used is Craig Reynolds Boids (Reynolds, n.d.). This boid algorithm simulates animal movement, such as schools of fish or flocks of birds. An agent based algorithm allows a great deal of control to be programmed into algorithm, which is what the algorithm used in the second stage of this project does. This approach also allows the blending of the algorithm design environment with the robotic programming environment. The novel process used to create the series of Percy furniture pieces is an agent based system that accounts for certain characteristics of the robotic 3D printing system. In this algorithm there is a single agent which is used to generate the tool path for
the robotic 3D pinter. By generating a tool path instead of an actual form, the difficulty of applying form to an algorithm is reduced. To facilitate this integration of the algorithmic and robotic environments, the single agent can be thought as the extruders position. The 3D form of the furniture is modelled with conventional modelling techniques, by modelling the initial form this way, the archetypal furniture topology can be maintain and controlled. This form is then imported into Grasshopper, where it is split up into layers. Each layer has 2 distinct stages. The first uses a path following set of rules to have the agent to follow the outside of the form, this maintains the products topology and the buildability of the piece. Some leeway is allowed in the rules to facilitate emergent behaviour. During the second stage, the rules are changed and relaxed. The agent seeks a point on the other side of the stool once it has completed a layer. During this an attractor(s) affects the path
The Percy Project
ryanpennings_thesis_final_005.indd 97
97
27/10/2015 10:56 PM
of the agent. The purpose of this second stage is to generate a unique output and to provide support to the stool. Once both these stages have been completed the next layer is started and the agents direction is reversed. The agent also only operates within the environment that is defined by the 3D form input at the start. This prevents the agent from travelling outside its bounds and disrupting the product topology. Layer heights of 3mm are used, with extrusion width approximately at 6mm. These values are programmed into the algorithm, giving the ability to control where the tool paths meet each other, to ensure proper connections between parts. Also programmed into algorithm is control of the speed and extrusion rate of the printer, these values are abstractly programmed in via tuning of the algorithm, thus the tool-path generated is suited towards these values and the desired result.
98
ryanpennings_thesis_final_005.indd 98
Control over product topology is maintained as research found that algorithms have a tendency towards complexity, and that this complexity can disrupt product topology enough to have the object unrecognisable and/ or non-functional. By forcing a strict set of rules to maintain the existing topology the algorithm is allowed to generate recognisability while preserving the emergent behaviour, flexibility and ambiguity possible with algorithmic design. An important aspect of producing robotically 3D printed furniture was differentiating the pieces from existing precedents, (namely Dirk Vander Kooij’s work). The second part of the algorithm works towards this goal by providing both unique form and function (by providing strength and stability to the furniture). The algorithm was iteratively improved during the development of the Percy series of furniture. It was modified to different forms as it progressed from stool to chair [to table]. The main difference between the final version of the algorithm for the stool and that for the chair is the addition of a third seek point, which allows for generation of back rest support in the middle 2 quarters of the stool.
The Percy Project
27/10/2015 10:56 PM
The Percy Project
ryanpennings_thesis_final_005.indd 99
99
27/10/2015 10:56 PM
Stool_001 The first version of the Percy stool was designed as a piece to test the agent algorithm. The algorithms main body development happened during the creation of this stools algorithm. The expectations of the final form after the algorithm was generated included: errors where the inner part of the algorithm crossed over itself and lots of dropping where the algorithm wasn’t supported. The intention of the crossover and layer change was to create a visual effect that broke up the layers.
Design - Form This version of the stool was a progression from the pre algorithmic stools used as test pieces for the robotic 3D printer. This form was designed to reduce plastic usage, print time, generation time and cost during the iterative tests. It featured more curves that increase the surface area of the stool, and add more visual interest, as well as added variance for testing the algorithms response. It was also designed to push the known limits of the robotic 3D printer, in areas such as overhangs and speed. The decision was also made to make the stools designed for a small cafe.
Design - Algorithm The programming of this algorithm was based on the Percy Stools algorithm, a few modifications were necessary in order to accommodate the new larger form. The two main starting points on the legs remained the same, but an additional set of points was needed at the top of the back rest. In
100
ryanpennings_thesis_final_005.indd 100
an attempt to strengthen the back rest, in the same way the algorithm in stool_003b strengthens the legs of the stool, the seek point was swapped from the back starting points located at the leg, to the starting points located in the back rest for the middle third of the print. The forces involved were fine tuned to have a similar output to the Percy Stools.
Robot Programming The robotic programming grasshopper sketch that was developed for the pre algorithmic stools was modified for use with this stool. Extrusion issues in previous stools were alleviated through the adjustment of linear movement interpolation methods from a distance based equation to a constant velocity equation. The robot, which uses a series of points to linearly travel between was set to 10mm increments, resulting in the generated tool paths being dividing into points each 10mm apart. This provided a good balance between resolution, smooth movement and output file size. The tool paths were divided into points, then layers and speeds applied. Commands to activate the compressed air at the correct time was added as was approach and exit points, which allow for starting and stopping of extrusion (which is manual at this point).
Production The new form resulted in better stability to the layers, which resulted in a more uniform print, this new form also minimised the appearance of algorithmic artefacts. New cooling systems also supported better
The Percy Project
27/10/2015 10:56 PM
Percy Stool_001
The Percy Project
ryanpennings_thesis_final_005.indd 101
101
27/10/2015 10:56 PM
quality of extrusion and printing. A problem still evident from the beginning is curling which is caused by the the plastic cooling and contracting. PLA was chosen to avoid this problem, as it has the least shrinkage out of all tested plastics. The bed material at this stage was self adhesive mesh tape, which gave the PLA a good surface to adhere to. The problem with mesh tape was it de-laminated from the MDF surface when the print starting curling due to shrinkage. The mesh tape also leaves a mesh surface on the bottom of the print. This curling also causes a slight indent in the first 4-6 layers.
Function Evaluation As the stool was incomplete, a proper functional evaluation isn’t possible, but it is evident that the stool is capable of holding a persons weight, and that the support aspect of the algorithm worked well. This aspect also eliminated the side to side wobble that was present in the pre-algorithmic stools. The grey coloured plastic provides very good definition and contrast to the algorithmic generation within the middle of the stool.
The inner algorithm exhibits its emergent behaviour and provides a high level of strength and stability to the stool. It has lots of touch-off points between the middle, sides and top of the space it occupies, while providing variance in its path, which translates to visual interest. The colour of the stool (translucent pink) makes it difficult to see details, but vibrancy increases contrast where contrast is already high. Inconsistent master-batch mixing adds variation to layering, which indicates the narrative of construction in the stool. Alternating layers, as seen in all previous stools are evident, but with less variation layer by layer than stool_001 and stool_002. The locations the inner support touches off with the top of the seat are close together, giving the seat more strength in the middle. Consistency between layers is very good and there is minimal print errors and defects throughout the print.
102
ryanpennings_thesis_final_005.indd 102
The Percy Project
27/10/2015 10:56 PM
The Percy Project
ryanpennings_thesis_final_005.indd 103
103
27/10/2015 10:56 PM
Stool_002 This stool was an A/B comparison to the previous grey stool (stool_001). The loose rules in the centre were replaced with strict path following rules, similar to the outside. The intended effect was a smoother and neater looking version of the support, where the support itself was properly supported [The algorithm was generated before stool_001 was printed.]. The height setting was also fixed after stool_001 was printed.
Design - Form
Production The new interior only touched off in the middle of the stool, which gave some of the stool a lack of strength in other areas. The inner support was supported on itself, but not as accurately as the outside topology, and there was no evidence that emergent behaviour existed, as the system was too controlled. The stool exhibited the same unexpected artefacts that were present in stool_001.
Function Evaluation
The design of the form is the same as stool_001 for the purpose of A/B test.
Design - Algorithm The replacement of the loose set of rules with a path following rule was intended to control the agent, and reduce the random movement it took. The agent was given a more relaxed set of rules during this path following than when following the outside (topology of the part); allowing the agent to move further away from the path before correcting itself.
Stool_002 stilled functioned as a stool despite the lack of support touch-offs. It is stable and able to hold a persons weight. The curve across the seating area (as in stool_001) does not suit sitting as it is too sharp. Because the touch-off with the support being in the centre only, the stool has no give in the centre but with give around it, this makes for an uncomfortable seat.
Robot Programming Robotic programming matched the programming for stool_003a to facilitate A/B testing.
104
ryanpennings_thesis_final_005.indd 104
The Percy Project
27/10/2015 10:56 PM
Percy Stool_002
The Percy Project
ryanpennings_thesis_final_005.indd 105
105
27/10/2015 10:56 PM
Percy Stool_002
106
ryanpennings_thesis_final_005.indd 106
The Percy Project
27/10/2015 10:56 PM
The Percy Project
ryanpennings_thesis_final_005.indd 107
107
27/10/2015 10:56 PM
Stool_003a Stool_003a features a number of improvements over the previous versions. The inner algorithm was returned to the loose set of rules, as these provide more visual interest, room for variance, and better support. The form was changed to improve the design, increasing in size and making it more curvaceous. This version of the stool was a test of how the algorithm would react to changes in form, both from the previous stool (stool_001) and as the form changed in each layer.
Design - Form In order to increase strength of the stool (without support) more curves were added around the legs, where support generally isn’t generated. These curves also rounded on the visual appeal of the chair and made it look less like a straight extrusion. Curves on the edge of the seating area increased seat surface area and allowed a more uniform curve across the top of the seat. The form was opened up to allow viewing of the inner algorithm from the front and back.
Design - Algorithm This change of form required a change of algorithm tuning to get an output that wasn’t the agent endlessly bouncing off the limits of the form. The values of the agent were adjusted until it resembled the output from stool_001. The starting points were defined in a more symmetrical way than they had been previously, and required a straighter path. A curved path resulted in the agent failing when the algorithm reached the middle section of the stool where more curves were added.
108
ryanpennings_thesis_final_005.indd 108
Robot Programming During the time between printing stool_001 and stool_002, work was done on the printer to improve printer quality, this included the addition of pressure control valves to the extruder. A change with increased the amount of compressed air cooling lines from 1 split into 3, to 3 individual lines capable of 8bar each. Speeds were also slightly optimised for faster print times. The distance between points was lowered to 6mm to increase resolution, this caused file sizes to increase and required the files to be split to 25,000 lines of code each in order to fit the robot controllers requirements.
Production The new form resulted in better stability to the layers, which resulted in a more uniform print, this new form also minimised the appearance of algorithmic artefacts. New cooling systems also supported better quality of extrusion and printing. A problem still evident from the beginning is curling which is caused by the the plastic cooling and contracting. PLA was chosen to avoid this problem, as it has the least shrinkage out of all tested plastics. The bed material at this stage was self adhesive mesh tape, which gave the PLA a good surface to adhere to. The problem with mesh tape was it de-laminated from the MDF surface when the print starting curling due to shrinkage. The mesh tape also leaves a mesh surface on the bottom of the print. This curling also causes a slight indent in the first 4-6 layers.
The Percy Project
27/10/2015 10:56 PM
Percy Stool_003a
The Percy Project
ryanpennings_thesis_final_005.indd 109
109
27/10/2015 10:56 PM
The inner algorithm is exhibits emergent behaviour and provides a high level of strength and stability to the stool. It has lots of touch-off points between the middle, sides and top of the space it occupies, while providing variance in its path, which translate to visual interest. The colour of the stool (translucent pink) makes it difficult to see details, but vibrancy increases contrast where contrast is already high. Inconsistent master-batch mixing adds variation to layering, which indicates the narrative of construction in the stool. Alternating layers, as seen in all previous stools are evident, but with less variation layer by layer than stool_001 and stool_002. The locations the inner support touches off with the top of the seat are close together, giving the seat more strength in the middle. Consistency between layers is very good and there is minimal print errors and defects throughout the print.
110
ryanpennings_thesis_final_005.indd 110
Function Evaluation Stool_003a functions very well, it is strong and stable. The size makes it very suitable for a small cafe stool. Comfort on the seat is average, due to the location of support material.
The Percy Project
27/10/2015 10:56 PM
The Percy Project
ryanpennings_thesis_final_005.indd 111
111
27/10/2015 10:56 PM
Stool_003b Stool_003b was a test of slight parameter changes. The purpose of this version was to explore both repeatability and the affect slight changes have on the output.
Design - Form The form remained that same as in stool_003a.
bottom, which caused excess plastic in the area. As with stool_003a, the algorithm was consistent throughout the stool. The touch-offs were spaced further apart and thus provide a more flexible and comfortable seat. The algorithm had the unexpected result of moving down in to the legs, this gave the legs a lot more strength and makes them extremely stable. It also increased print time, material usage, cost and weight. There were some print errors that required post processing fixing (this is done by using a heat-gun to warm the plastic to a malleable state).
Design - Algorithm Slight changes were made to the algorithms values to explore the affect they would have. The rules surrounding the outside path following were relaxed slightly, and the starting points were also slightly moved.
Function Evaluation The stool functions slightly better than stool_003a due to it’s increased strength in the legs, and the more comfortable seating.
Robot Programming Robotic programming matched the programming for stool_003a to facilitate A/B testing.
Production The changes made to the algorithm caused a number of differences between the output of this stool and stool_003a. Stronger emergent behaviour was seen around the edges, where the agent was allowed more room to travel due to relaxed rules. The changes to the second part of the algorithm resulted in the tool paths overlapping at the
112
ryanpennings_thesis_final_005.indd 112
The Percy Project
27/10/2015 10:56 PM
Percy Stool_003b
The Percy Project
ryanpennings_thesis_final_005.indd 113
113
27/10/2015 10:56 PM
Percy Stool_003b
114
ryanpennings_thesis_final_005.indd 114
The Percy Project
27/10/2015 10:56 PM
The Percy Project
ryanpennings_thesis_final_005.indd 115
115
27/10/2015 10:56 PM
Stool_003c Stool_003c was modified to show more of the inner algorithmic output than the previous stools. This was to see if the inner algorithm scaled up while maintaining it’s characteristics and could be made more of a feature.
Design - Form To make more room to see the inner algorithm, the middle curve between the two legs was lowered, making the space between the seat and the legs bigger, giving the algorithm more room to move about. No other part of the form was changed.
Design - Algorithm The programming of the algorithm scaled up well, it appeared to have completed the same function without much change to the settings. Most of the path following settings were returned to the values used in stool_003a.
Robot Programming
of plastic that did not retain the emergent behaviour evident in the previous stools. Because of the lack of support, the seat has too much flexibility, and while this still works, it gives a feel of unease to the person sitting on it. The path following values there were returned to the those used in stool_003a produced a more consistent print quality. This print also had a colour change part way through the print. Because of the way master-batch mixes, this change was very sharp and happened over 2-4 layers, with occasional alternations back to the previous colour. The white half provides good definition of details and good contrast between extrusion lines. While the yellow half provides slightly less contrast and a bit more vibrancy. A smooth transition exists on the inside between the two colours.
Function Evaluation Stool_003c still functions, but as a slightly less study and stable version than stool_003b and stool_003a. The adjustment of the inner curve does not have an impact on the strength or stability of the stool.
Robotic programming matched the programming for stool_003a and stool_003b to facilitate A/B testing.
Production This test did not work as expected. The inner algorithm failed to touch the top of the seat in the first few layers, this caused the remaining layers to drop, while also not touching the top area. The result was a pile
116
ryanpennings_thesis_final_005.indd 116
The Percy Project
27/10/2015 10:56 PM
Percy Stool_003c
The Percy Project
ryanpennings_thesis_final_005.indd 117
117
27/10/2015 10:56 PM
118
ryanpennings_thesis_final_005.indd 118
The Percy Project
27/10/2015 10:56 PM
Robot Printing - Stool_001
The Percy Project
ryanpennings_thesis_final_005.indd 119
119
27/10/2015 10:56 PM
Stool_003d Stool_003d was a look into the repeatability of producing stools while uniquely generating the inner algorithm. It was expected to work as well as stool_003a.
Design - Form The form returned to the form used in stool_003a and stool_003b
Design - Algorithm
had, but with less density of extrusion. This caused the chair to lack support on the top (print orientation) or right (use orientation). The back support did work, providing a fairly stiff but somewhat flexible back. The algorithm swapping the starting points on the back during the print created gaps in the changeover, which breaks the visual continuity of the print. The increased size of the chair gave the lots more visibility to the inner algorithm. The chair does exhibit similarities to simple extrusion chairs that exist in the precedents.
Function Evaluation
The algorithm was similar to that used in stool_003a, with a few small changes to encourage a different algorithmic output. These changes were mostly related to the positioning of the starting points.
Stool_003d is strong and sturdy, once the print errors affecting the contact of the stool with the ground were fixed. The seat was slightly less comfortable than most of the previous stools due to the support providing too much support.
Robot Programming Robotic programming matched the programming for stool_003a to facilitate A/B testing.
Production There was a number of problems with the printing of this new form and algorithm. Firstly the calculated speed to extrusion rate ratio was off, this caused too much plastic to be extruded in the beginning of the print. By correcting this in future versions the print can be sped up even more. Secondly, the inner algorithm didn’t always touch of with the top of the seat, and exhibited the same problem that stool_003c
120
ryanpennings_thesis_final_005.indd 120
The Percy Project
27/10/2015 10:56 PM
Percy Stool_003d
The Percy Project
ryanpennings_thesis_final_005.indd 121
121
27/10/2015 10:56 PM
122
ryanpennings_thesis_final_005.indd 122
The Percy Project
27/10/2015 10:56 PM
Percy Stools
The Percy Project
ryanpennings_thesis_final_005.indd 123
123
27/10/2015 10:57 PM
124
ryanpennings_thesis_final_005.indd 124
The Percy Project
27/10/2015 10:57 PM
Algorithmic Dining Chairs The algorithmic dining chairs or ‘Percy Chairs’ are a progression from the Percy Stools. They are an attempt to transcode the algorithm previously used across to a different product, while maintaining the emergent behaviour and visual language of the previous designs. By moving the algorithm to another more typical furniture product, versatility and adaptability of the use of algorithmic design can be seen. The chairs required a change in the algorithm, to enable the generation of the back rest support.
The Percy Project
ryanpennings_thesis_final_005.indd 125
125
27/10/2015 10:57 PM
Chair_003 The Dining chair was the next step in the Percy series. The goals of producing a dining chair were to explore the algorithmic design at a larger scale, to explore it in a more common product (and product topology), to explore translating the visual language of the algorithm across products, and to explore the ability for the algorithm to adapt to different forms.
Design - Form The form was built off the Percy stool in an attempt retain the visual language and character that it exhibited. In order to facilitate the current ability of the robotic 3D printing system, the print orientation needed to be changed, this moved the opening which the algorithmic output is mostly visible through to the side of the chair (whereas it’s in the front of the stool). The visual elements of legs were kept, as was the curve on the seat (which became the front of the seat). The back was added and made to match the rest of the design. Everything was scaled up to appropriate sizing, which resulted in a larger space for the inner algorithm to become visible. The legs were moved slightly back to accommodate the new centre of gravity, and the front was angled out more. This form provides a more conventional platform on which to examine the effects an algorithmic design has on furniture.
Design - Algorithm The programming of this algorithm was based on the Percy Stools algorithm, a few modifications were necessary in order to
126
ryanpennings_thesis_final_005.indd 126
accommodate the new larger form. The two main starting points on the legs remained the same, but an additional set of points was needed at the top of the back rest. In an attempt to strengthen the back rest, in the same way the algorithm in stool_003b strengthens the legs of the stool, the seek point was swapped from the back starting points located at the leg, to the starting points located in the back rest for the middle third of the print. The forces involved were fine tuned to have a similar output to the Percy Stools.
Robot Programming The robot programming for the chair used the same definition developed for the stools. This definition creates consistent printing parameters. The only changes here were related to speed. Having a longer tool path meant that speed could be increased without affecting the setting time of the plastic. The same file splitting technique was utilised to manage the increased file size generated by KUKA | PRC.
Production There was a number of problems with the printing of this new form and algorithm. Firstly the calculated speed to extrusion rate ratio was off, this caused too much plastic to be extruded in the beginning of the print. By correcting this in future versions the print can be sped up even more. Secondly, the inner algorithm didn’t always touch of with the top of the seat, and exhibited the same problem that stool_003c had, but with less density of extrusion. This
The Percy Project
27/10/2015 10:57 PM
*TO BE COMPLETED*
The Percy Project
ryanpennings_thesis_final_005.indd 127
127
27/10/2015 10:57 PM
128
ryanpennings_thesis_final_005.indd 128
The Percy Project
27/10/2015 10:57 PM
caused the chair to lack support on the top (print orientation) or right (use orientation). The back support did work, providing a fairly stiff but somewhat flexible back. The algorithm swapping the starting points on the back during the print created gaps in the changeover, which breaks the visual continuity of the print. The increased size of the chair gave the lots more visibility to the inner algorithm. The chair does exhibit similarities to simple extrusion chairs that exist in the precedents.
Function Evaluation Dining chair_003 has some problems with its construction that affect the comfort and strength of the chair. The inner algorithm failing resulted in the chair having a centre of gravity that’s shifted towards the left. This failing also caused the right side
The Percy Project
ryanpennings_thesis_final_005.indd 129
129
27/10/2015 10:57 PM
130
ryanpennings_thesis_final_005.indd 130
The Percy Project
27/10/2015 10:57 PM
DiningChair_003
The Percy Project
ryanpennings_thesis_final_005.indd 131
131
27/10/2015 10:57 PM
Chair_004 Robot Programming
This version of the dining chair was made to improve the functionality of the chair, and to improve the effectiveness and reduce errors in the algorithm.
The robotic programming was the same as for diningchair_003.
Design - Form
Production
The base for was modified based on the previous iteration. The entire chair was widened by 25mm, to increase seat surface area, and to shift proportions towards a typical dining chair morphology. More curve was added to the back rest to accommodate back comfort, this needed some minor form changes where the back rest met the seat. Finally, minor changes to some curves were made to smooth them out.
Design - Algorithm The programming of this algorithm was based on the Percy Stools algorithm, a few modifications were necessary in order to accommodate the new larger form. The two main starting points on the legs remained the same, but an additional set of points was needed at the top of the back rest. In an attempt to strengthen the back rest, in the same way the algorithm in stool_003b strengthens the legs of the stool, the seek point was swapped from the back starting points located at the leg, to the starting points located in the back rest for the middle third of the print. The forces involved were fine tuned to have a similar output to the Percy Stools.
132
ryanpennings_thesis_final_005.indd 132
An issue with the extruder caused minor colour changes and one major colour and plastic change during the print. The minor colour changes exhibited as black smudges for a short distance of 200-400mm, the major colour and plastic change equalled approximately a third of a layer in extrusion length. This change was black and had a bubbly plastic texture. The amount of plastic extruded during this error was greater than the rest of the print, causing it to disrupt the surface of the print on both sides. Within the back rest support, the tool path overlapped the exterior tool path on its way back down. This resulted in excess plastic being extruded, again disrupting the surface of the backrest as exhibited in stool_003b. The inner algorithm does get sparser at the top (print orientation), the problem of support falling to the bottom, as seen in DiningChair_003, exists to a lesser degree in this chair. This could be corrected with speed changes for this area, or an overall speed change.
The Percy Project
27/10/2015 10:57 PM
The Percy Project
ryanpennings_thesis_final_005.indd 133
133
27/10/2015 10:57 PM
134
ryanpennings_thesis_final_005.indd 134
The Percy Project
27/10/2015 10:57 PM
Function Evaluation The new algorithm adjustments resulted in equal strength across the seat area due to an increase in touch-points between the inner algorithm and perimeter of the extrusion. The curve added to the back rest is not severe enough, which causes the top of the back rest to dig into the back of the user. The larger width provides a more comfortable sitting option, and the proportions are better suited to a dining chair. The overlap of extrusion paths in the backrest causes plastic to dig into the users lower back if sitting fully back in the chair.
The Percy Project
ryanpennings_thesis_final_005.indd 135
135
27/10/2015 10:57 PM
136
ryanpennings_thesis_final_005.indd 136
The Percy Project
27/10/2015 10:57 PM
Working on Robots - Photo Š Scott Mayson
The Percy Project
ryanpennings_thesis_final_005.indd 137
137
27/10/2015 10:57 PM
Chair_005 Dining Chair_005 featured a significant change in both form and algorithm. The form changed continued the trend towards a more ergonomic and functional chair form, while the algorithmic rules were changed to produce back support that doesn’t exhibit the problems found in diningchair_003 and diningchair_004.
Robot Programming The robot programming for this chair was changed to use the new polycarbonate bed, which was located 9mm lower than the existing bed. In all other aspects the robotic programming was the same as previous stools.
Design - Form Changes to the form to make it more ergonomic include additional curvature adding to the backrest, to prevent the backrest digging into the users back. Changes to the curvature of the seat area also add extra ergonomics. The transition from the back rest to the back leg was pulled out to widen the area in which the inner support can operate in.
Production & Function Evaluation This chair had not been produced at time of publication.
Design - Algorithm The algorithm underwent a number of changes in order produce proper back support. The algorithm diverges from the previous attempts to use attractor points, and built upon the seek point method used in diningchair_004. This method, which takes 4 seek points and alternates to the next one when the agent comes close, provides a strict set of rules that generate back support every second layer.
138
ryanpennings_thesis_final_005.indd 138
The Percy Project
27/10/2015 10:57 PM
The Percy Project
ryanpennings_thesis_final_005.indd 139
139
27/10/2015 10:57 PM
140
ryanpennings_thesis_final_005.indd 140
The Percy Project
27/10/2015 10:57 PM
The Percy series of furniture shows an in-depth examination of an algorithmic design process applied to a product design
ryanpennings_thesis_final_005.indd 141
27/10/2015 10:57 PM
The findings that both stages of the project came across are presented in the Synthesis chapter.
ryanpennings_thesis_final_005.indd 142
27/10/2015 10:57 PM
ryanpennings_thesis_final_005.indd 143
27/10/2015 10:57 PM
ryanpennings_thesis_final_005.indd 144
27/10/2015 10:57 PM
Synthesis Introduction The synthesis section combines findings from both the divergent exploration and convergent exploration stages of the Percy project. These findings come from the analysis of the artefacts, and the knowledge gained through undertaking the algorithmic design process. This section includes a discussion on algorithmic design environments, methods of algorithmic design, the effects of using algorithmic design for a product, and the application of algorithms to a product design.
The Percy Project
ryanpennings_thesis_final_005.indd 145
145
27/10/2015 10:57 PM
Grasshopper vs Processing While Grasshopper was used throughout this project as the main design environment in the algorithmic design process, a number of other options exist. One other option explored late within the project is Processing. Processing, a programming language (see Introduction to the software for more information), is also widely used within algorithmic design (Krish, 2011; McCormack et al., 2014; Nake, 2014) , and provides a more robust and powerful set of tools to the designer. A number of difference exist between these two design environments, each has their own advantages to the designer. Processing for example, is capable of doing things, faster and better than Grasshopper does. The algorithm used for the Percy furniture was transferred from Grasshopper for this reason. While the time for one Percy Stool to be generated was between 1 to 2 hours. The time to complete in Processing is drastically reduced. This has major benefits for time management within a design process, especially when attempting to iterate through a variety of small changes in the algorithms input values. The downside to Processing for a designer is the steep learning curve. Processing being a coding environment is more difficult to learn and creating 3D forms or processes in a text based environment is a difficult thing for many designers who are used to working in visuals. Grasshopper on the other hand, provides a visual interface that is neatly integrated into an existing CAD program (Rhinoceros 3D), making it much easier to produce forms that are physically possible. A issue of building in one and transferring to over was discovered when rebuilding the Percy Stool algorithm in Processing. The
146
ryanpennings_thesis_final_005.indd 146
emergent behaviour that is experienced in the algorithm and shows in the furniture is a product of a number of elements. This includes the robot 3D printing system, the robot programming and the algorithm used to generated the tool paths. Within the algorithm, which is a complex system of parts, certain things work together to produce a very specific set of behaviour. Rebuilding this in processing is nearly impossible. Even if care is taken to mimic the processes as closely as possible, differences will occur from the Grasshopper version to the Processing version.
Why digital sketching works Digital sketching was used throughout the project as a design method. It proved to be a great way to explore options of form creation. This included the exploration of different plugins, combinations of plugins, and variations of methods used to construct algorithmic artefacts. Digital sketching also provides a platform to build a body of knowledge around algorithmic design, which in turn greatly increases the efficiency of the designer. Due to the emergent nature of the majority of algorithms, digital sketching allows the designer opportunities to experience results that would otherwise be unpredictable. This is evident in the Percy first stools, where the original intention was to create a simple support structure, but the actual result was a complex path that created variance, contrast and movement. Although the digital sketching method is very beneficial to designers, it also has some downsides. The algorithmic artefact stage of the project revealed that digital sketching could become a time consuming and aimless process. The creation of the CA Bowl is a good example of when the digital sketching process took more time than thought. What was originally a straight forward application of a
The Percy Project
27/10/2015 10:57 PM
Kuka - Robot Programming via PRC
The Percy Project
ryanpennings_thesis_final_005.indd 147
147
27/10/2015 10:57 PM
Kuka - Robot Programming via PRC
148
ryanpennings_thesis_final_005.indd 148
The Percy Project
27/10/2015 10:57 PM
Cellular Automata algorithm to a bowl, quickly turned into a laborious process of finding a technique to give this algorithm a form. The digital sketching ended in a undesirable result that lost the original emergent behaviour of the algorithm and it’s visual language. Both the Agent based pasta scoop and the potato masher show how the digital sketching process allows for slight variances in form and inputs to be explored. The potato masher went through a number of variations that ranged from organic to geometric in visual appearance and from producible and functional to impractical and not functional. In this case the digital sketching method provided a vehicle for exploring the relationship between algorithmic inputs and the outputted form, which was evaluated for it’s function as a potato masher. Digital sketching within the pasta scoop enabled a more microscope tuning of the form via inputs. In this case the body of knowledge gained was context specific, relating to the impact various forces (inputs) had on the agents and the form generated.
Emergent Behaviour The emergent behaviour experienced in the algorithmic design process can be difficult to work with. Generating a large body of knowledge around various algorithms and techniques is beneficial for the designer when having to deal with taming emergent behaviour. However, this knowledge is generally context specific, which perhaps leads to the replication of similar morphologies and topologies when using algorithmic design. Breaking out of this ‘rut’ is a challenge that was faced over the duration of the project. A conscious effort was made during the design of artefacts and furniture to avoid commonplace algorithmic morphologies.
Outsourcing form giving A major problem discovered while evaluating the algorithmic artefacts was that applying form to the output of an algorithm is difficult. Typical outputs from algorithms came in the geometric object types of points, curves or lines. Whereas a valid model for additive manufacturing requires either a mesh or a closed (poly)surface or solid. Attempts to tackle this in the algorithmic artefacts were only partially successful. The Pasta Scoop algorithm output a series of curves that often overlapped each other. In the end a Marching Cubes (see glossary) algorithm was used to apply form. The results which were unpredictable, and difficult to control, gave what could be considered an unrefined form. The application of form to the CA Bowl resulted in the loss of the emergent behaviour gained from the cellular automata algorithm. To combat this when designing the algorithms for the Percy furniture series, the form giving was outsourced to the robotic 3D printing system. This added new elements of emergent behaviour to the end product, and greatly simplified the application of form while simultaneously providing a more refined application of form. Another benefit that came from outsourcing the form generation to the robot was simplification of the algorithmic generation process due to the requirement of only having to generate a tool path.
The Percy Project
ryanpennings_thesis_final_005.indd 149
149
27/10/2015 10:57 PM
Providing Function with form.
Maintaining product topology
Making the application of algorithms to a product design worthwhile was a key factor of this research, and one that would make algorithmic design relevant in a product design context. This meant that the algorithm had to go beyond morphologies that provided purely visual qualities, to provide both functional and aesthetic elements. This was applied in the Percy series by creating an agent that simultaneously created a support structure that strengthened the stool and chair, and created a visually unique form. The nature of this algorithm meant it was a compromise between pure aesthetics, pure function, and appropriate use of material. While any two of these could resulted in an algorithmically designed piece of furniture, I.e. A purely functional approach could have minimised on material usage, the compromise in this context allows the algorithm to produce a suitable product. Certain algorithms have a predisposition towards providing function to a particular product type. In the algorithmic artefacts, the L-System algorithm proved to be highly suitable to creating structures that would suit the function of a potato masher. To a lesser extent, the agent based algorithm produced morphologies that would benefit a pasta scoop. The ability to identify these predisposition is largely related to a designers existing knowledge of the algorithms involved. The easiest way to gain this knowledge, as discovered throughout this project, is through the digital sketching technique.
150
ryanpennings_thesis_final_005.indd 150
During the algorithmic artefact stage of the project stage, it become evident that algorithms have a tendency towards generating complex outputs and forms. While one of the effects of this, is difficulty in applying physical form to the outputs (addressed in ‘Outsourcing form giving’ and ‘Digital Sketching, and why it works’), another effect is that product recognisability is quickly lost. This affects both the product itself, and the user. A complex form (for example the Pasta Scoop), is both difficult to make and confusing to a user, especially one unfamiliar with algorithmically designed products. It makes sense then, to apply rules to the algorithm used to help maintain conventional product topologies. This was explored in the Percy series by applying a strict path following rule to the agent based algorithm. This caused the outside path to be controlled and match what a user would expect of a stool or a chair. The rules were however should allow some freedom of expression in the algorithm, as not to lose the emergent behaviour that make algorithms so unique.
The Percy Project
27/10/2015 10:57 PM
The Percy Project
ryanpennings_thesis_final_005.indd 151
151
27/10/2015 10:57 PM
152
ryanpennings_thesis_final_005.indd 152
The Percy Project
27/10/2015 10:57 PM
Pushing away from Archetypical Topologies
Applying Algorithmic Design
The need to maintain product topologies contrasts the immense ability of algorithms to generate morphologies beyond human ability. This contrasts gives a designer the possibility to explore pushing the form away from archetypical product topologies, and towards new product morphologies. This is assisted by integration with advanced manufacturing techniques such as additive manufacturing and robotic fabrication.
Something that wasn’t explored in this project, was the application of algorithmic design techniques to different stages of an existing design process. In this project, the form was developed with an algorithmic method in mind for the entirety of the design and manufacturing process. It is however, possible for the algorithmic design section only be applied to certain elements of the design process.
Integration of Environments The integration of the algorithmic design environment with the robotic programming environment (Grasshopper and Kuka PRC Plugin) enabled the algorithm to have a high level of control over the final outputted form. Elements such as layer height, extrusion width, speed and extrusion rate are all controllable through the algorithm. In the case of the Percy series, due to constraints on the robotic 3D printer, extrusion rate was controlled manually. This integration gave the agent based algorithm (where the agent was effectively the digital version of the extruders location) the ability to generate tool paths that are correct and don’t create errors in the construction of the chair. It also gives the ability to easily encourage the algorithm towards specific functional and visual outputs, such as a support structure for the stools and chairs. This integration is a major advantage of algorithmic design, giving the designer the ability to not only design new morphologies, but to manufacture them, while maintaining control over the manufacturing process.
The Percy Project
ryanpennings_thesis_final_005.indd 153
153
27/10/2015 10:57 PM
ryanpennings_thesis_final_005.indd 154
27/10/2015 10:57 PM
Effective use of algorithmic design requires a body of knowledge and experimentation* *via digital sketching
ryanpennings_thesis_final_005.indd 155
27/10/2015 10:57 PM
The research found methods of working with algorithmic design That help maintain product topology while creating both aesthetic and visual elements
ryanpennings_thesis_final_005.indd 156
27/10/2015 10:57 PM
Conclusion The Percy project explored the application of algorithms to a product design, it did this through two distinct stages. The first was a divergent exploration of various techniques and algorithms, the second, a convergent exploration of one particular algorithm applied to a furniture series. The project combines the fields of algorithmic design, additive manufacturing, robotic fabrication and furniture, and home-wares in a product design context. Research into precedents found that there were numerous examples of products in the related fields, but none in the combination of fields that this project sits within. Examples such as Dirk Vander Kooij’s Endless Chair (Vander Kooij, n.d.) and Francis Bitonti’s Cloud Collection (Bitonti, n.d.) show the current stage of product development in their respective fields. This research also found various practitioners in these fields follow similar theories in relation to their work. These two theories, biomimicry
and ‘digital materiality’, each have a vastly different approach when applied to algorithmic design. While biomimicry takes an imitation [of nature] approach, digital materiality takes a more literal approach. This digital materiality approach takes into account the characteristics of manufacturing method. In this case, the manufacturing method was a robotic 3D printing system that was developed as part of this project. This system allows the construction of large scale 3D printed objects. The blending of the robotic programming environment and the algorithmic design environment allowed for a streamlined digital materiality approach. This in turn allows the designer to program in certain aspects such as layer height and extrusion widths, giving the algorithm the ability to output tool paths that are correct for manufacturing. The divergent exploration stage involved a range of parallel prototypes that dealt with
The Percy Project
ryanpennings_thesis_final_005.indd 157
157
27/10/2015 10:57 PM
different algorithms and design processes. These objects were analysed, with strengths and weaknesses being accounted for in the following iterative [convergent] stage. These findings identified that building a body of knowledge through digital sketching was the best way to design products algorithmically. The parallel prototyping also identified which algorithms were better suited to creating form and function suitable to specific product archetypes. It also identified the tendency for algorithms to generate outputs that are vastly different from existing product topologies. The Percy series of furniture made up the convergent stage of the project. An agent based algorithm was chosen. Rules were applied that maintained product topology, then transitioned to producing a support structure. The rules allowed for the exhibition of emergent behaviour in the tool path. Tool paths were generated to overcome the issues surrounding the difficult in giving algorithmic outputs form. The Percy Stool and Percy Chair both show how an algorithmic design an be applied to a product and produce a functioning design.
158
ryanpennings_thesis_final_005.indd 158
The Percy Project
27/10/2015 10:57 PM
Reflection Over the course of this project, my aim and direction has change drastically. While the original intention was focused on robotic fabrication, potential lack of access changed the direction towards another area of interest, algorithmic design. This change ended up combining a number of areas of interest for me, which include algorithm design, 3D printing and robotic fabrication. The focus of the research took a turn towards the process of algorithmic design, that I would not have expected at the beginning of a year. This focus however was very beneficial for me as I learnt a lot about the process of algorithmic design, and how to work with it. As it’s a new area within Industrial/Product Design, this was very beneficial for me, particularly as I would like to take it forward after graduation. The research part of the project was new to me (and my cohort), applying research methods to design was a difficult task to learn, as was writing.
I’m very grateful for the support I received from the School of Architecture and Design in regards to access to the robotic facilities, and the setup of the 3D printing system. This is especially true when it comes to funding. While working with the robots, which is typically the domain of Architecture, I was exposed to (surprise surprise), Architecture students, staff and researchers. This exposure was beneficial for me, in that it changed my perspective, and gave me access to knowledge of robotics and “algorithmic design” that is prevalent in Architecture. Overall, I am extremely happy to have produced a series of furniture stools, and gained some exposure from this. In terms of my project, if I was to redo it, a more expansive exploration of robotic fabrication to create products would be a focus. There is a huge potential to exploit in the combination of
The Percy Project
ryanpennings_thesis_final_005.indd 159
159
27/10/2015 10:57 PM
algorithmic design and robotic fabrication. Knowing what I know now about research (although still limited) and writing, a revisit to this project would have a better focus on exploring the algorithmic design process that was the earlier stage of this project. Once again a big thank you to the School of Architecture and Design, in particular the staff of the Workshops. And also to Scott Mayson, my honours supervisor for his continuous quality banter, trips to Mr Burger, and support and enthusiasm for my project. As promised, one stool is yours! Finally a big thank you to my friends and cohort at RMIT, who have suffered through my stressful weeks, and have been their to support each other.
160
ryanpennings_thesis_final_005.indd 160
The Percy Project
27/10/2015 10:57 PM
References Autodesk. (n.d.). Project Dreamcatcher. Retrieved April 8, 2015, from http:// autodeskresearch.com/projects/dreamcatcher
Retrieved April 8, 2015, from http://www. core77.com/posts/31179/Tech-Specs-VictoriaSlaker-VP-of-Product-Design-at-Ammunition
Bitonti, F. (n.d.). About The Cloud Collection. Retrieved April 8, 2015, from http://www.francisbitonti.com/ about-the-cloud-collection/
Dutch Profiles: Dirk van der Kooij. (n.d.). Dutch Profiles: Dirk van der Kooij. Dutch Profiles. Retrieved from https://vimeo.com/68328551
Batch, S. (n.d.). Diagrid Pendant. Retrieved from http://www.studiobatch. com/lighting/diagrid-pendant
Gramazio, F., & Kohler, M. (2008). Digital materiality in architecture. (M. Kohler). Baden: Lars Müller.
Bitonti, F. (n.d.). DITA’S GOWN. Retrieved May 11, 2015, from http:// www.francisbitonti.com/ditas-gown/
Gramazio, F., & Kohler, M. (2008). Introduction. In M. Kohler, Digital materiality in architecture (pp. 7–11). Baden: Lars Müller.
Bitonti, F. (n.d.). Inspiration. Retrieved from http://www.francisbitonti.com/ francis-bitontis-blog/2014/5/8/inspiration
Gimmii. (n.d.). Dirk van der Kooij. Retrieved May 11, 2015, from http://www. gimmii.nl/ontwerper/dirk-vander-kooij/
Currey, M. (n.d.). Tech Specs: Victoria Slaker, VP of Product Design at Ammunition.
Han, G. (2014, August 7). 3D PRINTED CLAY: CERAMIC SCULPTURES BY JONATHAN
The Percy Project
ryanpennings_thesis_final_005.indd 161
161
27/10/2015 10:57 PM
KEEP. Retrieved May 6, 2015, from http:// design-milk.com/artist-jonathan-keepsculpts-pottery-using-ceramic-3d-printer/
Computer Art. Leonardo, 47(2), 135–141. http://doi.org/10.1162/LEON_a_00533
Howarth, D. (2015). Design schools need to embrace digital says Ross Lovegrove. Retrieved from http://www.dezeen.com/2015/04/14/ ross-lovegrove-design-schools-way-behindneed-embrace-digital-milan-2015/ Howarth, D. (2015, June 2). Janne Kyttanen builds 3D-printed sofa from a minimal mesh. Retrieved June 7, 2015, from http://www.dezeen.com/2015/06/02/ janne-kyttanen-3d-printed-sofa-so-goodminimal-mesh-spider-web-cocoons/
Nordin, A., Hopf, A., & Motte, D. (2014). Generative Design Systems for the Industrial Design of Functional Mass Producible NaturalMathematical Forms (pp. 1–11). Presented at the CONNECTED ND INTERNATIONAL CONFERENCE ON DESIGN EDUCATION. Reynolds, C. (n.d.). Boids. Retrieved October 14, 2015, from http:// www.red3d.com/cwr/boids/
Krish, S. (2011). A practical generative design method. Computer-Aided Design, 43(1), 88–100. http://doi. org/10.1016/j.cad.2010.09.009
Rubinstein, D. (2014). Fusion Point. Architectural Digest, 71(6), 64. Schumacher, Patrik. (2010). Let the style wars begin. Architects’ Journal, 231(16), 41–45.
Laarman, J. (n.d.). BONE FURNITURE - Joris Laarman Lab. Retrieved May 4, 2015, from http://www.jorislaarman. com/bone-furniture.html Laarman, J. (n.d.). MX3D - Joris Laarman Lab. Retrieved May 11, 2015, from http:// www.jorislaarman.com/mx3d.html Martin, B., & Hanington, B. M. (n.d.). Universal methods of design : 100 ways to research complex problems, develop innovative ideas, and design effective solutions. (B. M. Hanington). Beverly, MA: Rockport Publishers. McCormack, J., Bown, O., Dorin, A., McCabe, J., Monro, G., & Whitelaw, M. (2014). Ten Questions Concerning Generative
ryanpennings_thesis_final_005.indd 162
Nervous System. (n.d.). About. Retrieved March 25, 2015, from http://ne-r-v-o-u-s.com/about_us.php Nervous System. (n.d.). Kinematics. Retrieved May 11, 2015, from http://n-er-v-o-u-s.com/projects/sets/kinematics/
Howarth, D. (2015b). Zaha Hadid, Ben van Berkel and more design 3D-printed shoes for United Nude. Retrieved from http://www.dezeen.com/2015/04/13/ united-nude-3d-printed-shoes-zaha-hadidben-van-berkel-michael-young-milan-2015/
162
Nake, F. (2014). Algorithmic Art, 47(2), 108– 108. http://doi.org/10.1162/LEON_a_00706
Schumacher, Peter, & Krish, S. (2014). Teaching Generative Design Strategies for Industrial Design (pp. 1–4). Presented at the CONNECTED ND INTERNATIONAL CONFERENCE ON DESIGN EDUCATION. Shead, O. (2014). Leading design competition, VIVID, announces 2014 winners. Retrieved from http://theinteriorsaddict. com/leading-design-competitionvivid-announces-2014-winners Shiffman, D. (2014a). 8.6 L-systems. In The Nature of Code. Shiffman, D. (2014b). Chapter 7. Cellular
The Percy Project
27/10/2015 10:57 PM
Automata. In The Nature of Code. van Daal, L. (n.d.). BIOMIMICRY: 3D printed soft seat. Retrieved March 24, 2015, from http://lilianvandaal. com/?portfolio=3d-printed-softseating Vander Kooij, D. (n.d.). About. Retrieved March 11, 2015, from http:// www.dirkvanderkooij.com/pages/about Woodward, S., & Fisher, T. (2014). Fashioning through materials: Material culture, materiality and processes of materialization. Critical Studies in Fashion & Beauty, 5(1), 3–23. http://doi.org/10.1386/csfb.5.1.3_2 Workshopped. (n.d.). Paper Light by Chris Hardy. Retrieved May 11, 2015, from http://www.workshopped.com.au/ shop_product/Paper_light?CID=3
List of Figures Figure 1: Framework Diagram - p.7 Figure 2: Field Map - p.19 Figure 3: Theory Map - p.31 Figure 4: Digital Sketching - p.41 Figure 5: Example of Radar Chat - p.53
The Percy Project
ryanpennings_thesis_final_005.indd 163
163
27/10/2015 10:57 PM
Glossary of Terms PLA - Polylatic Acid, a plastic made from renewable resources and not oil. One of the most common plastics used in a 3D printing application. ABS - Acrylonitrile Butadiene Styrene, a common plastic used in 3D printing applications. PE - Polyethylene, a common plastic. Although not typically used in 3D printing applications. Filament - Plastic which has been formed into a string and generally placed on a roll. Typically 1.75mm in diameter, it is used by FDM/FFF types of 3D printers. FDM/FFF - Fused Deposition Modelling/Fused Filament Fabrication. Grasshopper - A an algorithmic modelling plugin for the CAD program
164
ryanpennings_thesis_final_005.indd 164
Rhinoceros 3D, which in turn has it’s own plugins. Favoured approach for algorithmic modelling within this project. Processing - A programming language developed for creative people and artists, has a large community that supports it. CAD - Computer Aided Design L System - A algorithm developed by Aristid Lindenmayer to model growth patterns of plants. Cellular Automata - An algorithm developed and improved by many people, a Cellular Automata (or CA) can represent many processes, an common example is basic life. Mesh sub-division - An algorithm that divides a mesh surface into more surfaces, generally used to add detail and smooth out models.
The Percy Project
27/10/2015 10:57 PM
Magics - A program used for 3D printing applications, a common feature is the repair of CAD models for 3D printing. Very helpful when algorithmic output is not perfect. Genetic Algorithm (GA) - An algorithm that simulates genetic evolution to create newer ‘child’ versions of the products. Marching cubes - An algorithm that creates a mesh surface from a series of curves. It is complex and resource intensive, but capable of giving form to complex algorithmic outputs. Emergent behaviour - Results that appear in the algorithmic output that weren’t expected, or that appear as a repeating pattern or common element.
The Percy Project
ryanpennings_thesis_final_005.indd 165
165
27/10/2015 10:57 PM
Product/Algorithm Matrix
Source
Possible Processes/Tools Rabbit? Rabbit, Nudibranch? Galapagos/Goat
Kangaroo Kangaroo Lunchbox Lunchbox Panelling Tools Grasshopper Agent Elk Nudibranch Grasshopper Heteropetra
Process
Product
Name L System
Headphone Hanger
CA (Cellular Automata GA (Genetic Algorithm) Voronoi SCA (Space Colonisation Algorithm) Magnetic Mesh Tension Structure Simulation Panels Truss Panels Boxmorph Boids Topology Use Animatted Points Point Attraction Attractors???
166
ryanpennings_thesis_final_005.indd 166
Bowl
Cutlery
Chair/Stool Table
Outdoor Bench
Cup
Champagne Glass Candle Stick Hour Glass
X
X
Soup Ladle
Trivet
Desk Lamp
Floor Lamp Pe
X
X
X
X
X
X
X X
X
X
X
X
X X
The Percy Project
27/10/2015 10:57 PM
rivet
Appendix A: Matrix Introduction The matrix is used to identify and track combinations of algorithms and products (furniture and home-wares) that could potentially make a successful combination. This was used to help identify combinations to test in the algorithmic artefact stage.
Desk Lamp
Floor Lamp Pendant
X
X
Mug
X
Tongs
Egg Lifter X
Spatula X
X
X
X
Craving Fork Tea Pot
Plate
Kettle
Coffee Plunger (French Press) X
Coffee Grinder
Potato Peeler
Citrus Squeezer/Ju Garlic Crusher icer
Pizza Cutter Grater
Thermomet er
X
X
Matrix Diagram
The Percy Project
ryanpennings_thesis_final_005.indd 167
167
27/10/2015 10:57 PM
168
ryanpennings_thesis_final_005.indd 168
The Percy Project
27/10/2015 10:57 PM
Appendix B: Grasshopper Scripts Introduction The scripts show here are the full versions of the Grasshopper definitions used to generate each stool. This includes an overview of the Grasshopper file, a selection of key settings, and an image of the outputted tool paths and the elements (starting points, attractor points etc) that made up the particular algorithmic output.
The Percy Project
ryanpennings_thesis_final_005.indd 169
169
27/10/2015 10:57 PM
Stool_001 Grasshopper Definition This is the definition for stool_001.
170
ryanpennings_thesis_final_005.indd 170
The Percy Project
27/10/2015 10:57 PM
Settings - Stool_001 Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 8 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.25 to 1 based on distance to centre. Attractor Mass: 385 Lower Limit: 69 Upper Limit: 247 Conductor Script Tolerance: 3.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 171
171
27/10/2015 10:57 PM
172
ryanpennings_thesis_final_005.indd 172
The Percy Project
27/10/2015 10:57 PM
The Percy Project
ryanpennings_thesis_final_005.indd 173
173
27/10/2015 10:57 PM
Stool_002 Grasshopper Definition This is the script for stool_002
174
ryanpennings_thesis_final_005.indd 174
The Percy Project
27/10/2015 10:57 PM
Settings - stool_002 Agent Mass: 0.95 Max Speed: 4.5 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 8 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.25 to 1 based on distance to centre. Follow Path (Inner) Path Radius: 5.08 Prediction Distance: 11 Path Target Distance: 9 Conductor Script Tolerance: 3.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 175
175
27/10/2015 10:57 PM
176
ryanpennings_thesis_final_005.indd 176
The Percy Project
27/10/2015 10:57 PM
The Percy Project
ryanpennings_thesis_final_005.indd 177
177
27/10/2015 10:58 PM
Stool_003a Grasshopper Definition This is the definition for stool_003a.
178
ryanpennings_thesis_final_005.indd 178
The Percy Project
27/10/2015 10:58 PM
Settings - stool_003a Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 8 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.25 to 1 based on distance to centre. Attractor Mass: 385 Lower Limit: 69 Upper Limit: 247 Conductor Script Tolerance: 3.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 179
179
27/10/2015 10:58 PM
180
ryanpennings_thesis_final_005.indd 180
The Percy Project
27/10/2015 10:58 PM
The Percy Project
ryanpennings_thesis_final_005.indd 181
181
27/10/2015 10:59 PM
Stool_003b Grasshopper Definition This is the definition for stool_003b.
182
ryanpennings_thesis_final_005.indd 182
The Percy Project
27/10/2015 10:59 PM
Settings - stool_003b Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 8 Follow Path Path Radius: 0.010 Prediction Distance: 4 Path Target Distance: 3 Seek Weight of seek point scales on curve from 0.02 to 0.99 based on distance to centre. Attractor Mass: 304 Lower Limit: 58 Upper Limit: 255 Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 183
183
27/10/2015 10:59 PM
184
ryanpennings_thesis_final_005.indd 184
The Percy Project
27/10/2015 11:00 PM
The Percy Project
ryanpennings_thesis_final_005.indd 185
185
27/10/2015 11:00 PM
Stool_003c Grasshopper Definition This is the definition for stool_003c.
186
ryanpennings_thesis_final_005.indd 186
The Percy Project
27/10/2015 11:00 PM
Settings - stool_003c Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 8 Follow Path Path Radius: 0.010 Prediction Distance: 4 Path Target Distance: 3 Seek Weight of seek point scales on curve from 0.12 to 0.89 based on distance to centre. Attractor 1 Mass: 300 Lower Limit: 60 Upper Limit: 120 Attractor 2 Mass: 280 Lower Limit: 15 Upper Limit: 50 Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 187
187
27/10/2015 11:00 PM
188
ryanpennings_thesis_final_005.indd 188
The Percy Project
27/10/2015 11:00 PM
The Percy Project
ryanpennings_thesis_final_005.indd 189
189
27/10/2015 11:01 PM
Stool_003d Grasshopper Definition This is the definition for stool_003d.
190
ryanpennings_thesis_final_005.indd 190
The Percy Project
27/10/2015 11:01 PM
Settings - stool_003d Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 16 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.18 to 0.89 based on distance to centre. Attractor Mass: 300 Lower Limit: 20 Upper Limit: 200 Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 191
191
27/10/2015 11:01 PM
192
ryanpennings_thesis_final_005.indd 192
The Percy Project
27/10/2015 11:01 PM
The Percy Project
ryanpennings_thesis_final_005.indd 193
193
27/10/2015 11:02 PM
Chair_003 Grasshopper Definition This is the definition for chair_003. Seek point 2 and 3 swap for the middle third of the chair, creating support in the back rest.
194
ryanpennings_thesis_final_005.indd 194
The Percy Project
27/10/2015 11:02 PM
Settings - chair_003 Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 16 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.18 to 0.89 based on distance to centre. Attractor Mass: 300 Lower Limit: 20 Upper Limit: 200 Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 195
195
27/10/2015 11:02 PM
196
ryanpennings_thesis_final_005.indd 196
The Percy Project
27/10/2015 11:02 PM
The Percy Project
ryanpennings_thesis_final_005.indd 197
197
27/10/2015 11:03 PM
Chair_004 Grasshopper Definition This is the definition for chair_004. Between the middle 2 quarters of the chair, the seek point alternates every 4 layers. On the 4th layer, seek point 3 is active (seek point 2 is inactive) until the agent is within 30mm. At this stage seek point 2 becomes active and seek point 3 is inactive.
198
ryanpennings_thesis_final_005.indd 198
The Percy Project
27/10/2015 11:03 PM
Settings - chair_004 Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 16 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Seek Weight of seek point scales on curve from 0.18 to 0.89 based on distance to centre. Attractor Mass: 300 Lower Limit: 15 Upper Limit: 200 Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 199
199
27/10/2015 11:03 PM
200
ryanpennings_thesis_final_005.indd 200
The Percy Project
27/10/2015 11:03 PM
The Percy Project
ryanpennings_thesis_final_005.indd 201
201
27/10/2015 11:04 PM
Chair_005 Grasshopper Definition This is the definition for chair_005.
202
ryanpennings_thesis_final_005.indd 202
The Percy Project
27/10/2015 11:04 PM
Settings - chair_005 NEEDS FINISHING Agent Mass: 0.93 Max Speed: 5.0 Vision Radius: 295 Vision Angle: 210 Max Force: 0.935 Boid Size: 7 Follow Path Path Radius: 0.009 Prediction Distance: 3 Path Target Distance: 2 Attractor 1 Mass: 300 Lower Limit: 31 Upper Limit: 200 Seek Weight of seek point scales on curve from 0.18 to 0.89 based on distance to centre. Alternating Points during back support stage, which direct the agent up and then back down the back Conductor Script Tolerance: 5.00 Support Tolerance: 10.00
The Percy Project
ryanpennings_thesis_final_005.indd 203
203
27/10/2015 11:04 PM
204
ryanpennings_thesis_final_005.indd 204
The Percy Project
27/10/2015 11:04 PM
The Percy Project
ryanpennings_thesis_final_005.indd 205
205
27/10/2015 11:04 PM
206
ryanpennings_thesis_final_005.indd 206
The Percy Project
27/10/2015 11:04 PM
Python Script The python script is the main component of the algorithm used for the Percy series of furniture. This script controls layer height and rule transitions, and is in effect a conductor. The script uses sticky variables (variables that stay persistent outside of the individual grasshopper components) to remember layer heights, agent positions and transition locations. This script section was the most difficult part of the algorithm, and shows how visual programming is an easier method for designers to use.
The Percy Project
ryanpennings_thesis_final_005.indd 207
207
27/10/2015 11:04 PM
import rhinoscriptsyntax as rs import scriptcontext as sc
#time turner - reset everything if reset == True: sc.sticky[‘currentLayer_0909’] = 1 m=0 #call loop to int #newLoop(); sc.sticky[‘currentState_0909’] = ‘loop’ sc.sticky[‘followPath_0909’] = True sc.sticky[‘supportAgentBool_0909’] = False sc.sticky[‘thisSwitch_0909’] = 0 sc.sticky[‘seekPt_0909’] = 0
#height check end if sc.sticky[‘currentLayer_0909’] > height_layers: sc.sticky[‘followPath_0909’] = False sc.sticky[‘supportAgentBool_0909’] = False sc.sticky[‘currentLayer_0909’] += 1
#set m on start try:
208
ryanpennings_thesis_final_005.indd 208
The Percy Project
27/10/2015 11:04 PM
m except NameError: m=0
#check if sticky variable has been defined if not sc.sticky.has_key(‘currentLayer_0909’): sc.sticky[‘currentLayer_0909’] = 1
#redunancy check to make sure stick var is defined. #also resets loop switch if sc.sticky[‘currentLayer_0909’] == None: sc.sticky[‘currentLayer_0909’] = 1 #currentLayer = 1 #ref:000x32 m=0
# int followPath on start if not sc.sticky.has_key(‘followPath_0909’): sc.sticky[‘followPath_0909’] = True
# int support to off if not sc.sticky.has_key(‘supportAgentBool_0909’): sc.sticky[‘supportAgentBool_0909’] = False
The Percy Project
ryanpennings_thesis_final_005.indd 209
209
27/10/2015 11:04 PM
# int current state if not sc.sticky.has_key(‘currentState_0909’): sc.sticky[‘currentState_0909’] = ‘loop’
# in thisSwitch_0909 on start if not sc.sticky.has_key(‘thisSwitch_0909’): sc.sticky[‘thisSwitch_0909’] = 0
# in seekpt on start if not sc.sticky.has_key(‘seekPt_0909’): sc.sticky[‘seekPt_0909’] = 0
def main(): m=0 hack = 0 #FORCE Z HEIGHT
if sc.sticky[‘currentState_0909’] == ‘support’: supportMain() print ‘supportMain loop’ hack = 1
#don’t really need this, will leave because code exists/ceebs
210
ryanpennings_thesis_final_005.indd 210
The Percy Project
27/10/2015 11:04 PM
i = len(points)
#buffer to avoid matching to points just drawn buffer = 125 if i <= len(points) and i > 0 and sc.sticky[‘currentState_0909’] != ‘support’: print ‘AA’ if (i - buffer) > 0: print ‘BB’ #i -= buffer if len(points) > buffer: print ‘CC’ ### need to loop this if statement to check points, use buffer to reduce calc time as well for i in xrange(buffer,len(points)): #for i in reversed(xrange(buffer,len(points))): print ‘in loop’ print i if (rs.Distance(Position,points[i-buffer]) < tol) and m == 0 and hack == 0: #ie. what resets the reset value? something to do with current layer m=1 hack = 0 print ‘IN TOL’ support(); #currentState = checkState() #sortingHat(currentState)
The Percy Project
ryanpennings_thesis_final_005.indd 211
211
27/10/2015 11:04 PM
break
### function: decide what to do ##### options: ##### decide direction: add support or start new layer ##### decide if needs to move up or down
#sorting hat: decides what to do next #inputs: currentLayer (as sticky), supportfinished? (as sticky?)
#outputs: decision def sortingHat(currentState): print ‘sorting hat now’ if currentState == ‘loop’: print ‘thisloop’ return support() elif currentState == ‘support’: return newLoop() else: print “sortingHat can’t choose! value: “,currentState
#new layer: directs the agent to start a new layer loop. def newLoop():
212
ryanpennings_thesis_final_005.indd 212
The Percy Project
27/10/2015 11:04 PM
print ‘yeah we made it here’ #set var to new layer #enable follow path bool on & turn off supportAgent sc.sticky[‘followPath_0909’] = True sc.sticky[‘supportAgentBool_0909’] = False #sc.sticky[‘currentLayer_0909’] += 1 sc.sticky[‘currentState_0909’] = ‘support’ #next state
#support: directs the agent to produce support for the current layer #inputs: currentLayer def support(): print ‘now we are here’ sc.sticky[‘currentState_0909’] = ‘support’ #turn off followPath and turn on supportAgentbool sc.sticky[‘followPath_0909’] = False sc.sticky[‘supportAgentBool_0909’] = True
def supportMain(): if (rs.Distance(Position,supportEnd) < supportTol): m=0 currentLayer sc.sticky[‘currentLayer_0909’] += 1 sc.sticky[‘currentState_0909’] = ‘loop’ #next state
The Percy Project
ryanpennings_thesis_final_005.indd 213
213
27/10/2015 11:04 PM
sc.sticky[‘followPath_0909’] = True sc.sticky[‘supportAgentBool_0909’] = False sc.sticky[‘thisSwitch_0909’] = 0
#checker: checks to see if the agent needs to move up or down def checker(): #if need to move checker(‘up’) or checker(‘down’) return 0
#mover: moves the agent up or down if needed (ie. within support function) #enforces z height def mover(direction): #if move = None enforce z height #if move != None move in direction return 0
def checkState(): if sc.sticky[‘currentState_0909’] == ‘loop’: return ‘loop’ elif sc.sticky[‘currentState_0909’] == ‘support’: return ‘support’ else: print “error. current state: “, currentState
214
ryanpennings_thesis_final_005.indd 214
The Percy Project
27/10/2015 11:04 PM
#########################################################
main()
#set outputs currentLayer = sc.sticky[‘currentLayer_0909’] followPath = sc.sticky[‘followPath_0909’] supportAgentBool = sc.sticky[‘supportAgentBool_0909’]
The Percy Project
ryanpennings_thesis_final_005.indd 215
215
27/10/2015 11:04 PM
216
ryanpennings_thesis_final_005.indd 216
The Percy Project
27/10/2015 11:04 PM
Appendix C: Processing Scripts Introduction The processing script here was developed to remove the limitations that the Grasshopper based algorithm had, namely the time it took to generate a piece of furniture, which ranged from 1 to 2 hours. This caused problems with the time it took to iterate through multiple versions, of algorithm, and to spot errors within them. The script attempts to recreate the rule set from the Grasshopper definition as closely as possible, in order to retain the emergent behaviour and the existing developed form. This is a problem as recreating the Grasshopper definition accurately is not possible.
Shown here are two components of the script (showing them all would unnecessarily take up space). These are the main script, and the agent function where all the agents rules (follow path, attract and seek, bounce) are defined and applied.
This script was not completed by the end of this project, and this shows that coding algorithms for design is much more difficult than programming algorithms in a visual environment. The script however did show a drastic speed increase. Ultimately this version of the algorithm would provide greater control at the expense of complexity.
The Percy Project
ryanpennings_thesis_final_005.indd 217
217
27/10/2015 11:04 PM
Main_Code import peasy.*; //<>// //<>// import peasy.org.apache.commons.math.*; import peasy.org.apache.commons.math.geometry.*; import peasy.test.*; import toxi.processing.*; import toxi.geom.*; import toxi.geom.mesh.*; import toxi.math.*; import controlP5.*; Agent2 agent2; ToxiclibsSupport gfx; //create record path object RecordPath recordpath = new RecordPath(); // Using this variable to decide whether to draw all the stuff boolean debug = true;
// Processing version of stool generation void setup() { size(1000, 800, OPENGL); frameRate(200); pixelDensity(2); // for retina screens
importStrings(“curves_importgh.txt”); importAttractorPoint(“attractorpt_gh.txt”); importstartingpointA(“stptA_gh.txt”); importstartingpointB(“stptB_gh.txt”); gfx = new ToxiclibsSupport(this);
//setIntVec(); //generate_starting_points();
//Vec3D start = new Vec3D(201, 5, 0); agent2 = new Agent2(starting_points_a.get(layer), speed, force, a_mass, 90); showGimball = true;
218
ryanpennings_thesis_final_005.indd 218
The Percy Project
27/10/2015 11:04 PM
guiSetup(); pushMatrix(); //translate(width/2,height/2,0); //Peasy Cam cam1 = new PeasyCam(this, 2000); cam1.setMinimumDistance(20); cam1.setMaximumDistance(5000); cam1.setSuppressRollRotationMode(); cam1.rotateY(radians(45)); cam1.rotateX(radians(30)); cam1.setDistance(1000); cam1.lookAt(0, 0, 0); popMatrix(); }
void draw() { background(255);
pushMatrix(); // show gimball viewGimball(); //run agent if (!pause) { agent2.run(); agent2.record(); } // display agent when paused if (pause) { agent2.render(); //<>// } // draw GEO; drawGEO(); popMatrix(); // draw gui drawGUI(); }
The Percy Project
ryanpennings_thesis_final_005.indd 219
219
27/10/2015 11:04 PM
Agent_Code //new agent class, simplifed and corrected class Agent2 { Vec3D loc; Vec3D vel; Vec3D acc; float maxforce; float maxspeed; float mass; float viewAngle; Agent2(Vec3D l, float ms, float mf, float masst, float va) { loc = l.copy(); acc = new Vec3D(); vel = setIntVec(); maxspeed = ms; maxforce = mf; viewAngle = radians(va); } void run() { mSwitch(layer,loc); if (mSwitch == 2) { attract(AttractorList.get(layer), attractorLL, attractorUL, 1.453);// attractor pt, lower limit, upper limit, mass arrive(startingpointB); // error in this starting point??? contain(all_paths.get(layer),2,20); //applyForces(); } else if (mSwitch == 1) { pathFollow(all_paths.get(layer)); //(path) } else { println(â&#x20AC;&#x153;mSwitch error! mSwitch value: â&#x20AC;&#x153; + mSwitch); } update(); render(); } void record() { if (!pause) { if (recordCounter == recordcounternum) {
220
ryanpennings_thesis_final_005.indd 220
The Percy Project
27/10/2015 11:04 PM
recordpath.addPoint(loc); recordCounter = 0; } recordCounter ++; } } void update() { //Update velocity vel.addSelf(acc); //Limit Speed vel.limit(maxspeed); //Add vel to location loc.addSelf(vel); //Reset accerleration to 0 each cycle acc.clear(); }
void render() { pushStyle(); fill(#FEFCFF); gfx.cone(new Cone(loc, vel, 0, BOID_SIZE, BOID_SIZE*4), 5, false); popStyle(); }
Vec3D steer(Vec3D target, boolean slowdown) { Vec3D steer; // The steering vector Vec3D desired = target.sub(loc); // A vector pointing from the location to the target float d = desired.magnitude(); // Distance from the target is the magnitude of the vector // If the distance is greater than 0, calc steering (otherwise return zero vector) if (d > 0) { // Normalize desired desired.normalize(); // Two options for desired vector magnitude (1 -- based on distance, 2 -- maxspeed) if ((slowdown) && (d < 50.0f) && (d > 5.0f)) desired. scaleSelf(maxspeed*(d/5.0f)); // This damping is somewhat arbitrary else desired.scaleSelf(maxspeed); // Steering = Desired minus Velocity steer = desired.sub(vel).limit(maxforce); // Limit to maximum steering force } else { steer = new Vec3D();
The Percy Project
ryanpennings_thesis_final_005.indd 221
221
27/10/2015 11:04 PM
} return steer; }
void arrive(Vec3D target) { acc.addSelf(steer(target, true)); }
void attract(Vec3D attractor, float lowerlimit, float upperlimit, float attractormass) { //Vec3D atarget = null; Vec3D m2 = vel.copy(); //loc.copy(); Vec3D m1 = attractor; Vec3D f = m1.sub(m2); float distance = f.magnitude(); // should probably add roll off here... if (distance > lowerlimit && distance < upperlimit) { // G * attractormass * mass / distanceSQ float tempScale = (10 * 385.3 * 9.5) / (distance * distance); //10 * 386.3 * 9.5 //println(â&#x20AC;&#x153;tempScale: â&#x20AC;&#x153; + tempScale); //float tempScale = (G * attractormass * mass) * midDist; acc.addSelf(steer(attractor, false).scale(tempScale)); } } void pathFollow(Path p) { Vec3D normal = null; Vec3D target = null; Vec3D predict = vel.copy(); predict.normalize(); predict.scaleSelf(predict_dist); //arb predict location //set this later Vec3D predictLoc = loc.add(predict); float worldRecord = 1000000;
for (int u = 0; u < p.points.size()-1; u++) {
222
ryanpennings_thesis_final_005.indd 222
The Percy Project
27/10/2015 11:04 PM
Vec3D a = null; Vec3D b= null; if (direction == 2) { b = p.points.get(u); a = p.points.get(u+1); } else { //direction == 1 a = p.points.get(u); b = p.points.get(u+1); } Line3D currLine = new Line3D(a, b); Vec3D normalPoint = currLine.closestPointTo(predictLoc); float distance = predictLoc.distanceTo(normalPoint); if (distance < worldRecord) { worldRecord = distance; normal = normalPoint; Vec3D dir = a.sub(b);; dir.normalize(); dir.scaleSelf(target_dist); target = normal.copy(); target.add(dir); } } if (worldRecord > p.radius) { acc.addSelf(steer(target, false)); } } //ADD the contain function here... almost finished void contain(Path p, float predict_dist, float target_dist) { Vec3D target = new Vec3D(); Vec3D normal = null; //scale predict distance ahead Vec3D predict = vel.copy(); Vec3D inVector = vel.copy(); predict.normalize(); predict.scaleSelf(predict_dist);
The Percy Project
ryanpennings_thesis_final_005.indd 223
223
27/10/2015 11:04 PM
//add it to the current location Vec3D predictLoc = loc.add(predict); float worldRecord = 10000000; for (int u = 0; u < p.points.size()-1; u++) { //points for line Vec3D a = p.points.get(u); Vec3D b = p.points.get(u+1); Line3D currLine = new Line3D(a,b); Vec3D hitPoint = currLine.closestPointTo(predictLoc); float distance = predictLoc.distanceTo(hitPoint); if (distance < worldRecord) { worldRecord = distance; //calc normal direction normal = new Vec3D(); Vec3D lineVec = a.sub(b); lineVec.normalize(); Vec3D lineVecRot = lineVec.rotateY(radians(-90)); // change this if going the wrong way... lineVecRot.normalize(); lineVecRot.scaleSelf(5); normal = hitPoint.add(lineVecRot); if (debug) { pushStyle(); stroke(#F72F2F); line(normal.x,normal.y,normal.z,hitPoint.x,hitPoint.y,hitPoint.z); popStyle(); } //Calc bounce vector normal.normalize(); inVector.normalize(); Vec2D normal2D = normal.to2DXZ(); Vec2D predict2D = predict.to2DXZ(); //predict.invert(); Vec2D tvec2D = predict2D.getReflected(normal2D); Vec3D tvec = inVector.getReflected(normal); //using lineVec works... of course it needs reversing (dodgy fix?) // I donâ&#x20AC;&#x2122;t think the normal finding code is working properly... //tvec.invert();
224
ryanpennings_thesis_final_005.indd 224
The Percy Project
27/10/2015 11:04 PM
//tvec = new Vec3D(tvec2D.x,loc.y,tvec2D.y); tvec.normalize(); tvec.scaleSelf(target_dist); // check if hitpoint is in view?? //calc if vector is in view Vec3D AngHitPoint = hitPoint.getNormalized(); Vec3D AngDir = inVector.getNormalized(); float angleBetween = AngDir.angleBetween(AngHitPoint); if(angleBetween < (viewAngle/2)) { target = hitPoint.add(tvec); } //target = hitPoint.add(tvec);
if (debug) { //println(“hitpoint : “ + hitPoint); pushStyle(); // Draw predicted future location stroke(0); fill(0); //line(loc.x, loc.y, loc.z, hitPoint.x, hitPoint.y, hitPoint.z); line(hitPoint.x,hitPoint.y,hitPoint.z,target.x,target.y,target.z); pushMatrix(); translate(hitPoint.x, hitPoint.y, hitPoint.z); //sphere(1); popMatrix(); } } } if (worldRecord < 1) { print(“hit a wall”); target.scaleSelf(50); acc.addSelf(steer(target, false)); }
} }
The Percy Project
ryanpennings_thesis_final_005.indd 225
225
27/10/2015 11:04 PM
ryanpennings_thesis_final_005.indd 226
27/10/2015 11:04 PM
ryanpennings_thesis_final_005.indd 227
27/10/2015 11:04 PM
ryanpennings_thesis_final_005.indd 228
27/10/2015 11:04 PM