Skeletons in the Closet

JONATHAN GEFFEN: Welcome, and thanks a lot for joining us in this exciting session, Skeletons in the Closet. And you can see, we're having a lot of fun with the subject. When we came up with it, we were quite stoked and kind of took it on a tangent and went full-on with the outfit, as well. So we welcome you, and hope you have lots of fun with us in the session, as well. Now--

DIETER VERMEULEN: I can't move this one. Oh, it's not fixed. Let's not switch this one. Now, switch that one. OK, perfect.

JONATHAN GEFFEN: So just a quick intro about us, who we are. So my name is Jonathan Geffen, and I've only been with Autodesk for a couple of months, actually-- since March. And I moved to Barcelona for a cool role as a technical specialist for design manufacturing, because my background is actually in industrial design.

I love making things that actually-- or designing things that can actually be made. And this is one of the reasons why this class is also so exciting for me. And I love the sea, and the mountains, and the combination of all of this in Barcelona. It's great

DIETER VERMEULEN: My name is Dieter Vermeulen. I'm based in Belgium, also working for Autodesk since-- for more than four years, now. And I'm mainly responsible for everything around computational design and engineering, and a team, which is called EMEA, in northern Europe. So I'm mostly working for Scandinavia, UK, and Benelux.

So my passions are really about computational design and trying to combine this with my structural engineering experience I used to have from engineering offices in the past. So that's something that will reflect in this presentation today, as well.

JONATHAN GEFFEN: Cool-- oh, oops.

DIETER VERMEULEN: I was almost a skeleton myself, though.

JONATHAN GEFFEN: [LAUGHING] Yeah, exactly, skeletons laying on the floor. So just a couple of key learning objectives that we went to bring forth to you, and for you to take home with you, as well-- so for one, we want to show you, what is computational design? What can you do with it? How can you leverage it to work for you and create better design, better design decisions? And understand how to connect Dynamo, which enables computational design, with Inventor.

This connection isn't quite there yet, but we made it work for us. And also, to show what a skeleton workflow is and why we have these funny t-shirts on. And then, essentially, to leverage the skeleton workflow with frame generator and generate a frame, according to the computational design that comes from Dynamo.

Now, the purpose of this class-- you've seen the learning objective. And the background story to it is, we were looking for an application of a skeleton workflow, and also a frame generation workflow. And because of this, we decided to go with a roller coaster. We found this really, really cool art project by a guy called Julijonas Urbonas, or something along that line. And he designed this euthanasia coaster, which is a roller coaster designed to kill you.

AUDIENCE: [LAUGHTER]

[LAUGHS] So along the lines with the title of this class, we went with this coaster. And there's a really cool trailer for a short movie that you can watch on Vimeo that describes what this is.

[VIDEO PLAYBACK]

- To be remembered is the only thing that matters in life. So what are you supposed to say when someone stops the world that you are almost spinning and says, you're going to die? This will be my legacy.

5, 10-meter drop, 220 miles per hour-- do you know what that does to the human body? A prolonged, cerebral hypoxia-- pure euphoria as the brain is starved of oxygen. What's not to like?

[LAUGHTER]

[END PLAYBACK]

JONATHAN GEFFEN: So [CHUCKLING] going along with this theme, we are planning to take you on a roller coaster, as well. And the different industries that Autodesk is serving has also kind of gone on this kind of a trajectory. We, of course, don't want to kill you with this session. But we do want you to have fun and learn something interesting.

So we can see that a lot has changed already in the AEC and manufacturing industries. They're kind of converging. And up until quite long ago already, actually, Autodesk has kind of led the way into the era of documentation, which was to bridge the gap between a manual process of creating design data to a digital one.

And afterwards, we have participated and really formed the era of optimization, which puts designs at the center and enabled optimization and testing, virtually and digitally, of designs. And by now, we're moving into the era of connection, which really means that we can utilize our designs and our data that we create, to connect with each other-- with the stakeholders that are in the design project-- and make that data the center of attention, and make it a real project.

And in this era of connection, we're transitioning through different phases and different components, which is-- for one, we are utilizing the cloud, of course, to connect data, and to connect projects, and to connect teams. And we're also interconnecting to create insights, and to make informed design decisions, and to create designs that can actually be made. You've, I'm sure, heard of the notion of design and making converging. So we want to design things that have the making in mind. And this is why we want to deliver something that is connected and that you can constantly keep up to date, as well, along with design changes that go along with it.

So for the next part, I want to show you the background of some of what we are trying to create. And for this, you need to understand, first, what is a skeleton workflow, and what's the skeleton frame? So we're going to use-- out, go ahead, here. We're going to use the skeleton workflow inside Autodesk Inventor, which enables us to kind of create a top-down design workflow.

That means that you have a simple assembly and a simple part file, which is a skeleton. And you use the skeleton to then create further the geometry. The great thing about this is that, whenever you change the single-part file, which makes up the skeleton, it's very easy to make modifications to your larger design and your assembly. And because of that, you can reference common connections, and it's all based on the single design workflow. And that's something that is easy to connect into and to utilize for more complex workflows.

And to understand what types of skeletons there are, it's really quite simple. You could use anything from a surface-patch layout, or 2D and 3D lines, all the way to solids, and even their features. So anything along the lines, or the edges and points, and vertices, and so on, you can use as inputs for a skeleton workflow.

And the way this workflow is used in Inventor-- you would start by creating a skeleton as a part. So in this case, for example, we have a skeleton as a 3D line collection. Then, you place this part file inside an assembly. And this assembly becomes the ground, basically, for your frame design.

You then select the geometry. So you select the skeleton lines-- the bones, if you will-- of your design to generate more geometry, which is, in our case, a frame design. And from this, you move on to actually create the frame assembly and the part files. We'll look at the exact workflow a little bit later in more detail.

And using this, you can then utilize several different tools. So you can create end treatments for these frame members, like mitering and notching. And you can make these frame members in a way that you can actually manufacture them and create that detailing that you need.

And of course, as we are in a digital, very well thought out, and a complete CAD package, you can utilize frame analysis and simulation to validate your design. And because this workflow is based on the single-part file, you can actually use the skeleton itself with the kind of metadata that goes along with it, saying on which bone is which frame. And that makes the validation and simulation process extremely fast and very, very efficient.

Afterwards, you can create the bill of material. And more than that, you can create a whole catalyst including all of the end treatments. And then, essentially, go to the documentation. And this is all a complete workflow inside of Inventor.

And now, I will go on to my colleague. Dieter, talk about computational design.

DIETER VERMEULEN: Yes, so if we go to Wikipedia and you're searching for the meaning of the definition computational design, that's what it says. It says, somehow, that it defines some kind of a relationship between your elements-- between traditionally drawn elements, or sculpted elements. It's also creating data, and it's creating relationships between that data.

So you get what we call the interconnection of data. That's something that comes from that principle that Jonathan was explaining. In the era of connection, there is one principle called, connecting outcomes. So it helps you to drive your number of design options. So you get more design options, which you can choose from.

Now, to tell it a little bit more-- in practice, parametric design is already some kind of a computational design. In that parts, or in that principle in here, implicit relationships are built between parameters, for instance. So as a user, you create specific formulas. You create your relationships. And then, this could result in specific geometries.

So that's what you do when you create-- for instance, in Inventor-- when you are creating your catalogs and parts. I'm not really proficient and in Inventor, but I imagine it's a bit similar. I'm more a Revit guy. So in there, you have families, and then create those geometries and parameters, and so on.

There is also what we call conventional scripting. In the past, you needed to be a PhD in mathematics or in computer science to be able to do all of this. So this is actually an example, of Python Shell in Revit, to create a very complex double-curved surface.

I am pretty sure that some of you who are using Inventor are like, wow, do you need that code for that? We just do it like this in Inventor-- drawing two lines of them, and we have the geometry, as well. But this is more about automating your designs and placing formulas behind your designs. So this is really a technique that comes from the building industry.

Now, to make it a bit easier, there is also visual scripting. So for visual scripting, you don't need to program. You don't need to type that complex code for it. So you get a library of notes-- that's how we call them-- and you put them together in some kind of an order.

It's like a dictionary-- when you have a dictionary of words. And you get all these kinds of words. And if you put them into the right order, you will get a phrase that makes sense. So it's a similar thing with visual scripting.

There are also some sketching principles that are used in here, in this computational design problem that we are going to describe. And sketching has, also, some kind of a relationship already. For instance, in the Renaissance, they already used specific techniques to make relationships between geometries to have symmetries in there.

So if one of the crosses changes in size, it influences the whole building. So it influences that relationship. The only thing is that, at that moment, they had to restart over again, of course. They could not just use visual scripting for that.

Now, sometimes, you hear the word visual programming. When people hear programming, most of them are looking at the back door to get out of the room because they say, oh, no, it's programming. This is not like a DEF CON, or whatever.

Now, on the top left, we see something which is already visual programming. It's used by kids. If I'm right, Zach, this is called Snatch-- Scratch? Or-- yeah, OK.

Well, at the bottom right, we see a more professional version of this kinds of things. So this is showing us that visual programming is not really about programming. It's like building a flowchart. It's like building a relationship between those elements.

So think about how you design, right now-- or maybe in the past, even. That's actually the old way. That's the way where you have one human with a computer, and you create a design. So you're documenting, actually, that design.

Now, in the new way, you still have that one human. So it's not about replacing us by robots. No, we still have that one human.

And you give that one human a few algorithms-- like genetic algorithms, for instance, artificial intelligence algorithms-- and then combine this with the power of unlimited cloud computing, for instance. Well, then you get hundreds or thousands of design options in the same time as you would need to only describe one in the old way. So that's what we are going to prove today.

We are going to develop that roller coaster-- at least a part of that roller coaster. So we are not going to kill ourselves, right? So that's not the intention in here.

And in those workflows, we are going to use lots of software. One of them is, of course, Dynamo. This is more like a practical slide. It's for your reference for afterwards, if you want to try it out yourself.

You will find the data sets not on the class-- how do you call this?-- the class portal. You will see, there is the handout to the presentation. And then, there is something called Additional Information, or Additional Class Materials.

So we could only upload PDFs. So if you want to have the files yourself, you want to play with it, then you need to go into the additional handout that is also uploaded. And there you will find a link to this. So you will also find the link to all that information on here, plus also the videos. We are going to share it with you on the same platform.

Now, Dynamo Sandbox-- what's that? Well, Dynamo Sandbox is actually the version of Dynamo that is delivered in Dynamo for Revit. So we don't get-- you also have Dynamo Studio that's available for you to buy or download. But Dynamo Studio is not connecting with some specific products we are also using in here.

One is called Project Refinery. I will tell you a little bit more about that later on. So we are using Dynamo Sandbox for that-- part of Revit, OK? Also, Inventor is used in here, obviously, because we are talking about skeleton modeling.

Now, with Refinery-- Refinery is one of our newest products that got released as a public beta this Monday. It's actually a generative design for AEC. I know, in the manufacturing industry, you already have products for generative design, but not for these types of structures that we are going to do in here. Because we want to make something which has a very low threshold to use, so something that maybe only requires one or two-day training, without having to be a really big specialist in generative design.

So with Refinery, it gives you the possibility to explore and optimize your designs that you are creating with Dynamo. So it gives you also possibility to display, in an advanced way, your results. And it's using those specific genetic algorithms.

So I'm not going to go too far in depth on how that works. So if you have more interest in optimization, tomorrow morning at 8:30, I am doing a structural Dynamo-- or Structural Dynamite, it's actually called-- class about genetic optimization. So ideal stuff for mornings, especially if you guys have hangovers and so--

[LAUGHTER]

Then you feel like that skeleton. The workflow that is going to be used in the computational design here is, of course, generating geometry. So Dynamo is used in here to generate the geometry, to evaluate the geometry.

So evaluation will be done based on some parts. That could be the weight of your structure, that could be the manufacturability of it, that could be cost-- whatever you want to use as an evaluation. You define, yourself, how to evaluate this.

Refinery is going to be used here then to drive all the options, create all the design options, and help you to decide which is the best option-- so to make your selection. The model data will be exported to Excel. And actually, Excel will be our glue between Dynamo and Inventor because, in Inventor, we can read that Excel file. We can use iLogic, for instance, to program it so that we have an automatic link. So we are actually going to sync the Dynamo system with Inventor by using Excel in the background.

So that's what we were telling-- it's more like a concept. So it's not like, for the Dynamo users among you-- who is that? Perhaps are there Dynamo users in here? OK, cool. So it's not a package, yeah?

I know that there was a package in the past-- yeah, ages ago, there was something to connect with Inventor. But it didn't do that thing we're doing in here. So it's a concept-- maybe something to develop in the future.

Now, if we talk about generative design, how does this work? So this is only a part of the workflow in here. Well, we are going to set up the data-- data that consists of constraints and requirements, which are being used to generate.

So for instance, you will have one looping, all right? And that looping gets evaluated. Is it not to heavy? Can we fabricate it? And so on. If it's not enough-- if the score, for instance, is not OK-- then we are going to evolve it by changing the input parameters.

That could be everything. You will see immediately what parameters we are going to use. And generate a new design option-- evaluate, generate. Or evaluate, evolve, generate, and so on, and so on-- until you have the right option, or at least until the evaluation gives you a result that is acceptable, according to your own defined constraints.

And that's the moment where you start selecting. So you could select one option, but it could also be that you have multiple options that are possible to use in here. So that is the principle of generative design.

So let's start with a first video. The reason why we are not doing this live is not because we hacked it or we're just doing mockups or something. No-- it is because we only have 60 minutes. And some operations are sped up in here. Some operations take five minutes, instead of only 10 seconds.

Except for this one-- this is actually Dynamo generating, based on a formula. That looping-- because looping is a formula. We are not looping experts, so it took us a day, I think, to understand how a looping actually was designed.

I thought that it was an ellipse, but apparently, it's not. So it's quite difficult to find out. So thanks to Zach, who gave us a very simplistic formula. It's just a sinus. I didn't know that.

But anyway-- so what you see in here at the bottom is, these are all the notes. These are actually those words that are combined together until you got that phrase that makes sense. So it gives you those NURBS curves. I really like that word-- NURBS curve. So it's a very difficult one to pronounce, and I had to practice for that.

And in here, we are going to define our segments, because you're not going to fabricate that full looping as one piece. You need to have several pieces that need to be connected, taking fabrication possibilities in mind in here. So at the inputs, at the front end of the scripts, you could see something like maximum arc length. And that arc length, that maximum arc length, is going to define how this truss needs to be divided, all right?

Also, the number of diagonals that are used in there-- it's also defined by the input parameters. So it gives you such a flexibility that, for instance, if your supplier of elements for this structure says that, for instance, you can only make supplies with an arc length of maximum eight meter, then you just switch it to eight meter, and then that regenerates it-- done. So this is the initialization of the geometry.

If you go to the next slide, the next part of the workflow is actually where we are going to visualize it. This is more optional, because I don't like black lines. I like to see some colors and have some happy feeling about it.

So it's an amusement park, so you need to have color. So under here, you just use solid geometries, and colorize them-- very simple. But this helps, also, to understand how your structure behaves.

So for instance, all these red dots that you can see on there-- these are actually the connection points. These are defining which parts of the trusses needs to be created. So we can think, already, about modular building in here, about prefabrication of this part-- already, in the conceptual phase. So that's cool, right?

Now, we need to evaluate that structure as well, because it's not just as simple as that, and cutting off all those elements, and breaking them into systems. No-- we need to evaluate them. This evaluation could be anything. It could be structure analysis, even, but I didn't involve it in here.

What I did in here to evaluate it is, how many truss segments do we have? What is the weight of this structure? How many different elements do we have? So for instance, if you have a lot of element variations in here and have a lot of trusses, that means you also have a very high fabrication cost and construction cost on sites. So we need to take that into account to find the ideal solution, probably, to have a cost-effective structure.

And the moment you change one of those input parameters, of course, you get immediate feedback on those results. Again, this movie has not been speeded up. That was actually the real speed you have the moment you start dragging those sliders. Actually, and Dynamo can put it at what we call automatic run, which you can see at the bottom right-- the bottom left, for you. And the moment you start sliding, or pulling those sliders, you get an immediate visual effect in your canvas.

So what about Refinery? What is Refinery doing in here? Well, actually, we already had that slide, I thought.

So we are going to explore all the possible options in here. And we are going to sync it back to Dynamo, which means that the moment we will find our optimal solution, I want to see it immediately also in my Dynamo interface. So that's what is going to work in here.

Very important-- within Dynamo, you need to indicate what is your input, and what is your output. Without that, we find we will not recognize it. So that's also very handy, because it can have fixed inputs that can not be driven by an automated generative system. So these inputs are going to be reflected into the second panel, which you will see.

And we are going to optimize. There is also a possibility to do randomization, but that's more like a brute-force optimization technique. We are not going to talk about it today.

And in here, in the outputs, I tell what I want to minimize. I want to minimize the number of elements. I want to minimize the structure weight, but still respect specific requirements for the design of that roller coaster.

And then, let's start running it. So after you created that study, you generate it. And a few minutes later, you get already feedback in those thumbnails with all the possible designs of that structure.

And now, you can also see why this color to this place in Dynamo. Why they are handy? Because the thumbnails give you a better view. You see a lot of blue at the top right, which means that we have a lot of struts in there. So it might be too expensive to create that top one, because there are too many elements.

Now, what we also see is, at the top right, we get that scattered plot diagram. It's like a 4D diagram. You have an x-axis, a y-axis, the size of the dots, and also color of the dots. So these are indicating-- or representing, actually-- all your results and your inputs.

Table-- also, table view, and a parallel coordinate diagram. And most exciting in here is, you select your option, and it drives your Dynamo geometry real time. That's how simple optimization works if you use Dynamo. So make your script, make your evaluation, follow all these steps, run it with Refinery, and select your option. That's actually the full workflow for that.

Now, once we done that part, we need to get it into Inventor. I told you that we are going to use Excel. So Excel is the glue in here between Dynamo and Inventor. So that's a little bit of a work-around, a little bit of a hack we actually done for it.

It could also be done directly by generating notes inside Dynamo. But then you need to be a programmer. You need to know about C#, for instance-- create C, or Touch notes-- and to connect with the Inventor API. And that would work, as well. So if any of you feels like being a [? Chinese ?] volunteer for that, go ahead for that, all right?

OK, so we developed that part in here where the geometry got generated. Now, the geometry to export it to Excel-- it's very easy. You take the points of the lines.

So each line consists of two points. So if you have the coordinates of those two points, you can regenerate the lines inside of Inventor. If you know the arcs, then you also know the points on those arcs, or on those funny NURBS curves we have in there. So that's actually what the model export part will do. It will take all that information, combine it into some nice lists, and then export it to Excel.

So also, you can also read at the same time. That's something you just saw a few seconds ago. It's reading from that Excel file-- what is the actually current version?

And this version is going to be used afterwards to recognize how many times I run that script already-- how many times do you update, for instance. So there you have it-- the spline consists of spline name. We have point names, the coordinates of those points that are placed on those splines, and also the number of points we need to generate those splines.

So probably, you can already predict what we are going to do in Inventor. In Inventor, we are going to use the fit points of each spline to generate them and just two work points to create the struts. This information is stored in here-- stored in Excel. You get the line names to identify them afterwards because, of course, you can create in geometry an import/export.

But what about updates? So you need to recognize what element has been generated by Dynamo, what element has been generated in Inventor. And you need to make sure that you have something to compare them with each other. So make some kind of an element binding-- that's how we call this.

So to synchronize the data between the products, as I told, export it to Excel. And then, in Inventor, we make an iLogic rule and use that iLogic rule to read that Excel file and create all the data. And it also gives names to those sketch lines, so it's using actually attribute sets with a unique name. And that attribute set is then recognized by that iLogic rule, especially in here, when Dynamo is regenerating.

For instance-- yeah, changed to some ridiculously value-- 2.5 on the truss side. So we know that it's not a realistic truss in here. But anyway-- just to show you the principle. And there you go-- the sketch will be updated.

And that takes a little bit of time. So that's speeding up. That takes two, three minutes to generate it. But it's more like-- because iLogic takes a lot of time to read and it opens up, closes, opens up, closes.

So we probably might need to improve that script a little bit to get better programming rules in there. But anyway, that is the principle. That's how you actually can link Dynamo with Inventor.

JONATHAN GEFFEN: All right--

[INTERPOSING VOICES]

DIETER VERMEULEN: Do you go?

JONATHAN GEFFEN: Now, of course, with this amazing workflow-- which, to me, kind of opens up so many possibilities, because Dynamo is such a powerful tool and, in general, computational design is so great-- you can generate geometry that is complex and change it very, very quickly. And that's something that, in geometry like this, can be quite hard to achieve in Inventor. So this is the reason why we chose to combine the two and not do it all in Inventor, for example.

Probably, you could generate that skeleton inside Inventor on its own. But to actually optimize it like that and go through all of those algorithms would be extremely hard to do. And that's something where computational design is just far, far superior. And it just makes sense to combine these two.

And we really hope to get the ball rolling a little bit more into that direction, because-- me, as an industrial designer at least, I would love to see that that connection between Dynamo and Inventor much more seamless. But let's go now to the actual frame generation. And I want to show you how this works, how you start off creating an actual frame inside Frame Generator.

So you start, of course, with your assembly. As I showed you before, you've placed your skeleton part inside of the assembly already. And what we'll do now is, because Dynamo has given us these two different sketches, we can deselect one that we don't want displayed. And this window opens up where we can insert frame members. And you saw we can choose different norms, different industrial standards, and choose from whichever steel tubes we need to use, and the dimensions, as well.

We then define a location and a naming scheme for all of the parts that will be generated. And then, once we hit OK, we will actually generate all of these parts that then make up the loop. So we have our skeleton that now generated all of these different parts.

So let's go through it again, just to get it ingrained. We did the outside pipes, which are a bit wide, of course, because they have to carry more weight. And now, we'll choose the right size again-- the right industrial standard for the pipes that might be used in roller coaster design-- and generate the struts, as well.

And this workflow is a little bit sped up. There's a couple of cuts inside. It's not quite as fast with that many struts, but it is absolutely doable. And then, you save. And you've got, for one, your skeleton part. Then, you've got the assembly, in which this skeleton part is placed. You've got all of the different struts and pipes that are individual files. And they make up the assembly of the actual frame.

And now, this is just the start really, because we want to go and actually create a frame that can be produced and can be put together in a way that makes sense for welding-- for instance, in this way. So for example, one of the tools that we can use is mitering. I'm going to deselect all of the pipes outside, because those are not the ones I want to miter. But I do want to miter all of these struts inside.

You can see that they're coming together, and they're just kind of rough stopping at the end, and just cut off straight. And with a miter tool, you used to be able to only select two different parts. And now, with the 2019.2 update of Inventor, you can actually select multiple frame members, which-- I've seen in forums-- loads of people have asked for.

So you just drag a box around it, and it'll miter all of the frame members automatically for you. I've even added a 5-millimeter welding gap. So all of these struts will have welding gaps inside the miters.

So once this is done, and it's created all of the files-- this is pretty time intensive with so many struts, I can tell you that. So this is also sped up. But if we zoom in to the assembly, you can now see that each of these frame members have been mitered to fit exactly with an exact 5-millimeter gap all around.

So you can then, afterwards, go ahead and create a [? Weldman, ?] for example. And of course, this information also gets passed on into the bill of materials, which is really cool. But mitering is only one part of the operations, because now we still need to add the pipes around the loops.

And for that, we will use a command, which is notching. And that, in essence, is exactly the same workflow. But I'm going to go through with it with you, as well.

So in this case, I'm deselecting, again, the pipes. And we can see, I've actually not used the mitered parts for this example. You have just the rough pipes-- the rough pipe lengths.

You select the notch command. And this notch command-- what it essentially does is it takes one side and uses it as a geometry to cut away in another part. And also, here, just like you saw in the other example, now it's included the multi-select of the notching command. So that's really powerful.

You can multi-select the ones that you want to cut away, and the members that you want to use as a tool to cut these parts away. So you see, it's perfectly notched out this area, too, and fits to the pipes. And in combination, of course, then you can create an assembly, which is essentially mitered and notched, and can then be passed on to fabrication.

But now, what if-- and that's the huge plus, of course, of this workflow that we're suggesting. What if something changes? Let's say you had created this roller coaster skeleton inside Inventor, and something changes. Of course, you can add parameters and drive it with us, but not with the optimization workflows again. So this is what it's all about. It's about utilizing the power of computational design, and not so much replicating this ease of use through complex iLogic rules, and so on.

So let's have a look at what changes now. And the really, really great thing of what we suggest is that this workflow is associative. So whenever we make a change inside the Dynamo script, it will automatically push the new data to the Excel file as a kind of a tool-- an interim holder for the information of all of the points.

And the iLogic script inside Inventor will detect that there's a change, because we have a version number inside of the Excel file. So it will always take the most up-to-date version of the file, automatically, and produce the new skeleton. So it will get rid of the skeleton parts that are not needed anymore and regenerate the ones that are new. And with this, now we have a complete assembly of a complex frame.

And if we want to go ahead and actually produce it, of course, we have to create a bill of materials. And that's easy to do. Whoever knows Inventor knows that the bill of material is automatically generated. So we have all of the frame members inside. It gives us all of the detail, of course, of individual members, and their materials, and so on. But what we are missing from this bill of materials still is what would make it a cut-list.

So in order to make that, we can add more information into how the bill of material is created. And by this, we have to look at a specific member of this frame assembly to see what information is stored in it additionally. So for this we will, for one, add a new column inside the bill of materials, which is the item quantity, because we want to know how many of each frame members are added. I'm going to pull over the length as well, because I want to be able to read from left to right. I need one of this length.

And now, what's still missing is, of course, the detailing. So as I said before, we'll choose one of the frame members and have a look at what additional information is inside. And I can get this from iProperties of the part that is created.

So inside the iProperties dialogue, you can see Custom. There is text added by these defining names-- cut detail one through six. And if I go into the bill of materials again, I can actually add these custom iProperties. And if I define exactly that name that it says in the iProperties, it will automatically add these inside to the bill of materials.

So OK-- I've added all of them. And now, you can see-- here on the right-- the columns have been added. And you can go down and see that each and every part has its own specific cut information that is included. So that's how you can generate even more than just a bill of materials. You actually have a cut-list, which-- for frame members, of course-- makes a lot of sense.

And by this, we've completed the workflow. And as Dieter said before already, we have data sets of this class available in the additional class materials. So you can go ahead and download them there, and check them out yourself, and play around with them.

Again, I want to reiterate that this is a concept. We made it work for this class and this purpose. And we're very excited about this, and excited about the future, and hope that the development will go into that direction, as well.

DIETER VERMEULEN: So if you like the part of computational design and you want to see more about this, then there is also-- well, that was the class I was talking to you about tomorrow morning. It's already full, but I've pasted, at least, a slide in here. So afterwards, you have a reference to it. You can find it out on AU Online and see the recording.

Or you can still try to enter tomorrow morning, because I always allow more people than-- there's space enough. People can sit at the back. So it depends on the lady or the guy that is in front of the door. Yeah, it depends a little bit on their morning sense of humor.

[LAUGHING]

So now, before we let you go in here, and don't turn you up into a skeleton, we would really appreciate if you use the mobile app and give us-- it's only a few questions you get-- only two questions this time, this year? OK, that's perfect. So it would be really great if you all could give us some rating.

So this way, we know if it's interesting to do something similar next year, or even do better. Yeah-- at least that we know what to improve, OK? We also have some time left now.

JONATHAN GEFFEN: Yeah.

DIETER VERMEULEN: So we have some time for Q&A for you guys. So-- shoot.

AUDIENCE: This is the best class I've seen so far.

JONATHAN GEFFEN: Very good, thank you.

DIETER VERMEULEN: Thanks.

JONATHAN GEFFEN: Yeah, [CHUCKLES] yeah.

AUDIENCE: For the cut-list, is there a way to kind of show that there is multiple of the same member?

JONATHAN GEFFEN: Yeah, absolutely. So in this specific case, we haven't optimized it all the way through to the way that each line is exactly the same length inside the Dynamo script. This is something that can easily be done, still, in another optimization algorithm.

So you would have all of the same members that are the same length. And you would actually use Frame Generator to then, say, reuse one part as another part. And then, you basically specify that you have different instances of the same part. And that would then be reflected in the cut-list to say, I have four of length 1 and 1/2 meters with this detailing.

You can then even select instances and specify that you have two, or three, or multiple different instances of one part, but each one has different detailing. So you might want to cut the same length of tube, but then each one has different detailing. Yeah.

AUDIENCE: I've never used Dynamo. How much work and effort goes in there, setting up a Dynamo structure. I guess, were there any problems? How long does it take to configure that geometry?

JONATHAN GEFFEN: So wait, before you answer-- sorry. Because I know that you're an expert on Dynamo, but I am not. And I actually-- I used to play around with Grasshopper, which is a similar tool, as well. But I did that in my studies. And I got to know that to learn this is really just learning how to think about the process of designing something.

So you start with very, very easy tutorials. So let's say you create a point, and you want to create a line, though, that has a specific length. So you would, say, create one point here and then create another point at the coordinate of 0, 0, 50, or something.

And then you'd say, OK, and now create a line that goes between those two points. So you would have two points-- 0 and point 50-- and connect these two to a note that says, create a line between one point and another point. And that's already the start of a computational design workflow. And all of the rest is just more complexity, but the means of thinking about it is really the same.

It's really just breaking down the workflow into specified steps. And so I would say, if you have the capability to think about your design workflow and those steps-- which each of us has, because we're using design tools like this-- then it's super easy to use. Yeah, and I don't know if you want to--

DIETER VERMEULEN: Yes, I totally agree with what you're saying. So that's also how I learned it, more than four years ago. So you need to rethink about how you create geometries. And you really need to go back to the basics of this. So like you said-- points, lines.

But the three lines already create a surface. And the surfaces-- if you combine a number of surfaces, you get the volume. You get a solid. Solids can then be broken down again to other surfaces, and back to other lines. These lines can be used to create new points, and those new points can be used to create new lines again. So you get like a real-- yeah, it can be really complex.