FORM FINDING with Kangaroo Physics & Grasshopper

1. Course Introduction: Hello and welcome everyone to the form finding with kangaroo physics course, my name is Whatsapp. I'm missing architect, parametric designer and BIM Manager. With many years of experience using a teaching 3D modeling software and parametric tools. My first experience with kangaroo physics and grasshopper was during my master's degree in the USA. I have been since using parametric tools on a daily basis, solving complex geometric problems and streamline strategy, and providing early design solutions while combining them with BIM using Rhino inside Revit, as well as other parametric tools. My teaching passion found its way first at the FabLab Berlin, as well as other design companies, institutions and universities in Germany and Europe. Participants from all over the world with various design backgrounds joined my courses and benefited tremendously from them and are able to implement their knowledge in their studies and professional career. The course is divided into eight units, starting from beginner to advanced levels, you will learn not only what kangaroo physics can do, but also how to use it as digital lab simulator or forms with real-life case studies of notable projects, including Friar arrows, the inside membrane, and Heinz East layers, thin concrete shells, as well as how to simulate origami patterns and much more. The total length of the course is around 10 h. I highly recommend practicing daily, since the best way of learning it is by doing, making mistakes along the way, understanding how it works and learning from that to reach new levels. You will be able to download all the course files that include detailed explanations as well as all the components, practical examples and exercises. Whether you are an architect, engineer from all fields. It is added from all fields, including but not limited to product design, jewelry design, fashion design, graphic design, or a student of these fields, kangaroo physics would be a great addition to your toolbox and it will push your design abilities to a whole new level. Alright? If you want to learn how to use this amazing parametric platform that on board. And let's get started. 2. Understanding the difference between Form Making vs Form Finding: Hello and welcome everyone to the form finding course with kangaroo physics. In this course are going to learn more about kangaroo physics, which is a plug-in to grasshopper, which is itself a plugin to our restaurants 3D. So kangaroo physics actually includes a lot of interesting tools and components that would help us find forums parametrically speaking. Now, before diving deep into it, I'm going to first show you the structure of the course, which is composed of units. And you have already access to these files. And so for every unit, we have a rhinoceros file around a file as well as the grasshopper file. And inside of each grasshopper file, there are the parametric definitions that includes the kangaroo components and elements that are accelerated to the definitions themselves. Now, before starting with Unit one, please allow me to explain briefly about form finding. And what is it exactly about? I will open now this folder here. Alright. So first of all, there are two main design principles in architecture and engineering and in other disciplines. There is the form making and form finding. With form-making already have an idea. The general idea about what we already have, a certain shape or a picture, our imagination. And we simply want to draw it to make a quick sketch out of it. So the knowns with the form-making would be the general shape and an initial number of elements, e.g. and then for the unknowns, on the other hand, are dimensions of the elements there, thicknesses, they cross sections, etc. Usually we start with a sketch of lines to form a basic shape. And afterwards we start developing sketch by defining certain thicknesses and dimensions. And then after that, we search about the loads and forces involved in order to know what is required. What is the materiality of each element? Is it made out of concrete or steel, or is it a wooden beam, etc. That is how we develop the design in order to reach the final shape of the geometry. However, with form finding, there is no given form or shape. So we cannot simply start drawing anything before because we don't have the form yet. So it's basically the opposite of form-making. With form finding. The knowns are the positions of the supports or anchoring points or elements as an initial idea, the loads or weights involved, and the materiality of the geometry. So the unknown with form finding is the form itself. Alright? So knowing the basic difference between form-making and form, finding, the traditional drawing tools in architecture, engineering, and other disciplines. The drawing tools that are used in both analog and digital methods are no longer helpful or applicable. Like using the pen if sketching by hand, or using the cursor of sketching digitally. Such tools are good with form-making. We use them to draw the forms of objects, but you cannot use them now to find forms of objects. With form finding binaries in that field need, needed and used to Hank chains or they used to hang membranes in order to find the forms. They did not initially start with a sketch. So instead of sketching objects with a pen, they replaced the pen with study models. So they will start with a model that is fixed to certain base, e.g. it will be made out of maybe metal chains or a certain memory membrane. And they would find the form with the help of such study models. And then they would draw it afterwards. So it is an inverted process where the starting point is the model itself and not a sketch drawing. During the webinar, we're going to visit some case studies of a couple of pioneers in the field of form finding like Heinz easily and Frei Otto. And we're going to replicate a few projects using Kangaroo physics. I'm going to show you an example of form making. This image. We see a concrete bridge. This bridge as a result of form making and not form finding. Let's observe the elements of this bridge. Understand why it is the result of form-making. So first of all, we start with a deck. You can see this concrete deck element that supports the vehicles. This is the main element of the bridge. We know that we want it to be there because of connecting two points, for instance, two holes in this case. And then here it looks like there is like another road and then another also really like a small river. Maybe. We know that we cannot have the column on that lower road and in the water. You also know that we need a number of elements, the number of columns that support the deck. Basically. We place them with initial spacing layout. This is the initial sketch of the bridge and form making. And then after that, we start developing the elements, researching as the amount of vehicles traveling on the bridge per second, what loads are to be expected on the bridge, accounting for potential rain and snow, etc. Then based on this information, we start developing the cross-section of the deck. The thicknesses of the beams are required to hold it if thickness of the columns, etc.. And so with this method, the design is developed knowing that first the location of the deck, the height of the columns, preliminary spacing that we consider avoiding the lower river and road and the river. The general shape or form is already known, but not detailed yet to be structurally working. Now I'm going to close this picture and open this one. Here we can see one of Gaudi's iconic Sagrada Familia cathedrals study model. The model is Bay is built by using weight bags. There. The way that you present the loads that are hanging from above an anchor to support points at certain points. In this case, the model now is inverted, basically that's how it is. And the weight bags are pulled down by gravity forming inverted catenary arches. Now if we flip the image, let's look, check out how it would actually look like this. How is going to look like? This is the resultant reversed building. You can see the arches. On the left. You can see an image that is taken looking upwards. And you can see that the columns are not straight, but they look more bending. The columns are actually following the shape that was given by the inverted model. It is a direct result of this model. I'm going to bring it back to the original orientation of the image. This is another example of gallery study models, where we can see the kitchen arches that are formed by the hanging chains without using the weight bags. So the form is found using only the chains and the support points. If I now rotate it, this is how the building would look like. So there are two quick, so these are two quick examples showing Gowdy's form finding strategies. Let's look at some of Heinz Easterners examples. This is an interesting image showing the process of finding the form of a concrete shell structure using this model basically, you can see here the anchor points or the support points that then the shape. He uses a tensile membrane and plaster which we presented the concrete shell and mimic the concrete behavior. Then afterwards we get the resulting shape. The shape, which can then be drawn. So we don't start with a drunk sketch, but rather with the model. The sketch model basically that leads to the shape of the geometry itself. Once having found this shape, then it can be drawn on paper or digitally, and then extract the respective sections and then plants, etc. Now, having had a brief overview of both design approaches, I would like to quickly talk about the Roman arch and its relation with the topic of form finding. The Roman arch is actually based on this semicircle, this perfect semicircle. So we start with the drawing, we start with this shape and then we'll reinforce the built Arch with walls and buttresses. You can see here the direction of the loads and then the function of the wall prevents it from collapsing. So just to make it work here, the starting point of the drawing and designing the Roman arch is first the shape, a perfect semicircle. And then afterwards we develop it, making the loads and we're forcing it with supporting elements such as the wall and or buttresses. However, the opposite of this design principle informed finding is the catenary arch. So we'll actually start with the simple chain, which is hanging under its own weight. Basically. It's only supported at its ends and it's made of elements that can rotate without any bending resistance. It is just hanging freely downwards. And this will actually give us an optimized arch shape. I'm using this optimized shape. Then we can flip it to find the form, which is in this case the catenary arch. The benefits of finding the form of the catenary arch is that it reduces the bending moment, which is usually preferable by structural engineers. And also uses materials in an optimal way, reducing the use of unnecessary material and thus saving on both material and costs. So in comparison with the Roman arch, there is material that is added, adding a structural backing in order to make it work. To make the arch stand while having the perfect arch or semicircle. However, with the catenary arch, there is no need for additional material as the shape supports itself with compression, as it is, as we have it now. So this is a quick explanation showing the difference between the Roman arch and the catenary arch. And why are they different shape and how that affects later on the building process. So I just wanted to have this quick introduction about form-making versus form finding before we dive in kangaroo. And also, I found this interesting image while researching and finding materials for the course. In our daily life, we often pass my examples of catering arches. This is a simple example of a catenary arch chain that's supported by two poles and hanging under the load of its own weight. Basically, the chain connections are not subject to any bending, but they can only rotate freely. So this is the resting result of the catenary arch or chain. You see it is not forming a circle like that of the Roman arch because the points are spread out that much and we just get this shape out of because of that actually. Alright. What else? We're going to look shortly at how Hooke's law is applied inside of kangaroo. With few examples and simulations and try to double check those simulations and results with real physics equations. Alright, so I'm going to open unit to one Rhino file. Alright, and these are the latest. Want to extend this a bit? And now let's open the grasshopper. I'm going to just drag and drop Unit One. Grasshopper file. Can crew introduction. Alright, so this is unit one. And basically each grasshopper file has its rhino parent file and both have the same name so that you find them easily. And inside of each grasshopper file, structured by topic basically here, e.g. in your PT one file we have Hooke's Law inside of kangaroo than catenary curve, then what about kilograms and the pendulum swing, etc. So instead of every grasshopper file, the topics are highlighted by title and then the explanation is underneath. And later on. After the webinar, you can go back to these explanations and examples and even use them. Check what was covered, et cetera. You can go back to these and you can test them, make copies and change them. You can even change this. You can copy this to the side and then change it and play with it, tweak it, et cetera. It's for your own benefit and use later on when you want to revise any topic. So now we looked at for making versus form finding. And what's the main difference between these two concepts? Now, what does kangaroo, how does it work? Kangaroo is a live physics engine for interactive simulation from finding optimization with constant solving. And this is the main website where you can download it from. It is food for rhino.com. And I'm going to open the upside here. So this is the website where you can download it from. And it has a lot of versions like previous versions are going to actually be using two versions simultaneously. I've already installed kangaroo 2.42 and can groove physics 0.099. They are a bit different and they include mostly similar elements. However, some elements that are in this one can grow physics 0.099 are not included in the latest one. And also the way it works, slightly different how the components work together. I'm going to show you what I mean by this. Once we dive into it. Also, please keep in mind that kangaroo is not a structural analysis tool that calculates deformations or stresses inside of geometries. It is rather similar to a physics lab where you can simulate the elastic behavior of geometries, such as cables, membranes, et cetera, to predict the resultant shape through the form finding process. So in other words, it will simulate the equilibrium state of a shape by applying certain parameters that we set. E.g. gravity forces, anchor points, wind forces, etc. And then the resulting shape will be like the funicular geometry that has reached equilibrium or stability state under the applied forces. And in order to find the equilibrium, kangaroo applies Hooke's law to a particle spring system that we set. I'm going to show you soon what I mean by that. So note, since Kangaroo does not consider all physical aspects of objects, like material properties such as density or elasticity. It is not perfectly precise. Further studies about the materials properties would be than necessary. What is great though about, about it is that it's very fast at a free tool that gives you an early draft generation of funicular geometries. And so what we're doing in kangaroo is mimicking the work that is similar to Gowdy's studies, e.g. or similar to Heinz Easterners studies. We don't have the exact data of this model, e.g. the concrete or steel reinforcement. What we're trying to replicate the model by simulating the shape as an early sketch, as an early shaped study, basically, an early geometry study. The building itself is not going to be made out of chains obviously. But this is like a quick model that will actually show us, predict to us how the shape would look like by mimicking the behavior of chains, but now digitally and not analog way. So I already mentioned about the two versions of kangaroo from here. Let's check it out. Basically the main difference between both kangaroo 1.2, I'm going to maximize. Now the window here. I'm going to activate the type of kangaroo one. Firstly, the organization of the components. So you can see here under kangaroos main tab, we have just four sub-tabs. Forces, all the forces available that you can use. Then kangaroo sub tab called kangaroo, which includes the kangaroo simulators, anchor points, and few other elements. Then we have the mesh sub tab and the utilities sub tab. While with kangaroo two, now, these forces have been subdivided into more categories. Like these for structural studies, beams, rigid bodies. Then here we have angles, then call for co-planar or circular or collinear constraints, etc. And then we have the collision sub tab. And here we have a sub tab for lines or springs, then here for meshes. Then goals on meaning constraints, elements containing elements are on curves, are meshes, etc. Then we have points, anchor points, etc. Here, this tab is called main. It includes the main kangaroo simulators. And here actually we have more simulators than the previous kangaroo one. In kangaroo one, we only had two, which are kangaroo physics and zombie can grow. While in kangaroo two, we have now bouncy solver, soft and hard solver, solver, step solver, and the zombie solver, as well as the new grab component, which you are going to use soon. We have here a sub tab for meshes and utilities. So the first difference is the organization of components. The second one is how the simulator is actually work. 3. Kangaroo I vs. II & Hooke's Law Part 1: So are going now to look at three examples and show you the difference between the simulators, between kangaroo one and Kangaroo to simulators. Alright, I want to try an example as a proof of concept of Hooke's law, how it works inside of kangaroo. Because I said that kangaroo is based on Hooke's Law. And it is actually based on it. I mean, it just, it just uses it actually to make the simulations. So the physics of kangaroo actually work based on this law. That's what it is. I will zoom here. I took this passage from this website. So Hooke's law is a principle of physics that states that the force needed to extend or compress a spring by some distance is proportional to the distance. This can be expressed mathematically as F equal to minus k x, where f is the force applied to the spring, either in the form of strain or stress. X is the displacement of the spring. So much it stretches with a negative value, demonstrating that the displacement of the spring one stretched. The k is the spring constant and details just how stiff it is. This difference of the sprint basically, this is the diagram, a diagram showing the spring when it is at rest. And then when a force F is applied to it, there is stretching one X and one of the force is applied twice, then rushing to x. This is the basic definition of Hooke's law. Now let's try to apply this using Kangaroo. If we were in the lab, would need is real spring with the real weight. However, let's try now to see how can you rule, can actually do that for us. But now, virtually example, a 50 newton weight N is four Newton. And here I'm using a Newton unit because this is the unit used in Hooke's law. Basically. And later on, I will also use kilogram. Kilogram is because we're more familiar with kilograms and not Newtons. We don't usually use the uterus and the daily life, but these are proportional. And in the case, so here I'm saying that we have a 50 Newtons weight connected to a cable. Actually, I would say spring because I mean, which has a length of 100 mm. This difference of this spring is five Newton per millimeter. Alright, so these are the difference. According to Hooke's law, F is equal to minus kx. But I'm taking the negative out so that we don't confuse ourselves with negative distances or values. And let's just say that F is equal to x k. So if we know the following, the force applied to the spring is 50 Newtons and F is equal to 50 newtons k. The stiffness of the spring is five in Newtons per millimeter. The length of its rest is at 100 mm and x is how much it would actually move is missing. And so based on this equation, F equal to x k, then x is equal to F over k. So x is equal to F over k, which is equal to 50 newtons divided by five Newtons per millimeter. And then we end up with 10 mm. We can also use centimeters or meters or any other units. Here. For this example, I'm using millimeters. And so if I now draw it here, this is the spring. Alright? Now, we need to translate this equation into kangaroo components. Basically, we have to extract from this what we understand as components or to find these components, put them together and then try to simulate that with kangaroo. Result of the equation is 10 mm. So the spring should stretch, be stretched by 10 mm. And so the final length is going to be 110, right? That's what we get as from the equation. Now, what are the givens? What do we need to start with M kangaroo in order to start the simulation? First, we knew that the spring here, it is attached to a point basically. So this point is an anchor point. I will sketch this. We have here a starting point. I'm going to call it a. Alright, that's the first step. We have this spring itself, okay. We have this geometry here. This one. I'm going to call it S. And we have the weight. We have 50 Newtons, which is the weight. So we have another point. Let's say this is W for weight. Alright? So we have these three ingredients for the simulation that you want to apply. So let's now try to gather these components. I'm going now to push this back here and then push this here. Alright? So we need a point. We need first point that is, that represents a, which is, which actually means that the anchor point, in this case, for this spring we can start with as a geometry. Now, in Grasshopper, we can say that it is aligned a simple line. We need a weight. The weight is also another point. These are the basic ingredients. And then we want to put these together in order to make the simulation. So what I've done here, I'm going to bring these here. So to build the point, I first use the construct point component that is coming from vectors. Point, construct point, this one. I just wanted to say that actually what happened is that for some reason I wasn't able to see the preview of the point in front view, but I was able to sit in top or perspective views if that happens. Because sometimes it may happen that with kangaroo, we just need to make a new viewport, basically to solve it, right-click and select new viewport and set the view to front, e.g. then now it appears. So this may happen sometimes. Free to solve it. You can apply this solution. However, I'm not the case. So we said that we have these three ingredients to start with. I started by making this construction point and did not give, give it any value for x, y, and z coordinates. I keep it at 000 origin. And I built a line which is 100 mm. Make sure that your rhino files units are in millimeters. I move the point with unit z -100 downwards. So what done is by 100. And then I have the line as a resultant. So this process, what I'm doing now is to go from a theory to the geometry, to use this geometry with kangaroo. And this is called discretization, which means transforming geometries into discrete counterparts basically. So we can now use these ones. Now, once we have the line e.g. which represents the spring as a first step. The second step, we want now to find components inside of kangaroo that actually worked for us to convert the line into a spring or just to consider it as a spring. I will expand this a bit. Alright, now, using Kangaroo 0.099, Let's go to this tab. I'm using here. This component, springs from line to create the Hooke's law springs. This is what I've done here. And let's now check out the inputs here. For the line. In order to convert it into a spring, we need this component. So the first input is the connection, the curve or the line. So a line connecting two points from the springs to act between. So this is the line, the stiffness. So remember that actually in our example, we said that is stiffness of the spring is five in Newtons per millimeter. So it is five. We don't need here to add the units newtons per millimeter, just the value itself five. You can also use a number of stator or another value input type if you want. That's really up to you. I'm going to keep the damping at ten as default value without changing it. Also, the upper cutoff and the lower cutoff. At plasticity. Going to change any of these inputs. I will only connect the value of the length to the line. The rest length, which is hundred. These are the main ingredients of the starting point of the spring. It's 100, the rest length, length, the stiffness of it. It's five. And this is a spring, the line which represents the spring. You don't need to model the form of the spring itself in 3D camera understands the line, in this case as a spring. And that's why it makes it, it makes life easier for you to do that. And that's what actually the name of the component indicates, the springs from line. So converting lines and two springs. Now, the first, the first step, now the weight w, The point is actually the second point, The end point of the line. So we have the line, we have the point here. And then for this, I'm going back to forces. And here I will use the urinary force. And if we go back to the width and hover, it says a vector force acting on a point. That's what it does. Okay, I brought this one here. So this needs a point. So even though in reality it is a sphere, like this example. But in Grasshopper, we're not going to use a sphere, but just a point, just to represent that weight. And so forth. The point or using a unit of force. And for the force input, It's a vector. The vector basically here, I'm using unit Z vector -50 because we said here that example, it's 50 Newtons weight is pushing downwards. And so I'm giving it a negative value -50. Alright? Now, if I did not give it any input, just free to know as general knowledge when you check the input in this component without giving it any value. By default, the force has a vector of 0x0y and the Z direction. It's -9.8. And this represents the gravity, the gravitational acceleration force. And by default, it's given like that as if you want, let's say to apply a force that would represent an object that is free falling under the gravitational force only. And also from the website extracted the definition of the gravitational acceleration, which is our crops approximately 9.81 m per square seconds. Which means that ignoring the effects of air resistance, the speed of an object falling freely will increase by about 9.81 m/s every second. So this is a standard value given with this component and kangaroo, but we can now ignore this for now. And in this example, the springs is not free falling, but only has a weight attached to it, which has a specific Newton value of 50. Alright, so we have the spring. This one converted the line geometry bent to kangaroos language, it kangaroo component. We converted this weight with a unitary force that is done. Now what you are left, we're left with is the anchor point, and this is the first starting point. The starting point, I used this point component just like a shortcut and I called it here anchor point. Okay, So these are the three ingredients that we have to start with to run this simulation. Now for the simulation, we need the component that would simulate for us the spring situation. I just got the kangaroo physics component. And this is it always, as a rule of thumb, flatten the first two inputs, the force objects and the anchor points to make our work organized, I always also put all of the forces together with emerge component. I connected these springs from lines and the unit of force. Now the anchor point with kangaroo 0.099 is not considered as a force, but already, this simulator has anchor points input. So just give this anchor point to the input basically. And so we have now the two forces. The spring from lines have the properties of springs with a stiffness of five and Newtons per millimeter. It is not like a normal cable. So this force, this force are given to the input force objects. The anchor point is connected to the anchor points. Input settings will not change. I will not eat anything in here. For now, the geometry input, so I hover over it, it says geometry to transform. It is the line, not the springs, but the line. The original geometry that we started with. So don't confuse this with the spring. This is the line, this one. Then the output. Now we're going to see that it's going to be like the line here. The particles out are the points that are given, et cetera. Now this simulation reset, the final input is reset. It needs a Boolean input, either true or false. And so it tells you through to input the setup false to run the simulation, which means that simulation reset through. So please don't do anything, just keep it as reset. When I double-click on this, I will make it false. That will now run the simulation for me. And I also need this trigger. Right-click. Go to intervals on this one. Select ten milliseconds. You can also change these later if you want. But I just like, you know, usually use this one. And so we said this, this value and then just click, click and drag from this dark grayish and onto the Simulate. And then it attaches itself to the play automatically. I'm going to delete this one and keep this one. What I'm doing here is I want to check the length of the line at the output. So now the geometry output of the simulator is defined by the geometry input, which is the line itself. Will also have the particles out output, which includes the starting and ending points and the resulting line. And I can also make out of them two spheres just as a visual or graphical presentation. But this is not really needed for the simulation. And now we can see that the rest length is 100. So now let's see what happens when I run this simulation. I will activate the Boolean. You see it's moving downwards. Since I have the panel showing the curve length changing live, it looks like it's reaching 100.999, 110. So this is what we expected from this equation. Based on Hooke's law. Given this information, the spring, the length, the weight applied to it, the stiffness of it. We get this result, the final length being 110. So this is basically a proof of concept that kangaroo physics now is applying Hooke's law with these forces to this geometry, to this line. Basically. Alright? So this is what it is interesting. Now, e.g. if we miss some of the inputs, so e.g. if, let's say I missed to give the anchor points as an input, what would happen? What do you think it would happen? Let me just now re-size it. I'm going to make it true. So I reset the simulation. I'm going to take this out. Let's say by mistake, we were building this definition and you have lots of inputs, but then you miss this input for some reason. What do you think it would happen? Let us now check, if I double-click to run this simulation to make it false. Oops, it falls down as if there was no anchor point basically. Now you see that even if with this, the length of the curve is growing, but really slowly, there is no anchor. Okay? This is interesting. What is remarkable about this is that kangaroo is not telling us, hey, it is wrong. It is not like this turning into a red color. Usually you would expect that sometimes grasshopper, or most of the time and grasshopper, when we are missing an input that is needed or necessary for the simulation, when you're giving a false input, then it becomes red or orange with a warning message saying, hey, something is wrong, something is missing. You have to still give an input. Here. We miss the input, but it's still, it's still runs the simulation, which I think is logical. It's working. It's applying the forces and just working. We don't have an anchor because maybe we don't want an anchor. Sometimes you have a situation where e.g. we don't have any anchors, basically, it's working. What if we had already an anchor? But we don't have a force, the unit of force. I'm going to take this from this merge. So we have the spring from line. We have an anchor point. What? We don't have any force pushing it downwards. If I now run this simulation, I think happens. Even these springs length is always addressed. Why? Because nothing is pushing it downwards. And I'm not telling it now that there is actually gravity. It is not considering anything except for the forces I am feeding it with. Springs from line. Okay. Fine, thanks. That's it. We have an anchor point that's anchored there. Alright. What can I do more for you? Nothing. I mean, that's what we have, right? Even if the anchor out, since this is starting as a line, and then there is an output, this output. And I turn this false. Okay? Our only solution, but now it's simulating something, what is not doing any change? Because nothing has changed. There is no force pushing anywhere. What if I bring back the unit of force? And I take out the springs from line, what do you think would happen if I do this? So what's happening now is that we have an anchor, anchoring the point. We have a force pushing downwards, but we won't have any springs. We don't have any stiffness as if there is no spring to the cable with zeros stiffness, basically that's what it's going on. If there is no force that is pulling it together. In other words, and that's why there is no force pushing downwards. Basically, it's stretching. Length of it is going crazy. And thousands now 4,000, it's going forever. That's what's happening now. I'm going to reset it. And so now we understand this is actually a force pulling the line together as if it was spring with a certain stiffness. Now, we just saw that if we don't have any spring given, and we run this with a unitary force pushing it downwards. We get this as a result. What if we do this again? But now, instead of the current stiffness of five will give it a stiffness of zero. Let's try that. Because I just said that we don't have any input given. That could mean that this difference is zero, right? So let's try that. It's going also as if there is no force putting it together in a way. It looks like it's slower, but it's going without stopping or slowing down. You see as if we have this spring, but it has zero stiffness. So it's not stopping it, just increasing the stretch. Here, we can just play with it. So if this difference was zero, that means that it will stretch continuously. If, let's say now becomes like, it becomes like a game where if we play with the input, let's say ten, then 50/10 equals to five. So that means that the resultant would be 105. If I change the stiffness to ten now and run the simulation, I will lose five. That's what we would expect. It's looks like switching something. You see it's applying Hooke's law. Again. That's what's happening. Just a proof-of-concept that just doing that, applying it. Okay. I'm going to reset the simulation. And I'm going to bring this back to five to match our example. Now, I'm using here kangaroo physics with the simulator. Okay, if I use the zombie kangaroo, you see here it has a similar inputs, but not the same, not all of them the same. So if I flatten this one, and I flatten this one. And if I connect these ones here, the anchor point here, the geometry, the line. I won't change the threshold and iteration will also keep it unchanged. I will also copy these in order to test our result geometry out. So what, what is, what is meant by a zombie kangaroo? Zambia Islamic kangaroo means that it's not going to show us any bounds or iterations. This is what it's meant by it. Islamic kangaroo means that is not going to show us any bounce or I iterations. This is what, what is what is meant by it. So zombie kangaroo means a non-life version To be used without the timer. You see, I did not give it any timer. And so it either performance a set number of iterations or continuous until an energy threshold is reached. And this means that it will give us the, directly, the final result. But here you see that did not reach one of the ten exactly. Remember this one? When we did that, it reached 110 exactly. Waited for it. And then it's Wonderland ten. And then you stop there. This one did not do that. So here you either have to tweak these inputs to maximize duration and then threshold. Or you have to be careful about that. If you don't find the optimal result, the equilibrium for this example, let's say with 2000 iterations, That's the maximum iterations that this component is using. Now, if I just try to change it to, let's say I don't know, 10,000. It didn't do any change. If I change the threshold here, it's currently 0.1. If I say 0.001. Okay, became bigger. It was 109.65, now it's 109.9. If I also make this even smaller, we get even a higher value, 109.99. So you see these are settings that were set correctly. You would actually get directly the final result without having to wait for it. If you don't want to wait and see the bounces off, I personally like to see how it's bouncing and sometimes going back and forth. And you may like to see that happening. And not directly the final result. It's really up to you. I just wanted to let you know This exists as an option and that it will give you directly the final result. But be careful that it may not be 100% accurate or matching what you would get with the normal solver, the kangaroo physics. And this is always about kangaroo, 10.099. We're also going to look at these ones from kangaroo two. Alright. I'm going to move this one. I think this now pretty clear for us using this example. 4. Kangaroo I vs. II & Hooke's Law Part 2: Now let's use the same example. But now with kangaroo two, I will stretch is maximize it. And here I'm using is actually the same. So the same steps here. So construct point moving downwards by 100 mm, then making the line that's the same. Alright? And here for kangaroo too, there are small differences. If I bring quickly the standard normal solver. I'm not going to use this one here. But you see that if I just put this one side-by-side with this one. So this is just above this one. You see that we have here gold objects versus force objects. Because these are now called goals. We don't have an anchor point input. So they're good points with kangaroo two are actually considered as a force component. And I also think that it is now more logical. The act of pushing the objects or geometry, or trying to keep them there as if they had a force of keeping them. They're maintaining them in place. And other words, that's why anchors became goals and not the secondary input. Also, there's no geometry and put anymore. So in order for us to see it at the output, we would have to use a new component called show. We have a reset input. The threshold and tolerance here are not changing. And then the on which replaces simulation reset. Now it's called on and now the opposite is actually the opposite. So if it's set to true, kangaroo will continue to iterate until reaching the given threshold value. If it was true, it would start at, if those false, it won't start. But here, if it was false, it would actually start. So if it was true, it will not start is the opposite of it. So here's the simulation reset true. So it is set to where it is, reset it to zero. But here with Kangaroo to it is the opposite. So when it's false, it's saying, Don't start, don't simulate. But when it's true, run this simulation or simulate, which I also think it's more logical and makes a, makes it more intuitive for us while working with it. I'm going to delete this one. And then first, before showing the simulation, I tested here all of the solvers of the new kangaroo, the different solver types. But before doing that, let's now try to find these ingredients that were actually used with kangaroo 0.099, but with the new one or you can go to two or 2.42. And so this is actually coming from here. Anchor, anchor goals point, anchor, this one. And this one, it needs a point to be anchored. Actually, I'm going to, let's see this off. Alright. So the anchor is the point, as we said before. Now for the springs from line component that was coming from Bengaluru, one there from forces within grew to it is actually called length from goals line. So it is the length of the line. So as if now to make things a little less confusing than before, do you remember when we were saying that, Hey, we don't have to draw it as an actual spring, but this will actually be converted to become a spring. Here, kangaroo two, it has a different meaning, but the inputs are the same. So that's the strength which represents the stiffness. It has a length, arrest length, and it has the line input. The output is a spring, but it's not called Spring. The output, the components called length line. Output however, presents a spring. The main difference is in the naming, but it's doing the same thing with less inputs. So here we have connection, the line, the stiffness, damping, rest length, upper cut off, lower cutoff plasticity. Here only have these inputs, the line which was previously the connection. So the line, what is our line? The length of it, which is the rest length. When you hover over it, it says length. If not provided, starting length would be used. Okay? Actually, even though knowing that I'm feeding it with the length of the line itself and the strength. So the strength, which was called previously stiffness. I'll bring this back to 5.4. The only force, remember the unit of force that was pushing downwards. Now it's called load. And actually it is the same icon. By the way, it's under goals point. Is this one load while there before it can go to one. It was actually here and it was called the unitary force under forces. And you see the icon is the same. Basically. So goals point, load, alright? So this load needs, while before it, it had actually only two points, only two inputs, the point and the force that is pushing, and then we're in whatever direction of the vector of the force. Here. Not only we have that one, but also weighing. So we have the point, okay? The second point, which is just given as an input, we have the force vector, which is exactly what I've given here before, Unit z -50. And the weighing is a scalar weighting factor. For most purposes, you can leave this as the default one dot zero. I'm going to also leave this there. I'm not going to play with us anymore. But you can later on use it and try to play with it and then check out the results. But for now, let's keep this here. Alright? And also for the anchor, there's something else for the anchor. Before it was only like a simple point. You see the input of this in the simulator in kangaroo on. It only needs a point to act as an anchor. But for the NCL component now, this coming from Kangaroo to this one, it is not only a mere point, but actually there is a point input, it has a target. And you are actually going to see this later. So it's location to pull the anchor tool. If left empty, the initial location will be used. For now, we're not going to move the anchor around. We're going to keep it where it is. Alright, so that's the origin. But actually we can play with this. And later on, I will show you in the next units that you can start with anchors where they are, let's say starting position. And then during the simulation, in the middle of this simulation, we're going to move these anchors around. We're going to stress the membrane and play with it. This for you to know. Emily, strength, because the anchor should actually not move, right? The point, I don't want it to move anywhere. So that's why I'm giving a really high number as a strength. And in this case I'm giving it like 1 million as a value. So there's 1 million newton per millimeter as the stiffness of the anchor. Alright. I don't have to call it stiffness. Actually, I'm going to leave this out. It is an anchor point that has the strength of 1 million. Basically. That's what I'm giving you here. And you can actually give it maybe 10,000. It works. But just to be on the safe side, I prefer to give it a really high value. Sometimes it may happen that if you are, let's say you have like a big project and you might move less a few millimeters something. If the object is too big or something it might happen. So that's why I prefer to be on the safe side and give it a real high value. Now, what is new additionally in a kangaroo too, is as before, we have now many more solvers than before. It can grow on. We only had two, physics and zombie, but now into the two, we have all of these except for the grab and show. All of these are solvers. And I'm doing here is actually to show you the difference between each of these using the same example. So we can see the difference I'm using here. For instance, this one is the solver, the normal solver. This one is the bouncy solver, which is this one. And then you see also the icons of them. They show what they will be doing. For the normal solver. There is a simplified kangaroo icon. You see this kind of small red curves and it is bouncing in a way. This one as the zombie solver. And then the last two here I'm using are the steps solver, which is this one. This one. And then you see here like a film strip showing frames representing steps. And the soft and hard solver, which is this one. Alright, so most of these actually have the inputs that need a reset and on and off. In this case, the reset is used to reset the solver as a button. And the on and off now are different. So the action is the opposite of previously when we had this and kangaroo one. This Boolean toggle for the simulation recent. Remember this one that was true for reset and then false to run it. So now it's the opposite as we, as we said, false means to turn it off. And then orange threw this on just to run it. Alright, so what else? We also now don't have anymore the geometry input. We saw that the anchor points now have been replaced with the anchor, this one, but now also the geometry input here. We don't need it. We don't need that anymore actually. In the next sessions, I'm going to show you we would need something sometimes to use this show component, which is a new component and into r2 that replaced the geometry input without needing to input the geometry itself directly into the solver. But it would be part of the goals in any case. So we have these and the outputs of them. This one For the goal option, output three, which includes all of the geometries except for the points, this v for the vertices or points, and this RI for iterations. So this is the normal solver. As the reset input, we only need the goals from the merge, the reset button, and the Boolean toggle on and off. For the bouncy solver, we have this, but then with few more options for damping. And for the, for the zombie solver. It actually doesn't need any button, only the goals, and then it just runs automatically on its own. The steps solver, it's going in steps, so we will see how we can actually use it to animate options. And then this one for soft and hard solver, we're going to dive deep into this one. Here you can separate your goals between soft and hard goals. Basically, that's the main idea of this one. In any case, let me go back to this one. Starting now with the default solver, the normal solver. Also. One of the other differences is that it has this message under this one. So the bouncy solver and the soft and hard solver. They have this message which says, it would actually give you the status of the solver that now what is paused or when it's done, it's going to say converged. And when it's running, it's going to say running. So you can actually know what's happening, what's going on. And you can actually understand that maybe you would have to wait a bit when it's running and then wait for it until it becomes converged. In any case, I'm going to zoom back here. Okay? So now I'm going to turn this on. So I will turn this one on. And actually these two buttons are linked to all of these solvers where we can actually use them. And you can now also see the difference in the outputs. So that puts you, I'm using again the same thing as before. The curve is the output and the length of the curve. And I want to check and see if it would give me the same result or not. If it's going to give me the correct result, which is 110 or not. So let's check this out. If I turn this to true and then I reset. You see, now, this actually worked really fast. Looks like close to the zombie solver behavior and then away. This one took a bit of time to converge. Now you see both of these are now converged. It's all random and silver. If I do it again, you see that now it's converged directly and then this one is still running and then it's converged. See that this thing is that we're getting now 109.99, etc. While here I'm getting 110 dot 000 and then something with the zombie 9999. So you see that there's a bit of difference in terms of how they behave. Let's see why this is happening. What could be the reason behind this? If I'd not change any inputs of these inputs here, Lawrence is now 0001 thresholds at zero. Let's see if we actually tried to affect these inputs here. What would happen if I change this threshold? Let's say to one. So there is a change if I rerun it. Okay. It's actually different from before. It was wondering 9999. Now it's one of 986. If I change it to, let's say 100, 100. Okay, it looks like the same. If I bring it back to zero. You see this behavior. I wanted to show you this that sometimes when you change some of the inputs, in this case, especially for this solver, if the threshold is changed to one, and then we bring it back to zero because we started with zero. Actually, if I do this, you see it's going back. If I change this back to zero, because we actually started with zero, it doesn't converge. It's staying, just stays running. But it's actually giving us the correct answer though. But it is still running. I think this is a glitch in kangaroo. If I change this to one, then I try now to play with tolerance. If I want more zeros here and then start again, you see, they're not really affect that much. If I bring this back to three zeros, you see an order for you to test or no. If you're component is the default one, you can always bring a new component and u1 from the plugin. So you can check. So this is the tolerance with four decimals. And then this is with only zero. Now if I bring this back to zero, does this, if I tried to play with it and then make it, let's say I don't know 100 instead of zero. Similarly, the previous results. Now you see this, I did not change anything with this one. If I bring these goals, actually two here, just take all of these inputs back here and then, and then this, you see this back to 110999. And this is at zero. Okay? So be careful about that. If sometimes you play with the inputs and then you get an unusual behavior like this one. I bring this back to this one and the threshold bring it back to zero. You see it's not converging. This is like an abnormal behavior basically. So that's why I'm saying that you can do that. I'm going now to take this out and then bring this back in its place in any case. So this is quickly about the normal Solver. The Solver, what is interesting now with this new input about the iterations and also that pink I'm not going to talk about, I mean, I'm not going to play with these thresholds and tolerance, which are the same as here. But I'm also going to touch this one. I'm going to try to focus on the iterations. This one. Now for the iterations. So it's saying this many I iterate internal iterations will be performed for each result output if I play with it. So if I click on this to see how it's behaving, you see that it's bouncing. That's why it's called bouncy solver. Actually, when you look at this result, it reminds me of what we were actually doing with kangaroo one. Remember it with kangaroo one. We're looking at this. And then you see stretching and then it's reaching the goal without bouncing. That's what. But also different with this one. Usually when we have a spring in real life and you're applying a weight to it, it will actually bounce and not just stretch down as if it's like an elastic. It's stretching and it has an elastic and then converging. But it should actually be bouncing. Like this one. That's a more natural behavior actually. And that's another observation about the differences between kangaroo 1.2, especially with the behavior. Now, let's go back to the bouncy solver and look more closely at the iterations input. Here I'm using a number slider. If I change the values now, reaching 110. So if I say put it at ten, what would happen? It's 100.999. If I slide it to 20. Again, you see the number is closer to 110. If I change to 38, it's almost 110. So it looks like now it's slightly higher than 110 with a very small factor. As if now it's bouncing and then you are requesting it to add more iterations to the mounts. And then with the 50 iterations, it is now reaching the result 110. So this for you to know. The only thing now that I don't really like is that it's not bouncing anymore. I mean, yes, true. I'm getting the correct result, the correct answer, but it's compromising on the bounce effect. The more bouncy effect was with only one iteration. And then now it's like it's bouncing more or less, reaching converged. It has taken more time, which I would like to see, but it is not really the correct answer precisely. What is interesting though, for us now, this answer, this is a really small, really small difference between this one and then this one was wondering, wondering then absolutely, but there is still like small difference. But beyond this decimal place, then the case zombie is the same. So actually, we don't need to reset the goals. And that's it, just bringing the goals and that's it. You can actually play with the maximum iterations. So for instance here now by default, when I bring the zombie solver, by default, the value is 50,000 for maximum iterations. Here it is the same. If I now change this one to, I don't know. Actually down to, let's say 100. And I disconnect these ones. Okay, it looks like we're getting the same result. If I bring this back to 20,000, didn't really change. I thought maybe it would give another result. But it looks like it's not if I actually try something. If I do this, if I and I do this, it is different. Okay. Looks like maybe this one maybe maybe blocked was kind of like blocked or stuck somewhere. Yeah, it doesn't change anymore. So also be careful about that. When the zombie solver, it may not respond directly to the changes that you are applying in case of maximum iterations. In this case, if I change this now to 50,000, because I remembered that this was actually different. Okay, It changed. Alright, so here it is good to keep this max iterations at a big number actually. And then there's also a pretty close to 110, although it is saying 1009999 steps Solver. Now, this is an interesting new component. Sorry, I'm going to talk about this message soon. But let's go to the step Solver. What is interesting about this one is that, so it says the description says the solver, which advances only when input refreshed, useful for making animations. I'm going to keep the tolerance, as it is. Momentum. I'm going to keep the true. It's true. But if false, the simulation tries to converge as quickly as possible. So I don't want that. I want to make it bouncy. Bouncy than pink. Keep it as it is. Sub iterations, I'm going to put it at one. And this means that the number of iterations per frame for the animate, if I set to false, the simulation resets. If true, the solution will advance by one frame each time this input is received. And here I'm saying that I'm going to have only one iteration per frame. Alright, so let's look at this. The goals are coming from here. If I play with it, you see, it is kind of controlling the speed of it. If I change it again, It's not bouncing back. Round 109. More or less, more or less. It is like a natural pounds. This is how the results would look like. And you can see that now for the 50th iteration or frame, I'm getting this result if I actually make this bigger. So let's say 5,000. Let's go back to zero. Bouncing, bouncing around saying 3,000, almost 110. Okay, Then it looks like here, it just doesn't give me any new different results. After 4,000 something. And you see that even when I go back here, what's doing is that when I progress and then go back, it just like adding more iterations. Basically. What is interesting about this component is that now you can actually export these as frames, so forth, e.g. if I can say I want to only let's say 100 frames. And also keep this. Alright, like this. And now you can actually right-click on this number slider itself, and then click on animate. And then you can animate, you can actually export your frames. So frame-by-frame to assert the location that you choose. And then you can actually make a batch out of this or make a GIF image out of it, or even like a small video sequence out of it. Just use these frames for animating the simulation. Alright. So the other thing is that I thought it would be actually interesting in this case to have a counter that would have a running number that will just increase with time. And we can actually input this into Animate input and then see what would happen. So this counter, How I Built This one, actually, I got this counter from kangaroo one. It is one of kangaroo one components. It needs a reset button to reset it. It needs a trigger with a timer. This one, which is coming from perimeters trigger, this case, I'm using 50 milliseconds. And here I'm saying, so counter makes sure to click on Play button. This one to run. I'm going to first reset it. Click on this one, and now it's paused. It's not playing. And now I'm going to give this, instead of the numbers data as an input, I'm going to click on this to see a preview of it. And I'm going now to click on Play. Also. I want to see this length here and play. You see now this number is always feeding into the animate input. And you see now around 100. It does not say converged. But I know that the answer is 110. You see? So for me, after 100 it's converged more or less. So reset, bring it back in. Now because this is playing. When I did reset it. Just replayed without having it to right-click on this. So if I click Play and I make it run, and then I click on Reset. Now in the middle of it, it just resets again. I don't need to read click again on play. In order for me to stop this, I have to click on pause, and then that's it. And then the result is reset. That's it. So pause. I stopped this counter from running. Reset and that's it. Alright, so this is what's interesting about these steps solver. If you need to animate the simulation for any project that you may need. And as I said before, the soft and hard solver, it's up to you to test and play with this. I want, I'm going to check this solver in depth here. So this is basically a brief comparison between these solvers. The main difference in Kangaroo to about the solvers. With this really simple example. Before jumping to the second example, I'm going to show you quickly about the new graph components. I think it's really interesting component doesn't add more accuracy in a way or a different result. It just lets you play with the geometries, with your resultant geometries. I'm going now to connect this with emerge. So this is like one of the goals. Actually. You see I said before that when this part of the goals, the zombie solver doesn't work, as it doesn't have a reset button, and it simply shows the final result. It does not work with Grab component. All right, I think that's fine for us now I'm going to click on the bouncy solver, I reset it. We don't see anything yet. The thing is that when we run it and to make use out of it in the previous version of kangaroo. In two-point for t, if I'm not mistaken, you had to click on hold and Alt and then drag geometries or particles. I will actually change it to particles because in this case, if you try to drag the line, it won't respond. Just not do anything. But if I Tried to drag the particle. It will work. So many, but I will expand this a bit more. You see that? Now we can go 2.42. You'll need to click and hold on Alt anymore, as it will also work without that. Just now simpler and more intuitive because I will also take this out from here. Correct? This one, take this out. So click. Drag. Alright. One thing which is now interesting is to see again, the response of the different solvers with the normal solvers, you see not normal. So we see that it bounces very quickly. You see it looks like the zombie solver, like it doesn't bounce at all. But with the bouncy, one is more natural behavior. It is more playful. Now, what if I try to move this point towards the anchor? What would happen? We can feel the stiffness of the line resisting the pool of its ends and towards the anchored. If I tried to change the stiffness less than five, if I changed it to one. You see it now stretches more. Because this is a difference in our less, which is normal response behavior. Especially as more than 110, it becomes one-fifth t, It looks like. And if I now try to play with this, you see that it will not only bounce, but also looks like it's more elastic, more stretching while bouncing. Which is an expected behavior. If I bring this back to five, you see that now it only directly responsive to the parameter change and adapt to it in the middle of the simulation. Reset. You see, so this is an interesting component that lets you play with the geometries, try to make studies or tests with them. I'm going to take this out. Alright? So my goal now, until this point, is to show you with a really simple example with kangaroo quickly about the main components, the solvers and the resulting simulations and the results that come out of the solvers. So this is it for this session. The next example will be the catenary curve example, which is a more elaborate example. It will be the start of the next session. So thank you very much for your presence and see you in the next session. 5. Learn how to simulate a Catenary Curve : So this example of the catenary curve, we're going to replicate the physical glittery curve, the physical category chain. But now with kangaroo, This is a quick definition of the catenary curve. So Caitlin Marie and mathematics, a curve that describes the shape of a flexible hanging chain or cable. The name derives from the Latin cutting area chain. And if really hanging cable or a string assumes the shape, also called a Jeannette. If the body is of uniform mass per unit of length and is acted upon solely by gravity. This is the source, and I'll let, let me show you again the diagram of the catenary curve. This one, It gets rid chain. In this example. We're going now to try to replicate this example. But now in kangaroo one. But now in kangaroo, one thing to know is that the category curve application is also the basis of most hanging geometry studies in Kangaroo. We saw that kangaroo uses Hooke's law to make simulations. They get a curve, on the other hand, can exist in most hanging geometry studies, such as a 2D catenary curve, membrane studies, ridges, etc. Similarly to the example of the spring as a very basic simulation, if we now understand what is a category curve and how it can be simulated and getting kangaroo. More complex examples of mesh membranes, etc, would be then easier to apply in any case. So first let's start with this one. I'm here also applying the same example, but in both kangaroo one. And can go to, alright, just to see how both work with they can't reserve. So I'm going to nudge this one here, this one here. Alright. So I have previously drawn a kid a curve inside of rhino. And I did not want to draw the curve like a parabola, similar to its resting shape. So to make kangaroo challenge and the way I wanted to draw it differently. So this is the curve drawn in Rhino. It's inside of this layer curve. And the first step is, well, first referencing the curve. I'm going now to turn the layer off. So this is now reference. And now I'm converting this curve or this geometry into components that kangaroo would understand, which is called, as we saw before, discretization. So I'm dividing the curve first. I kept this count to ten, the default division value. And then I'm making polylines between the points. And then I'm exploiting this one polyline to get the individual segments In-between each point. So these are now the lines segments. I have now ten. And now with this list item, I can check if everything is working well, where these are, 123, etc. So I turn this on as well. These points, I can see these segments between the points. Alright. Now, once having done that from the curve, I got these segments and these points, these points, this is the shortcut from the points. Now, I'm using also the same components as previously used. In this example. With the springs from line, unitary force and the point as anchor. However, we don't have now one anchor point like before. We add here, one anchor point. Here we have two points as anchor points. So from this curve, when I extracted the points with the divide curve, I got these points obviously. And then I just called the middle points. And a fault actually two steps. I got the endpoints with this endpoints component. So these act as anchor points and I put them together in a group. Then what I did is that I excluded these two points from the rest of the points. I use the coal index with zero and minus one because I know that I want to take out both the first point and the last point. Of course, with the rap true, otherwise, the minus one won't work. And then I got, I get now these points. Now from these points to these points, and then these remaining points to work as anchor points. So now these are my points which I will use to apply the unitary force onto. So we have the unitary force that is now pushing these points supposedly now downwards with the force of gravity, I have the anchor points that will actually prevent these segments from falling down. But to keep them anchored at these two points. And I have the third force, which is the springs from line, to have the force in-between each segment to maintain it, to keep it together. Similarly, in real life, when we have a chain, a metal chain, the distance between each chain connection will not expand. Normally. It should stay the same, right? If this chain is made out of metal, let's consider. Now, I'm giving a high number for the stiffness for these trying to let the leg can grow. Understand that. Please don't compromise on the length. Let's keep it as much as possible, the same as the original one. So I put now these springs from line and the unit of force in one merge component. Here for the unit of force concerning the inputs I use here -102 are going to actually now play with these and see what results we would get. So I use this as a number of stator and then this is an input for the stiffness 1,000. The rest length is the same for this segment. Nothing changed in here, not play with any of these options. So now the segments, I would hit expand this a bit. I'll zoom this out a bit. So these two ones, as we know and kangaroo one go together into the force objects. And then these anchor points, the extremities, will go alone inside the anchor points input. And I use also the lines. These ones, the original ones that I'm making out of these springs from line. I'm using these as the geometry to be transformed. And I use the same trigger here. And now I have with this, what I will do. Turn this preview on. And let's turn this to false. Now we get this result. So as a first observation that looks like it's logical, right? It looks like it's working correctly. It's hanging down as we're expecting it, and don't arrest again. If we click it again, it is responding as expected and it's bouncing a bit. But you still see that actually the result is not the final result, it's still running. So what I did, I use also the same strategy that I used before with the previous example when I'd also used also here previously the curve and length. And then I double checked if the simulation was actually applying the equation correctly. Remember, with this 110 value to see if the result was correct or not. I thought what if you could actually do the same here and double-check the curve lengths, the output of these. And I put next to the original curve lengths. So these lines before that were not yet applied to any force to these segments from the curve. What I did is that I extracted the curve length of all of these. I use these inputs for the curve length for this component specs from line. However, I also used this as a double checker. Next to the new results, the output of the simulator to double-check. Okay, So when we look at this now, it looks like you see it. Remember when we ran it and then it looked kinda logical, but actually it was not correct. You see now the result, we're getting 774 here. But the original length is seven to eight. It's a bit, It's a big difference. It's not that order of several decimal places, but it's a big difference. Here is 709, here is 664, etc. It's a big difference. So we learned that as a rule of thumb. Even if you see things that seem to be working, you have always to be critical and have a critical eye about the results and double-check this. You know, like in this example, we have the original length. If, in this case, where, let's say we're considering that we have like metal elements or something that will not expand, they should maintain the original length. So actually, what I want to now to play with. With these inputs for us not to go back and forth. I'm going to just bring these, put them next to us here. And we're trying to check out what, what's going on here with the forces. So this unit of force, Let's check out and see if the effect of this simulation we have now 100. So it looks like maybe could be that this value is too big, pushing too much downwards. Because the results are now bigger than these. So these are the original lens. And you can see that these are bigger. So it looks like they're being stretched more anyway. Maybe, let's say if we decrease the value. You see now how this simulation behaves when I play with it, with this value, even when it becomes a positive value. Now it looks like a catering arch. So just flipping the value from negative to positive, we get the arch. Because now the vector is pushing upwards or downwards anymore. But in any case, so if I go there, so if I change the value to, let's say, let's check the value now. If I change it to, let's say, minus ten instead of 100. So the results are now much closer to the original length. But still here it is, let's say 733728. It's still not the same. However, here it was seven before. So it's now six dots 68, so it's much better, but still not yet acceptable for me. I would be happy with at least three matching decimals. But now still the first decibel is not matching. And so what I've also play more with, let's say, you see now it's going up. Maybe if I, let's make it minus three, Let's see what happens. But still still bouncing. It's still not the same. You see that? 1 372-866-5664. It is much better, but still a bit, let's say not within the acceptable boundary. Actually. Let's try to play with the stiffness. I gave this 11000 as a value. If I give it, let's say 10,000, what would happen? See what happens. I think it's a glitch, glitch inside of Rhino or actually kangaroo, that it does not tolerate high values for the stiffness. Maybe in this case only being more than 1,000. Let's try with, let's say 5,000. What would happen? Okay, it's working. Hopefully it will not crash. Okay, it's working. You see that because the stiffness is much stronger, that it was a bit slower to react and duress down. It looks like now it's much better. It's now 7 2 8 9, 7, 2 8 6 6, 6 4 5 6 2, 6 4 3. Still it's not the third level of decimal that is matching, but it's much better. I think in this case, if you go down with the urinary force to, let's say minus one. I think it could go if I now rerun it. And what I would do. You can try to play with it. If we check, let's say 1,000 again. What about 100? And let's check the results. Bringing this back. And then let's make this back to 5,000. And then this back to minus one. You see that the middle of the Tribulation changing inputs. Now maybe could be that when you do that, you may get wrong results in the end. Like things would wrap around other things or get stuck somewhere else. So it could be that it wouldn't I mean, it might happen. So be careful about that. When you're changing the parameters during the simulation. Now you can see, I can see the results now. There are much, much better. 7287, 7286, 6644, 6643. I mean, it's still yeah, it's close enough but not perfectly the same lens. As the original ones. Let's see if I do minus zero dot one. So it was like just barely pushing down. But not too much to affect the lens are alright. Now it looks like it much better. 7, 2 8 6, 2 8 6, 6, 6 4 3, 6 4 3. I think all of the numbers are at third decimal precise or matching. Maybe not. This one is 69, this is 70. Almost there. Yeah. Well, That's what I wanted to show you, is that you have to play with the parameters, in this case, to try to find what you're looking for. Matching your situation. Basically, it is a chain of metal or elements or wood or whatever material connections that you may have. Just bear in mind that maybe you have to input matching parameters like stiffness to make them work. And you saw that if we go, let's say 10,000 stiffness, it may break. So maybe 5,000, it's working better. Maybe I don't know, lets, you can try also, let's say 7,000, what would happen? And checking the results. And you see that now when I bring this back to 1,000, you can see it's reached the action with the inputs. So I'm going to bring these back here. But then we're okay. We'll turn this off. And we'll reset the simulation with the true end kangaroo on. Now, let's look at this same example. But now we've kangaroo two. Okay? So here, the same start. I have the curve, the curve, and then I have the points, the polylines exploded and then segments the same thing basically here. And as we said before, that now we don't have any more anchor points as input. I know geometry basically. And so here for this, for this test, I'm only using the normal solver and the bowtie solver. I'm going to make these as preview on both of them. And so what I have done here, we have the endpoints. These ones. I put them together to feed the inputs of the anchor point component. Lines. These ones, the segments. I'm using these ones to feed into the length line. As we saw before. This is similar to the springs from line from kangaroo one. And the unit of force which is now integrity to the load. Here I am applying this to all of the points except for the anchor points, as we saw before, except for these two. Alright? Alright. Now, I'm doing the same, the same here. So the output here is a curve at length. And then here I'm using clean tree because otherwise I would get empty or invalid results which are not useful for us for now. And these original length and the petal next to the simulation results. Now, let me run the simulation by clicking here. Okay? What we are seeing now here is both simulation results. It looks like this is what solver one, this is the outside one. It's bouncing but really slow. And that's because the value given to the stiffness of these lines is extremely high. It's like with nine zeros. What I will do actually here. And there's also given the same strength for the anchor points, which I think makes sense that the anchor points, we need them to be extremely high value because we don't want them to move anyway. That's the definition. So I will copy this over there. And I will now zoom out a bit just to show the results here. So first I will start with the 100. Okay? So when we have 100 as stiffness strength, we get this result, which clearly is very far from the original length. And also because it's pushing strongly down, It's like with 100 as a weight. So let's say minus one. You see now it's better. The results are much closer to the original length. So it's similar procedure. Now what I want to say here is that what is interesting with kangaroo two, which is not in kangaroo one, is that if you bumped this to the higher numbers, the strength of these ones, you will not get this broken like before with kangaroo one. If I don't get to go to one on and run this simulation. And I make this at minus, as we saw before, 0.1. And this is a 5,000. So we saw that this is a really close but not perfect. The fourth decimal place not matching. And this is the first one. You see that like we have three curves here. Simulating, running, still running, and maybe merging. It looks like merging 21 common location. This one as this one. It's coming from kangaroo one. So it's kind of like going to arrest. And I think it's really slow because of this high stiffness value. If I give it, let's say 1,000 stops there. If I give it 2005, let's say 5,000. Trying to reach or match the location of the other ones. Now, here, the strength should be very high. If I look at the results, it looks like at the fourth or even fifth here. Fifth decimal place, it's matching the original 16. The sixth one is not matching anymore. So we have 28 617-128-6176. So I think that the result is now pretty much acceptable in a way, although not perfectly matching all decimal values, especially that these are now in millimeters. So the precision level is not acceptable. And you see like this bouncy one, you see very small differences between these two is over and the bouncy one. So this is the solver. This is the bouncy one, and the middle. The middle is the kangaroo one. And it looks like they're all pretty much close to each other. So this is the good thing, is that in Kangaroo to, you can bump stiffness or strength values to really high numbers without having geometry to crash like and can go to one. Now one thing I want to show you is what if, well, I was thinking about that from a physical, real-life point of view. What if, instead of calling these points out and only apply the force to these points without applying them to these anchors. What if actually, because in real life, I mean, these anchor points, although they are anchored, but they still have their own weight. Let's say they're anchored and they are also affected by gravity. What, what if actually also give them like a force? Would that make a difference? If we include them, let's say with the load pushing down, as well as having them to be anchors at the same time. These points as our anchors, and additionally, they are part of the points that have the load being applied to them. So what I've done here with the same example as above. What I've done, I'm going to make this minus one. I did not use the coal. I just use all of the forces that we have for the load to be applied to. Of course, these points will have any way to be anchored. This is giving a really high value to both the anchor points and the lines. And now when I run it, this is on and maybe turn this is on. Alright, checklist or this off. We'll also copy this here. Try to run it, maybe by making 1,000. Then get this back. We'll copy actually this number there. Now what I'm doing here is I'm showing you the results that are coming from all points, including anchors, are given a load. What we have done here without calling these points, with these two points from the load, I have this panel that is showing these results, please ones which are the points. So only Paul is not touching anchors are given a load and the original lens. And you see that it looks like there's a small difference between these ones and these ones. So here is like 61716176. It looks like 7171. So these are actually closer to the original length. 4, 4, 8, 6 4 3 4, 4, 6 4, 3, 4 0 4. You see? So these are the results where the anchors have the loads applied to them, not excluding them from the loads. And it looks like it's like a more accurate result. So it's really depends on how you build your definition. What to include in the definition. What are the force is used? What are the stiffness values or the strength values, the anchor values, the load values to affect the results. So with this example, I thought it is more realistic and it looks like it's closer to the original length as in the end. So that's quickly looking at how to make catenary curves or arcs with kangaroo. Now, what about kilograms? 6. Use real life units, converting Kilograms / Pounds to Newtons: What if we actually have a certain cable or a chain? And it has a certain weight in kilograms and not in humans. And we just want to try to try that out with him Kangaroo to see how it's going to, it's going to behave when it's hanging or whatever we want to do with it. So actually it's pretty simple. We can simply convert kilograms to mutans. As we saw before, the component units such as the unitary force and other components. In kangaroo, they work with Newtons. So from another website, we can find this definition of kilograms. A kilogram force is a unit of force and the gravitational metric system. It is defined as the magnitude of force applied to 1 kg of mass under the condition of standard gravity is 9.8 066, 5 m per square second. We saw this before with the gravitational acceleration. So 1 kg is therefore equal to 9.8 0665 Newtons, which can be just here. We can use 9.81 Newtons. Also, this is the same with the other units. You can convert that to pounds or to any other unit. In this case, we're using kilograms as an example for us to use, let's say, more real-life scenarios with kangaroo. So for instance, as an example, we have a cable that is 9 kg in weight. The important thing actually for us to understand is that the cable itself is not divided by nature. It is a cable that is not divided. It just comes in one piece. However, we need to convert this cable into a group of segments and particles. And you're going to ask like why? Because actually in Kangaroo we need these particles that we would apply the load forces onto and not the cable itself. So as we bought, as we saw before, the cable, we need the segments to be used for the length of the spring length. Then we can give a high value for the stiffness or the strength. Black there. E.g. we said that that will prevent stretching and then eventually use the load to apply to the points which are the particles that constitute this cable. And so in this case, we can say we have a 10 kg cable. And so this is divided into five segments as an example. Alright? And if we sketch the cable like this, this is a quick sketch of the cable and with five segments that we actually have six particles. So we need to be aware of this if we have this situation with six particles. And so section 12345, particle 123456. Now, we said that the cable has a weight of 10 kg. We also know that 1 kg is equal to 9.8, 0665 newtons. So ten times 9.8, because we have 10 kg, we have 980665 Newtons. Alright? Now, the whole cables Wait, is this much in newtons? And we need now to convert this. We want to also let kangaroo know each particle. What is the weight of that particle so that the weight is distributed equally on these particles. And each particle will have the weight of 10 kg divided by six, because we have six particles, which is equal to 1.666 kg. And so this is equal to 1.66 kg times 9.8 Newtons, which will give us 16.3, 378, etcetera. Newtons. Or from here, from the 98.6, 0665 newtons divided by six. This is the whole weight of the cable. But in newtons divided by six also gives us the same result. So the same answer. So now we can convert kilograms to Newton's following these steps to make kangaroo understand what we need from it. And then this is the same step. So actually I'm going now to take there. And I'm going to take this one just to make it turn off. So we have a point. And I actually moved this point by 100 in the x-direction. So like 100 mm. And now we have a line. And then we have this one. Now here, our cable. Now I'm dividing the curve, the cable, the line by five. I want five segments. And afterwards I'm left out with six points. Alright, so these are the six points. So now we are replicating the sketch particle, the particles here. And then these segments. If I now use shatter segment and I use the line as the curve and then the parameters of the divide curve as the parameters. And then I will get these segments separated. So the first 1, s, third, fourth, fifth. Alright. So now we have five segments, and each of these segments is equal to 20. This is the length. So we have 100/5 equals to 20. So that's correct. Double-checking. We don't have, don't really need this but just in case. So this is the line. And now we want to again attach the line, connect the line extremities of the line or the cable to two anchor points. So I got here the end points of the line. And I put them together. And I'm using here again the same anchor components for the anchor points. These segments. I'm using them for the length to keep the spring, to maintain the springs length. Also for the length is important. You don't always need to extract the curve length. You can also use the same output of the segments for the length. Also that works for the strength. I'm using a really high number for both the anchor points and the length of the segments. And for the load, I'm now using all of the points. I applying load to all of the points, this x particles with unit Z pushing down by one by minus sixteen.337. You can also make it like 338 if you want to round that up. I'm going to keep it like that for now. Or actually I want to just make it 338 just to be more accurate. So 3378. I mean, it's really up to you just to make any any number, but just in case. So let's now the actual weight that we're trying to get as much as possible close to real life scenario. This load is now being applied to all of these six points. Two of these points are used as anchor points. And all of these segments, these segments here, the five segments, have their length being as much as possible maintained with the high strength value. Alright, so are putting all of these into one merge component. Then let's see. Now on one thing also before running the script, the output of this is obviously the curve and then the lens. And then here I'm trying to check with these lengths if they are maintained or not. So all of the points, including anchors, are given a load. And you see that it just barely nothing happens. If I zoom in a bit, it looks like it's sagging down slightly. And you see when I click and hold on the Reset button, it resets the result to 20. And then once you release it, it's converged. Slightly more than 20. Result, I would say is kind of expected. We have a big weight of 10 kg over a small piece of cable. Even if, let's say all of the, let's say the joints are really well tied together and it's different, strong would still see like it's really small sag. That could be possible. But at least the lens are maintained to be to the fourth decimal place to be zero. So this also more or less equal to 20. Right? Now. What if here I want now to change the strength or the stiffness here. So I will copy this. I want to maintain the anchor is stiffness or strength. But then now I make this a bit less for the length. I also get this closer. This is now with nine zeros. If I change it to 1,000 and I take, I take out the six zeros. You see, it says more. And the lens now are much different. Instead of 20 2017. Although this difference is 1,000. And again, that's because this is relatively a really high value for the weight. Now, if I make this minus one, yes, as expected, it goes up a bit. You see when you play with these inputs, Obviously it updates automatically, automatically and accordingly. One other thing I want to show you, I'm going to bring these back to these initial values. Considering that we have this situation. And it was like barely sagging. Now I want to show you the target input for the anchor points. What if we change the anchor points? Now, these points, these are the two extremities. And I want now to try to move the anchor points. The insight, e.g. try to move both anchor points as if, let's say you're holding the cable with your hands, your hands being the anchors. And then you want to move your hands to the inside or up and down. But then what would happen? What would we get? So I'm going to get the point component. So this is like a shortcut from these two points. And then I want now to release these two points from the reference. I want to right-click and then click on internalized data. Once I do that, having the point component with the preview on. And this is off. So it's showing what is on. Select the component. And now I can see the gumballs of these two points. I can move them around. If I move these points around. Now, nothing happens yet because they are not yet linked to the target. So the target means moving the anchor points to a new location. Basically. Now, if I link these to the target, now, what's happening? The anchor is moved to that location. You see that because now the distance between the two points, these two points is larger. That now as if it's not anymore reaching the end of the anchor points. So these segments cannot actually stretch anymore because we gave them a really high stiffness value. So this is now like a straight line between these two. However, if we move these points, Let's say closer to each other, then we get a category curve effect or chain. Out of that. Now you cannot actually move the two points with these, these painters snap movement. Like in the x, z plane. In this case. There's actually a glitch inside of grasshopper. When we internalize points, we can not only, you can only move them along the red, blue arrows or the red and blue and green arrows. If we were in perspective view. But not in the along the planar snap. And because this difference is really high for the length. If we again try to play with the value, if I take three zeros out, again, the movement will be faster. But obviously the stiffness would be less for these ones. So bear that in mind. So that's a quick example about trying to use kilograms instead of Newton's. And I think that's it. That's the quick demonstration about, about that. And now, what about the pendulum swing? 7. Simulate a Pendulum Swing: This is the last example I want to show you as part of Unit one as an introduction to double-check about Hooke's law and its integration in kangaroo. I'm going to now turn these back. I will label this points, internalized points. Alright? Alright. So these are the points. And later on we're going to look at meshes and how we should have anchor points to work with meshes. Especially that the starting location of anchor points must be on the mesh itself. But we're going to see that later. Anyway. But for this one, in this case, it works. So if I now take this out, it goes back where it was. And if I link, this will update. And I want to click on the on these. I can now play with, just stay with them. And also assume that even if we add the graph component, this is the graph component. And I add it to the merge. And now I can even grab these particles. I can play with these. I don't think I can move the anchor points because these are anchor points by definition. But I can grab these other points. Alright, so let's move, let's move back to the pendulum swing. I want to make this preview off now. Now, what about a pendulum swing? Can we do that in kangaroo? Let's try to see the behavior of a dropping weight attached to a cable. Now the starting position of the weight is not supported and the cable is rigid. So keep that in mind. Would it swing back and forth and behave as a pendulum? So again, you are starting with a, with that, I'm going to go back to the front view. Okay? So this is the point of origin. And I'm moving it again, 100 units in the x-direction. And I'm making a line. And now what I want to do is the first starting point is the anchor point. Basically this is the only anchor point. There are no two points. The line. There's the string that is pretty rigid because we want it to be rigid and we are applying a load onto the second point, not the anchor point. The anchor point is there and the load is applied on this particle with, let's say minus ten. Change this to ten. Alright, I'm going to turn these to preview on. And I will allow activate. Well, actually now I want to see depending on behavior, also with both solvers, the normal solver and the bounty solver. I will turn this on, reset. Uh-huh. You see here, I think this is the one that is about C1. This is the standard one. So it's like an inverse. Then stopped and the length is now at 10001. This is now a swinging. Hopefully that it will not stop. Okay. So it's like a pendulum swinging. But it just stops there. I thought it would swing a bit more. Let's try to play with this difference. Maybe. If I change this difference to, let's say 100. Okay, he had swings much more. So you see this difference affects the behavior in a way that when it's like too strong, it is like the, the point is pushing too much or trying to maintain this distance that when it's swinging, it is also the same time pulling hard towards the anchor point and then stopping sooner. If I make this, let's say ten, its wings even more. But obviously the length of the cable is now 101. This now they converge. One is 101. So it's like if it's longer than the original 100 length, I'm saying 100 length because we know that when we move to this point away from this point by 100 units, That's why I know that it should be 100 and not 101. What if to maintain the stiffness? Maybe one-thousand. Keep it back there. Let's see if we can change the weight of it, but not too strong. Okay. You see so also because the weight was relatively small, like only minus ten fingers, relatively slow. When I give it a little higher weight. Actually, solving faster and more actually. So this is now one minus. Then when I add two zeros, 1,000, then it's faster. Obviously. Now it's also pulling more because there's more weight that's pulling it. This is the conversion one. This is the MS1. Also you can play with this forever to also affect the behavior to make it actually more or less. So this, let's say with more iterations per bounds. And when I increase, the value becomes faster. I mean, I personally like this one. It just depends on what you want to do with it. Okay? So that's basically it. We saw how we can perform a pendulum swing with kangaroo with these parameters and components. And I think that's it for Unit one. 8. Learn how to simulate a Catenary Mesh: Welcome to the unit to class. In this unit we're going to learn about mesh. So this is like a follow up step from unit one where we saw how we can simulate a catenary arch or a catenary curve. So now we're going to take a look ethical quandary mesh and also have a quick case study analysis inspired by Frei Otto's tensile membrane. And more specifically from the project the German pavilion export in 1967. This unit is divided into two main parts. The first part, which is the Cadbury mesh. Then the second part is the case study inspired by freight autos and cell membrane structures. So let's start first with the category mesh. In this part, as we saw before in unit one, we saw how we can simulate the catenary curve or arch. Now, what if we had a mesh? As a first step, we need to know how we can describe the size mesh from Kangaroo, Kangaroo to in order to understand what we want. Here. This whole part is made inside of grasshopper. All of this one. There are no reference geometries from Rhino. Only these layers are what I will be using for the second part. The first one. Okay, so here what I started with is a plane surface from within Grasshopper, from surface, primitive than plain surface. And then I gave, I gave it the size of x and y minus two, minus ten to plus ten. So it is going to be 20 in both directions. And then from this plane surface, I extracted first the points, the corner points. Because I need now to these points, basically, my main goal is that I would like to imagine that this is a plane surface will drop down like a turnstile. That's what's going to happen actually. Like a wire mesh. You can imagine it. And the only be held up by the four corner points. That's the main idea. So for that, I extracted the four points with a deconstruct be rep component. So I got these four vertices and I converted the plane to image surface. And the value of ten for the UV. So 20. And so now this is the output of this mesh. This is a mesh here. These two are like shortcuts. I could have also done that like directly, like this, but just to make things clear step-by-step so you understand what I'm doing here? So we have the points, well, these ones, and we have the mesh. And so to run this simulation, we need first the four corner points to be anchor points. So I got an anchor point, an anchor component from kangaroos goals. The first one. And I'm using here the first anchor point without a target. However, show you later when we actually move the points, what would happen? I'm giving here a high strength of 1 billion value. Now the thing is that you need to be aware of is that if, let's say we want to give a number that is even higher than 1 million, let's say with nine zeros or more. If you use the only the number of stator like that, you bring one and then you edit it and then you try to. So let's see here, let's say nine zeros. So these are 969. All right? You see that doesn't give us nine zeros, but only up to 1 million. Basically. That's what's happening. So I can do that. Actually. The thing is that if we want to make like even higher numbers, there are two ways. Either you can use a panel, is simply panel with as many zeros as you want. Just bring your panel and then write whatever number you want. Or you can, instead of doing, doing that, you bring a number slider. You can actually double-click and then type your value. So 3456789, Enter. And so now this number is Slider can give us this value. Like big value that is actually not given by default when we start, when we started to like, you know, the other way. That's for you to know to be aware of if you want to do that. Because in some situations, actually, when you have, let's say like really big geometries, the scale is too big. They won't million might not be actually that's enough to maintain. Points in their places for the anchor, for the anchoring. And then you might need to use such high values for the strength of the anchor points. So we have the points now that work as anchor points. We have the mesh. Remember before the catenary arch, what we had, we had to divide the curve into segments. Right? And then we gave for each segment, part it straight segment part, the component for the line length. We used this component from Kangaroo to maintain the length between the points. But now we don't have, let's say single lines, but we now have the whole mesh. And so for that, we have to use another component that would affect the wire off the mesh or otherwise of the mesh. Basically, we can use it this edge lengths components also from kangaroo. This is especially made for meshes. And so in this case, now we can use this one and you can input the mesh here. So instead of the line before, it's now the whole mesh. The length factor. The whole mesh where we specify how much the mesh would stretch. Literally a length factor with one equivalent to 100 length factor and this strength as input. And so once we have the forces between the mesh wires to be now controlled, with this one. We have the points that are not working as anchors are still missing the load. I'm going to first run this simulation but without the loads. And also I mean, this is like a new load component, by the way, it's not like the same as the one that we used to have before, which was the other one coming from Goals points. So this is the load, this new one. But now going to use the vertex loads because we want to apply those to all of the vertices of the mesh. Alright? But before that, let's just run it without the vertex loads. So I have this, this is the output of the bouncy solver. And so to initiate it, I will turn this to true. We set it as the first look. Nothing happens. Why? Because we're actually giving if value of one for the length factor. So it's not changing anything about it. So even if I change the strength, nothing will happen because it's just trying to maintain the length factor as it is, that girls are not changed, so that's fine. Or if I change the length factor, you see what happens now. Now we're having this reaction that's happening. And of course I can change the strength as well. Let's try that. Strength is zero. It won't change anything, but I gave it at least a value of one. And then one is enough. We could use the value to ensure that the lengths are maintained. Alright, so now we're having this effect. However, in real life, this will be hanging, right? So we can add the vertex, the vertex loads here. Now these are actually positive. If I change that to negative. So we get this behavior. And of course you can go back and play with these. Maybe let's say we want to the length factor to be bigger and then the loads to be less powerful or more powerful. So this means that actually the length of the resultant will be larger, around 1.5 times the original length. Basically. Or we can say No, actually want them to be less. It depends on what we are doing, what you want. Or actually, I mean, what is the property of the mesh itself? How much it can actually stretch. And now comes to show you when it comes to temperature. But this should show component, what's called the show component. It will actually add the geometry connected to it as an additional output. So if we try it now without the show component and check out the solvers outputs. Currently we're not getting lines or only getting lines, or have the particles out of the V, the vertices output and then the output from this side. That is suppose for this other supposed to be for geometries, it's only lines now. So these are separate lines. If I now connect the show with emerge, now I get one mesh and the lines. So now the mesh becomes part of the output geometries. This is actually a certain history with kangaroo one, where in kangaroo one solvers where we had two input here, the measures geometry, e.g. in this case. And then we would get the mesh as a geometry output. But here, since we don't have anymore the geometry input for the kangaroo two, that's why we use the show. Now. Instead, this will not only show us the mesh, but we'll also have it as an output as a result of output. Okay? So this is basically a quick example of the kitten 3D mesh. Now the thing is that the resultant behaves like a net. That's what we see from the result. And the quads before the original quotes of the mesh become diamonds. Basically. So it behaves exactly like a wire mesh. But what if our geometry is not a wire mesh? It's made out of another type of material. Maybe it's like a piece of paper, e.g. or like a rubbery material. In that case, that behavior actually it would be incorrect. Let me explain a bit more. This quad area of the paper or the rubber surface will not behave this way. And so in this case, we would need to maintain the diamond, the diagonals basically inside of the original quotes so that we don't get this sum, something like more quality than diamonds. All we're always having force applied to it. Pushing downwards or upwards, et cetera. So in that case, so this is a catenary mesh. But now if they mentioned is made out of rubber or paper. So what do we need to, to maintain the shape as a material continuity, basically, it's the same start, same components. So the points, the mesh, the same thing will always have these points as anchor points. We have the edge lengths of the mesh. We have the vertex loads and also the show component as well. So until now, we have the mesh that's giving us Diamonds. Until now. But we can add now to the recipe in new kangaroo component equal lengths. And so this coming from kangaroo too, goals, goals line equal length. And then we want to part of the discretization step, which is converting the geometries into parts that are understood by kangaroo as points, as anchor points at mesh or wire. We want now also in addition to the mesh, we want to explode it on the side and parallel to extract the vertices. Here after the mesh explosion, we have single phases. So here we can now test what we want to do. Only to one face first. And then after that, once we know what are the correct steps, then we can apply the same step to the whole mesh. So first, I use this list item, and then for the index I keep it at zero. I get deconstruct mesh. And then extracted the four vertices. And then I constructed lines between the first and the third, second and the fourth. Like that would not really make sense if we use the outlines like here, but more of the diagonals to maintain this trend, the lens basically. So these would actually stop or prevent the face from deforming in a diagonal way. So these will actually now give us these diagonals as forces which will be added to the recipe for the simulation. Once we found this, we don't need to use the list item. Then directly. We do this. So this part is now replicated here. Okay? And now we can see the tree of all of the diagonals of every single phase. And then these lines, we will put them in a merged together. This is also like a small shortcut of the diagonals. Again, this is not a must-do, but to make all steps clear to understand. And then now I'm using here an equal length component, but obviously a previously, I also tried to use the length line because we use this one previously for the catenary arch. Remember we use, we use this one back then. Now, if we do actually use this one, we don't get the expected result. Let me show you what, what we get if we start with this one. So let's connect it to the marriage. Then I click on this one and reset. It does this. Now, we actually want to have this effect. Maybe like somewhere, sometime, I don't know. Just to show you the different the behaviors of these components. In a way, what do we see here? This bag? It introduces like new lines as if newlines are added for each phase. And that's why it's not really doing what we want. Now. You could actually want, you can see now that these are actual lines. And as if it was like a truss system anyway, which would be something that we might want. But we don't want that for now. That's why I will now take that out. And I will link this equal length, which will just maintain the lengths of the diagonals of the quads. And so now it's maintaining the diagonals. You see now it looks like a piece of paper instead of a wire mesh. And you see that now here this corner quad, where it was more like a diamond shape. Now it's not anymore a diamond. But now the result of the geometry is what we're expecting. Basically. We can always play with the loads. So basically, this is what we actually need for this effect to work. Otherwise, if I take this out, we get again the wire mesh like in that behavior. So basically this is how we can, without having to add like any material properties similar to other plugins where you can specify material properties, densities, et cetera. Here, just to the quick geometry thinking, we can translate that into kangaroo components to find the form that we are looking for. This is it with the category mesh? Now, in the next session we're going to start beginning with the case study following up on this example. Thank you very much and see you in the next session. 9. Tensile Membrane German Pavilion Expo 67 Frei Otto Case Study Part 1: Welcome back to the unit to class. Last time we left at Unit two and we were looking at the category mesh and how we can build a cadre mesh with kangaroo physics. Now we have the case study to look at. I'm going now to reset this one and make sure that this is false and reset. I'm going to disable these and white now to enable these ones. That's because they're a bit heavy to work with. And just the cookies to worry about the tensile membrane. It is historically inspired by some of the first manmade shelters, such as the Black dense, first developed using KML leather by nomads of the Sahara desert, Saudi Arabia, and Iran, as well as structure is used by Native American tribes. Structures offer a range of positive benefits compared to other structural models. And so first, before starting with the example, I'm going to show you these photos. And the idea of this step is not to precisely replicate this example. That's not exactly the idea. The idea is to find how we can mimic this geometry looking something similar to this one. And later on. You can then of course, if you have the correct or precise lines of this and the heights of the columns, then you can replicate that. But our main goal is not to spend too much time on exactly replicating this shape, but to try to do something similar, I'll show you here a few examples, few images I also found through my research at this interesting case study about the project by Spanish students. I think most likely university projects about structures. And so they are showing here like a case study of the mesh of the tensile membrane with the holes there. And so it's important also to notice these holes in the images. The holes are not totally a parent or a possible. We can somehow see them. But the image would suggest that there are maybe part of the mesh or something like that. But actually these are holes and they seem to have different materials that are inside membrane. And so basically you can see here more clearly the membrane and the holes. So close this. And going back to the Grasshopper definition. Alright, so I'm going to talk about these, but after we cover the first part of the analysis, I'm going to expand this a bit. So basically, what i followed as a strategy to mimic this example is to do it simply step-by-step. So for step one, we are now simply building a flat mesh at the starting point here is similar to the previous example, where I'm starting with a plane surface and then I'm converting it into a mesh surface. And also extracting from this plane surface the vertices. So this one here, look at the preview. So I have a plane surface. And then the points here, it's converted into a mesh. Again, this is also like a short shortcut of the mesh output of the base anchor points. And so both of these are extracted geometry parts elements that we need now to connect with the kangaroo components. So here I'm using first the flat mesh for simulation, only the anchor points and the edge lengths for the limit for the mesh. And of course, the show to have the mesh as an output. So if I now move this one, they're a bit. We have this one. We have the show, the anchor points, the edge lengths as inputs. Once we run the simulation. So we get this effect. This is now happening to a flat mesh. Basically without any loads yet. I'm not going to play too much with these now because you have already seen this in previous examples. Now, the second step is to move the anchors. What I'm doing here as steps, I'm just copying this, Let's say first step down and then adding more components than copying the step-down. And I think more components, etc, to make the process easier to understand and more controlled. And then you can go back and play with each step alone, double-check what's going on there. And if you have any doubts or curiosity about what would have happened if you change something else, then you can also go back to these steps. The second step now is I want to move the anchor points. And the only difference between this one, the step and this one, is to add the target points. Basically, these would have done is that I simply copied it. So Control C, Control V to paste in place. And then I moved up, let's say with holding the Shift key. And then I right-click on it and select internalize data. Once I do that, I can now turn this preview on and I take this out. And then now I can move these around inside of the rhino viewport. So this is what I've actually done with these ones. I can now turn preview on. I will delete these ones just not to get confused with them. So as I said before, we have the anchor points and the edge lengths. And I have now these internalized target points before they were there. And now they are here. Just wanted to check if there are other components somewhere that maybe may have their preview on. Let's check this out. Maybe these ones, now these ones are, so let's turn this off. Alright. So we have these base points, these base anchor points, and then these target points. If I don't use it, if I don't give these yet as inputs. And I now look at this result. If I turn this to true. So that's the effect that we get without changing the base anchor points. Now, if I now input these new target points to the target input here, now I get this result. And so basically, what's happening here is that these points have moved towards these points. Now what is interesting as well is that now we can play with these in the viewport of Rhino. So that flexible. Always make sure that this input here is preview on and then you have this off. And then you can play with these with the cursor. Alright. This is small note about not making the value to zero. Otherwise you would get weird behavior of the mesh. If we tried to do that actually here. So I'm going to reset this one. And if I bring this to zero, so the strength is zero and I run it, we get something like that. I mean, even without using target points, we run again. So there are, there is no strength, let's say that is affecting the mesh. That's why we get this. Once we increase a little bit, then we get this result. So that's the only thing to be aware of. Maybe that you leave the input here at zero and then you see nothing. So if you do that, if you keep it at zero, then you run it. And you play with these. Click on these and move them around. That looks like really weird behavior. That's only moving these points when we have target points. Otherwise it just doesn't do anything actually. So that's the only thing to be aware of. So I'm going to change this, connect these ones. So this is the second step with moving the anchor points. Now, the third step is to add loads. Well, adding close to the mesh itself, not the anchor points. I'm going to now to turn preview these off. And I'm going to turn this preview on. And these on the base points and the target points. Then here, the only difference with this one is that I added this vertex loads component that we saw before, which especially which was made for 3D meshes. Why? Because now this load is going to be applied to every single particle or vertex of the mesh. And it is like as if the mesh, they tend cell membrane itself has its own weight. We talked before about kilograms and the uterine units. You are not going in depth into this topic trunk to find out exactly the strength of the values. Because now we're just working with it virtually without a real physical reference. However, later on you can definitely use specific values as per real weights involved. Alright, so I'm going now to turn this on. And you see now I have not yet used the target points as input for the target. Let's see reciprocity between these two inputs and the strength of the edge lengths. So the strength of the mesh itself, how much the mesh itself is strong to maintain its integrity is geometry. And the vertex loads force pushing, in this case downwards. We're using here a negative value. So let's say I make this value less. You see, we get this behavior. You see when I use a negative value, it pushes upwards. And then, and then when I keep going as if it's mirrored effect with the x plane. And so the inputs are controlling the length of the mesh wires simultaneously as we change them. And this is the length factor. So it's as if the length of the wires is at 67 per cent of the original mesh and not 100%. Otherwise. If we decrease it, it becomes more stretched. I will for now keep it at this value. And then now when I play with the vertex loads, if I increase this value going downwards, so it's a greater negative number. So increasing the force that is pushing the mesh downwards. If I change this to zero. But we'll go back to flat because there are no loads being applied to it. Now if I change this to a positive value, we get this inverted effect, like the catenary arch versus the cathodic curve. Alright. So just keep this in mind that these perimeters work together affecting the simulation. As according to the situation or the properties of the geometries involved. We'll have to tweak these parameters in order to have correct or logical results. Depending on the situation and what you have set up in what is involved with all of these jump trees. Now if I connect the internalized anchor points, we get this result. And I can now always move these points around in 3D according to the needs are required. Alright? So this is about adding loads. 10. Tensile Membrane German Pavilion Expo 67 Frei Otto Case Study Part 2: Now the final step, step four, is to define the base and the top anchors. Let's go back to the images of the pavilion. If we look at this actually from a geometric point of view, as you are now working with kangaroo and its components, who are familiar with the anchor points right here. What we can imagine that if for this example, we want to duplicate this example precisely. I would imagine that this would be an anchor point. Somewhere here. It would be an anchor point, maybe this point as other anchor point, this one. And so then the whole membrane is the mesh. And what about these points? What about these tips here? These are also anchor points. So these are new anchor points that are not like the normal anchor points that are at the base. But now I would actually call these top anchor points. So now we have the base anchor points and the top anchor points. This is now the new things that reduced in this example, which is now base anchor points and top anchor points. I will close this and go back to our example. Now. So far, anchor points are used. By definition, points that would usually anchor the geometry to a certain base or to the ground, or to a wall. And so far the anchor points are external. So what I mean by this is that they are anchoring the mesh with the chosen external vertices. But for us now to define base anchor points and top anchor points, we need to introduce new, well, more anchor points maybe in this area to push now the wave from this mesh. So let's see how to achieve that. Let's go back now to the step four. So again, the same steps here. So we have the mesh vertices. In this case, if we go back to the image, we don't have only four points, but we have many more. Along this side. We have 123456 anchor points roughly. So that's not only two points but six points. And so here I would imagine several anchor points here, several anchor points along this side and on this side. Right? And so in this case, this component doesn't really work for me. These four vertices are not enough for me to replicate the example. For that would need now to extract from this mesh certain points. And in this case, I'm using the deconstruct Mesh Component. Similarly to deconstruct be rep, but now with the mesh and we're getting now all of the vertices as an endpoint that you can use as anchor points. And so here what I've done is that I used a list item. So from the output of the vertices, I used the list item and I played with these inputs. Now they are not exactly the anchor points of the pavilion, but rather a quick mimic of the overall shape. As we said before, it's more about the concept of reproducing this effect rather than precisely copying it. So basically here by using the merge with the multiple values, are able to choose several points based on their index number. And then use these afterwards as anchor points. Here it was first done step-by-step until I got all the points in place. You can choose these ones. All of these indices. Want to choose them step-by-step. Then I can check where they are and I can make sure that it's working. And then once having all of them set, now we can connect the merge there. You can always go back to these and change them obviously, but make sure that they are always external. So for now, just keep these as they are. And of course, you can always come back to the number of sliders. Here I used a new shortcut to make it easier to manage and to make things clearly explained. What a lovely to do that you can also directly connect them without any shortcuts. These are my base anchor points. Okay? Now for the top anchors, what I'm doing is exactly the same thing. Extracting from all of these vertices of the mesh. New points, but now in the internal area, alright, not along the external edges. With this multiple values for the merge. And I call these as top anchor points. Now, all of these points are still flat. So it's exactly going with the same process. But now we have two anchor points, component to anchor components basically not only won, one for the anchor points of the base and one for the top ones. The anchor component, one for the base acres. We have this show. We have the edge lengths for the mesh coming from the mesh input. Here, we have another NCL component for the top anchor points for these points. And now let's run the simulation. If I turn this on, we'll also turn the Preview on. We get this. Actually I'm going to turn all of these. So the base points are on, the top, anchor points are on. And you see it kind of stretches the mesh towards these points. But these are still not the top. I mean, not really moved upwards yet. And so in this case, this is where it comes handy to use the target points. So here I will use the internalized drop anchors. As I showed you previously. We can copy this component here. Right-click, click on a generalized data, and then now we can move them. Now we have more of them like this. I would see nothing happening. Why? Because I still need to connect these ones with the target input. And now I'm getting something similar to the example we saw in the images. Maybe I want to move this one downwards. Let's check. Yeah, this one, This one upwards. You suddenly starts to look like the image. So I have actually done this previously with these ones. I'm going to connect these ones there. So this is not a perfect replication of the example, but it is following the same result, the same shape. Okay? So that's basically it. It may look a bit complex if we did not see the steps. But now as we know what happened, the detailed steps, it doesn't look too complicated to us. But if I showed you this final step as a starting point, it wouldn't be obvious why we have two anchor points components, why we have all of these components. It might not have been intuitive. What now as we went step-by-step with the flat mesh, then move the anchors than adding loads and then now adding more anchored components as top anchor points and base anchor points. Now it makes more sense. Now you see that the behavior of the mesh is interesting. If I rerun it, it's like a nice slow bounds of the mesh. You can always go back this input here. We didn't really play with it before with the previous steps. But now you can get a number slider, let's say 1-10 with integer numbers. And then you can change the bounds effect. So if I change this to six, you see now it's much faster. Let's try with them. So it depends on your preference. It's really personal preference, which affects you would like to see or how you want things to look like. Does that for now. Let's bring it back to six. Alright. Now, what if I was actually thinking about that? Well, we saw before that we can actually add vertex loads to this one. Previously to make it sag. Here, will not do that yet. We only use the anchor points and the lead if the edge lengths without the vertex loads and so forth. This result, I'm going to now add the vertex loads and see what happens. To be able to compare with this example. So this represents, as we saw before, the weight of the tensile membrane. If I connect it, sags down a bit. And this depends on this value. And this value represents the weight. So once we know the exact weight in real life, how many kilograms, as we saw before. Now we can convert kilograms to newtons, and then we can give this value here as a negative value pushing downwards to be the weight of the ten cell membrane. If I don't connect it, it is as if the membrane doesn't have any weight. And the shape of it is just only being formed by the mesh edges. How strong the mesh is to maintain its geometry, integrity and the anchor points. If I add the weight, the vertex loads, we have now, let's say a more realistic result. And then what about, by the way, this is now a new component. What about we have windy day? So what would happen? And so what is interesting is that we have this component which is called wind from kangaroo two from goals mesh. This one. And so basically for the wind, when you bring a new wind component, it needs a mesh. So the component will now mimic a wind force onto the mesh with the wind vector in a certain direction. In this case, and I'll give it a z-direction. But you're both x or y vectors work. Here. I used an x vector with a value of 50. And if I connect it, you can see that this is the number of slider. Now it's low in the other direction. So we have, let's say -52 plus 50. I found these values in this example to be the maximum. Otherwise, if I change this to 100, it would not really work. It would kind of break. Let's try with 70 and then reset this one. Alright, now let's push it and see what would happen. It doesn't break yet. Okay. It looks like it's going to break. It broke. Let's see what about the mesh strength. If we bumped the strength here, maybe that would reinforce the strength of the tensile. Could be. Okay, it doesn't break. Let's reset. You see that? We have to play with these. If I now decrease the strength input as if I'm telling it that it doesn't, it's not really strong enough, then it may break. Okay? So I'm going to bring this back, to reset this one. Bring this back to 50. Alright. So this is presented as an example. And it works. Now, what if, What about we want to be more flexible about these points? E.g. imagine that the mesh changes, maybe the subdivision count changes. And then in this case, the points will not be the same. Because as the god of the vertices would have changed, then the choice of indices would then need to be adjusted accordingly. Which would become rather a manual work. Which is not really like parametric speaking. But there is another way which would involve geometry referencing from Rhino, which would make the workflow more flexible and faster. And I think it's more precise. So I will turn this off. 11. Tensile Membrane German Pavilion Expo 67 Frei Otto Case Study Part 3: And actually it's the same, it's the same step four. Step five as we are not adding a new step, but rather changing a bit. The demarcation. What we have done here, instead of using this method, I'm actually now going to use here these curves that I actually drew before. So these closed rectangles are actually drawn to be encircling some vertices off the mesh. And so the red ones here, the red layer is for the base anchor points. The blue ones will represent the top anchor points. Okay? So it is the same thing basically like here. And now the output of the mesh here will be to construct mesh again. But instead of now using a list item with all of these values, I'm using point in curves component coming from curves analysis, pointing curves. And I'm using these curves. These curves, the curves inside Anchors base. And then I'm using inequality, equality, which reads the results from the relationship from the point. So if it was out, 01 coincides and to inside. So I want to find which points of these vertices are actually inside of these curves, these ones. And so I get now this relationship results which I connect with the equality component. So coming from math, equality. And so which ones among these results? Or equal to two? Basically. And then now the last step is to use this dispatch. And then I'm using this output from the vertices. And I'm using this quality, which is true, false results to extract only the true results equals to two, which are the ones inside of this. And then the outputs will get the list, a list to be the true ones, the false ones, and the true ones are these points basically. And so these are the base acres. What is interesting now is that I can get back to this layer and I can turn on the preview. I can change the anchor to be not this one, but sorry, need to turn on the gumbo. This one, e.g. or this one, depends on which one you want to use. Alright. So these are the base anchor points. These are the top anchor points, again with the same way. But now what we're using, now, these curves, the blue ones, to test which ones among these vertices are inside of these curves. And then I'm dispatching the list to get only these ones. Again, I also internalizing them to move them upwards to really have top anchor points and then have the other ones as base anchor points. What else? Before now proceeding? I would need to have like a final step here to add, which is not included in the previous one, which is to have holes in the mesh. So if we go back and look at these images, we see that there are holes in the mesh. If I flipped through the images, we can see these ones look like holes and might have other materials that bring light in without having, let's say rain to go and maybe glass or plexiglass. And this interesting study of the project shows more clearly these holes in the mesh. So how can we have holes in the mesh? Alright? And that's pretty simple by simply calling some of the mesh faces out. Basically. That's the last step that we have to add before using the mesh input for the edge lengths here. And so for this mesh, the original one, I'm using a mesh explored component. Then I'm extracting the mesh area for the image explode. I think you need to install mesh edit plugin. Have already received the list of plugins required for this course. So make sure to install it before you open the file. Because if you open to without having the plug-in installed, then you will get an error message mentioning that some components are not available. You cannot see them because you don't have the plug-in installed already. So please make sure to have that installed. And so we're doing an explosion of the mesh first, which gives separate phases. As a result, it actually looks the same. But now we have the faces separate with 400 faces. And then I'm using this area to get the centroid of these faces, these points. And what I'm doing here is doing something similar to this step. I'm using pointing curves component as well. And I'm using these curves. And then I'm saying that these ones, please choose them. And coal faces, so-called the faces that have their centroids inside of these curves out of the, of this mesh basically. So when I do that, I get the result. And what is interesting is that we can now change this, this selection later on, even while working with the simulation. So I'm going to keep this as it is now. We have called these faces out from this mesh. And this is now my mesh, my hollowed out mesh. And now I can use this for the geometry to preview this on. Let's check this out. This one. Turn this on for the edge lengths and for the wind. Okay, Now before using the wind, without this, let's see what result we will get when we turn this on. If I bump this a bit, we can make it faster. You see now we get this result. As I said before, working with this is flexible. It's actually we can, what you can do now is let's say if I want to move this hole in the mesh, maybe there, I can simply move the curve. You see how it affects the mesh. Maybe in other situations I want to make this bigger. I want to capture maybe more faces. It really depends on what you want to do to achieve what is your goal. Maybe I don't want to have this anchor point as a base point, but the neighboring one. No, you see it did not work here. Why? Because I did not say hit or match the point. If I turn this on, you see it did not headed. So if I move it there, it'll bring it back. You see? So if I move it out, It's not finding any point. It's not working. If I'm over there, it will find that again. So that's what I was meaning about being more flexible. We're now using reference geometries from within Rhino to link them with Grasshopper to make kangaroo understand that these points should be base points or not, or the whole should be there or not, etc. I'm going to now to undo what I've done here to keep the example as it was before. Alright, I think that's how it was. Let's turn this preview off. And again, if we add here the wind, we will get this effect. This is using the y-direction. Alright. I'm going to turn this preview off. Now, one thing or issue that we have now is that the mesh itself is not totally smooth as it would be. In other words, this step of smoothening of the mesh could either be like an easy, straightforward step or it may need, let's say, more work to make it look like exactly how we want it to look like. Now I'm not going to spend much more time to perfectly solve it. Exactly as smooth as it would be. But it's technically about showing you how we can achieve this initial result with kangaroo. The second part of the work would be more working with the mesh itself. But there's actually a quick step that we can try, which is weavers components. So in this case I'm using a weaver birds got more Clark subdivision. But before going there. And the output here is the data. So all of these are database. And I want you to extract the mesh because as we saw before when we had the show on and off, we had the mesh with a lot of geometries. And actually this is still running by the way. I think because of the wind. It keeps blowing on it, preventing it to converge at some point. I will take this out for now. Anyway. So if we have a lot of outputs other than the mesh, I'm only using a Mesh Component and then cleaning the tree with the remover, nulls, Invalides, and empty. All of these would be true. And then I have only the mesh left out as an input as a result. Now it's working fine. And then here I'm getting this component. The weaver birds got more clerk subdivision. This is a quick description. It says calculates the type of mesh based on recursive subdivision described by Edwin Catmull and Jim Clark at first and their paper. And then the resulting mesh always consists of Quad faces. Okay, So that's what we have to keep in mind. Otherwise, we can also use other components like this one, which will have always triangular faces. In this case. The sentence in the middle of the second line, the resulting has always triangular faces. While here it says it will only be quadrangular. Now, when I click on this, turn this on, you see now it's a bit smooth and here are interesting inputs. If I use this as fixed. So the smooth naked edges input, it says defines how to treat the naked edges, the external edges, and also these ones, because these are also considered as naked edges. Either fixed. So naked edges will not move or be modified. And in this case, at this point, that is pulling towards these points are not considered as naked edges. And actually you can look back into these images. You see that here the membrane is cut and then there is a structural column continuing. So also here. In the same way we can later in more developed status, we can cut the mesh here to make it look like in the image. And then we can of course continue with the lines and the curves. And so the first option is to have this fixed or smooth. So the naked edges would tend toward a spline. You see. But now this became smoothened. Now if we look at the images, zoom in a bit, these seem to be pointy, but actually the base anchor point is much further somewhere there. For this one is obviously there. Or third one, corner fixed, which means corners, two-sided vertices will be fixed, while other naked vertices will tend toward a spline. So the corners here are pointy. But the remaining ones will be, let's say, more curvy, more rounded. So you can play with these and check the results. Hopefully that this would give you the result in intended without needing to add more steps working with the mesh itself. Because that would be take more time. 12. Tensile Membrane German Pavilion Expo 67 Frei Otto Case Study Part 4: Alright, in this step, it is kind of dirty to Kangaroo, like kind of continuation on what we have seen like the simulation process. It is a visualization step that I think would not only like visualize the results, but also enhance them, make them more apparent and understandable. I won't actually show you the final result before explaining how to reach it. Making sure that these are off. Alright? So the visualizations that consists of adding colors to the mesh faces based on their respective sizes or areas. The areas of the faces for us to see now the result. Because I see nothing here in the Viewport of rhino, I have to turn this on. So turn this the only draw preview geometry for selected objects off. Like this. Then right-click and show the select, Show Preview on the Select. And then we get, we get this result. This interesting visualization or a graphic of our resulting mesh. This is like a really simple script here added to the output. Here we are. I'm just extracting the mesh as previously shown here. So the mesh coming out of the data, I want the mesh. I'm cleaning the tree because it has so many things other than the mesh. Now we have only the mesh. I use, the mesh explodes. So I, if I go with this step-by-step, we have the mesh explode. I'm extracting the phase boundaries. I'm exploding the boundaries. And I am here from the vertices of the boundaries. Building surfaces not mesh. Then finding here the geometry. So basically the areas of these surfaces from the area output abusing pounds. And I need bounds. This one will give me the maximum and minimum of all of the areas. So if I get the panel now and check out the areas, we have all of these areas, but we need for the coloring now to give colors. And this actually is coming. It's coming from parameters, input gradient. We need the lower limit and upper limit and then we need the parameter. So for the lower limit, after we extract the bounds, which is giving us now the domain minimum, maximum. So from 145, etc, 293 or nine, et cetera. So we use this deconstruct domain as a final step coming from math domain, deconstruct the extract these two values. Alright. So that is now so wonderfully to the end is the 93. And then now here I'm using, I can now start. I can actually start with this, starting with the lower limit, and then this to be the upper limit. And all of these areas will be the parameters for the parameter input. Basically. Then I get this result. Or as I did before, I just switched them. So now what is happening is that if you imagine that along this line, the gradient, we have all of the values from the smallest 142 here up to the largest. It was like 9.309, right up to there. So something in-between, everything in-between would be colored according to these colors. So they would be in red. The biggest ones. The smallest ones here will be in red as well. The bigger ones tending more towards orange. So starting with red, magenta, purple, blue, green, yellow, orange, red again, I thought it could be more interesting if I actually flipped these, invert the results like that. So that's the smallest ones are actually here, shown in yellow and orange. We can also use another gradient. Now, we can go to the presets. We can select e.g. this one. I will also flip these again, lower and then higher. So this shows us that the smallest ones are in green and the biggest ones are in red. This could be less confusing in terms of colors, because with the previous one, we were getting ready for both biggest and smallest values. Alright, so the greenest ones here are the smallest ones and the yellow than red. And we can go back to these ones. We can play with this, you know, maybe black and white stood up to you. This is just like a personal preference. Actually depends on which kind of diagrams you want to get out of this. In any case. One thing you would ask me why aggravated the meshes into surfaces. I could have also gotten the mesh area. There's also this component, and I can use the same one. The thing is that the graphically it will not look like this. Nice, like this one. What I like about it is that it looks with glossy or shiny. It has a nice shine to it because it's based on surfaces. If it was a mesh, it won't look like that. It won't have the shine that the surfaces provide. What would rather look more faded or the linear way. You can try this later if you want and check out how it would look like with the mesh. But this is just a quick explanation about the conversion to surfaces. Because this is only for purely visual purposes. I mean, if Graphics don't really matter, then you can surely directly use the mesh areas that without having to use that extra step. Alright. So with this last example, unit two is completed and see you at Unit three. 13. Thin Concrete Shell Heinz Isler Case Study Part 1: Welcome to Unit three class. In this unit, we're going to look at a UK study. It is the case study of Heinz easily as an adult, the attack could sing, and this is the German pronunciation, which means the National Theatre in London. And it is a thin concrete shell structure. So we're going to look at how we can actually build or replicate this thing. Concrete shell with canker to physics and also trying to mimic as well ions easily as previous methods that he actually used in the lab, like the analog one. But then we're doing this one. Now, the digital tools. Alright, so before we start to look at the grasshopper file itself, I'm going first to show you the images part of the course files. So basically, these are the images of the project. And you see this is the shell. Obviously at this point where the shell is grounded or anchored to the ground, it is much thicker than there. These are the images from the lab during the analog studies of the shell. And of course you can see the anchor points or the anchor sides of the shell. And then here also other Rochelle forms that have been plastered. I found an interesting website actually where I found these plans. And this one and this one, these two images. This one and this one, I found this website. It has shelves that Princeton dot edu. And in this website they have a nice article about this project and they have drawings about it and a lot of information. And what is really interesting is that they provide like many images and diagrams like this one, e.g. as well as let's look here. This one as well. And so from this image, I was able to trace out the outline of the base mesh on which we would run our study. So it's a nice opportunity that we can now try to test out kangaroo with the help of the sketch and see what simulation results you would get. These are also informative structural diagrams. So as I said before, kangaroo is not a structural analysis program or plug-in, but more a form finding plugin based on Hooke's law. Of course, if you want to dive deeper into these structural analysis side, you can surely use other plug-ins like a rumba or other ones that are more specified. For structural analysis. Means, however, using kangaroo and not like a structural analysis tool. So let me go back to here. I'll close this website and you actually have it here. So this is the link in case you want it to go back to it and check it out again details. And so what I found really interesting in this online article about each layer structure is dimension of the form finding strategies that are now trying to reproduce in kangaroo virtually. But those days when these structures were built, they were done in an analogue way in the lab. So I chose these two paragraphs for you from the article which I found really interesting as a historical link between when these buildings, these structures were actually designed and what you are now trying to do by replicating virtually in kangaroo, sitting on our desk in front of the screen at trying to do something that would take us a few minutes. But back in the days, we'll take them hours and days to test in the lab and then reach the final results. So it goes like this. At the first Congress of the International Association for shell structures in Madrid, 1959, is little presented a paper that outline these new ways of finding shapes for shells. These methods were first that really shaped hill, secondly, membrane under pressure. And the third, the hanging cloth reversed. So the form of the network the attacker singing was found with the third way, which isn't there believes is the most efficient and accurate methods since the loads acting on the hanging model and it's reversed form are both gravitational forces. The principle behind easily as Hagen cloth method can be understood as the three-dimensional version of folks discovery basket, a quotation. You see here the mention of Hooke's law, which we saw in the very first unit, that everything in kangaroo uses the Hooke's law. So it goes further continue. A piece of the cloth that is hung from several fixed points would create an ideal form that is completely intention. Over this shape is frozen and flipped. The resulting shell should be incomplete compression, which is convenient for concrete structures since concrete performance well in compression but poorly intention. The main difference between the work of Gaudi and Islam is that the Spanish architect found this form or this form through a network of two-dimensional case and 3D shapes. While the Swiss engineer also used one hanging elements, a piece of fabric to determine the ideal form of a structure of quotation. Also see this reference to K2 reshapes or catenary curves, which also we saw how to replicate visually or virtual actually didn't kangaroo. And as well as the piece of fabric, which basically refers to the mesh geometry. So I just wanted to make this small historical link reference between what was done in actual reality and what you are now replicating. And I could really imagine that maybe back in those days that may be both cloudy and Islam, or if they had those tools in their hands back in the days, they would maybe have used kangaroo actually to make their studies. Alright, so back to our example. What interests me now is this plan, because this will help me trace the base mesh of the project and then also try to find out at the end the height of the shell. The thickness of the shell will actually give the thickness to the mesh to mimic the real project, etc. So now, as information provided in the article, the span is 42 m. This image, we see that it is 42 m spanning in width and then to an 8 m in depth. And then the height. When the geometry become converged in kangaroo terms. Then it is 10 m high, and then the shell thickness is 9-12 cm. Okay. So let's go back to Rhino. And I have here imported this image which was found in the website, this plan. And actually here there are two study plants. However, the end result was based on this one. What we have in this image, both, I'm now tracing this one only. I'm going to lock it. And here we can also double-check the dimensions, the width of it. Let's go to top view. That from this point to this point, it's around 42 m. Almost. Not like pinpoint because it's like, you know, like a sketch declines. Alright, and then the units of the file are in meters. That's an important, That's important. Okay, so once having done that, then we can trace it in this layer. Here. This is how it's organized in different layers. So we have the image reference here, then we have the shell plan, trace and mesh. Now at the beginning before having this as a mesh, because all of these are now meshes. Individual matches are different ways. You could either directly just go to the Mesh Tools and then click on this component and then start to trace. That's something you can do obviously. And here you have to see after snap. Still, I think it may not be, let's say, helpful this way to make things that are straight because I'm not able to snap to this point. So e.g. e.g. that's one unit mesh. Careful to turn vertex and zero point on. So that's something now I can snap to this one. But maybe this one, this is not fully straight because as we saw before, it was not snapping to this point. So that's one way. The other way which actually recommend to do is to just trace first with lines. You can see here that this man is symmetrical with this x being the mirror axis, right? So we just need to trace this part and then we can mirror it. And what I've done before is that I have traced these lines like this. So that's the first one. Something like that. Look there. Maybe now I can hide this one and delete, delete it. And then I got these two, these two polylines and then after that, I would convert them into surfaces. So planar surface like that, I did it the polylines I have now the surfaces, then I have to convert these into meshes. Mesh I can use fewer polygons and then I delete the surface and then I am left out with the meshes. So that's how I reached this result. If, let's say for any reason you want to do it with the one like trace the mesh, like the single mesh faces. If I do that, let's say this method, you will not get these lines. You will not get these ones. So that's something to not be worried about, just to let you know that this is how converting surface to mesh, you will get these lines. Otherwise you won't get them. And so basically these are now the mesh faces individual phases. Now let's go to grasshopper. Alright. So the first step is to reference these mesh faces with this mesh component. Now, these two components are extremely important to have a clean mesh before we start extracting from the mesh all of the necessary vertices or use the match the mesh itself and other in order to use them and kangaroo components. So before doing that, we need to make sure that the mesh is joint and clean and so forth. To do that, we have our first using this mess joint component from the native mesh utility sub tab from Grasshopper. And then we have the mesh Weld Vertices. It's coming from the same place, but part of the mesh edit plug-in. And so you can see here the difference when I check out what's going on. So all of these meshes are separate individual mesh faces. And then once I joined them, I get this mesh. It's one mesh with joint faces. And then what I, well, the vertices together, then I get this result. And you see here, now we have a smaller number of vertices, which is good because otherwise, before we had duplicate vertices, which is not good. It is not a clean mesh to start with. Alright, so once having reached a good clean mesh, then now I'm doing this discretization step of extracting the anchor points, et cetera. Now for the anchor points here, we see from the image, maybe this one that these sides here, these segments are anchoring the structure. And I know here I can spot them easily. These are the ones that I'm anchoring at the ground. And so for that, we need to just extract now the points there that would work as anchors. And so here also to show you in the layers of rhino, we have also, we also have the dimensions layer that I make to check the dimensions. By the way, when I traced it based on this plan. Based on this plan, when I had the width of the mesh exactly to be at 42 m on these edges. I got it depth when this gate was proportional to meet this dimension 28.5 and not when exactly, it should just let you know to avoid any confusion. Here, it says to 8 m, but when someone wants to trace this one, you will get 8.5. It's not a big deal for us, but just to avoid any confusion later on. Again, the main goal or purpose of this case study is to replicate the behavior of the thin shell, but not to meet the final result vesicle. The vesicle results with millimeter precision, since we don't have the necessary information for that anyway. So for further structural analysis, we would need other tools. As we mentioned previously. Alright, I said before that we found these parts to be the anchor points of the shell. And I drew this layer, which I call curves. Anchors just drew rectangles around these sides. Basically. They don't need to be this super clean rectangles, just closed polylines that include these parts inside of them. And once I've done that, what I'm going to do now is to extract these points from the mesh that are inside of these polylines basically. Alright? And the step is easy. I think we've seen this before as an, a previous unit. I'm doing it. Deconstruct mesh first, then all of the points, the vertices, then this component is referencing. These anchor points is anchored, anchored curves. These are the curves for the anchor points. And then I'm extracting the relationship of these, all of the vertices with these curves. And I'm only now interested with the ones that have the result of two. Which means that these points are inside of these curves. Which among all of these points coincide of all of these curves. And then I'm using here and equality component, which one's religion is equal to two. And then I'm dispatching this list of points and then I'm using this list a, which is all of the points inside of these curves are polylines. And then I'm getting these points. So now it's like a quick way of extracting these. Then now I'm doing, I'm done with this step which is finding the anchor points. And I'm using this component for the anchor points, which we have seen before coming from goals point. The second step is we want now to define the mesh. And we want to tell kangaroo that this all of this mesh is one piece of geometry. One piece of mesh that we want to maintain or we want to control the edge lengths of this mesh basically. And so this clean mesh that we got previously, the output here, this is our mesh. And third step, we have to also apply some vertical loads because otherwise nothing will happen as we saw also previously. So we need now to apply forces onto all of the vertices with the vertex loads. And we saw that now we are using this one for the image versus the other load component, which was only for individual points. And then finally, the show component that will actually give us the mesh as an output. Otherwise, without this one, we won't get the meshes and output. And putting all of these components will expand this one a bit. Being one merge component. And then I'm using a bouncy Solver. Now, this was set to true. I'm going to set it to false, to rerun it. I'm going to click on this, go to perspective view and check out the results. Turn off these. Now click on True. You see that now what's going on is that these points are working as anchors. This is our mesh with the edge lengths. And then the vertex loads are pushing upwards. These have a positive value. Otherwise, if they were negative, they would just sag down and if it was exposed to gravity. Now if I want accelerate the behavior, I can hear bump up the value for the iterations. Let's say 15. And I'll bring, bringing this up back, back up again. Because of course, what do you increase the value more and more. Of course, it's going to push it more and more. And so the behavior of this is controlled by the vertex loads, strength as well as the edge length, a length factor and strength. So if I bump this one to one or more than we see that now at the lengths of the edges are now longer than original ones by 50 per cent or more. But I want to keep them at one, or I want to make them at 90% or 70 or 60, etc. And there's also the strength of the edge lengths. What I've actually found is that when I put this one in top view. And one thing that we want to also need to consider is the height. Remember that we saw that the height is 10 m, right? So now in order for us to match or find this geometry, I'll go to front view. And here I made the new, new layer called 10 m line. And with this layer, this line is a reference height for us. Know what you can do is that we can control our inputs here to make it match this line. So maybe I can now drop down the vertex loads. It looks like maybe at 2.5 more. 554, I think, was the value that was very close to the line as well, basically now what are matching almost the original shape of the concrete shell? Otherwise, we can also play with these ones. But obviously, if we play with the edge lengths too much, then we will get, let's say, a deformed geometry. More or less. Or in other situations, we can make it, we can keep it at one. And then when we go to the front view, then I decrease the vertex loads. But in any case, I found this top view to look a bit farther than the real shape in plan view, at least of this plan. That's why what I found here is a good combination of parameters that's working to meet the shape is to have this at 0.9 and then have this at 2.54. I found out that in plan, the resultant matches more nicely the curves here and here, obviously going to push to the inside because of the shape of the geometry. And if we go back to this component of the boundary Solver, click and hold, you will see how it starts and then it reaches the result. Click hold. And then and this is in front of you to check the 10 m height. This is until now, like a quick demonstration to show how we can quickly replicate this case study digitally instead of doing it in the analog way in the lab. Now, what if we wanted to give a thickness of this shell? Because, I mean, obviously this shell has a thickness is not like a flat tensile structure where we would say that it ends. A membrane is super thin or it is more or less zero thickness. Usually in kangaroo or rhino, who would like to give thicknesses of a few centimeters or something. It depends on the geometry. But for tensile structures, sometimes we can ignore that and we can keep them only. Keep the mesh faces without thicknesses. But in this case, these are mesh faces. We know that this concrete shell that has a certain thickness of 12 cm. And so in this case, the output of this as a mesh, and I'm using clean three because I know that here we have the output includes many more elements. I'm telling the balances solver, I need to find, to find the mesh and then clean this tree. So clean all of the empty, invalid and outputs or inputs, and then only be left out with the mesh. Then now here I'm using this weaver bird mesh thickens component coming from weaver bird transform. And this one will give the mesh thickness. And so from this, we get this basically. Now obviously we know that the thickness is changing and it's not, let's say the same thickness all along this mesh. But for now we're just using one thickness for the whole mesh. On another thing that we can also look at is the kind of refined a bit, the geometry. And this can be done with weaver birds, Catmull Clark, which we have also seen before. So from this mesh, we can now make it more refined, quote-unquote. And you can play with this smooth naked edges input here. So to either have 01 or two depends on what you want. Here. I'm using a level two. And then for the smooth naked edges, this is at zero, means fixed. So I just will not move or be modified at one. Smooth edges will tend toward a spline. We can see the difference here, here and there. However, in this case, even these ones will be changed to splines. So this is not actually what we want. Or two corners, fixed corners will be fixed while other naked that will tend toward this blind. And also think that this case, all of these work except for these two. For some reason these are not behaving like these ones. But in any case, I'm not going to try to solve this now. We can later use other tools or methods that can, that are specific to. Solving this, maybe by extending the mesh downwards and then got it, trim it, and then reached a level that you want. But most importantly, this is what we need to know from kangaroos part. And then we can add the thickness as well. So this after smoothening the mesh, then we can add the thickness again. Now, something I found to be interesting as well here to, let's say, visualize the results. And it is actually the same thing that I actually used to make the background. Here. This illustrative background, which is with the colors and then with these vector arrows. And so basically here, what I did, adding this part that gave me that result, I simply started with the mesh first. The output of the kangaroo result. Clean again. Well, actually I don't think I need to clean this one because it's already cleaned. So I will take this one there. So we first start by exploring the mesh and I'm transforming it into surfaces. So extracting the phase boundaries. And then I'm exploding all of these boundaries and extracting the vertices out of which I'm building now, it will new four-point surfaces. And then here I'm using an evaluate surface of all of these surfaces in order to extract their normal vectors. And then using the points, I'm using these points to be like the hosting location for these vectors. And then with the height of these points. So these are the center points of the surfaces. I'm deconstructing their x, y, z values. And then since the z is the height, I'm using the z, the heights of the points to be the amplitudes of the vector display. When the point is higher, the effector is longer, bigger, when it's lower than it's smaller. And then here, all of these z values of the points, I'm finding their bounds, minimum and maximum. And I'm inputting. Now I will turn this off. And we'll also turn all of these off here. Yes. So basically I'm using these bounds, the extremities of the z values. I'm telling grasshopper here with this green color component, please use the starting point to be the upper limit here, and the endpoint to be the lower limit here. All right, I could also have done the opposite, but we can get flipped results. Now, let's say that the starting point is here and then the end point is there. And then all of these z components are my parameters. And then I'm giving not these points, not just parameters, but the surfaces themselves, colors based on the height of the points of each single surface. Basically. This is what I'm, what's going on here. What is interesting is that we can rerun it and then see it playing. Like I said before, that I liked as a personal preference to flip the colors. So to have the starting here inverting the colors. But otherwise, we can also right-click on this gradient color and then go to the presets and then choose another preset altogether. And then you can say, you know, like the start screen, the nth is red, which means that the lowest point surfaces will be green and then the highest will be red. And so this is more descriptive diagram showing the heights. And then I get rerun it. And what is interesting is when we click and hold the reset button and release and see this relation progressing. Alright, so we have seen how we can visualize these now just bringing this back to where they were. 14. Thin Concrete Shell Heinz Isler Case Study Exercise : Now let's try something different. And here, let's actually try to do this as an exercise. Please have your files open and please try not to look at this part here. I mean, this is the solution of the exercise. But what I would like you to try to do is this. I will now show you the gold needed. First. I will reset this one. Okay? Reset this one as well. Okay? So what we want is if you could now do this. So we already have in your file now, you have this part. You have the mesh, you have the anchor points, right? And now we need this again for the exercise. So we need the anchor points, we need the edge lengths, we need the vertex load obviously. But the difference now is that we have this hole in the mesh. Alright? So how can we reach this result? From this one? I run it from this result to this. Let's say that, you know, our shell has something, they're under it anchoring down. Maybe it's a booth or something. Maybe also later we can see if we can actually move this upwards and it is in the z-direction. But for now, let's try please. Let's take 10 min, maybe. Let's take 10 min, and then please try to replicate this example. And then after that, we're going to come back and then take a look at what would be the solution. Of course, there is no one solution, but there are many possible solutions. I'm going to show you my solution. So please try not to look at what I've done here before it reached the solution. Try it on your own to do this, to reach this result and look for whatever components that you might need to reach this and see you in 10 min. 15. Thin Concrete Shell Heinz Isler Case Study Exercise Solution: Alright, so I hope that you have found a way, an idea to reach this result. What I'm doing here is I'm taking these anchor points exactly as they are. Just making this shortcut here. Putting it here as the anchor points, I have the anchor component here. And now the change, the main change is applied to the mesh. And with that, we saw before actually with the previous unit when we were making holes in the mesh of the tensile membrane. And then we used some curves actually. And so here I used actually the same, this curve, only one curve from this layer. I built this curve in Rhino and this is called curves called mesh. And this is the curve referenced here. What I've done here is exploited first the mesh explode. Then I extracted all of these centroids of the mesh faces with the mesh area component. So all of these are the points, the center points, and I use this component called point and curves. This one, what it does is that it will find for me the points that are inside certain enclosed curves, polylines basically, or spines and it can be just curves. And then I used a cold phase component. We also used this one before. And with this one, we can remove select faces. And so from this original mesh, mesh kill one. I'm now calling only these two mesh faces that have their centroids inside of this closed curve. And then I'm using this output mesh to be my new mesh. So now, instead of using this previous mesh for all of these edge lengths and vertex loads. Now I'm using this mesh with a whole new one for the edge lengths and the vertex loads basically. Now, even if we do that, we still need another step. And this is because now if I keep this as it is now, without adding any other new step, and I tried to run it, we get this result. So it is like this one but with a hole there. But actually what we saw is that we need the hole to be anchored. Also. It's anchored there. It means that we need to add more anchor points. Alright? So I hope that you also have figured that out, that you also need another anchor component. And also what we need to now extract these points. We want to define these new anchor points. And that's by these colored faces. I'm using weaver birds naked boundary component. This one. This will give me the curves, all of the curves as the naked boundaries of the mesh. And what I'm doing here, I'm just sorting out with this sort list, the one that is the smaller in area. So it is a parametric method here. But of course this may not be applicable to other examples where let's say, I don't know. We may have, let's say, the same size of all of them and then you need to choose one specifically. Then maybe you need to find another parametric way to choose that specific curve. In this case, what I know is that I have two curves and that I'm only interested with the one that is the smaller curve. So I'm just choosing the area component and then I'm sorting this list of areas. And then I'm using a list item, I'm extracting the smaller one. So index zero, I know that. Now we have all this sorted out from the smaller to larger with the values out, not the keys out obviously. And then I have this curve selected. And then after that, I want now to explode this curve into segments and vertices because I know that this is coming from this previous mesh phase. And I know that this curve has zero points there. These are the vertices. So these are now my exploded curve with these points. And then these vertices now are my new anchor points. So new anchors around the whole opening. And then I'm using a new anchor component. So basically now if I click on this, I see this result while seeing the result. While this has been converged, I can now link this one there and attaches now to the bottom side to these new anchor points. Alright, so this is one way to reach our goal. A further step that I was thinking of, that Well, maybe there's been like a actual move upwards in the z-direction. Maybe. I don't know. Maybe like under the shell there is a small room, maybe a kiosk or a ticketing booth or something. So if you consider that, then we simply need to just use, well, the target input for the anchor points, for these ones. And then move these points upwards. In this case, the same points. I just use the Move Component with the z. Then here, if I click on this one, now I'm moving these ones upwards. And now it's like zero value, so nothing has changed. But if I now try to play with this slider, now I get this result. So you can imagine that now there's, let's say Walls under this opening. I don't know if for any reason. And then we can now play with this geometry so fast, so quickly with these components. And imagine that if we're now doing this in an analog, analog way in the lab, we might have to spend more hours to build this membrane that we are working with. But now, with this digital tool, it is super-fast. Now, what if someone in the design team, while designing, they decide maybe we want to move this whole somewhere, somewhere else. Maybe. Maybe I want to move this one. Let's say the back. Simply I can grab this curve, select it, and I can move it. Or I can move it to the side. Maybe my opening is there. And maybe it's also moved upwards, maybe downwards. I don't know. Let's now change this to negative 20 as my minimum. Instead of moving it upwards, I'm moving it downwards. It is very flexible to change. You see that it's only now taking one phase out. Why? If I look at the original mesh, you see that? Well, actually at these points, the points you see that we only have this point inside of this curve, which is the center point of this phase. This one. That's why this phase only this one got called out. If we move this one, they're, both. These ones will be called that it's illogical behavior. You see now we have four, because this rectangle is now having all of these four points within its boundaries. Alright? So I'm going now to undo all of these movements here and here. So the same thing here. What we have done before is that we give it a thickness and also refined the form with the thickness again. If that's what you would like to reach as a result. Alright, so please, if you have any questions about this, please email me your questions with snapshots and files about any specific components that we're not working with you, please let me know about them and thank you very much for attending unit three and see you at Unit four. 16. Planarization of Meshes and Polygons Part 1: Welcome to the unit for class, where we're going to explore methods and binarization of meshes and polygons. So for the unit four, we're going to look a bit shortly about how we can do the polarization with kangaroo is 0.099. It's a good way to start trying to find ways of thinking of how we can actually find the correct components that are, that are actually used with kangaroo. And then later on, we're going to see the same process but with small differences with kangaroo two. So here we have the regular polygons and polylines, then meshes polygons, but with circular and spherical cap linearity. Now, the main focus of this unit is going to be on linearization of hexagons. And that's because it is a more challenging thing to do. Rather than plenty rising quadrangles. Simple quadrangles is more challenging and it's always, I mentioned topic in parametric design. We can actually bring arise hexagons, hexagonal patterns of a facade, like a glass or any surface, making the hexagonal cells or panels flat. And of course, this method can be applied to blend urbanization of quadrangles, pentagons up their guns, and any types of polygons. Basically. What before going into that, I would like to first have a quick look on hexagons. What are hexagons? And also have a bit of knowledge of previous examples, previous projects that were made with Blender hexagons. First, I would like to say that a grid of exclusively regular hexagons can only be flat, exactly like a honeycomb. That's what I'm saying. Regular hexagons mean that all hexagons are regular. That they have the same length of their sites and the same internal angles. So what is a hexagon? Basically? And here are a few sources for you. I will open them in the browser. So the first one is about what is a hexagon? This one, this is the question. And it is a two-dimensional shape that has six sides, six vertices, and six angles from the name hexagon x. We can find them around us. I mean, here in nature like an honeycombs of bees or like in soccer balls. And the types of hexagons are either regular hexagon like this one or irregular ones. Now we're going to see that we cannot have regular hexagons that are planar and at the same time laid over a curved surface. So we need to know that the interior angle of each corner of the hexagon is going to be 120 degrees. That's basically the main idea. The same angle, 120 degrees, and then the sides are equal. And of course the total is going to be 720 degrees. Alright? Now, the second thing I want to show you is about the honeycomb structure in nature, which is space efficient and strong structure. And this has been known since early age of humanity when we started to observe things around us, then discover things and how nature works, etc. What is interesting about hexagons as a geometry in real life is that they maintain a bigger area possible with the smallest perimeter possible. So let's say, let's say we had like a square with a geometry, e.g. in opposition to a hexagon, it would need more perimeter or wall area to enclose a smaller floor area. But the hexagon has a better area. Efficiency ratio includes a bigger floor area inside a smaller area. So hexokinase and close more space using the same amount for all material. Basically, as I said before, the pattern will be planar. And of course in nature we could see sometimes like wasp comes or even wild bees, honeycombs that have, that might have been deformed or curved. But since they are not flat, these hexagons forming the columns are not regular ones. Now, the third link, I think I missed it, I will copy it. There. It's about the geodesic polyhedron. So this type of geometry can actually have flat x against y. The geometry itself is not flat geometry. There is a spherical geometry. However, we must have, together with the hexagons. Their guns and other types of geometries or polygons. So this is like a more detailed explanation about different types of polyhydramnios. So you see this is the geometric reconstruction of a soccer ball with hexagons and pentagons. Okay? The last two sources, right, shows are about precedent examples of pavilions that have been actually made out. Well, they call them hexagons, but they're not regular hexagons. The first one is this one. We can see here how the Mexicans are very deformed and changed, not maintaining the regular hexagon shape to reach the main shape. The pavilion. What is interesting is that they mentioned in the article about kangaroo that thanks to the use of kangaroo plug-in with Grasshopper realized by Daniel Parker, who is the person who actually developed kangaroo were septate the constraint for the calculation of the binarization of all the elements and then the final shape. So they actually used Kangaroo to reach the final shape of the pavilion. I think this is a snapshot from the rhino viewport. This is a Nested layout of all of the panels for CNC cutting. Alright. And then the final example project I want to show you is about this other pavilion where we see how the hexagon is hadn't been deformed in a way to form this final shape of the epithelium. And always keep in mind that we can never have a curved surface of regular hexagons. And so this is a quick introduction about this unit and how we can replicate some of what we have seen. First, we have here, we'll close this one. So basically here, what I made in Rhino is I modeled two curves. This one and this one. And I made it a surface out of these two curves. So the first one is this one that works as a rail, and this one is the cross-section. Both of these with the sweep component will give us the surface like this. And I intentionally made it curvy and not flat surface because we want to test how we can first make a pattern of hexagonal shaped cells onto the surface and then tried to flatten them out. So I'm using here a hexagon cell component from lunchbox plug-in. Alright, with a certain number doesn't really matter. The number, both in u and v directions. And we noticed that for the ones who already have experienced with lunchbox, that all of these components, except for the hexagon cells, all of these will give us the resultant panels, basically surfaces, except for the hexagon cells. It doesn't give us surfaces but only cells or polylines. Alright, now before diving into the definition and the solution, I would like first that we can think together what would be needed in order to make these hexagons flat? I mean, we saw before with kangaroo that it can actually use Hooke's law as a base and make it very arches and get to revolt or meshes with the components. But what is interesting now is how we can actually use the same Hooke's law engine to let kangaroo plain rice geometry. If we look at this geometry and we tried to reflect on it, to polarize these cells, we would need maybe I will type it here. So let's say, what do we need? Maybe we would like first, this is on. So we would need to flatten or plane arise. Let's type it. Flatten or playing arise. The gonadal cells. Maybe. Also, while the binarization is happening, we would need to maintain these corners, right? These corner points. We could also call them the anchor points, as they are anchoring the corners. So maintain the corners. Anchoring. We would also like to maintain maybe the length of these hexagons, the cells, while the polarization is happening. Of course, we're going to have some compromise. We're going to say we want to push the strength of maintaining the corners. Where they are at a really high value and also would like to maintain the length of this, of these cells very strongly without having some compromises. Because if we do that, the current shape stays as it is without any polarization. So we will need, we'll see maybe giving the polarization force a bigger value and then smaller values for the others just to maintain them in their place more or less. So also maintain the hexagon Hexagon sides, insides. What do you think? Any other points? Also, you could try to think about maintaining maybe all of these like hexagons within the original surface. I mean, maybe that while the polarization is happening, these might drift away or to the inside of this surface. So maybe also maintain the original outer edges? Yeah. I think outer edges of the main surface. I mean, not the outer edges of each hexagon, but of the main surface basically. Okay, so that's a starting idea. Or points, starting goals. Now, let's start with the first one, flattened or playing arise the hexagonal cells. As I said, I'm starting with kangaroo 0.099, which is this one. If I go to forces, I will find here I can see to be the realization components. The first one is this one flatten a quadrangle quadrilateral, and the second one is binarize any polygon. So if I bring this one first, flatten a quadrilateral. So it only needs four bytes. Now we have existence, we have six points. So I don't think this would actually work for us, but good to know that this exists there. Let's go back to here forces and then go back to this one. So plain arise any polygon, it needs vertices. Okay, So it's interesting. Now what's giving us more flexibility to print arise any polygon. In this case, we have hexokinase. That's the first one, maintaining the corners of each hexagon. Let's see what we can use for this purpose. Maybe we could try to use either anchor spring or actually when we use this kangaroo physics simulator, we could also use the anchor points input. Maybe. If we tried to use that one, we can check the chicken at that route and see what happens. So this is for anchoring the points. Now I would also like to think about maintaining the hexagon sites. The sides means, in other words, these segments, these lines. And we already know that there's this interesting springs from line component that will actually do this thing. So we can use this one for these lines. And then the final one maintaining the original outer edges of the main surface. It could either be anchoring these points like these ones. These points there that are not the centroids, but these are the ones on this curve. And I think one interesting component could be a curve pole. So if we want to pull these points onto this curve, then this curve on this side and etc. So these are our starting steps. Maybe they all work, maybe not, maybe most of them work or some of them work. Let's check them out. I'm going to just move these ones downwards to make this, make things a little less dense. Okay? So this is our starting point. Now, let's start with the component. First. What I have done here from this hexagon cells component, the output of it are here, the hexagon cells. And so this means that if I use a list item, this one, they're just check out the results. So here I have all of these hexagons, each one alone. Okay, that's the list of the existence. Now, in order to tackle the first point, print arising the hexagon cells. We know here from this component, from this one, it needs vertices, right? So from here, we need to extract the vertices, the points of this hexagonal cells. And that we can do this is explored component coming from curves, utilities then explode. So we are exploring all of these polylines into separate segments, individual segments and vertices, right? So you would imagine that the output of these segments, we can see this list of all of these segments. It's a tree of lines, separate segments, not joined as polylines. Here we have five, I think one of the edge, these F6, so an index of five. So there are six sides of the hexagons. However, now, what do we need to use as well? Get the vertices right? So these are the vertices. The vertices I just separated. This one, put them there. So now we're doing this discretization step. So we're just transforming our initial pattern into elements that we know. We can apply to them. The forces from kangaroo. So these are the vertices. I can now simply plug them into this input of the plenary rights component. And here I have the strength input. And one thing that you would think of is that, shall we like, remove the duplicates of these? Because what we know is that this is a cell, this is a cell, and this is a cell. So at this point here, this one, actually here we have three points. We have the point coming from this cell, from this, from this cell. You see here, there are three points. I think since we're playing rising each cell we want to have in the end planar cells, we should not remove the duplicates. We would need to maintain the duplicates because we need to maintain the binarization of every single cell alone. So for this, we have to memorize all of these vertices and for this cell of these vertices alone. So that's why we need to maintain them and not remove the duplicates. Now we could try to remove duplicates and then check the results out. I'm going to do that soon. But first, this is the linearized components. We said that we need to maintain the corners, the anchors. So here with this method one. So first I will now enable this. And this is set to true. So it says that now it's not running, it's not being stimulated. It's like reset it. And my goal is that the output I'm using here first, the method one, it's called particles focus to where I'm using these vertices themselves to be actually the geometry to be transformed. And then the output of that. These points after being plagiarized and everything is going on here. Inside of this kangaroo simulator. The output of that, I will just make polylines out of these and then use a boundary surface component to flatten them, to make flat surfaces out of them. And this component to give them color. This is the strategy that I wanted to follow. Now, if I try to use these points as anchor points like this, okay, that's one thing I'm using. So what do we still have maintained the hexagon sides, so the springs from line. And so for, from these segments output here. Remember when we saw the segments, how they are being organized and data trees. And I said then that when we saw the points that are here, that we have here, these three points and not one point. Here, we have now two segments. Not one segment, because this is a segment of this hexagon. And this hexagon, this is segment of this exocrine and this exit. In this case, though, I think it would be better to remove the duplicates because we just want to simply maintain these lines. That's it. We don't want to I mean, we're not really saying that we want to maintain the original hexagons rather than just maintaining these, well, their lines where they are in space only. That's it. That's why here I'm using remove duplicate lines from kangaroo itself. Utility. This one here. I'm first flattening. And the input here, all of these. So the input here I have. 101 and what thymidine one segments and the output will be 594 segments. And then here I have the springs from line component. I will also talk about this, the stiffness and then the length of this strength in a bit. Now I think we're done with at least these ones. I'm going to see later if we need to use this pole or not. The fourth point, let's first see if actually we would need that or not. So let's now see here. Let's check. Our strength value here of the plenary rise is set to zero. Now I'm going to launch this. I'm going to actually click on this and check the results. Okay, nothing happens. Let's check if we increase the strength value here. Would it work? Okay, Still nothing. Maybe I need to click on this one. Still nothing. Okay? So this is what I want to actually say that even if it seems that all the connections are good without apparent issues, what's preventing things from working or the anchor points? And so this is why I have this important observations note. So trying to use the vertices as anchors, as anchors would block the IP simulation. And if, even if we try to use now, the anchor is like this component. We saw the anchor spring. Also. It may not work for this connect to this input. Okay, I reset the receipt, how it started to simulate. Let's try now to use this anchor spring component. That's what we have actually laid out there. So if I also do that and launch it, we get an error. Although it's simulating. What we can see the error. It says data conversion failed from anchor spring to point. Although it's still working, which is interesting. The thing is that even if we use it, even if we tried to play with this, it doesn't really change anything. There is no effect on this simulation, which is itself while working fine. But actually this is not what I have to do here. I actually have to link this one, not here, but actually with the emerge, with this one as a force. But not there. Because if it doesn't, it doesn't do anything there the input needs actually points. Also something to consider that when we want to input anchor points, it is not the anchors from spring, but rather this will actually go the merge. This only takes zero points. That's why actually it worked before, because it did not really understand that it gave us an error, but it still worked. The simulation was working, which is interesting. It kind of ignored, even if I was, it was an error. This is one of these subtle things that sometimes if you make a mistake while working with kangaroo, it launches the simulation without stopping it. But then the bad inputs, all input is not really doing anything. It's not affecting the simulation. So I now disconnect this one. I'm going now to actually add this to the merge. Let's see what happens. Alright, so as well, it doesn't do anything. It kind of like blocks the simulation. So if we add the vertices in the anchors input, it will block it. If we also actually use the springs, the anchor spring, it will also block it. So keep that in mind that in this case, the strategy doesn't work. So this is to keep in mind when I bring this back to true. And now I will launch this without these only plenty rising these springs from line. And the geometry of the points, the geometry to be transformed. It now works. And so basically as I said before, that the output of the points are being converted into polylines and then the boundary surfaces. And then we're giving here a blue color. Now, if we increase the stiffness, let's say to ten, it kind of goes back. And then tries again to plane arise. But slower and not sure if it will actually reach a final converged result. With all of the panels being penalized, with this value being at ten or not, or at 100. It looks like it's working. You see that now in order for this to work, It's kind of pushing outside of the main surface, the original surface. If I now also turn on this surface Preview on, we see this red one is the erosional surface. And then these blue panels are actually the ones being binarized. And you see that it's really dragging away. Now all of them are flattened. But there are now really far away from the original surface. Now, maybe we would like to have this as a result. Maybe that could be fine and that we are done with this now. However, if we needed to maintain these original edges of the original surface, then as I said here, we would need to try this curve pole. However, before trying it, I just wanted to show you here that if we remove the duplicates, if we call duplicates, so instead of the points, you're not being called, as I said, then what would happen? So that's also what I wanted to show you here. These are all of the vertices. This is a data tree. And then here we can see the organization of all of these vertices of the hexagons. And then after calling, then we have individual points, but without any duplicates, basically. So if we try to remove the duplicate points and we only get the points without any duplicates. What would happen? Lunch? We get this result. The pattern breaks away. So that's why it makes more sense in this case to maintain these, maintained these points. So maintaining the same data tree structure and not calling duplicates because we need each one of these corner points for every single hexagon cell. So that's why it doesn't really work here. To call it replicates. And for this one, for these ones, if I now reset it for the segments, I said that we can actually remove duplicates because here it doesn't give more benefit of maintaining every single one. Let's try to do that. Here. I'm removing the duplicates. It works. If I don't. Also make sure to adjust the rest length input. Let's try now. It's also working. So in this case, with the segments, both methods work either using all of these segments of every single lexicon or removing all duplicates. However, I would rather prefer to use the Remove Duplicates as we have a less number of elements to be simulated, to be calculated for, it's always better than to have more elements. Especially that if we have a big geometry and lots of elements or a huge project and then you are running the simulation. So we might then face problems if we don't call it duplicates in this case. Okay, now I'm going to reset this one. We said that because we gave a high value for this stiffness of the springs that we saw, that it was kind of drifting away outside of the original surface. Now what if we use this curve pool component? And so for this one, we need first to separate all of the outer edges of the original edges of the surface. So this one, this one, this one, and this one. And then we also need to separate all of the points. Then we will need to find out only the points that are actually on these curves. And so for, for this surface here, first I'm doing a deconstruct, deconstruct, be wrapped, extract all of the edges. Either they graphed three here. So putting each one of these curves into its own branch, I'm flattening the points, all of the vertices, putting them all in one list. And then I'm calling duplicates. So from this 1,316 points, now I'm left with 400 points without duplicates. So what I need now is to, I would like to find the curve closest point from this. It will give me distances. And then from these distances, I will just need to take the ones that have the distance equal to zero basically. And so these are the curves. These are the points. And first, I tried the quality component coming from math equality. And I can see here the distance from the distance here. Alright, here we have four branches. And you see here like we have 00. If I sort these, because I want to sort the distances to be from the smallest to the largest and to check if I have all of these zeros, all of these represents the points that are actually on these curves. All of these points. So this point, this point, this point, etcetera. But what was actually interesting and kind of weird when I did that, I did not get the logical result of getting the trues and falses, the output of the quality to be as I was expected. And so here I got instead of a true, true, true, like matching the zeros, I got only true and false, false, false. And then for the second branch, for the second side, the same thing basically through their than false and then we did not really work as expected. And actually if I use this one, equality. And now after finding distances to be equal to zero and then finding the quality Boolean. This true, false boolean result. Using a colored pattern. With these points. I only get these points. Instead of what I was supposed to actually get. All of these like this one, this one, this one, etcetera. And that's why I thought maybe if I use a smaller than, instead of like the quality, by, then I use a really small number, like 0001, knowing that the smallest one, after sorting the list, it's around 0.74, 90.001 is a good precision. And when I do that, and now I get a points. Okay? So actually here, I have now 70 points matching with this. If I actually did a flattened before just to match this one with this layer structure. If I do the flattened here and usually sort output. If I do this. So we see here it's giving me the first until index nine x nine and then false, false, false. Which is actually weird because this item zero equal to zero at index ten is giving a false result. And this should have been actually true and not false. And I think here the reason is that it's really, really small number like zero.00 something. And then a number like one or two or something. It's actually being grounded inside of the panel here. But Grasshopper is not recognizing it as being grounded since it's not really absolutely equal to zero. That's why we're getting a false result here. That's the reason why. So after sorting them, I'm using this sort, so the keys, but then I'm also just bring these back here. Okay? So I did these smaller than 0001. And then now I get, so after doing that, actually here. And this one again, you see now it's matching. So 70, 71st is now false. At 71st, null is false, and now it makes sense. Okay? So we'll bring this back there to maintain the 3D structure. And now I'm pulling, let's see these points. Because I maintain the tree structure. When I grafted this list of these curves. This means that I would like to pull all of these points to this. This curve and then all of these points to this curve, all of these points to this curve, and all of these points to this curve. That's the main idea. And now I'm using the inputs. So the curves, the grafted curves as the input of the curves, the points into the points. And if I actually see this list without flattening. So this list is maintaining the structure for the points according to the curves. Okay? And now I have this curve pool component. I will maybe move this down a bit and then I will connect this one with emerge. Here. I'll actually turn this off. Only seeing these. So since I added a new component, a new force to pull these points towards the outer edges here. You see that now it's much slower as the simulation. Before. If I disconnect this to remind ourselves how fast was. It's much faster to simulate and plane arise the hexagons. And when I connect now, the this curve ball component, it's a bit slower. And it will take more time to finalize the simulation. This they're better. And so here we just need to make things, let's say stronger or faster. Simply because this value, it's making this binarization component going stronger and then move and then also more powerful. Now be careful, here, I added this note, values above 1,600 would break the simulation. So if now I increase it to 1,600 broke, you see, it does this weird result. So if I bring this back and you see that now deformed a lot, these hexagonal cells there, although you see that now the edges are maintained. So this is the compromise that I was talking about is that we would need to compromise a bit on, let's say the length of the lines or this side here. In order to achieve a plane arise the result. If I increase, let's say this one a bit more, it will go back and then take more time to simulate. If, let's say I discovered that it's pushing outwards, then I would need to increase this value in order to give it a more powerful strength. And also of course, if we wait more and maybe decrease this value, then it would finish the simulation sooner. But I won't wait for it now. I'm going to stop the simulation. And I have also another method called method2, lines focused. So one would ask, okay, we used what we use these points as the geometry is to transform. We could actually also have used the segments as a geometry to transform. Both approaches actually work. If I enable this. And if I turn this on. And this is actually the same, the same components, basically, the same inputs. But the only difference that this geometry input, we have the segments. And since we have the segments in the output, I'm simply joining the curves. And then making boundary surface. Instead of, you know, they're making polylines boundary surface, I'm joining them because these were separate segments. Now if I click on this, Simulate there. And what we can do now, since I'm giving two different colors, I can now try to separate both simulators and then try to see what would happen. Enable these ones. Okay, run both. Do you see the small difference that there is a difference between both? And also like some plain rice cells in one are not paying arised in the other one. Although the inputs are the same, except only for the geometry input. Which is actually different. Like, you know, points or segments. Well, it is interesting to know. Do you see that even though the same components, the very same forces, except for the geometry input, will get slightly different results. Check this side. Okay? Yeah, Well, these are still not been arised. What about this side? A bit slow. And you see here like it's kind of like a line that has been formed over there. And the middle. Alright, I'm going to now stop these two simulators. I think this is mainly how we can simulate the generalization of polygons with kangaroo. One. Of course, depending on your project, on the simulation, what's the geometry made out of? You might need to also use maybe other components. Like maybe anchoring the points in a different way or having a different anchoring situation, et cetera. So it actually depends mainly on the geometry. But for now I think it's interesting to try to bring arise hexagons on this curvy surface. I'm going to disable this. And then let's check out how we can actually apply the same thing now. But with kangaroo two components. 17. Planarization of Meshes and Polygons Part 2: And I will now enable these. I've actually is able to most of the components and I've enabled only the ones I'm working on. Because actually if all of these were enabled, then even if the simulators are not running, then that will cause the file to be really slow. So with kangaroo two components, the main process is the same, almost the same. Most components that you are using are similar, but some are different, and we need to be aware of that. So I will not talk about this one first, but about this one. Remember when we said that the first step for kangaroo one, we need to find a plane polarized or a flattened component to plagiarize the hexagon cells. And then we found out that this plane arise. Any polygon components will do the job. However, in kangaroo too, if we go to goals mesh, we only have this one about binarization. Not two components, only one. And if we bring this one, it's about only branded rising a mesh, but without having the possibility to actually input points. So that's the first difference. So here instead of doing that, there is a similar component that's called Gold co-planar. And this will actually play the rise points. So any polygon, basically, it doesn't specify any specific thing or geometry in particular, but only with the description co-planar. It doesn't have more details. But this does the same effect like the previous kangaroo one plane arise. Any polygon. Here? It also has the endpoint, the points as inputs and the strength. This is the first difference and I have it here, this co-planar. The second difference is that as now we also know that it springs from line component from kangaroo one is now the same as from goals line, the length line. So we're using this one for the lines for the segments of the hexagon cells. One of the big differences is that we're actually now anchoring the points. We're using this anchor force to keep the points of the hexagon cells as much as possible on there or in the original place without causing them to drift away from their original locations. This is now possible even though we use this one as one of the forces are goals with kangaroo two, it will not block the simulation as we saw with kangaroo one, that when we use the points as anchor points or when we use this accurate spring, then it would block the simulation. And this one, the curve is actually the same as the curve pole. Remember when we use this curve ball also has the same icon. Actually it can go to. And I believe it's let me check. Yeah, coming from here, goes on. And we have three components on curve, on Mesh and on plane. So these actually deal with geometries to keep them on either curve or the mesh or a plane. And this one is on curve. So on curve for kangaroo too does the same thing. Actually. It has the points curve and strength. So we saw that we have the co-planar for planar rise, the length line, like the springs from line now is the new one anchor on curve the same, the second one, which is new, is this show. We saw previously that the show would actually interesting about it is that it will include certain geometry that we choose. For instance, I'm using now the hexagon cells to include them in the output. If I don't do that, then we will only have the outputs here, the points and the lines coming from the line length. But without these as hexagon cells that have not been yet exploded. And this actually replaces the previous input with kangaroo one. The geometry input where we have to choose the geometry to be transformed. It is the vertices or the segments, et cetera. In the new one. Simple, we can simply use the show components, then connect the geometry that we want to maintain as part of the outputs. Also, let me now bring. This there. And I will actually now snap pool. Second. Yeah, make it a bit bigger. Alright. Let's check. Okay. This is on basically the same steps. The same start is the same starting point with the sweep one and the surface and the hexagon cells. This is the same until here, and also exploring the hexagon cells with these points. Also one of the same things is that we have the co-planar. So this one is the same one. However, one of the differences is that we want to show you that even when you go more and 1600s, as we solve the previous definition, it will not break. It will go up real high values without actually breaking the length for the springs from line while removing all of the duplicate lines of the hexagonal grid. So we're doing the same thing actually like previously for the anchors. We're also removing all the duplicates points of the original surface. And these will actually work as anchor points. And here, since the data structure is a tree including every single hexagonal cell, I would actually need first to flatten all of that, all of all of this, and then use this. So the input here is flattened. And then I'm using this to remove duplicate points from angry to utilities from here. And then from 1,316 points, I'm left out with 400 points. Here. I'm using these points as anchor points coming from kangaroo two goals point. And also I'm using the same thing with the discretization of the curve. The surface edges of, well, these surface edges with the points that are only on the edge or the edges of the surface and then using the curve or previously the curve pull component. But order to maintain these points always on these curves. Alright. I'm going to zoom out a bit here. Now, basically, what I want is from the output to get these hexagon cells that have been playing the rised. After doing all of that work. And then do the same afterwards with this boundary surface to make surfaces out of them after being flattened and also give them a color. I'm going to turn this geometry on. What else may be also these curves. I will see if there's anything else here. We'll also, well, let's take care. Okay. That's yeah, maybe these ones. Let's check this one as well. Okay. That's why coming from here somewhere. Alright, If I now run it without this, let's look what happens. Well, the thing here is that I cannot, well, I cannot actually use these to flatten them with the boundary surface. They are all in one branch. This list here, simulation is, it's actually working. I can check these values here. Tried to change and see what happens. Let's check the strength here. This one. But I cannot extract every single hexagon cell alone. And not all of these segments that are scattered all in one whole list. And as you can see here, that the output of this is only lines or null or empty fields. When I use this show components coming from the curves here. The closed polylines. Then here I have, among the results, I have these polylines for learning curves. And so how can I now extract these, put them on this side. As I know that these are actually closed curves. And so what I can do is I can first flatten the output and then I can use this closed curve component that tests for closed curves coming from curve analysis closed. And it will give me a Boolean result of true and false. And then I will use this result to this patch, this list of all of the elements and then only get the closed curves. And then now in this list, I will have the 195 borderline curves. And then I can make surfaces out of them. And then I can also see the geometry with this color component. So with Kangaroo to why simulating, I'm here using the normal solver. Now, it's converged with having only these values as inputs. Okay? If I now change them, now it's making the flat surfaces. I'm trying here to kind of force flatten. Just a friend threatened everything as much as possible. Now, all the hexagons are plagiarized. And you see that it's like kind of like forced the flattening where some panels sides became like straighten, straightened in order to reach the result. Now here we have to know where we gave high values, where we gave lower values. And so what forces are dominating the simulation? Because that would greatly affect the final result. If I now increase this value, you see that now one of the panels is not any more flat. So if I have to then increase this one more to force the binarization. One other factor would be the anchor points. If I increase their strength too much. So it's trying to pull the corners back to the original edges. And so the polymerization has been now overpowered by the anchors. I need now to bump this even more to force it back to plain rise, to overcome the force of the anchoring in order to reach a full parameterization. All planar results. The final result is a combination of all of the strength values given to the various forces involved. Let's try to make this smaller. And then we zoom in on the hexagons. You see how the shapes of the hexagons change. When this value is zero. It's like not giving any anchor force to the points. If I increase the strength, you see that it's as if the hexagons are moved back to their original locations. Zero no force. A higher value, pushing them into their original place. And actually even if, let's say, if I turn this preview on, we can see the original pattern. So no anchoring, zero binarization without anchoring. But it will actually move them around the bit, move the points around it to make repolarization working. When I increase this, it will bring them back to where they were originally. And then I have to also bump this higher as we saw, push them back to reach a flattened result. Even with 50,000 year still not reaching the A-Flat result. That's why I would hear have to tweak. Maybe they're a bit less. Maybe you're a bit less. You see to reach a working result. And as we saw before as well, the arm curve component. Now you see here this at zero, it's not given any force. If I start now to check it out and then try to increase the value, you see, it's now trying to move to the original edges. You see. So it becomes like a game with different parameters. And then we have to choose where we would like to compromise. Because you see here, when like, you know, this one is at zero, e.g. if I rerun this, I was getting all of these. Maybe this one and this one is like straight line and maybe I don't really like that. I will turn this preview off. You see it looks to me a bit far from the regular hexagonal pattern. These ones, if I increase this EBIT, if I increase these a bit, maybe the length of these wall of the cells here. I will rerun it and see what happens. It's still maintaining these two lines. And this was 50. By the way. If I make this less rerun it, you see, because I will run it, it changes the result. If I now start with, let's say 40,000 and rerun, we get a different one. You see, that's why we have to be careful about this to be aware of what we get as a result. I personally like the previous result that's coming from kangaroo one. It was not, Let's say, too strong on life changing the shape of the whole pattern. However, Kangaroo to kind of provides these more functionalities. And in a way, we can actually force binarization to a certain point. Like we can hear, rich, like 50,000 and even higher values without having to break. But the kangaroo one, we saw that anywhere above 1,600 newtons for the binarization, it will just break. So we have to weigh our priorities where we'd like to compromise on the geometry so that we would reach a final satisfying result. This is one of the reasons why I'm comparing between kangaroo 1.2 are working good. One is older than two. It might have at some points, it might give us, let's say for certain situations, certain geometries. I wouldn't say better results, but different results that may suit us better depending on what you want to achieve. And what is our main goal basically. Alright, so we'll bump this, maybe back down and also this down. And what else do we have? Let's see. I'll just stop. This. Will actually make this a bit less. And this one as well, a bit less re-run. Let's see if it would play enterprise. All of them will just like maybe brink. Let's just wait a bit and see. Maybe bring this back down a bit more. Also. Maybe this one down. Yeah. Okay. Well, still leads to just slightly down. Let's see what happens. Okay? I will just pause this. And I can now use this result. Okay? And then now I would like to do, is I would like to visualize this result in comparison with the original surface. So I will turn these preview, these ones preview off. And these ones. And okay, So basically here, what I'm doing is I want to actually see the deviation of the panels, of the newly polarized panels. Their deviation from the original surface, how far they are deviated. So e.g. I'm doing a certain projects, either it's for me personally that I would like to know out of curiosity. I would like to see how the simulation affected the panels, deviating them from the original surface. Or I would like to present it maybe to a client or to the team that I'm working with or to consultants I'm working with as well. It depends. So showing first the original surface and then the parameterization process again grew. Showing you the simulation reaching to this result. And here I'm doing it, but with two methods. Either I'm extracting the center points of the panels, will move this here. So the centroids of the area component with every component and so it goes like this. Also, drag this a bit. There. I'm getting the center points, I'm finding the surface closest point. We can find this component from the surface sub tab. Licking the original surface here from their connection. Here is hidden so that we don't mess with the layout. And then simply extracting distances, we get the distances that are coming out from here. And then I find the bounds, which will give us the maximum and minimum values. And then deconstructing this domain, minimum and maximum and to separate numbers. And then simply, I'm getting here now this gradient component, I'm feeding it here with the lower limit for the smallest number of deviation and the maximum, the highest number here. And then all of the distances into the parameters. And then here I'm using this custom preview and then this gradient output will be linked with the material output input here. And then I'm using the surfaces as inputs here for the geometry. And then I will make this preview on. And then now I turn this off. And then now I can see this graphical representation of the deviations of the panels. I can, of course play with the gradient. Now it looks like for all of those, all of the ones that have a lighter pink color have the smallest deviation, which means closest to the original surface. And the ones that are more reddish are actually further from the original surface. That's what this means. Basically. Now one might say that they are actually hexagons. And so the point of one hexagon, e.g. the distance of the centroid to the original surface could be something. However, the distance of the corner points could be something else. So maybe we could try also to find out how far each corner point is far away from the original surface. So this is the second method of visualizing the deviation of the petals, the vertices from original surface. Instead of only the distances or the panels themselves, only taking their centroids. And that's by simply extracting the vertex by exploding the polylines that we got from here. Get the vertices here and then here, I'm removing duplicates of the points because I need for this purpose, for this point, only one and not the three points coming from the adjacent takes excellence. Having done that, I can use this surface closest point as well. With these points being as the input surfaces the same, finding the bounds deconstructing domain. And then now here I'm using another gradient. And I will turn this on, turn this off, and then turn this off. And then we can get this nice result which shows the deviation of the vertices. I can also turn this on to see the cells. And for individual points, we can see now visually how close and how far they are from the original surface. The greenest being the closest, at the reddest, being the farthest. Something that well, you might ask yourself would be about the points. Instead of having points with small x's. Can we have small circles or spheres? That's possible. We can do spheres. We can simply get this fear component. And we can do, well next, get the points as the base points for these fears. You see now because I'm using the spheres, it becomes a bit slower because now it's calculating for every single spheres location. But although it's low, it's possible to work with. However, when you want to run this simulation, it will become extremely slow. Calculating for every single sphere location, center point, and then building it and then visualizing it. And then for every iteration is doing the same for 400 spheres. That's why it becomes extremely slow and might freeze the simulation. So be careful about that. By default, radius is one. I will change it to zero to two. Let's check this out. Okay? And then now I can use these fears as the geometry color to color, preview off this one. And now we can see the visualization of these spheres, basically with colored spheres. Let's try to make this 03 maybe takes a bit to load. Okay? So these are the spheres, but I will remove them, bringing this back here. However, this is for you to know that you can also use spheres instead of points. Alright? I think that's it for this part, the binarization of polygons and polylines. I'm going to make sure that this has stopped. I will go to disable these ones. 18. Planarization of Meshes and Polygons Part 3: And now let's look at how we can plane arise meshes instead of polylines. So in case we already have, let's say, a pattern of meshes or surfaces. But now we will try to, well with meshes and see how we can play around with them. There are a few differences. So let's check this out. I would make sure that this is on and will enable these. Will also enable these. Alright? So basically what I'm, what I've done is that I use the same procedure to model the surface. This one with the two curves, making sweep and surface. And then instead of making hexagonal cells, I just made simple quad panels. So this is the start of, of it. And then here I'm converting the quad panels and two meshes. First step is converting your app to a mesh. And then here's the really important. You see that we have here now separate meshes. I have to join them and weld them. So basically I'm using the weaver bird joined meshes and weld. The two steps of joining in welding can be done with one-component, which is found here. This one. Or as you saw previously, previous examples, we can actually also use two components, joined N world, native and grasshopper. In the case when using this one just makes sure that the weld here is set to true because usually it's by default it's false. And so from here, hundreds of meshes. From this output here is only one mesh with 121 vertices and 100 faces. So all of these are now one joint mesh. Now, most of these steps involve similar or same components that are used with the kangaroo simulator. And let's check them out. The first one is the plenary rise. And for this one, instead of using the previous one, we co-planar, which uses points as inputs here. And the new one I'm using the plane arise. So it's a similar component to plagiarize meshes. And you see this m input for meshes. And it's coming from kangaroo two goals mesh plane arise. And this also similar to the kangaroo one component. You will need to start with zero first, I'm bringing this back to zero. So this is step one, polarization of meshes. Step to strengthening the edges and so forth. This is from the mesh output. Here I'm actually extracting the fixed boundaries and exploring these segments. And here what I could do is I could either give this directly as input, the equal length component. And here I'm not using the line length, so I'm not using this line length length lab component but equal length component. I could either do this or I could also hear remove, duplicate lines because I know that since this is a mesh and this is another one here, that the adjacent segment is now a duplicate lines. So I can now, instead of having 400, I can use this one. I need to flatten the input to have all of the new segments, these segments in one list and then the output, now I have 220. So that's also a better, more efficient way. And also add this one to the group. So strengthening the second step that we saw, a strengthening the edges of the meshes. Also bring this to zero. Third step is strengthening the diagonals. And in this case, I'm extracting the fixed boundaries and then I'm exploding again the same step be there. But instead of getting the segments, I'm using here, the vertices and I'm just drawing the diagonals inside the faces. So I'm doing this and that. So basically I'm enforcing or strengthening these distances within each phase. And we have seen this before actually, when we were simulating Hooke's law within it. Remember that with the contrary mesh? But then we said that what if we had a paper or a rubbery material instead of in it? So we need to actually maintain the material continuity. Basically also the spring. Let's bring this also to zero. And then the fourth step is strengthening the particles. And here we have two ways with the particles. These points, basically the corner points of each mesh phase. I could either use a deconstruct mesh, which comes with the mesh edit plug-in under Mesh Analysis. And the output. Are the points. Or I could use this naked vertices component from kangaroo. Alright? And what is interesting about this is that I have here multiple output options. I could either use the naked points. But you see that I'm only here getting the external points. And these points are the internal points. I need to make sure that these are now given the input here for the points. So here we have 121 points, or from here, the same points basically. And also to bring this back to zero. By the way, this component is actually coming from kangaroo one. It's actually working normally, doing the job of getting the naked vertices. This is something to know also that you can use components from kangaroo on if needed. However, this is also present in Kangaroo to, it's basically the same one coming from Kangaroo to mesh naked vertices. But let's just use this one to stay consistent with the components, although it may not make any difference. Link this one there. Then preview off of this one. And the sort of the group. Alright. And what else? And for these points, I'm using the anchor component to anchor them in their own place. In other words, I'm having here a series of compromises between the position of the points, the length of the edges of the mesh faces, the diagonals, the binarization in order to reach a working result. Basically. And then step five, the last one in this case is to maintain the outer edges. This is similar to the previous step that we used. Here. With the exergonic simulation. I'm doing a deconstruct B-Raf of the original surface. And then I'm getting or grafting to get each edge in a separate branch. And here I'm also extracting the vertices called duplicates, etc. Doing the same thing basically. Then extracting these with the smaller than 0.001 as we saw before. And then we got here the outer points. And we'll also bring this to zero. And I also use this on curve component, which we saw previously. Alright, so we will first start with that. And later on we're going to also try this experimental step with this mood component. Alright, so we have all of these steps together. So a quick wrap-up, binarization. Step one, step two, equal length of the edges of the mesh faces. Step three, strengthening the diagonals. Step for the anchor points, the corners of each phase. And step five, maintaining the outer points. Okay? These are all now at zero. I will turn this on. Or actually what I will do, I will enable these and this one. And this one, basically the output of that. So what we're doing is to have the output here. I'm extracting the mesh, cleaning the tree to get only the mesh geometry. I'm extracting the phase boundaries and then I'm making flat surfaces out of these. And this is the preview of the surfaces. Alright, I will reset and quickly check the other parts. Okay, turn this off. So now we can see the phase boundaries, the lines, and then when we have the flat surfaces, they will appear in pink. Alright, so now let's run it. You see when we start like this, we get this result. This is because we have no force at all from any components being applied. So we can start by e.g. strengthening the lens slowly. You see there's a weird behavior. Maybe if I start giving the anchors some force. So you see what happens. If I decrease the force? We get it again. We get this effect again as if they got scaled out of it. With this, well, I mean, interesting effect. But when I increase this slider for the anchors. Now you see that it's maintaining the points where they should be. So that's my expectation with this component to maintain these points where they are as much as possible. Actually, I want to explain why I'm using this two input values with the combination of the power of ten. What is interesting about this is that it will give us quickly high numbers, high values when we use this one, instead of using the normal number slider. And even if we increase the range, it won't be as intuitive with our examples. So even if I have, let's say zero to 15, but then ten to power zero is 1.10 to power 15 is really big value. This is why I'm using this method here. Like a turbo slider kind of. Alright, so we strengthened the anchors. And let's keep this not a high-value, not too much. Hi, I want to strengthen the diagonals here, starting also to get some panels. But when I increase this, for some reason, it does, this effect will not increase this too much. We'll keep it now. There will also increase now the linearization. You see when I do that, we're actually getting 9,000. Okay? So it flattened everything. So now this is one of the working results, let's say. But what is now compromised is that it is not really maintaining the original edges. If I now turn the face boundaries of the original surface, you see that looks like this, and now it's a bit too far here. I will go to step five, maintaining outer edges. And let's try to increase this one. You see that now it's bringing them back to the original outer edges of the original surface. You can see that when I do that, it gets closer to the original, original ones. You see. But when I have let's see, you know, like less flat panels. Let's see what we can do if we go back here and try to increase this. Okay? So you see that now it's playing arise the remaining ones. So now we have flat panels and it's making, maintaining more or less the outer edges. Let's try to go back down. The thing is that when we play with this, you see that it's now getting closer to the outer edge. Could be that certain situation, other situations we have a certain frame, like an outer frame or maybe it's part of a building facade with millions. And then we have different compromises that we want to consider to make everything flat. One of the things that we cannot compromise on, e.g. in this case, could be that this facade or Ethereum element or skylight cannot actually move too much away from the outer edges. Because most likely that we might have an opening in the roof or Ethereum or at the edges of the facade. And then we must be this new part with the existing installation or structure. And so we cannot really compromise on that. That's why we can play with these components or these ladders to kind of choose where we want to compromise or not. You see that now because of that and the parameterization that we are not following anymore, the diagonal are the, actually the original surface grid. This is what we are getting as a result. You can see the original grid. If I now increase, let's say the anchor points and bring these back where they were trying to push them back again. You see it's pushing them back. But now I don't have any more flat panels. If I increase this too much, then I have no more flat panels except for like there. You see, we have to make compromises with this collection of components. It broke. Okay, I will reset it. Just bring these back down to zero. I will rerun it. And we'll keep this there. And let's bring this up slowly. You see it's now sliding this way, trying to play in the rise of them. Now you see that here it's doing that problem. That, well, what I will do, bring this back down, bring the slider for the anchor down a bit. Not too much. We'll bring this back up a bit. So we don't see that happen there. And when we increase this, tried to do it slowly and wait to see what would happen. Okay? Slowly will actually bring this back. At this one, this one up the diagonals. Then bring the anchors down a bit. You see, so there is now a working, okay. So now here again, in order to pause it, I double-click on this one. And if we are now satisfied with the result, that is like maintaining more or less the shape of the panels like the quadrangles. Also, it's maintaining these the outer edge of the original surface. And now let's check the experimental part and afterwards the visualization. Let's go back there first. So this one, it will apply a smoothening effect. It's coming from kangaroo goals mesh and then smooth. And for this one, it would depend on what you need, on the situation that you would like to use it. Or I will show you what it does. So I will connect this one here. Okay, not reset it. And now let's see. It. Does this affect if I bring this a little bit down and this on as well. To make its effect more apparent. Baroque rerun. Actually the brain arise is too big in this case here. Let's bring this down a bit. This one as well. Bring this up. And we'll go back to this one. It does this kind of effect. Like a smoothing effect. Broke again. Alright. Yeah, this is what I wanted to show you. It does that thing. So it could be that you would like to do that? I would like to reach something similar to that. It's just smoothens the mesh basically. So that's just for you to know that this component, this effect exists. So you could actually try that whenever you need it. I will allow to take this out. And you see that while working with it, I had many times to reset because once we're using high values, this might overpower other forces that are being used, and then it might break. So that's why you might need to reset several times until the final result is reached. I'll bring this back to the working result. And then let's try to increase the polarization. Okay? Alright, now we'll pause this again. Now, let's go to the visualization. So I am now here turning these off and I'm doing here the same as we did before. We'll enable these and preview on. And I've done here the same as previously, where sorry, I need to turn this off as well. Okay, So the same thing, which is first from the meshes. Extract the boundaries. These ones explored them, build a four-point surfaces, and then you centroids of the surfaces trying to find the distances to the original surface with the centroid. Finding the distances and then extracting the domains minimum and the maximum of these distances. And then using these along with all of the distances in order to give a color to the resultant based on these numbers. Basically, as we have seen before, it looks like in this case we have this area that is farthest from the original surface with one, that one as a distance. Basically. And also I can now turn on this one. So this is about the deviation of the panels from the original surface. And this one is about the deviation of the panels vertices from the original surface. And so for these points will also have the same deconstruct mesh from the mesh output, got the points or the vertices, and then remove the duplicates and then did the same thing. So distance between point and surface got the bounds and then use these start and end. So minimum and maximum values with these, with this gradient to give them colors. And you see here, it also makes sense that in this area, these points are the furthest from the surface. And we also have more points here. And then all of these are the greener ones that seem to be closest to the original surface. And also as we saw before, we can make small spheres and then give them the same colors as well. Alright, I will make these preview off this off and disable all of these. 19. Planarization of Meshes and Polygons Part 4: Let's go to the last step, which is about binarization of polygons with circular and spherical popularity. I will enable these. I will keep these disabled and we'll explain soon why I did that. And now the thing is here, I'm using only four points from Rhino. And these have been drawn inside of this layer. Points. Four points. These are my points. And now what I'm doing is I'm building a k2, r3 mesh with hexagonal subdivisions. Before we've talked about what is meant by spherical and circular coplanar city. And in order to understand how this vehicle and circular collinearity components work and how they affect the simulation. Let's see what would happen without them. So during this off, so I have here the four points, these ones. And I'm making out of these surface. And then I'm generating hexagonal cells subdivision with lunchbox. And then here I'm exploiting them and then extracting the segments in order to. So what I want is to make a k2, r3 mesh. So I need a weight that would be applied to all of these segments. And for that, instead of using a load, I'm using something called dynamic wait one day coming from goals line. And what this does is that it's a load in the negative z-direction which updates its magnitude according to the length of the line. Basically that's what it does. So the weight here is based on the length of the line. This is one component. The second one is I'm using a length line to maintain the lines, maintain the segment's length. With this length line component. I will actually enable this one. It's to make all of the points planar. So the co-planar component with the points. As we saw previously, with the hexagonal subdivisions. We will see these ones after that. But before we see these also have the anchor points to anchor the four points and they replace basically. Now, if I click there, turn this off. Keep this one on. The flat surface is generated. Reset again. Now, make sure that all other previews are also off. Now when we start, obviously these are flat, right? That's why we see them like this. If I turn this on. Okay, first, I need to bring this down. This one as well. And what I think it would be good to turn this on. Okay, turn this back on. So we are getting this result. It's a category mesh as we saw previously, but now based on hexagonal subdivisions. And when I increase the strength for the length line, you see that now it's going down more. So it's maintaining the lens. Of course, if I do that, I will try to flatten it, but we don't want to do that now. And here this is the dynamic weight pushing upwards. You see that even with a small value, it starts to react. And the Copeland arity is to make everything planar as we saw before. So that's what we can get now with what we have as components. However, when we tried to add the circular coplanar, righty. Now we will see what would happen as a result, as an effect. If I enable these. Well, you will read on this one, start slowly, this one increasing. So what it does is that it adds this effect, which is similar to as if, let's say we have a ball. Sphere under the mesh pushing upwards. If I disable this one, we get the normal category mesh. Lucky to revolt in a way, if I enable now this one, we get this effect as if like there's a ball pushing inside upwards. And if I increase this a bit more, okay, these are not planar anymore. I also have to increase the polarity brain arise these ones. So this is the effect I wanted to show you. On a similar note. If we go to kangaroo with two goals, goal, we can find all capillarity components in there, including co-linear to maintain points along a line. And there's also the coast spherical. And you would think, okay, let's also try cause spherical. But in this case it doesn't really do the job as expected. If I now enable this here, I'm actually connecting this one there and I'm disabling this one. Rerun. Can you guess why it's kind of staying flat and not really changing anything yet. It's actually because we did not start with a low value for the popularity. So it overpower the simulation by keeping the geometry flat. So we need to first bring this to zero to launch the simulation. That's why we have to release this. Run the simulation and then increase this to print arise. Now, let's do it now Let's see. Okay, binarized everything. So the cost frugal, does this affect which is not K13, but also not totally spherical. A little bit different than the code circular. Although the components actually called cost spherical. It doesn't give the expected result, but this one does it better. If we see this again in comparison, you see this is like a bigger ball pushing upwards. So in any case, you may want to use this one. It really depends on what you want to do, basically, what are your expectations and goals. But just to let you know that these two have a similar effect, this one provides a more drastic effect as like a big ball pushing upwards from inside. Alright, so I think I will keep this. There are there. Now. One thing concerning managing the results and data stream, as we saw previously. Like it could be that sometimes let's say here, when we had this and I want it to extract the mesh only while having several types of elements going from the data output. And I use the mesh and then clean the tree to only get the mesh without any invalid or empty fields. With this, there is another way which we can also use. It's called entwined, which is similar to merge, but this one will merge for us trees while maintaining the brand structure of the tree. So basically because of the show component that is actually linked with the hexagon cells. It is now in the first input here, the output of the solver. The data here is maintained with this one. The output of this one being the hexagons, all of the polylines basically. So from here, I mean, this one, the input for all of these ones. These ones. So it maintains them. Otherwise, it could just use the curve component and then try to find out all of the closed curves and then dispatch them. That could also work. This is a different method, basically using the end-to-end feature of maintaining the brand structure in the output from the solver. The output here. And then I can apply the boundary surface. So these are two working methods. Now, if this is something I discovered while setting up the exercise to show the difference between the emerge and they intertwine. I tried to run both together, and it could be a glitch. I found that they would not work correctly together simultaneously. If I now run this one and I preview this one on and this one on, I also reset this one. Actually will have to decrease the co-planar as well. And then when I start to do this, one of them starts to break and you see it's kind of a strange behavior. You may find like a weird results. It seems to break down. And so that's why Be careful. I mean, normally they should be identical. There is nothing changed. I mean, the same stream of input of forces is exactly the same. What somehow, because I have both working. You see it kind of does this somehow. And that's why be careful if you want to do solvers together. And also with, let's say int1 then merge, tried to deactivate one and then only use the other one. So I'll disable this one. You see now it's going back to where it should be enabled. Now, this one, okay, You see, they should be there. Now, if I rerun this one, Let's see what happens. If I increase this. You see, it's a bit weird. I don't know why, What's going on, why it's happening. Something really weird. That's why if I now disable this one, e.g. and in this case, I rerun this one transdermally alone, but together it will not work. So that's a small interesting discovery while testing many, many things together. So please be careful that if you want to run two simulations, are two simulators and also two different inputs merge and entwined at the same time. You might face problems, so be careful about that. All right, I'm going to pause this this one as well. Even if it's disabled, disabled everything disabled all. To reset the file. And I think that's it for Unit four, then you very much for your presence and see you at unit five. 20. Learn how to simulate Organic Tunnels: Welcome to Unit five class. In this unit we're going to look more in depth about organic totals and developable surfaces. Now, let's start with the organic tunnels. On this side here. Something important to understand while working in kangaroo is that we always have to make sure that each mesh side or corner or vertex matches with its neighboring side. In terms of mesh division or vertex, any mismatch may result in a failed simulation. So let's take a look at this example. I will not do this one here and this one there. Alright. So here what I've done, I built manually a mesh. It looks like a pipe with rectangular profile. If you see this without seeing the mesh wires, make sure to go to the Display tab and turn on mesh wires. So we understand how the mesh division is actually working. And this actually, this is actually really important. The goal of this part of this exercise is to show you what happens when we have either matching or mismatching divisions or subdivisions of meshes. Basically in this case, the first layer here, It's called mesh clean, which means that I've already cleaned this one and now it's matching. We see that the subdivision of all of these mesh faces are equal or matching with their neighboring faces. Alright? These ones here, all of these are matching. Well, look manual instead of rhino. And what I've done here is first, I referenced them. I will turn off this one. I made sure that the beginning to prepare the mesh. So by joining and then welding the vertices. So here, when I hover over this, we have all of these 14 meshes. And you see that the v and the F count, the vertex and the face counts. And when I joined all of them together, we have one rash. As a result, with this number of vertices and number of phases, the first step is to smoothen the mesh. So from this, I use this smooth than coming from mesh utilities smooth mesh. This result. This is the first step. And here you can later play with these values. I will keep them as they are now. And then as preparation for the kangaroo simulation, what I would like, what I would like now to do is to take from this mesh first to show it, to get it as a result. Because now this is like one part. Later on work with it. I need the edge lengths and I would like to control these lands and anchor points. So basically for the edge length, I would want to have a certain control over the length. And the anchor points as well. I would like to control, well, the points, these ones, these outer points, I'm using the naked vertices component coming from kangaroo mesh, naked vertices. So only these ones. Okay? Alright. And now I connect the show, all of these and then the show edge lengths anchor points with merge. And I will actually make this bigger, the smaller. Keep this one on so we see what's going on there. Alright, and now I will just use the normal solver. I will click on this one to activate through. We can see now the mesh without the vertices is E. So we reach this result. Now it's converged. I can now pause it. And so basically, this is one way of making tunnels, as we could call them. And in this case, what if, however, we had similar looking mesh faces but without matching faces actually. So I actually made another layer here in Rhino. In this case. What I've done, this is the first step that I started with. And then I defined refining the mesh to reach this step. I started with the measures without having matching faces, and then I increased the face card in order to make them all matching. But actually this was the first step, the unclean one. So I'm showing you now the clean way of doing it. And then now the unclean way, the unclean mesh. What did the results actually would be using that. So you see that for this example with this face here, you see that the neighboring faces on this one are not actually matching with subdivisions. Neither here. You see that they are like double and count. So now either we need to decrease the number by half or decrease, or increase the number of these ones to double them. These ones are matching fine. These are matching. These are not matching. Matching. So some parts are matching, some are not matching. Here are not matching at all. Okay? So I follow it again, the same procedure, actually, the exact same steps with smoothening of the mesh. You see now here from the beginning before starting the simulation, after cleaning the mesh and reaching the joint and welded mesh. Now here we get this result. And that's because we did not have here matching will turn this on matching subdivisions of the measures of the phases. And so basically when we start with this result, whatever we do later, it will not give us any cleaner outcome. So I do this, I can click on this one, simulate. Then I can run it. But because it was already starting with the mistake or with an error, let's say not really built correctly or properly. That's why we get this result. Alright, so I'm gonna now reset this one. Something to be really aware of. This is a quick example to show you the importance of starting with the clean geometry, correct geometry. So that later on you will not have or not face problems. If you look actually at this definition closely, we have nowhere, an error message. We have nowhere, like, you know, like an orange or a red component saying, Hey, be careful there is something not matching. And just doing it, what's supposed to do, Just doing the simulation, what's expected to do. And since the vertices are not matching, it's giving us this result because we're already giving it a wrong with geometry. And going forward without showing any red flags. Saying like, Hey, be careful, something is wrong. But we, as designers, need to be careful as responsible designers to start with correct and clean geometry. So that's the first part. Let's disable this one. Now, I would like later on to test the second part. With this one. The developable surface and scheduling of strips apply to this one. However, for the second part, I will now start with a new example. Before diving. In the new example. Let's have a short description or introduction about what is a developable surface. So here are a few definitions that we can find online. I found two interesting ones that capture the definition of developable surfaces with different formulations. Developable surface, also called a flat surface, is a ruled surface having Gaussian curvature k equal to zero everywhere. Developable surfaces therefore include the cone cylinder, elliptic cone, hyperbolic cylinder, and plane. This coming from this website, mathworks.wolfram.com. Another definition is as follows. In mathematics, a developable surface or doors is a smooth surface with a zero Gaussian curvature. This is a surface that can be flattened onto a plane without distortion. For me, this is the most important part of the definition. It clearer for formulation that I can grasp better as a designer. It can be flattened onto a plane without distortion. Okay? It can be bent without stretching or compression. I'll also show you these two websites. So this is the first reference. They don't provide any diagram. This one, the second one, they provide this small diagram showing a cylinder. And this is what they mean when they say that it can actually be flattened. So it can be flattened onto a plane without distortion. Imagine the cylinder. We can actually unroll the surface and then you can make, we can make it flat onto a plane without stretching or compressing it. So that's basically the definition of a developable surface. Now, what is an undeveloped will surface? Non developable surfaces are variously referred to as having double curvature, doubly curved, go pound curvature, non-zero Gaussian curvature, et cetera. That's actually the opposite. It is not developable. We cannot flatten it on a plane without needing to actually stretch it to make it flat. Basically, this coming from Wikipedia, actually this one, the definition of an undeveloped resurface as part of this page about the development of surfaces. And also they have the same diagram. It looks like it's the origin is this one, this website also having the same formulation. And here we see the different diagrams of cylinder, cone, etc. And here where they talk about the non-verbal surfaces. Alright, now, there's an interesting online tutorial about building a developable surface where the grasshopper and kangaroo by Daniel biker, who is actually the developer of kangaroo. And so instead of me now explaining to you about how to build it, this is interesting tutorial that is well detailed. And I will also show you here the tutorial. It is split into three parts. So part one, part two, part three. And for me the most important part, the most important section of this tutorial is how to start building the mesh. How to have first a mesh that is actually correct or proper, be unrolled with flat strips. Basically. This topic is any way related to the first idea that we saw here to have a correct mesh that we can start with, which should then lead to a good result. Here. Actually, Daniel Parker spent a lot of time on explaining what do we need first to build a proper mesh that we can have it strips, subdivisions to be later on unrolled on a flat plane. Here he mentions how to draw the initial mesh. Like with these steps, with specific steps to take into account while modelling the mesh in 3D. And explains the process step-by-step using the kangaroo components. So this is part one. And actually what is interesting is that he included the grasshopper files. This one here, developable strips tutorial. It is a file with kangaroo one. And you can also find the link here that you can download if you want. You can either copy this one into your browser or you can just click on this one here to download it. And interestingly, under the comments section at the bottom, it actually includes the link to Kangaroo to the same definition, but we can go to Part two. He keeps explaining about the following steps and how to refine the mesh to prepare the mesh for the later steps for flattening of these strips. And the last part is actually the kangaroo simulation. And then after the simulation, I will get unroll it. So I will now not spend time on this in particular to explain the steps it's there for you to read through and you can check them out in detail. What I would like to say is that for our example, there's actually the file. Again, go to part. I pasted it here for you. It is part of this file. And what I've done is I only reorganized the first part before the simulation, before the solver. I organized the same way that I was explaining with the previous examples, the steps of discretization of geometries in order to reach geometries that can be understood by Kangaroo, to be simulated. And also with the kangaroo components organized like this. So actually it is the same thing. All of this until the simulator here, the solver, or the same exact components. I just to organize them basically and labeled them in a way that is easier to understand for we will or learning kangaroo. But before showing you what's happening with the component, my main interests here is about that. Well, what comes afterwards with the management of the flattened strips and how we can organize them or present them in a way that is understandable and can be also shared with other designers, consultants, engineers, or fabricators. And that's for me, the most important part of this unit. So let's go back to the initial part here. So we saw before here that explains about these steps. Let's see quickly the simulation animation. So it starts like that. And once the organic tunnels are formed, then we have the strips now flattened onto a plane. Basically. I will nudge this one. There. I'm going to close this. Alright. So this is the original mesh that actually came from well, with Grasshopper definition file. And here are the steps that are actually part of the definition, like refine, clean, et cetera. And we have these steps here. These ones, these components for kangaroo. So let's have a quick look. We have the show, you include the mesh because we want later on to work with it planar as component to pay rise the mesh faces, length line to control the internal subdivisions of the faces or the edges. So we want to maintain some points on curves or the outside. Maintaining these ones, they're these ones. Then we also have the equal length. Maintain these ones not so strongly with the strength of one. So here we can see the values given to the forces. So we can see that you are actually kind of like using a really high number for strength. So 100 is the maximum value given. We have seen before that in previous examples. Binarization of surfaces and meshes that are used for some components. Really high values like with thousands or tens of thousands or hundreds of thousands as values. Because as I said back then that we would like to maintain the anchor points or I want to maintain the length of the lines. And also I want to compromise on the distance from the original surface, e.g. or I want to compromise a bit on the external edges. What I wanted really to make the polarization strong and working everywhere. So I gave an extremely high value for the binarization. In this case though it is not the same. And so here we can see that when we start with this mesh, Let's go back here, this one. And when we run this simulation, as we saw previously, okay? You see that it's kind of drifted too far from the original shape. So it was previously like this. One, I click on it. It became like this. So actually erupt really interested with keeping the resultant close to the original. Because the main intention anyway is to turn it into an organic shape. And then later on try to flatten or unroll the strips. So you see now how it looks like. It had sharp corners, but now it has smooth external surface. What I've done actually in addition to that, is that I baked this one. I'm going to turn it on. So the original one, I baked it, this layer, I locked it. I don't want to touch it. And then I actually made another one like this. Just copied it here. And then try to stretch some edges, different directions so that I can just double-check it to see what would happen if it will still work or not. So this is the Edit Mesh. If I do that, I hide this one. I go here and I run it again. And also it works fine as expected. So we don't have two problems with this one, even when we change some of the edges. Okay, now I'm going to stop it. I will relink the original one. But this was just like it. That's the quick test to check whether it's going to work with other shapes or not. So this one is there. You have seen before that we're using entwined, in this case with the show of the mesh from the strips here coming into the first input of the branches and then output from the first branch. Output here. Alright? Now posit is now converged and paused. Now until here, it is exactly the same part as the original definition from Daniel picker. But then afterwards I follow another procedure. I will actually show you what he has done here. So we have the strips. So if I run it now, starts running. Let's turn this to true. Okay, Now it's running. And then we get this one still running. I will right-click and then set this to false to posit. Now this is called edited them and this will allow the data to follow from the other side when I click on play. And this is important to use as a tool. Because if I don't use it and I'm using a procedure to enroll all of these strips and then orient them in a certain direction. It will maybe freeze or take a really long time, or become really slow while doing that. Because it will always update with lots of geometries, basically coming as inputs, continuously changing and updating. That's why it's good to, once the solver is done, paused, that we can now transfer data from one point to the other side. So click on this one. Now I have these ones here. I have these ones here. Stripper coming from Kangaroo to mesh stripper, then unrolling all of them like that. And now this unroll with this input, when we use one, it means a complete unroll. It completely flattens all of these strips. In other words, and this is another data dam here. So then this part is called laying out. It's laying out all of the measures along the x, y plane. Like that. It's really nice method to flatten all meshes so that we can clearly see them. However, my approach to this is actually what if we would like to make a schedule out of this? We want to make a schedule showing not only the parts that have been flattened, but also maybe we want to give them like tags, text tags, numbering, etc. So how can we do that? 21. Organic Tunnels Scheduling and Annotation: Alright, let's go to here now. From this output here after the dam. And also we have the same exact components on row and then the mesh output. And now you're actually starts difference with original part of the definition. And here I have divided the process between flattening, orienting, as well as scheduling the parts. Here we can see the meshes still on oriented with a list item. We have in total around 32 meshes during the rapid to false and only see what we have. Alright? So the initial step is only to check what we have. Everything is there in place, etc. Now, what I would like to do, since every single mesh is flat because we have a complete unrolled. What I'm doing here is I'm first orienting on the world x, y plane. We'll just call it here x, y without the z. Okay? And then for that, I'm following this procedure. I'm getting the message coordinates. Actually. What I will do, I will show you here only with one. I will take just one. So I'm taking the MS corners and I'm building a four-point surface. With just the first four points. It can have more than four points. But since all of these points are planar, I'm using the first four points to build out of these first four points is surface. And I know that this reference is a flat surface. Then I'm using evaluate surface. And I'm using the frame because I know that this frame is the flat frame representing the flatness of the surface or the orientation of the surface in 3D. And then I'm orienting. I will connect this one. I'm orienting the surface here. We see more elements because of the list length of the centroids. So let's check that out. So basically what I'm doing here for orienting and in parallel, I'm first extracting from all of the measures, their number. So we have 32 values, so it's list length. I am using a division by four. We can use another value if you want. But my goal is to build a square grid of four by something. In this case, it's 32/4 is equal to eight. So this is a parametric grid, automatic grid that will generate for ourselves and points. And in this case, I'm using these cells here. I'm using the center points in order to actually orient these, all of these meshes onto the center points of every single cell. And because here it's this part here, I said that I'm using only one, applying this to only one to show you what's going on. Now, if I bring the connection, the linked back to this one, I will bring this back to all of the meshes and all of these ones. And so now all of the measures, I want to orient them based on their respective source frames, individual frames that you can see here. And now with the target being the center of the cells. All of these centers. I know when I do that, then I click on this and then I have all of these meshes oriented inside of the cells. Let's turn the cells on a strict these out, okay. So from there to there. Okay. And now what I, what I can e.g. see is that some are not aligned with the center of these cells. So for some reason. And so for that, I'm extracting out all of these meshes here, these center points or centroids. And I'm building a line between these center points and the center point of these cells. And then I'm moving all of these meshes towards the central point. So then I click on this and click on this. Well, these ones. Now I can see that they moved a little bit more to the center. If I select this one, they were there and now they moved a bit towards the center. Now they're centered inside of the cells. Now what I would like to do next before tagging is that it looks like maybe I want them to be looking similar. Maybe all of them are oriented in the same direction. In a similar one. Maybe along this one, or maybe two, this one. And not in this direction. That could be something that we want to have, maybe not. But let's try to see how we can actually do that. First. I will also start with one. So here I will use a list item. This one, this one. Okay? And also connect that one there. And basically the idea here, the strategy here is that I want to find the longest. If you want to think about it, an analogue way, not in a digital way. What if this piece of paper, e.g. a flat piece of paper in front of us on a table. And we want to rotate it or maybe align it, align these two edges maybe along the x-direction. You know, like, you know what, I just rotate it a bit. Then one method out of many other methods. But one method could be that I would extract the longest distance among all of the sub phases. Then try to find the line between the farthest phases, which means the longest distance. Once I find the line that I can orient this mesh phase from this line as a starting point, as a starting source towards a new direction. From this point, let's say, see these ones. This one is starting source from this point oriented in the X-direction with the same distance. So like a rotation, we could either call it irritation or an orientation from this position to a more straight position along the x-axis. And it would be interesting to find answers online about that. Actually, I found this interesting definition. I'm not using all of it here, but just part of it that's coming from and it's coming from this source here. This online post on McNeil rhinos official website, where there is there was like a topic about finding the longest distance among the points. And when you visit this website, you can actually find many of the proposed solutions by different participants. I found this to be the most, let's say working in this case. For this example. Let's go quickly through the definition. Let's look here. So we have here the mesh face, faces. We have the areas of each one. And then we have like a procedure using reaching with all of the distances is being sorted and then finding the longest line. And then here I actually added this one myself. This component, the end points. And then I'm finding here they are x values. And then I'm sorting them and sorting the points based on their X values. So the one was the smaller one. Always make sure that I'm starting with this one. And then I'm making a line knowing that this slide is actually in this direction. So for this point, towards this point and not vice versa, That's why I'm making sure that this is controlled. And then I'm moving the first point towards the x-direction, using this line as a factor of movement. And I'm getting this line. And for the final step, I'm using the Orient direction. Orienting. This geometry based on this line. With the point a is this one. Direction a is this one. This line. And point B is also the same point, but direction b is this line. And then now I'm going to rotate this one from this position to this position. Okay? It's not a very complicated procedure. And then we get this. Once we know that we can apply this to one phase, then we know that we can apply it to all of the other phases. So this is rotating only one mesh in the direction of x. Now rotating all of the measures in the direction of x. So instead of using the list item here. Only applying list only the first one. Now without using this one automatically or sorting all of these following the same procedure, reaching this. And now we see that there is, there is an orientation some of in the vertical direction, sum in the horizontal direction. Now, all of them are oriented in the horizontal direction. And after that, because we hear hat explode mesh, part of this definition here, we need to make sure that the mesh is clean. Again, join and weld all meshes with this component. Either here I'm using this one from weaver bird. This one joined measures and weld. And make sure that when we use this one to right-click on the world and make sure that this is true. Because by default set to false, we can either do this or we can use what we have done previously, which is meshed join and then mesh Weld Vertices. The mesh Weld Vertices is coming from the image plugin. So either these two steps or weaver birds, one step, one component. I'm always like, I always like to show different methods so that, you know, it's not always, let's say one answer, but it could be many different solutions. Alright? This important step of cleaning all the meshes. And then I'm now here again because you see that now when we, when this happened, when the orientation of these happened, now we see that there are not any more centered inside of the cells. I'm using here the same step of finding the mesh aerial a line and moving all of the measures again towards the center points of the cells. And then I'm using the same here, areas of all of these. I'm making a line towards the center point of the cells, these ones. And then moving them toward the center points. Like that. Of course you could say we would like to also orient these to be also pointing toward downwards. You can also do that. I'm not going to do this now, but you can also follow the same procedure finding maybe this line orientation, maybe the shortest line between inside of this triangle, e.g. all of these you can make as triangles, then shortest line direction to always point downwards or upwards. So it depends on what you would like to do for me now. It's fine. I'm going with this. And I have all of these now, well oriented. Alright, now what I would like to do here, I will actually show you the end result. And then the steps. I would like not only to have these in cells like that, but as I said, I would like to make a schedule so that I can later on share it. I can fabricate it. I can send it to other consultants then designers to understand what are the parts that constitute this geometry, this be villian that we would like to build. And I would like to make this to have this schedule with the strip number 123 and with the areas as well. So how we can do this? Let's go back to here. This step, we have the meshes. Let's make this a bit bigger. So first things first, I would like to extract the indices. And I know that we have 32 meshes. I would like to make this automated. I'm using an index item component and output of this is the same input from the meshes in the list. And the item I'm extracting the index list to be a list of numbers of values starting with zero. However, we usually don't start the count in real life with zero. Like we don't usually say the zero part then the first part. But what we usually say is like first part, second part, third, etc. We don't start with zero and real life. That's why in this case, what I would like to do, I can right-click on this expression and then here type x plus one. So I have done this one now here in this case I just copied this one. Then right-click expression x plus one. So it adds one to all of these results. And now I have this result. So 0-31. And we have here 32 items because it starting with zeros. So now it starts 1-32. Alright, so this explanation of how we can do it, right-clicking and then adding x plus one. Now, this is the list of all of these strips. Now, I would like to make a nice text out of it. Only 123, but I would like to use here we concatenate component coming from sets text. And this actually inspired by Excel where cells can be concatenated together. And this means merging bits and pieces of texts together. When we hover over, it says concatenate some fragments of text. We can also zoom in and add more inputs for fragments here. I'm only using here a panel. I typed inside of it, stripped number. The first part, and the second part is this list of numbers. And then let's check this out. I have now this result, strip number one, step number 23, etc, until 32. So I joined this one and this one to make this list. And then now I'm using this text tag 3D coming from displayed dimensions. There's one year. In this case, we need to, we need the location of the text tags. Here I'm using the center points of the meshes. And I move them a bit down. And then I'm using these points as the location. I'm using this concatenated text as the text input. And I'm using this size here, this value to control the size. Alright? I left this one's unused. Color and justification. You can later on play with these if you want. So first step here, we have the meshes. These ones, we have the cells and now the tags. This merger is coming from the geometries themselves, the meshes, as well as from the cells here, the original cells. So this map shows both together. Okay, so here we have the geometries. Here we have the first text tags. Now what if the consultant requests to have more information about this departs the strips and they ask to have their respective areas added to the schedule. The solution is simple actually. Since we have the meshes here, I'm extracting their areas. And I'm not using the centroids, but using the areas themselves as values. I'm using this component. Actually, it's an old component, not anymore used with recent versions of grasshopper. Actually found it also onetime while researching online. And so what it does, it rounds up the values. We have now, let's say these various areas of the meshes. And I'm using this one to round these up to only two decimal places, e.g. and then here we need the values and we can hear you going to control the decimal place, count, like this, etc. Here I'm using the concatenate again. The first bit of it is the area text. The second is the, these values, the mesh areas. And the third one, I will change it to millimeters square because the file is units are actually in millimeters. So this is important because there are actually no units in Grasshopper. It's all based on rhinos units. So if it's millimeters, we have to have this in millimeters. If it was in meters or in inches, it should be changed accordingly. In any case, this is a fragment of text, so it doesn't really understand what these units are, but only for us as a visual indication that these are actually units. And now we have the concatenated information. And I'm using again another tech stack 3D using the same procedure of the centroids of the meshes, but now moving them more downwards and adding the areas as text. So we have these ones and these ones, and we have these ones. And now we have this interesting schedule. Alright. We can now organize it. And the way we want, we can adjust the grid, make it fit in the landscape sheet, and also scale it to fit inside of a specific sheet size like A3, A2, A1, or any sheet size desired. That's really up to you to take this forward in whatever way you want. What is more important and interesting to know is that once this is built, this text tagging or scheduling of all of these, like whatever now would change. Here, it will update. So let's say now e.g. I. Have this. I click on through and I run it again. I pause it. I go back to the **** I run this dam here, letting information goes through. Then we will get this updated. I will turn this preview on. And we'll actually turn this preview off. All of these. First, I will save. If I try not to use the dam to see a live change. Maybe that will either freeze or break or not. And I will run this. It's becoming really now. I'll reset it now. Okay, you see it starts like that. And now it's running. You can see that the strips, as well as their areas are updating. It's a live real-time change or update of the schedule of strips while the solver is running. And so that's the power of grasshopper. Parametrically speaking, that once we have built something, it will actually remember and go back following what's linked with what basically. Now I will posit. So if I turn this on, this is the result that has been unrolled to flat two flat strips. And then scheduled like that. Preview off. And I will actually link this dam because it's very important, as I said before, to have this like a security key in order to control the data flow from one point to the other without having to run all of all of these at the same time and then making things sometimes, maybe freeze or even break or crash. Okay. Now, that was about this part about developable surfaces and scheduling of strips. Now remember when I said that I wanted to test something with these elements, these ones, trying to flatten this out. And I said that. Let's first talk about this part. Now, let's check this out. How can we unroll these ones and make them flat? Would that work? So let's try to do that. And here I'm not using this because I did not actually start with it. This was the way of building the mesh, but now we have already the mesh itself. So what I would consider now is using the stripper and the enroller, or these now actually work. And that's why I don't have this part here, but only the stripper and the enroller. So I will now click on this Play button. And we have the stripper here. Click on the enroller. You see it doesn't work. This is because the geometry itself is now doubly curved or double curved. Or It's an undeveloped will surface. In other words, most of these. But these ones that haven't been actually enrolled as a complete unrolled are actually developable surfaces, but not the other ones. And that's why here. When I turn these on together, you see that most of these were actually non-diversifiable surfaces. And the thing goes back to the methodology of modelling in 3D, where and how to start designing shapes like shall I, shall we start with a surface or a shape that is already developable or not like this one. What are the constraints? Are we free to really reach any shape we want to have or not? We have seen before in it for that, we can use binarization of measures so that, that could be also another answer to this question. In this case, we saw that it is a particular specific defined way of starting with a mesh and building it in a certain specific way as the annual biker was explaining in the three-part tutorial and making it later and unreliable flattening the strips. But that can only be achieved in this case with this shape. But we cannot actually apply this to any shape. That's why I'm saying that we always need to think about the intended end result. What are we going to do with it later on? Maybe in this case, I would need to apply not the unrolled strips, but maybe the polarization of surfaces, which we have seen in unit four. So it really depends on what is the end result that you want to reach our goal. And also, we have to think while having that in mind, what is the methodology, the process that we need to adopt in order to reach our goal. And always makes sure that the start that correctly, even if we have a methodology that is correct. But if, let's say the mesh, as you have seen here, was not built correctly with mismatching faces, then it won't work. So we have to keep that in mind as well. Always as designers, as responsible designers, architects, engineers, product designers, in any type of field or discipline that you are actually involved in. We always have to keep that in mind. How we can reach our goal, what are the methods to reach it, and what we have to consider before starting all the parameters necessary so that we don't face obstacles in the middle of the process and lose time and energy, etc. So that's it for this unit. And see you at unit six. 22. Origami Introduction Ron Resch Case Study: Welcome to Unit six class. In this unit, we're going to explore how we can simulate origami geometries with the help of kangaroo. Before we dive in details about the tools and components that are going to use in Kangaroo to make origami geometry is to simulate or a gummy folding patterns. I would like first to talk about Ron Rash, who was an artist, Computer Scientist and applied your geometry, just known for his work involving folding paper, origami, the solutions and 3D polyhedron. I'm reading actually this information about round brush extracted from this website. And I'll also show you a quick excerpt from the run rush paper and stick fill. You can find this video under this YouTube link. Actually are going to quickly watch few seconds from the film that I think directly relate to our current work with kangaroo. And using the computer in order to make simulations digitally. All schools of art, architecture, and design have classes they call a fundamental, basic design. Perhaps even elementary composition. These classes are usually given to bring the students into his initial understanding of how the orders. Now we won't watch the whole film, but I want to show you quickly about a few things that we're going to explore and kangaroo and tried to apply them, inspired by his work, elevate, twisting, rotating upward. You'll note also that there's a kind of wing. Or i then determined that a square and a hexagon folded in a similar way. So fold the paper up with straight lines in such a manner that you achieve. Modules maybe derived from. I would like to take you to the end of the film where already mentioned the use of the computer and how it can help designers design and develop their ideas digitally. Thus expediting the design feedback loop until reaching a final working idea faster and more efficiently, which ultimately boosts creativity. And it starts around there. Continually. People asked me, now that I've solved the folded paper problem, why it is that I stay with the computer business. In fact, many more people asked me, how is it even possible for an artist to relate to the computer field and to do research in that area. And a few of my work in terms of the months and years that I spent fabricating models after I asked myself some question about the geometry, it seems most natural to me. Design is a kind of feedback loop between the artist and the environment, between the designer and have some posed problem. It seems that the person isn't always in a position of saying, I wonder what will happen if or he looked at a problem and it says, perhaps this will work and he goes out and try something. New environment responds by collapsing quite often is proposed solution when he fabricates it. And then he makes modifications and goes again, this kind of loop keeps going back and forth. In the interim though there's not much information. There's just a lot of labor and a lot of expense. It's my hope that the computer can become a medium in which these post ideas posed solutions can be tested out. And the information coming back from the results of this post and solution can be modified. The computer can really speed up this kind of design loop and I think greatly aid creativity. The excitement for me is to try to develop the computer then as a medium for exploration and as a medium for expression. So basically the last bit of what he was saying is put in there in text form. It is my hope that the computer can become a medium in which these ideas until as a medium for expression, I find this beautifully expressed and formulated and actually directly illustrates what now we're actually doing. So back then, when he was actually trying to do in the lab, in the studio to build geometries with paper and stick. Taking so much time and effort and energy to reach the result that we have, like the shapes and his mind. Now with kangaroo, with Grasshopper, with Rhino, we can really do this like an a matter of minutes basically. So that's why it's interesting, exciting times now that actually living that we can do this easily and quickly. Additionally, useful resources are listed here for the ones we're interested to know more in details about origami tessellations. So this is the run resh.org website, gallery page where we can find a nice resource about Ron rashes projects and experimentations. This is the one called dot info website where you can also find a few examples of kangaroo patterns. This for instance, inspired by rashes, triangle, water bond pattern. Alright. There is the online paper by Sebastian Collins and a mirror that poor entitled From flat sheets to curved geometries, origami and Katie, Katie gummy approaches includes many interesting projects that are mentioned here, as well as geometric studies about shapes and geometry. This origami tessellations.com website as well is a good resource for the ones who are looking for the latest updates and workshops and events going on around the world. And the last one I want to mention as a resource is Eric here, this website, which is also will include that provides a lot of interesting information about this topic. Alright, so all of these websites are actually listed. Here. I will close the browser. And now let's look at how we can actually play with origami and make some nice simulations. 23. Origami Applications: Now we don't have to be an expert in origami to do that. We're gonna see how we can make interesting simulations. With kangaroo. Once you understand basic rules of folding. And what is interesting is that kangaroo two does not include the organic component because there was actually an organic component in Angular one, the zero.099 version. And if we go to the kangaroo one, basically now, let's go to utility. There is this organic component. Now when we bring this here, what I've done, I've put it there. So we'll delete this one as it's the same, the same component. This component, if I now try to click on it, Control Alt and hold and select it. The usual way to find components from the tabs. I would not be able to do to find it because this is actually a cluster. It came with kangaroo from the tab as a cluster. And when you hover over it, it shows a thumbnail view of the cluster inside. If we double-click on it, then we open the cluster of different components. Some of them are actually kangaroo components, like e.g. the synch points. And this one now coming from kangaroo from the mesh sub tab. And these ones again are actually additional clusters. So if we double-click on this one and open it, and you find out that it includes the springs from line component, which we have seen before. And it's coming from forces springs from line. I will notice guard and close. Go back to this one. So what I have done is that I copied all of these into the main grasshopper file. Let's close this one. This is actually equal to this. What we have seen. And these two ones, this one and this one are actually clusters. They include these ones. And these ones that are encircled are actually kangaroo components. The other ones are normal grasshopper components like CP evaluate, et cetera. Now we're not going to spend a lot of time looking at these specifically, but just to know the background about this. Now, the next step is to simplify the inputs. So we have this kangaroo component and when we bring like this, when ring a new one, you see it. It has these inputs like mesh, curve number, curve number, number. And it's not really intuitive to let the user know what is meant exactly by both curve inputs. Like why are there two curve inputs? We need two sets of curves, and we need also the three values, three value inputs. But we don't know the description exactly. So what I have done as a personal preference from my side is to just rename this. I renamed this to origami cluster kangaroo 0.099 to know that this coming from this can grow version. And I also kept the mesh as it is, the mesh input, but then I renamed these ones to make things easier for us to understand which geometry is we need, what would need to use for the inputs, for the component. Where we would need to use something called the mountains. So Mountain curves, mountain angle, then valleys, Valley angle and folding. I will now explain more in detail about these inputs. What do they mean? However, this is the same component, including exactly the same cluster. But now with this renamed inputs to make work easier. So origami is original cluster inputs. Outputs have been renamed for an easier workflow. And now it's always important to know that we are using Kangaroo 0.099. So we have to have this plug-in version of congruent stalled. Alright, so now I'm going to split the screen. And let's look at the first example. S1. Alright. So I have called it a trial run rash triangles. And here we have many sublayers. We have the nerves, which represents all the surfaces. So these are not meshes yet. So it's open surface. Open surface actually I traced around rushes pattern. I simply brought an image and then I trace the pattern to get these surfaces. So individual surfaces, not linked, not joined together. And then I drew over the mountains. And the valleys. So what does that mean? Is that these mountain curves will actually push the surfaces. The red crease lines towards the outside and the valleys will push the blue crease lines to the inside. Basically the opposite movement. That's why cold mountains and valleys and the ones among you who have already worked with origami might have passed by these terms. So Mountains pushing up as mountains, valleys pushing down like valleys. And this is the base layer inside of which we make the simulations. Alright? I'm going to adjust the sizes here. Alright? So we said that we need here the mesh input. So since these are surfaces, the nerves layer includes surfaces. These are the surface referenced here. All detached. I joined them. Then this is an important mesh preparation step to first convert them to mesh and then weld them together. And then this is here a shortcut. The meshes here ready for this simulation. The mesh of flat folding pattern. And this goes into the input of the mesh. I referenced the curves of the mountains, these ones from this layer. And I have also used just to be on the safe side. They delete duplicate curve, which is also coming from kangaroo. And the input for the mountain angle in this case. So this one reads angles in radians and not degrees. So if we're using degrees, this number is ladder, e.g. we have to first convert this degree angle into radians. And then we can use this one as an input. And then we have the values input. So we'll also have the valley fold lines, these ones. And also the delete duplicate curve as a security measure. Then we have the valley angle. So from degree, then convert radians. Then we use this one for this input and for the folding, we have numbers. Ladder is going to be from minus one to plus one. If it was zero, that means that it's not folding at all. So zero fold. And then either minus one, which inverts the folding effect or one as a full fault. Basically. I will now here keep it at 0.5. And on this side, we have the kangaroo simulator. This one. As a standard procedure. I flattened the inputs for the force objects and the anchor points. These are the forces and the output of this mesh is used for the geometry input. Output. Now, the resultant is coming from here, and I'm using here a custom preview to give the color blue color to the mesh. So if I now click on this one, I will see, you know, the preview. Now nothing is happening. It is not computing anything yet. I will just show you soon when we can use anchor points and see what the results would be. So these are now put on the side, not used at all. Alright, so here also one more thing. I found out with studying these examples that the optimal angle for the mountains, the mountain folding, would be around -90 degrees or minus Pi over two, basically. And the optimal angle for the valleys would be around by 180 degrees. So that's what I've found. Of course, you can play with these angles and change them. I will also show you soon when we change them, what would happen. But these are for now, like standard default angles that should normally work with most origami folding simulations. Alright, so I think that's explained about all of these inputs. Now, here, what do we want to run this? You can go to simulation. One thing about the kangaroo, 0.099 is that when we double-click on it, we get this simulator control buttons. And then we can click on Play. And now it's folding. Alright. So you see that These lines here, let's click on stop. You see these lines, they fall to the inside, mimicking valleys. Now let's try to decrease this. You see how they fall to the inside. And then these lines, the red ones stop again. These red ones falling to the outside mimicking mountains. And now if I increase this, so we see now the effect more, increase more. See that there are now folding to the inside. These ones and these ones with the outside. This is now a full fold. You could actually go even beyond one, although I don't see that currently, we don't need to do that or there's no real reason to do that. And what I was saying previously is that we can actually reverse it. If I now bring this back to zero, let's say no-fault. I reset and play. Nothing is happening because nothing, there's no folding. But if I go to minus a negative value, it will now invert the folding. So now the valleys become mountains and the mountains become values. And so the effect is now being reversed. Let's bring this back to positive. It is as if we are now folding the paper and the other direction. Let's bring this back to 0.5. Alright, now, here we have few studies like small trials, where I built a small pattern quickly with surfaces and lines in order to check the simulated results. And then after that, I built bigger geometries, which I will show you soon. So the second one is this run rush quadrangles. If I select these ones with this example, it is not actually a surface, but a mesh, an open mesh. And so in this case we have the other option of just referencing this one mesh. And then I will just link this one there instead of choosing the surface as previously. So we have now both possibilities. You can either have junk trees and surfaces or as meshes. I will now select the mountains. And then here right-click and select will set multiple curves and also do the same for the valleys. Alright, we'll turn these off. And now we see that we have the flat geometry still on simulated. Now, let's double-click on this and select Play. Let's play with the folding value. You see how it reacts life as we change it. You see how fast you are able to now make these simulations without touching any piece of paper or scissors. And later on we can obviously print this pattern. Then we can use it. You can use these valley and mountain lions as creased lines and then we can replicate the origami with real paper or cardboard. Now, if for any reason the mesh was flipped, so try flipping the mesh and check the results. Let's try to type here. Flip, enter to flip the direction of the mesh, and I rerun the simulation. You see that now it's behaving in reverse as if given negative values. So I was actually expecting to get this, but because I flipped them, then we get this opposite result. So this is also a good time to mention that the orientation of the normal direction of the NURBS surface or mesh is crucial in order to get proper results. And this also relates to the previous units where we looked in depth at how we have to start with correct subdivision of meshes, e.g. to have the correct simulation. So here in this case. Stop this one, flip this again, bring it back to the original orientation. Alright, turn this off. Okay, so this is about this one. Stop it. Now, let's check this one. And so this is trial water bump with anchor points. This is the interesting thing about this example. Also, this is a mesh. The anchor points are these points, multiple points. The mountains and the valleys. Okay? Now, before I connect the anchor points, Let's see what would happen if we just run the simulation without them. So we get this result, which is more or less expected. Alright? Now, what happens if we now connect these anchor points into this anchor points and put play? Okay, now you see that it's kind of being stuck there. If I now move these points in space in 3D, it will affect the geometry. So although we see this effect, however, since paper is not by nature stretchable, this particular session is not totally real, I would say. But let's see what happens if I move it to the inside. Now, what if we start with these points, e.g. this one not being at this corner. If I now stop it and replay it, if I move this one, it will do nothing, not affecting anything. Why? Because we did not start with this point being at the edge, at the corner. If I move this one, since this was actually started there and its original position. Now it will affect the simulation. I will now undo because this one has restored. Now the second simulation that was not in its correct position, in its original position, it was not affecting the simulation. And that's why always important to keep that in mind, especially when intending to move anchor points. To have these anchor points being on the mesh at the corners or vertices so that you can later on move them and then affect the geometry, the simulation. This case, I'll move this one to the edge and also move this one there. So now all of the points are now in place, them on. So now if I play it, if I move it to Lafayette again, undo. Alright. So this is a quick example about using anchor points. And now the bigger example, which I'm calling here run rush triangles, vase 20 sides. And basically here what we have is this original pattern that we started with previously. This one. What I've done is that I just took a piece of it and then I laid it out this way around this polyline like that. And then of course, when doing that, always maintain the mountain curves and the valley curves together. This is the base. Layout of all of the curves. I will now turn this off. Alright? And then now let's try to see what would happen when we use this one. I have here nurbs, not meshes, select all of these, right-click set multiple surfaces. I connect this one there. Select these mountains. Right-click, assign these ones. De-select, select these ones, and also assign them here. For the valleys. Turn everything off. Only check what the result would look like. We'll also take out the anchor points. These are only for the previous example. I will now run the simulation and see what would happen. Double-click play. Alright, let's zoom in a bit. Stressed this one or so, it's now folding slowly. Let's try to increase the folding value. So basically this increase increases the speed, affects the speed of the simulation. When we do that, it also marks the limit of the simulation until it stops the folding. So actually what this means is that if, let's say we would like to have some sort of a geometry like this. Maybe like a vase or a lamp shade or wherever you would like to build. Who would need to start with this? So this is our starting point. And then when we build it, when we apply the crease lines, and then when we fold them, then we will get this simulated geometry. I will now click on pause. If I liked this position, and then later on we can make it and then render it, etc. I've actually done that before with this one. Click to stop it. Then we'll rerun on the week one. So this is one option, one example of this simulation. Alright? So this is with 20 sides. This also with 20 sides, but longer than the previous one. And again here, we also have a different big options. This make one, make two. So it's like while being simulated, I would pause, bake than play again, then pause and wake, et cetera, until almost a full fold. Basically. Like that. Yeah. These ones. So all of these options I have here, previously baked. And the last one I want to show you is this one. Let's check this out. Referencing the surfaces there. Okay. Then the mountains. Select all of these. Then select all of the valleys as well. Again, referenced them here. And let's turn these off. And let's launch the simulation rerun. This is the run Resh quadrangles. And this is based on what we have previously seen there. This pattern. You see when I play with it, with this ladder, it will affect the simulation. Well, obviously. And if, let's say who would like to play with these angles? While the simulation is running. And I tried to change the ankle slider, the middle of the simulation. You see that it will also affect the resultant. The behavior of the simulation. So it's responding directly live to the change of the angles. But as I said, these are like the standard inputs to keep them at the -90 degrees and here and then 180 degrees there. Okay? And some of the results that I already baked, or like this, one, like this, you can see that you can kind of like warped results. Alright, so basically this is a quick intro about how we can quickly with a basic understanding of origami folding of mountain and valley creases. How we can achieve it with kangaroo 0.099 with the organic component. And the last thing I want to show you about the zombie kangaroo. What is interesting about this one is that it will give us a kind of final result with a pre-set maximum number of iterations. If I keep this at 5,000, e.g. and what I would like to show you again about the first example. I think it's a bit freezing. I will see if I right-click lock solver. Okay, what I would like to do is replay this example. But with a zombie one. So let's reference these again. Alright? And these ones. Alright, During these off. And also let's disable this one. Actually. Yeah, let's just table it. Alright. So it gives us straightaway the result. We can play with the folding inputs here. But it does not show the bouncing of the simulation. It is just like a static final result. Go back. Where does that? So that's why it's called Zombie kangaroo Because there are no bounds. Now, the thing is that, let's say I run this one with it. Play. Let's see what happens here. It will not simply stop at where the zombie kangaroo stopped. But we'll kind of keep going a bit more because there is no kind of a break to just stop at preventing it from further moves. So it slides a bit more towards the higher value result. Here, the, the, the zombie kangaroo, which seems to have reached 66% or 0.66 value fold. But the normal solver keeps going a bit more. That's why we would ultimately need to posit to stop the movements are order to maintain one result and then bake it. Otherwise it would keep going forward slowly. So please keep that in mind. At any rate, I personally like more than normal kangaroo solver simulator and not the zombie one because I like to see the bouncing. But keep in mind that it won't stop where it reaches what is actually supposed to reach. And then converge like with the kangaroo to just keep going a bit sliding way from the real result. In any case, I'm going to disable this one. 24. Origami Exercise: Now that we have seen an introduction about how we can simulate the origami folding with kangaroo, it would be interesting to actually try to apply the knowledge that haven't been acquired through this introduction into smaller exercise. And so basically the idea of the exercise is that I will show you now the behavior of the resultant. And it's a basic mesh folding. I will show you the resultant, the behavior of the origami simulation. And you would need to try on your own, please, to replicate it, to try to rebuild it from scratch. I'm going now to turn on this layer. I'll preview of this one, and I will preview on this one. Alright, so you have already the file. Please try not to look at the layers. What do they include? Try to please make a new layer on your own. On this side, not this one. And try to replicate it. Tried to replicate the behavior. Now, basically we have a flat mesh, a flat geometry surface. And the idea is that we would like it now to fold like that. Basically with these crease lines. Then you have it folding that way. And if I now play with this folding slider, I would get this result. And so to help you out with the steps, because this is important if you are able to replicate this example. I'm not gonna say like sit forward from this first try that this is the main goal. The main goal is for you to understand the process and how the steps are organized leading to the result. And once you understand that, then it would be much easier on the long run to replicate any origami pattern that you can see. The idea or actually the steps in order to reach the results are summarized under a few points. So these are the steps that you would need to follow. I'm going to do this. Alright? So basically first observe the effect happening and try to guess how the parametric definition was built, how the resulting geometry behaves. And so there are a few points to ask yourself before trying to tackle the exercise. First, what would be the base surface or mesh? What are the mountain curves? What are the valley curves? Is the geometry fixed at a certain point or not? Or their anchor points involved? In other words, that's the last question. So if I now play it again, well, actually bring this back here and we'll keep this like that and we'll play it. You see, we get this result. This is the behavior of the folding. And of course, I've shown you if I play with the slider, the folding slider, it will increase or decrease the folding, but this is a basic mesh folding. So please ask yourself these questions and try to replicate this simulation based on what you see. And you can just simply use these ones. I just basically this definition from here. So basically you can use the same just here. You have to figure out what would be needed. And it doesn't really need to be exactly perfectly what you see, but something similar to it. Alright, So I would say maybe, let's give ourselves maybe 10 min to try to figure this out. How you can build this definition. With mountain and valley curves. All of the geometry is required. And then we're going to see this simulation afterwards. Alright? So 10 min. 25. Origami Exercise Solution: Alright, so I hope that you have achieved to replicate this origami simulation. The solution steps, what you should have followed in order to reach the result is step one. So will the base NURBS surface or surfaces. And I guess maybe if we have opened this, I hope not, but this includes the solution. So if I click on this to turn this on, we first have to build the base surface. And these are detached surfaces. As we have seen before that we can start with V-tach surfaces. We have to build the mountain curves. And I've put them under the mountains layer. And you can see from this, the behavior of this mesh is that when it's folding, we have one crease line folding in this direction towards the inside, which is the valley. Then we have this folding towards the outside, which is the mountain, and vice versa. So the pattern goes as one PS10 in this fashion. So it would be now easy to build these ones. So we know that we have a pattern of mountain curves, then valley curves than Mountain, et cetera. So we built the first step, the first surface than the curves. And also I've seen that when we run this simulation, I will allow try to play this. It doesn't really move away from where everything is because these four corners points are kind of maintaining the mesh location in place. And that's why you will also have to add anchor points. So here, these are four anchor points. That's how it is. So the last step is if there are any anchor points placed them at their most logical location. In this case, these four corners important to make sure that the value given to the folding input is not set to zero. That's important because if it was set to zero, we'll see nothing, no difference, nothing happening. Stop and play again. You see nothing is happening. If I change this value. And every have seen before. If we make this negative, it will flip the effect from mountains pushing down. Then the value is pushing with the outside. In any case, that's a detail. And also show you if I don't use these anchor points as anchor points and we rerun it will get this result. That's why we have to use anchor points in this case, for this definition to work as we have seen it. If I now play it again, we get this result. One thing though, please. If you, while working with the simulation, if you try to change the position of these points, it will change as if we have the origami paper or material in your hands. It will change. However, if you stop it. And then if you play it again. Now this point is lost. Always, always, always. You have to start with the anchor point being placed at the original location. So we'll here under the movement of the point. Alright, so now if I play it again, you see now it's back to the corner. Now I can move this one. I can move this one. All of these. But always making sure that I've already started with the points being placed at the original place. You can see that since I'm doing that. So basically it's kind of against the nature of the material of paper that it would never stretch that much. That's why it's behaving in a crazy way. And so that's why we get this abnormal result. I will bring these back to their original place and stop this one, undo, undo. Move these ones back to their original place. So basically this is a quick basic exercise about the basic mesh folding. And if you understand this result, this exercise, if you are able to replicate it, then it will be easy for you. To more complex examples that you can also look at them quickly decipher how they were made. And you can actually just remake them, replicate them. You can simulate them with kangaroo easily knowing that you have the basic DNA of the simulation, the basic surfaces, the mountain curves, the valley curves. Alright, so thank you very much for your presence and see you at Unit seven. 26. Origami Lamp Shades Experimentations: Welcome to Unit Seven class, which is about origami, as well as a continuation from Unit six where we started as a reduction about origami simulation with kangaroo physics. Basically, in this unit, we're going to look at all of these experimentations with lampshades. Some of these start with the basic pattern. And then later on, we're going to explore how that pattern would be applied on the lamp shades shape in a basic way. And how would the results look like? Now we're not going to simulate every single one of them like a live simulation. However, I'm going to show you quickly about each one's resultant simulation, which I've already baked previously. So instead of spending time on simulating every single one, I've already put here all information that you need for these simulations. So you can later on redrawn the simulations. You can change them. You can add whatever edits you would like to add. These are, I would say, the reduction to the world of origami simulations. And more specifically about lampshades, experimentations that are actually based on origami. Alright, so let's start. As you can see, the file is divided into parts or layers. Here for the first layer, it's about the Euro already pattern. And then we have the water bump pattern. We have lozenges than your own Rush. Inspire triangles, quadrangles, exit triangles and then hexagons and triangles, and then the spider on. And then last but not least eric year the experimentations as well. And here instead of the grasshopper file, we only have this part, this definition that's actually the same as the one inside of the unit 65. So you don't have to change anything. These are just pasted inside of this file. So you can use the same definition. I wanted to just separate them so that we don't get confused with the files. Alright, so here with the first one, the mural already, I'm starting now with the flat surfaces. Let's just make this a bit bigger. So the flat surfaces, These ones are flat and detached, not joined together. And then if I do this, if I select these and reference them here, then I select the mountains. Let's hide the surface to see the curves, the mountain and valley curves. If I said the mountains and the reference them here, then the valleys. I referenced them here. Let me bring this, maybe, something like that. Alright. Now when we run this simulation, double-click and play, I get this result. Then I can go back to this folding value and I can change it. So that's the behavior of the mural or a pattern basically. Okay, So knowing that then what I have done for this second one, so equal long 2 cm as this, this is the result. So basically instead of every single layer, if we open these layers, you will see that you have the geometries that are the base for the simulations. So we have the NURBS surfaces. Sometimes we may have meshes as well. We have the mountain curves and the valley curves, and then we have the different resultant variance. So in this case I have a Beta-1 and Beta-2. And the variation, the various baked results are baked at different times or intervals showing how the result in geometries would look like and each result baked in its respective layer. And the origin of this shape is not at all circular, but there's actually rectangular. So it has four sides like that. And based on what we have seen previously, this flat one, then we're applying here the same logic. And then here we have the mountain curves, the valley curves like that. And then we have the results. That's what we're getting. So this is how I describe the results. Long, 2 cm square, 8 cm, which includes the size of the initial NURBS surfaces. If I check the distance 8 cm. So this is how the size or sizes are described with the layer names. What is it about? What is the starting point of the origami? Basically, this is having this shape as a result. This is the mural or equal square eight as well. This is a bigger one with a 40 cm. And so we can now try to imagine that these, actually, these shapes would look like lampshades. And in order to get this result, if you imagine the lamp shade hanging from the ceiling having this shape, then in order to get this shape, you have to start with this shape. And so if you want to fabricate this shape, there are two options. Either the first option, which is more genuine, is to laser cut these shapes and add decreased lines. Of course. So that when we are fabricating these sheets of paper or cardboard or thin cardboard, whatever material we would like to use to make the origami lamp shade. Then we would know where we have to make a decreased lines and in which direction we would have to fold them. And so actually, what I'm now reaching to is this example. So let me first show you until we reach that one. Few of these different options if we make them longer or shorter, etc. This is the water bump, origami. It's a different base pattern. And this is based on this one. Okay? So most of them have a squarish base layout. This is a bigger one. Now this layout with the unrolled for laser cut at the end is where we can find the layer here called unrolled. And what's going on here? I will just minimize this one. What's going on here is that I'm taking these sides and I'm enrolling them on the flat world x-y plane so that I can later on laser cut them and then I can fold them following these crease lines. And the thing is that for this one, I just had to take, just copy these. Let's go to top view and take this one, selected this side, and now I copy it like that. Let's try to move it a bit. Oops, I think it looks like I took one line by mistake. Alright, be careful with that. It's a simple rotation. Just rotate it. That's the top view. Here. I don't need the surface. I can remove it. I can move all of these surfaces. And then I'm left out with these. And then I can also add here, I added the line type for these layers. So I know that the ones that are more spaced out lines or the mountain creases. And then the ones that are denser or the Valley Crisis. So that's when, that's how actually you can laser cut them and we know in which direction we have to fold every single line. So that's it for this example. Just need to take this original geometry. Then work with this one and not with this one. Right? And the other option, one option is to do that. The more genuine origami folds to have a real origami lampshades hanging. The second option is that we can just simply 3D print this one. We can give it a thickness. I can give thickness to the mesh. And then after the simulation, and then you can 3D print it. We can go down to maybe half a millimeter of thickness and then we can 3D print this one. So it depends on what we want to do with it and what technologies are available for us to manufacturer the project. I'll clean this up, keep this one like that. And so basically this is the unrolled as an example. So we have two sides and then two sides of the bottom side here. So we continue with the water bumps. Now the lozenges. That was a test to check how they would behave. And if I go back to this one, It's based on this pattern. And I get this result. These are square based variants. This is another variant as well. And with these ones, the resultants become kind of worked geometries. So these are quick experimentations trying to find out how would these resultants look like. Now, going back to run rash. So these are inspired by Ron Rash patterns. You can see the various proportions and sizes involved in this case. Now, let's also see the next one as well. Because there are similar. The second case we'll sort of the previous one. I use the anchor points like Angkor corners basically. So for these corners, I use these points to be anchoring. So they maintain the squarish shape. Obviously, if you're folding the origami with papers. And then we start, let's say with this layer, with this start here, with this layout, we will not end up naturally with this one, but with the circular one. And so in order to get this result, particularly, who would need either to 3D print it because it's fixed as a geometrical shape. Otherwise, we would need to make the origami folding. And then we would have to attach or constrain these corners, these corners curves to a certain element so that we can maintain this shape, basically, the square shape. This is with the quadrangles. So this is the first flat trial. And then this is now with the lampshades. I actually took the screenshot from the documentary film, and I then built it. The pattern based on that one. Basically, I could not find like this pattern online. So I just took it from the documentary. And I just built these mountain and valley curves as well. And the surfaces obviously, if I turn off the image, then we get this pattern. And we get now this result that we see in the documentary film. And let's go to this one. So this is now a lamp shade inspired by the eggs are triangles. Byron rash. And here I had to, not, well, I had to exclude these. Let's check these ones, these corner surfaces here. Because otherwise it would not really work as a transition from this plane to this plane. These two planes. And that's why this interesting result. We get with these corners, with the OLS being in them. So it's something actually that is unusual and kind of knew within this branch of lampshades. And now this as well, the hexagons and triangles. It's called hexokinase and triangles because it's based on hexagons that have in-between triangles. And then we get these folds. This is here a trial based on the hexagons and triangles. But you can see that it's not really working and becomes worked. Spider on distillation is really interesting example. And what is interesting about this one is that it does not have straight lines. It does not have straight mountain or valley curves. So these are curvy. And this is the image on which the base pattern is based. So these are now surfaces. And I also added these curves based on the image as a perfect replication of the image. And as a result, we get this. These are like the mesh wire lines. So this is the spider and desolation. And we have the last, but not least, eric geared the inspiratory gummies with three variants. This one is called eight dot-dot-dot for flagstone. And the second one is called Cairo, based on this pattern. So these are not really lampshades, but just experimentations, experimental patterns. And the last one is called the decagon flagstone. It's like a flower based inspired pattern. And to make it more interesting, I made a big flat pattern trial. Like this. These layers show the further or continued folding reaching these results. So from here to here to here. Alright, so basically these are the origami experimentations that I wanted to show you. As I said, these are inspirations based on specific patterns as a starting point which we can change or refine or adapt to whatever shape or design that we want to achieve. What is interesting about these experimentations is the potential of using Kangaroo to simulate origami patterns. And for the last ones, we saw that we used images of patterns as a start. And then based on these ones, I built the kangaroo definitions to reach the final origami lampshades and experimentations. Thank you very much for your presence and see you at the next unit. 27. Particles 2D Shape Collision: Welcome to unit eight class. In this unit we're going to explore new methods including solid collision, packing, wind, and other effects. Okay? So this is the unit eight file. And we have here the particles 2D shape collision, 3D shape collision, part one, onto part three, then packing wind and drip. Okay, let's put this here and split the screen in half. So for the first part, which is about particles 2D shape collision, which means trying to simulate a collision between particles or points and a 2D shape, which is usually a curve or a polyline. So first of all, here we can see we have in Rhino the layers that I have already prepared and organized for each exercise. For the first one here, if I click on this one, we have here two layers, the points and the curves. We have one curve. And basically the idea here is that we're going to simulate a collision between these points and this curve. So what if, let's say these points are falling down and touching the curve? The curve would actually prevent them from continuing falling down. And that would just dressed. They will, they will actually rest on the curve. So how can this effect be simulated? So we need the curve here. Here are the 2D shape, the curve and the points of the particles. And something to also have in mind. Like a background. While I'm explaining, is that in real life, as small as you can go with particles that are going to be or end up being spheres. I mean, if we go into the atomic scale, they will be considered as fears and not absolute points, right? So we have to also bear this in mind that in real life they're not gonna be pure points, but actually spheres or bolts basically. So let's say now we want to play with spheres and not zero points. Although kangaroo here is simulating the effect with particles with points. So how can we now knowing this and are actually dealing with the spheres are not points. How to translate this idea to kangaroo in its own terms as it only knows about particles. So is there a certain workaround in order to make it work for us? So let's start with the components of the recipe. So first, here we need to use this curve point collide component coming from kangaroo two from these goals here. So it is curve point glide, which needs points to be colliding with a curve. This is the curve input. For the plane here. I'm keeping it empty. And for this one, I'm saying it's now set to true. If false points would be kept outside the curve. If true, they will be kept inside. I will try now to test this and see the difference and this strength. I'll also try to play with this and see if it affects how it actually affects the simulation. So first of all, if the curve point collide, we need the spherical light. So as I said before, these points in real life are actually spheres are not points. So we need to translate this idea to kangaroo. And this is the component that actually does that it translates this idea into a tangible scenario, so to speak. It is an inter sphere collision. So if two particles touch each other than they will have to collide and not just touch and overlap. And then keep going as if nothing happened or as if they don't have any radius. Let's say they will have to have, they'll actually have to collide with each other. And this returns. Now here, we need the centers of these spheres. And this is the radius input. It's only one value for all of the radii and the strength of the collision. So that's the second one. And third one is the load similar to real-life scenario, where we have gravitational forces pushing it this fierce downwards. So we need to also apply a load to all of the points. Alright? With vector Z pushing downwards as an option, or actually two options we can grab. So after the simulation. Once we have the converged result, then we can try to move these fears around and see their behavior with the grep component. And on blame. Bear in mind this is optional. You can use it, you're going to have to use it actually. But for now, because the points are already placed in this weight, placed in the x, z plane, this one. So the small representation of the plane shows us that you are in the x and the z plane. I can even quickly draw it here. Just to show you quickly the graphical representation of it. Top view. So extrude the line. So this is the plane. If I move this, I mean this corner at the origin to be really like the real x z plane. So this illustrates graphically the x z plane. All right? We could have been working with the x y plane or the y z plane, right? That's also possible. But for now, I'm working with the x z plane. So we can actually use this component. It maintains the points on a certain given plane. That's what it does. As an option. The effect works without it. You can also use it if we wanted to say to guarantee that the points won't go outside of the plane. Although I don't think they will go outside of the plane. So supposedly they will stay, they will remain in the initial plane in any case. So we have the curve point collide, we have this frequent light. And for the inputs here, the radius input with this number slider, I'm not a big value, small value. And I'm also going to hear turn on just to see how they look like at the beginning. It is important to know that these fears, we cannot really use them as direct elements for the simulation because all of the inputs or most of the inputs of the components of kangaroo actually require points and not spheres. That's why I was saying that we need to consider that kangaroo understands inputs with particles. And then we need to translate the situation of spheres and not points with radii and geometry. So bear that in mind that we will only have these as a preview of where they are now and later on. So here we have the points. All of the actual components merge together. After the simulation, the output V for the vertices, Then we can hear it was another sphere component and use the same radius that was given here for the spheres. And the sphere collide. The inter sphere collision also give the same value to the radius input of the output of the vertices to make new spheres and then see the results there. So now to launch the simulation, the spheres are there. Okay? Let's first see how the simulation would behave and then try to check different options for the components. If I turn this to true, it does this. If I reset it. Okay, So they fall down quickly and they collide with the curve as well as with each other. Now, we're saying here to test what happens if this was false. So they will just go down as if there was no curve. Now understand what this means when it says if false points will be kept outside the curve, and if true there will be kept inside. So by outside and inside, it means on curve as if they are resting or should they resting place is the curve. And that would actually let us think, okay, if we don't use a load, what would happen if I disconnect the load for a second? Totally not even giving get a zero because here it was given a small negative value just to tell it to push it downwards in the minus z-direction. But what if we don't use the load at all? And you reset? You see, so it does that. It does not, well, there is no load anymore. So basically it pulls towards the curve. Now if I play with this, so here play with these two are actually, we'll change it to three sliders and check the results. Okay, let's keep this on. And if we go to zero here and reset, okay, So nothing happens. So if this curve point collide is set to zero, this is set at a certain value. Now, these are in the resting position. They don't collide with each other. So if we increase the radius, for instance, you see that now we collide. So this is the beginning position. If I do this, you see that only this one is working. The sphere collide. This is not happening because I'm not giving, actually I'm giving it a zero and there is no load. If I give it a load, they will go down. But there's not working because it's at zero. Okay? I will reset it. Let's turn the starting ones on. So these two will collide with each other and then move away. And all of them will go down following the load component effect. And they will not collide with the curve. You see these moves away and then move down anyway. So that's why if we activate a curve collide, they will go back to this one. If we give it a higher value. So they're colliding with the curve. Now, you see that when we play with this, you see its effect. How these are behaving. If we increase the negative strength of the load, the behavior becomes stronger. If we decrease the negative value like minus zero, that's 01. Let's see. They bounce a bit more. Then they go into this position going downwards with the weight being applied to them. Like this. Now, if I zoom in on them a bit, and let's check the spherical light component. If we change this value itself to zero. You see they will not collide with each other. If I give it one. They will behave like this. You see they are slightly colliding because it's a low value. And if we make this higher, you see they push outwards more. Let's make this a real number. And I'll make it like a0.01. For instance. You see, so the force of collision is really weak. You see? And then as we increase it, they are pushing more against each other. Maybe a value of ten could be like a guaranteed value. In this case. Preventing the collision. I mean, they won't actually overlap, they will collide and deed. So this is now the first step. The first way of colliding particles with a 2D shape. And we've have seen that playing with these components, what we can get as behavior if we use the Grab. Now after it's still running, it's saying that it's still running. But in any case, let's check. If we turn this off. So here we can grab them. We can play with them with the grab components. Alright, so this is the first step for the particles and 2D shape collision. Now let's check out the particles and 3D shape collision. Let's disable this part during this off. And this one as well. 28. Particles 3D Shape Collision Part 1: Okay. And turn this on. So in this case now, I will enable fees. Okay? So in this case, what we are doing is to collide these spheres with this box. And now it's not anymore a curve. And they are not anymore planar in one x z plane. But they are in a x, y plane. There are planar and then they will fall down and it will hit the box. And then we're going to see the collision simulator there. For this, if I drag this to the side. So we need the B rep as the box. I have already constructed this box, this one. And the points population curve, which means it's only this curve. And what I have done is that I use this one I made populate 2D. So if I click on this, we have now these points and these out of these points, I made spheres. Basically, that's one way of building an array or a group of points quickly with the papillae 2D component. And that's it. I'm going to turn this off. Alright? And this is our box. Now, what we need for this one is a solid point collide. Remember here we had the curve point collide. Now it's a solid point collide coming again from here. Kangaroo. The same subtype goals. This one. We need a sphere collide again, the same interests field collision. So this is the same as this one. Sphere collide. We need a load and they grab. The only difference in this case, to convert the effect into a 3D effect is this solid point collide. Again, you understand that a false points will be kept outside the solid. If true, they will be kept inside. So let's see here, it looks like it's going to be kind of inverted. Also change this to three. So this is the beginning. We'll keep the BI rep on. All of these ones. Keep them on. Alright? Now, if we keep these ones off for now, keep only this one on. Alright. So important, if these fears or not already touching each other, colliding with each other, they will only move down and stays too. Let's check this out. If these fears are not touching, which means if they are small, right? So let's say they are small like this. Okay, starting with this situation. And we run the simulation, they will do this. That's it. And so here, previously, in the previous example, we saw that this needs to be true as the input. So if false points would be kept outside the curve, if true, they will be kept inside. And we said that we want to keep them on the curve. So true. But in this case, it's actually the opposite. So let's check the explanation out. If false points will be kept outside the solid. If true, they will be kept inside. So this means that if true, there'll be kept inside the solid. But I want them to be outside of the solid. Now you see that if I do this in the middle of the simulation, it won't work. You see in the beginning of the simulation after we run it. Now in the beginning with the middle of it. If I say true. So make them inside. They will keep going and then gets stuck inside. If we change it again and we change them to outside, then they won't go back outside from there. But they will actually keep going downwards. Like that until infinity. That's why always in kangaroo, if you are changing the inputs, be careful about the results. Because if we find out that the true is the correct one, and then they disappear, Where are they? Related needs to be resected. So just reset and change this to false. So recently again, the inputs here. Okay? So now this is working well. I would say, well half working. Why? Because although there are colliding with the box, but normally we would not expect them to go halfway into the box. But they would sit on the box on the surface of the box and not like this, right? That's how we would expect them to behave. And so we can have a workaround. And this workaround will be to push them upwards by the radius value. So if I use the radius value that was given for these fears and the sphere collider input. And so with the, with these spheres here, we can use the move and turn this preview off. And now they are resting, as you are, would actually expect them to behave on this external surface of the box like this. I'm actually in a ghosted view mode. So I can also see through from this side in any case. So now we're having this effect. We have to do this work around after the output, once the result is done, and then move them in the z-direction with the radius value. Alright, so I said here that if these fears were not already touching each other, colliding with each other, they would only move downwards and stays still. But what if they were touching? They were colliding from the beginning, what would happen? So I will actually stop it, reset, and I will make them a bit bigger. Let's try to increase the radius until they start to touch each other. Something like this. So now they are touching each other. And for now, we'll keep this for the moment off. And keep this on. Alright? So even like someone outside the box and kept falling down, like in real life, if we have this situation, they would most likely go outside of the box. And there are still going down like so they touch, they collide. They got pushed out as a result of the collision. And when outside of the box. And these are moving around as we would expect them to do. If we bring this to four, I think they would still collide. Let's see if we run this simulation again. Yes, they still collide among each other. And the dome fall down and stand still, but they go down and then they collide and they move around a bit. Let's make this even higher without having disputes to go outside the box. 4.3, let's say hopefully that they won't go outside of the box. Okay? Now I can again turn this, move upwards with the radius in the z-direction so that now they would sit on the box. As we would expect them to do. However, it looks like there's something still strange. Some spheres seem to be touching the box, kind of overlapping with the box. Not correctly colliding on this side, e.g. and so the workaround, this movement of the sphere upwards with a radius value. Just solve this issue. If I turn this on again, let's take a look here. This issue of not having them to do this, right? So I turn this on again. And now there are good like this, but some are not looking, correct. You know, quote unquote. They don't seem to be behaving correctly. They're not really colliding with this side of the box. So observation, you can see that although these spheres are falling down and successfully not colliding with each other, some seem to collide with the solid box. Actually something to not collide. So I would say seem to overlap with the solid boxes walls. Right? This is happening because there is no component affecting the collision between the box and the spheres, but only between the box and the particles. In order to solve this problem, we need to add another component that simulates or prevents, actually, yeah, I would say simulates, simulates the collision between two solids, box and Spheres, not the box and particles. Remember that here because the components are simulating the collision between particles and solid, between points and a solid. Or here the blue wrap the box that all of these input points that in the end here we would have to, we had to use this move up in the z-direction using the radius value in order to make them look like, like this, right? This view. But from this side, this is not solved yet. And so actually the problem is deeper and we need to try to make collision between box and spheres and not Box and particles. 29. Particles 3D Shape Collision Part 2: Let's see now how we can actually solve this problem with another workaround. I will allow disable these, turn this off, and we'll turn this on. So basically this work around instead of using or actually moving these fears upwards or trying to move them and decides to account for what we have seen. The issue with not colliding with the walls. I would actually do the work around with the box itself. What if the box was actually smaller than this box that we're seeing now. And we have the collision being simulated with the smaller one that we don't see. And then it would look like as if these are touching this one, right? So instead of moving the spheres away from the box by the radius value, what if we could actually invert this statement by actually offsetting the box by the spheres radius value. So that the box becomes smaller in a way. And it will look like with the bigger ones as if it's working correctly. So let's try to see how we can do that. So here we have the box. Okay? And what I would like to do now is I want to offset it. This one to make this interior area smaller for the spheres. I turn this off. And now we have this relation happening here. One thing we would ask why I'm offsetting the box by 6.932 and y naught by four. Well, because I've tried this out before, it looks like if I do this by four, it will not give the correct offset value. So if I turn this on, so this is the original one. This is the new offset one. If I tried to make a quick distance check by I it looks like the distance offset it here around 2.3. And that's why I figured this would be the value for it. So 6.932 in this case, if we check the distance now, it's around four. So that's what the offsetted new box we need. And it's a bit strange why it doesn't work with this one. I didn't get solution or a good explanation about that. I even tried to use the thicken if we try the mesh thicken from weaver bird. So this is the mesh. So this is the box. And I do this. Sometimes strange things happen, but I couldn't find the explanation for that. If I give it a value of four. And let's check. It looks like the same result as the one that's happening here. By the way, this components coming from puffer fish. I'm using this puffer fish plug-in offset mesh to do the offset. And it's an interesting result that we're getting and not exactly the correct for dimension. So again, if I tried to quickly check the distance by eye without snapping anything to 0.24. It's really not correct. However, if we actually offset, if we offset the box or not the mesh, but if we offset surface this original beer app, it would actually work. So if we do that and then we offset this distance by four, we have a lot of things above each other. Preview off these ones. Alright, so now this new offset that result from the B wrap, this one. This looks like it's correct. Let's check the distance around for this, correct. I don't know why meshes that doesn't really work. However, I cannot really use this one. In this case, actually tried it and it didn't really work. This is not considered as one mesh because we have many reps. When we miss them and join them together, it doesn't really work as we want it to work like this result. So I want exactly only one box. Turn this off. Only one box like this. That's what I want. But the offset surface is offsetting every single surface of the B or AB. Thus make multiple boxes, which is not what you want. So be careful about that. In any case, this is not a kangaroo issue, but more a grasshopper or actually a rhino problem. I figured that this value would give the closest value to be for as a final value, the four offset. And so please be careful about this later on. If you want to make a mesh offset with a specific distance, double-check it. And even if it seems it's working, it's not giving any error messages. It might not actually be the case that it's actually working, but it may be actually not working. So always keep that in mind. Alright, so in any case, this is now the box that is now bigger in terms of the outer volume. But this area here, this one is smaller. So these walls are pushing to the inside by the value of four, which is actually the radius of the spheres. Now, doing exactly what we have done here. So nothing changed from this side here. I only added this offset mesh here. And I now run the simulation. I will get this result here. Now you see that some are doing this overlap which is actually expected. However, this is not the original box, right? Remember, this is only the offset To do the workaround. Now, if I turn this off and I turn this on, now, it would work correctly. Now there are actually behaving as you would expect them to behave, to collide with the boxes walls. And now even here, remember this work around that we did before. I did not delete them. I intentionally kept them and put Xs over them. So no need for this boost simulation operation as the offset mesh box solves it. That's what's happening. Because the offset is in all directions. If I go back to this view and I turn this offsetted mesh on, it is offsetting in this direction of the walls and also the surface upwards. The floor here of this area is also offsetting upwards by four. And so that's why now this is being solved. So we don't need anymore to move the spheres after the simulation. After this folder is output. Alright? So I will turn this off. This is just a small workaround before this simulation. The simulation with the box, not with the spheres to make the effect working correctly. 30. Particles 3D Shape Collision Part 3: Okay, Now one thing that we need to know is that in the current Kangaroo to plug-in, there is actually a missing component that should make a collision or a simulation of a collision of spheres that have varying radii and a box or a mesh. This is important to know. And here actually like added the note. So important. This solution with the offset at mesh box works only when all spheres have the same radius. In case there are different radii, then you would need to use the collider component instead of the sphere collide. The solution to the right, part three is inspired by Daniel bikers proposed definition. This is the link to the page. It is here. This is the simulation of a collision between multiple spheres with different radii and the mesh. And here he says that he explains what's going on. And by the way, this is also the link to the file. If you want to download it, I actually put it for you here. Under Part three. Here's the phi content. So this is the original file. This solution is inspired by Daniel packers definition or proposed definition. And it is there as a reference source. So what he says here is, I realized though, that there wasn't really anything in there for collisions between spheres of different radii and meshes. You could do it by offsetting the mesh for each different radius. But that would be rather slow. So I put together a new goal for this. So a new component which is actually not in kangaroo too, but actually inside of this file. I will show you soon this new component. You will need to set the assembly reference location. Okay? So the new goal is a C-sharp solution component. So if I enable these and we'll now disable these. So now it's making a collision between different radii spheres with the mesh. So this offset mesh, There's not actually needed anymore. Because the workaround will, will actually do it, will do the trick without having to do this. Alright. Just make this a bit bigger. Okay, here we have the B-Raf, the box, the mesh. And this new component, which I believe would be part of the next kangaroo version, sphere mesh collide. And this is now currently a C-sharp component. It is not yet a kangaroo component. Alright, so collision with box, there's not yet a component in kangaroo. If you double-click on it, this is the code of the component. Alright? And here the input. So for the mesh, I would rename it solid for you to later on understand the inputs, radii and strength there. So you see it's really high and not one radius, but multiple radii. So the first step is the collision with box solid and points with radii. We also have these points where the collider. So also the second thing that is different is not anymore. The sphere collide, but collider coming from kangaroo under goals, collision collider. And again, because we have now different radii of spheres that we need this inter sphere collision to happen between these spheres of different radii, right? So this is the second part, the anthrosphere collision, then the load and the Grab option. Alright? And for the different radii spheres here, we can actually do this. So you see this, we can, from popular 2D, these points I'm using here a list item. So how many do we have here? We have 20 and I'm using a random component. And then I'm constructing a domain between these two values and then connecting it with the range input. And this will just randomly make values, 20 values that are in-between. These two values, these two extremities or bouts. That's what's doing. We can change this later on and just a variation of the radii of the spheres later on. For now this is between these two values. We can actually make this, let's say a bit, maybe bigger and the smaller, the minimum. So these are the spheres. Again, we cannot use these directly when the components, but only the value of the radii and the coins. These ones. And now let's look at this. If I now launch it. Okay, I'm making this ready. And through someone outside. If I actually make this smaller, let's say six and reset. Alright, one went out, It's fine. Now it's working correctly without even needing to do any work around. So this is the cool thing about this is that now we can use this sphere mesh collide component. This new one, which is still not in the official kangaroo, but most likely part of the next one. And this will now do the job for different radii spheres. And please don't forget that this is inspired by Daniel Parker solution. And you also can find the online link to it. Here. You can download the file from this link. And as we're now looking at it, this is a quick run of it. This is the simulation we saw previously online. This is the animation here and the website based on this one. Alright. So I'm going to disable this and also this one. And now let's go to packing circles on surface. 31. Packing Circles on Surface: And this one is rather a simple definition. But it has a really interesting effects, especially with packing circles on a surface and not only flat surfaces, but also curvy surfaces. I will show you what I mean by the soon. Here we have the layer packing circles on surface. And what I've done here is first, I built a surface, a quick surface like this. Then it turned on the control points here. And here, like this. Then had to rebuild the surface. Turned on the points again. And I moved a few points from inside up and down just to give them all the surfaces small bumpiness. That's it. So that's how I reached this surface. This is a quick review of this. And then I drew a closed curve like this, a planar one. And I used a trim command. So if I copy this on the side, we go to top view. We make this ghosted type trim. This is the cutting curve like this, and now we have the final surface. So I want now to work with this one. Alright, so this is now the trimmed result. This is what we want to work with. We want to pack circles onto the surface. Okay? So now move this there. Alright. And I will enable these. So first, this is the surface referenced here. And I'm just doing a populate geometry. It is actually similar to depopulate to D that we saw before here. But now it's populated geometry which works with surfaces. Let's turn this on. So this is the count of the points, okay? And you see that population of the points is randomized. Whenever we have a CD-ROM put, it means that the component is working with randomization. And so basically they are scattered on the surface without any order. Just randomly. I can play with these. I can now play with this, scatter the doubt. And we need here only two main components they grab is optional. Now the first one is the unmatched. So we want to keep these points on the mesh so unmatched. Second one is fear collision. So this is the spherical light component that we saw previously with the particles. And this will make a sphere around every single point and then simulate the collisions among the spheres. Here. All of these circles are going to have the same radius for now. This is the first part which is preparing these components. If I click on this now, the output is going to be zero points. Now, if I make a sphere out of every single one of these, it freezes a bit. It looks like. And then I give a radius value. This now to this. So now this means that these are the spheres that will be simulated soon. But remember, I want to have circles on the surface. I'm going to show you later after this how we can do that with this step here. So I will now turn this one off. And I will now run this simulation again. You see that because we're trying to preview spheres, there is freezing and the simulation is slow because we're dealing with lots of spheres and not circles. If I tried to orbit in 3D, I'm not actually able to do that because it's still freezing. After a few minutes, I was able to turn this off false. So please don't use fears as it would just freeze or definition. But in any case. So we want to pack circles on this surface. We have these points and then we get the vertices outputs here. And then if I change this to true, you see this is the simulation. But we said don't see the circles on the surface, so we need to make circles out of these points to be normal. Do the surface. Alright. So in this case, we use this component first, the surface closest point. And the input of the surface is the surface itself. And put forward the point is the vertices. We only need this component to give the UV point of every single point with which we're going to do and evaluate surface. This surface with all of these points with their respective UV values. And then the output frame. So the base frame of every single point onto that surface that is normal to the surface on each point's location. So if I turn this on, actually, you see all of these planes now. These are the normal planes on the surface at every single point. And then we use these base planes to the tuple to be the planes of the circles. So every single circle will not be along the x, y plane, but along these planes will turn this off and on. And now we have the circles. So now the circles are on the surface. And what is interesting now is because we have the grab on. We can go here in the viewport and click and move circles around. We can adjust the result if you want. Like that. Just play with them. We'll turn this one off. Only keep the result. Now, something to be aware of. If we turn the strength of the sphere collide too high, it will not give us like a homogeneous result. In other words, if I bump this too high and if we have more circles like this, alright, let's say 400, but will not look kind of nice in a way or like a clean result. If we take this back down to one, round one, it will look better and more homogeneous result. And of course, if we play with the number of the circles and re-run. Now, nothing happened because these are not colliding with each other. We don't have enough circles. If we bump the number up, then start the simulation. And of course, the radius. Let's play with it, as well, as well as the count. So it becomes a nice interactive simulation. So this is basically backing circles on a non planar surface. I just wanted to say that we can also packed circles on a flat surface. However, this example shows the more extreme or let's say more challenging situation. And we can even use this type of simulation if you were, let's say, simulating a layout of tables and the restaurant. Or if we have a certain pattern, like an urban pattern of buildings or something. Or we can actually use this trick to try to simulate how would we get the spacing of different elements may be furniture elements, maybe on an urban scale, like patterning or spacing of buildings or blocks with this simple method. And even like structurally. So it really depends on what you are, what you have as an end goal and how you'd like to use this definition to meet your goal. I'm going to disable this and enable this part about the wind. 32. Wind Simulation: So yes, in Kangaroo, we can actually simulate wind like they wouldn't effect on geometries. And here, I'm going to do this. So for the wind, we only have this surface that I've built inside of rhino referenced here. And I turn this off. So first of all, we need to turn the surface into a mesh surface. For the UV count. I'm using 15 for both u and v inputs. I need the show component because I would like to see the mesh on the output. I need to use the edge lengths because I want to maintain the mesh net. So the length of the interior edges of the mesh. And I need to use a width component from kangaroo. Two, goals, mesh, wind. And in this case here, the one is affecting a flag. So I need to use anchor points to anchor points to anchor the flag. And vertex loads because in real life scenarios, we would have the gravity. So when there is no wind, the flag would just hang down. And then when there is wind, it will just blow on the flag and then make it move with the wind. So from the surface, what I'm doing here is I'm using a deconstruct, be rep. I am extracting the points, this one and this one. And I'm moving this one downwards, making a line in between and then making pipe as a 3D representation of the rod, not the flag. This is a graphical step. It has no impact on the simulation process itself. And then these two points, here, I'm using them as anchor points. Alright? Without any targets, so the flag will not move the mesh surface. We have this one, the edge lengths with the strength value. Also using the same mesh for the wind. And the vertex loads applied also to the mesh. Okay, so first things first, I would like to show you first if I use a unit x-direction for the vector. So this w input is the wind vector, the direction and strength of the wind. Alright, since this is now along the x axis, how do you think this relation would behave? How do you think the window would affect the flag if I turn this on? So we have this pipe on and we have the output here with the mesh on here. And if I click on true, it will just to this. So we have only the vertex loads affecting the flag, but without any wind effect. Although we have is strength value here. But it doesn't seem to affect the mesh surface, the flag. And that's because it's going along this direction. This one, since the mesh surface of the flag has no thickness, the wind is unable to see it, quote unquote, therefore affecting it. And that's why it is not doing anything. If I now use the y vector direction, Now it works. And if I change this back to the x-direction, it will push it back to the x-direction and then keep going. If I turn this back down, Let's say to one, maybe even less than one. Now, simulating a gentle wind. And if I turn this to zero, oh sorry, if I turn this to zero, not minus one. As if there are no loads pushing down. If I rerun. So I get a really small value just to be more realistic. And I bombed the slightly higher. Alright. So this is the wind effect. Applying it on a flag. We can apply it to any mesh that we want. Alright, so I'm going to now stop the simulation. Okay? I will disable this. 33. Drape Simulation: And the last but not least, drape effect. I will enable these. Okay? Under the drape layer, here we have the drape surface. This is the surface, and here we have three layers. So we have the cube, we have this fear, and we have a torus. And let's see how the simulation with a B would actually behave with each of these solids being used as inputs. So basically for the drip, there is no specific draped component. But we need to combine three components together to give the effect of a drape. So we have the mesh surface, then we need to maintain the lengths of the mesh wire. The first step. So this is maintaining it the edges of the mesh. We need to give a solid point. Collide. This one for the points of the mesh. So you would need to have to imagine that rape is colliding with the solid. So it's resting on a solid. For this, we need to use this component. The solid point collide. And all of the points of the mesh will be colliding with the solids and play with these ones here. So here we have the box first, then this fear and the tourists. And we need a vertex loads to push the mesh down onto the solid. And as an optional input, we can use floor. This defines a base plane collision, preventing the drape from going beyond it. I will show you what happens when we use it. And finally, the grab as an optional component as well to play with the output resultant. Alright, I'm going to first choose the cube. We'll turn this on. Alright? As the solid with which all of the vertices of the mesh will collide with. So now we get this result with the cube. We see that we did not use a floor. If we use the floor now, it would snap upwards. It's only affected the simulation instantaneously. If we start the simulation when the floor being part of it. It will do this like that. And here for the floor, it is using the x, y plane as the default plane. So let's keep this as it is for now. So this is now with the box. If I turn now this off and I turn the sphere on and I use it instead. We run it. So now we have this result and if we don't have a floor, we get this result. So the mesh is draping onto the sphere and you see that it's kind of like sliding off and fall down to infinity slowly. Or we can use the tourists. So turn this off. Let's turn this on and use the torus if you aren't rerun, falling down on it and also slightly sliding. I was ready to save it and use the graph, but not really helping. And it's also falling downwards. And if it's negative z, alright? So if I connect the floor again, it will just like snap super-fast upwards. Okay, reset it. Going back now. Resetting the floor on. So this is more realistic effect. Adding the drape resting on the torus, on the floor. And you can of course, play with this by dragging or grabbing the mesh with the grab component on. We can try to grab this to the center, maybe. So we can do this as well. It's not really reacting quickly because it's trying to simulate the grabbing action. And even when we tried to orbit, it does not orbit directly while wrapping something. So yeah, just keep that in mind in any case. So yeah, that's it. There is no draping component, quote-unquote. But you can actually build the dripping effect with these components. The length of the lines of the mesh, maintaining the solid point. A collision and the vertex loads. The floor is optional of course.