Dynamo from BIM Automation to Generative Design - Part 3 of 4

PRESENTER: OK. So I'm glad you're all back from lunch. And I hope you had a good lunch. Actually-- so when we started the rung with the 100-sized population, it actually-- one guy managed to have it finished during lunch. And this is the results that it came out with. I just quickly wanted to show you, because I thought they were quite interesting.

So you see this nice curve along the parietal front. But because we have three goals that we want to optimize for. It's not just one line, but it's actually like, you see a bit of, like, a field behind that. And that is the solutions that score better in the third category, that we cannot sort by, and if we have, like, this two-dimensional graph. But when we act activate the size and put that to the third goal, we see that the ones that are in the back are bigger in the size, so they are the ones that score better in the third category. So I thought that was just very nice to show that to you, how the results turned out. OK.

But now let's look into the third part of our course. And what we want to do now is to look at an Open Office situation. So we have this room, in which we want to locate desks. And the goal would be to have as many desks as possible, while still being able to work comfortably for everybody.

So we need to figure out how and where to put the desks, like, how to orient them, and, like, how close to pack them. And also with the desk clearance would be like, how much space you can have behind you so that we can still fit as many desks as possible and have as much space as possible for every person, yeah, but also not wasting space. So that would be the space utilization. So have all of this space used for the actual desks and for the work space.

OK. So if you open up Revit again. And now open in the third folder, the [INAUDIBLE] one, the Revit file, Open Office layout. You see that here is the room that we're looking at. And then we can open up Dynamo. Oops. And open the [INAUDIBLE]. So here we go into the Dynamo files folder and then to Challenges. And the Number One Metrics we're going to do.

And as you can see, this is now a bit of a bigger graph than what we were dealing with before. But it follows the same pattern. So we have, here in the beginning, the inputs. And we import some geometry from Revit. And then we have all our operations. And in the end we have the outputs. And we're going to create them together.

And so how this works is-- so first we're going to import the room from Revit, and then turn that into a solid. And here, basically, where we just want you to display the geometry, so we divide the room geometry that we have into the phases. And what we are most interested in, of course, is the bottom phase, and the outline, so the parameter curve of that. And then we color one in the pink and the room itself in this light gray transparent.

And then this step is a bit complicated. But essentially-- so we have our inputs here. Maybe let's talk about them first. So as I said, we can put the desks in different orientations. So you can see here, this is the rotation parameter. So when you change that, you will see that it changes the orientation of those desks. It manages all the time to fit them in perfectly. And we're going to see later how it does that.

But then this is one thing. And then the other thing is the position, so basically where it starts to position the desks. So that is one in the U-direction and one in the V-direction. So if we change that, we can see that they will move to the bottom or to the top or to the left and the right.

And then the user clearance width is how much space you have behind your desk. So if we turn that up, you see that it's only able to fit a lot less desks than before. Or if you have low user clearance, it's able to fit more, but you will have less space per person. And then the end offset is how much space you need at the end of every row.

And then you have some fixed inputs that are not touched by Refinery, that is the desk width, the desk length, how much user clearance lanes you have. So that would be the space in between desks. So it's at zero now, but we can turn that up as well. And you can see that the desks move apart. But we don't need to worry much about those right now.

So according now to the start point and the rotation, it will start to create, just a bunch of planes that are later turned into the desks. But if we enable the view for the last note here, if we enable the preview, we can see that in the orientation and at the start point that we've selected, it will just create this row of planes that are then later rearranged into the planes where the desks are positioned. OK.

But let's turn the preview off again for that. And now it will divide those planes that it had created in one row into the different rows, according to how much user clearance we have, and according to the desk length and all that. And then on the rows that are generated from that, it can start and place the actual desks.

Because, of course, Refinery, like Dynamo, doesn't know where to, like, stop putting the desk, because it doesn't know about the room that it is in yet. We have now to delete all of those conflicting desks that are outside of the room or that are touching, like, the wall of the room. And so that is what happens here. And that's then how we end up with the number of desk that we get. So it basically checks all the desks that are intersecting with the outline and deletes all of them.

And now we want to create the outputs that I've described before. So these are like the number of desks, then that desk area per person, the space utilization-- so how much total space you have per person. And then later on we're going to look at the private desk, cause that's something else.

But let's first maybe-- so because I have all the notes prepared that you are going to need to create those things. Maybe if you want to take, like, two or three minutes to come up with them, with the rearranging and the connection of that yourself. So as a tip, like, those code blocks are just to get the data from somewhere else.

So, for example, because the graph is so big you sometimes needs data that is, like, somewhere on the left side of the graph. So I created these, like, highways. So you can just take it from here. And it's really easy if you check that the name is matching. So desk length connects with here. And then that will make it easier, so you don't have to go back and forth the whole time.

And then of course the watch nodes are where you want to end up. They are the goals that we, in the end, want to have. Maybe also as an explanation-- so can everybody see the thing here/ so if this is one desk and this is the next one, then-- whoops-- then this is the desk length and this is the desk width.

And then you have here there's the clearance space. And that's where it gets a bit confusing. This is the, again, the clearance width. And this here is the clearance length, so the space between two desks. But we set it to zero, but still you need to transfer that. Does everybody see that?

[LAUGHING]

Is that maybe a bit small? OK.

AUDIENCE: [INAUDIBLE]

PRESENTER: Oh. Do you want me to come or do you--

AUDIENCE: No, I guess-- how did you get the original geometry? Was it from a room? The original geometry of the--

PRESENTER: Yeah.

AUDIENCE: You got it from a--

PRESENTER: Yeah. I think so. Yeah. No. Yeah, yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: Do you mean from the Revit?

AUDIENCE: Yeah.

PRESENTER: Yeah. That's a room.

AUDIENCE: [INAUDIBLE]

AUDIENCE: I think it might be extruding the rim factory in Dynamo.

PRESENTER: No. It's-- like, it turns the room straight into a solid.

AUDIENCE: Can you check the use of clearance lengths [INAUDIBLE]?

PRESENTER: How do you want me to check it?

AUDIENCE: If you go back and see what that's--

PRESENTER: The length? Ah, that's at zero.

AUDIENCE: It is supposed to be zero?

PRESENTER: Yeah.

AUDIENCE: OK.

PRESENTER: Yeah.

AUDIENCE: So when you're calculating the metric, try going over that desk layout metrics.

PRESENTER: Yeah.

AUDIENCE: OK.

PRESENTER: Whoops.

AUDIENCE: Layout metric.

PRESENTER: Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: No. Do you want to-- You have to add them, like this plus this.

AUDIENCE: And this is zero, right, because the length is zero?

PRESENTER: No, but you have-- no, it's not multiplying. This is adding. So it's the length plus the user clearance length, and then the width of the desk plus they user clearance width. And then those get multiplied.

AUDIENCE: It's the same question, right?

PRESENTER: Why the length is zero?

AUDIENCE: Yeah. So am I supposed to-- like to get the area per person, I'm just supposed to multiply the width and the length, no?

PRESENTER: No. You have to add to the desk lengths to the user clearance length and then the desk width to the user clearance width, so you get the entire--

AUDIENCE: Oh, OK. [INAUDIBLE]

PRESENTER: Yeah.

Let me give you, maybe, a tip for it, because there were some questions. So the area that you have for, like, one person is this entire area. So you don't need to multiply by their--

AUDIENCE: [INAUDIBLE]

PRESENTER: OK. So do you think I should continue?

AUDIENCE: How many do you have to go through?

PRESENTER: I just have to expand the private desk thing afterwards.

AUDIENCE: OK. Maybe get done, like, three more minutes and then just step through it.

PRESENTER: Yeah. Yeah. But have you ever told the people that, like--

AUDIENCE: Yes. [INAUDIBLE]

PRESENTER: If you're not sure what to do, you can always ask. These nice gentlemen are happy to help you.

[LAUGHING]

Like, they're still--

AUDIENCE: Some of them are still trying to--

PRESENTER: Yeah, I know. A lot of them are trying. I think we should give them a couple of more minutes.

AUDIENCE: When did you start [INAUDIBLE]?

PRESENTER: Do you want me not to do the [INAUDIBLE] thing? I'll just quickly-- I'll explain that-- their private desk thing is [INAUDIBLE].

AUDIENCE: Do I have the stuff that-- for you we have to start this [INAUDIBLE].

PRESENTER: OK.

AUDIENCE: Right?

PRESENTER: Yeah. Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: OK.

AUDIENCE: Maybe talk to them about--

PRESENTER: Yeah.

AUDIENCE: --detail and then give 'em [INAUDIBLE].

PRESENTER: Yeah.

OK. So maybe let's take a look at it together? So one thing we want to have is the number of desks. So-- one second. Let's-- I didn't connect that one. Oops. Yeah. So here we have our list of desks. So we can just go and count them. And that way we'll end up with the number of desks.

Oh. Did I connect it to the wrong thing? Oh yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: Ah. Here. Yeah. So that should be right.

And then if we want to know the total area per person, we can just take the surface area of the entire floor and divide it by the number of people, so the number of desks. So we can get the surface area from here, the face off the floor. Oops. And then divide that by the number of desks. And that way we'll end up with the total area per person.

Now if we want the workspace area per person, that is where we get into this drawing thing. So as I said, we want to have this entire space. So that would be the desk length plus the desk clearance length, multiplied with the desks width plus the clearance width. So--

Ah. Does it not have a node for the desk width?

AUDIENCE: [INAUDIBLE]

PRESENTER: So, then let's go back to the parameters and find the desk width. Yeah. Here it is. I hope this didn't cause too much confusion. I actually just saw that there is a fault in the script. They used the desk lengths twice, instead of the desk width. So I'll need to change that. OK.

And then we can multiply those and we'll get the workspace area per person. And now, if we want to know the ratio of the total area compared to the desk area, we can just divide the total area per person-- yeah, by the workspace area per person by the total area per person, and then we'll end up with the area utilization. So everything else is like, not used up by this.

Who got it like this? Very well. And [INAUDIBLE] actually they're prices. So you got this-- whoops-- this cool Dynamo bag. Oops. Well done.

AUDIENCE: Good job.

PRESENTER: There was somebody else. Yes. Here you go. Did I miss somebody? OK. Here you go. Congratulations.

[LAUGHS]

AUDIENCE: [INAUDIBLE]

PRESENTER: If you're saying you're only counting the parts right to every desk. Yeah. I mean, you could have it more detailed because now, it doesn't account for the last desk in the row. But, I mean--

OK. And now, we're going to add another metric that is-- we want to measure how much privacy you have. And of course, that is difficult to measure. So the way we decided to do it is we going to measure the distance from one desk to all the surrounding desks, and then count how many desks are less than 12 feet away from each other.

And then, when we have that for every desk, we can count how many desks have less than three desks within 12 feet. How you define that is, of course, subjective. Somebody might feel like 12 feet is too much or not enough. So but for now, that would be one way to measure it.

And so, we can just take-- going to use the desks again. So connect that from here to here. OK. And we want to get the curve of each desk. And then, we're going to go to calculate the distance from every desk to every other desk.

So they are going to be-- this is going to be the input for both of those.

AUDIENCE: How do you set that so that it measures every desk to every other desk?

PRESENTER: Just connect it to both input. And the lacing is set to cross product. Because otherwise, it would go through both lists. But if you have the cross product, it goes every item-- it goes-- all of them are connected with each other.

Every desk is connected to every other desk. And then, we want to have all of-- we want to count how many desks are less than 12 feet apart. And then, count all the desks that have less than three desks within that distance.

AUDIENCE: There was a question about [INAUDIBLE]

PRESENTER: It means--

AUDIENCE: Is it greater than?

PRESENTER: It means not, right?

AUDIENCE: So that pretty much means-- [INAUDIBLE] The first part before the first part is the [INAUDIBLE]

PRESENTER: It's basically an if statement, right? OK. So that is the condition of the if statement, like a must be smaller than 12. And if that condition is true, then it return one. And if not, it will return zero. So that's like-- that is like else if an else.

So it should have all our outputs set as outputs already, but let's just check. So we want the private test. We want the area visualization. And then the total area as the output. The workspace area, that one is an output too. And the number of desks, of course.

OK. So is everybody ready to go? So let's save as. And then, export for refinery again. And launch refinery.

And so, in our new study, we now want to maximize the number of desks, maximize the workspace area per person, maximize the total area per person, and maximize area visualization. And of course, and also maximize the amount of private desks.

And now, let's just run it quick. Run off 10 generations. Any questions while we wait for the results? Yeah.

AUDIENCE: Where's the surface area coming from?

PRESENTER: You mean in the connector?

AUDIENCE: Yes.

PRESENTER: Yeah, sure.

AUDIENCE: [INAUDIBLE]

PRESENTER: Yeah, don't worry. So the surface area, it comes from the top here actually. The face of the floor. Yeah. Yeah.

OK. Now, I sorted by number of desks and workspace per person. Where would the utopia point be in this case? Yes. Yes. Top right, because we want to maximize the number of desks. And we want to maximize the area per person.

What we can see here now is, because we're dealing now, we have five, I think. Five goals. And now, with this tiny amount of just a population size of 20 and over 10 generations, we can see that when we're dealing with such a multidimensional solution space that we need more larger populations and more generations to get to a Pareto front.

But I think-- Yeah. What was the question? Yeah.

AUDIENCE: On some other thing, we've seen where you have a star graph.

PRESENTER: Yeah.

AUDIENCE: How do we create those?

PRESENTER: It's not in the refinery UI so far. So whenever-- so for example, I wanted to have that for my master's thesis, as well. So I just created it myself in Dynamo and had that next to the spot. I think they call spider web graphic. I made a polygon and then, yeah.

AUDIENCE: We can talk about radar transport.

PRESENTER: Radar--

AUDIENCE: We were talking about whether they're a good idea or not.

PRESENTER: Yes.

AUDIENCE: I have a question. Could you safely export [INAUDIBLE] you get on this chart and use it as a determiner for a piece of equipment? So based on [INAUDIBLE] Could you, say, based on [INAUDIBLE] location dictates how the pieces are [INAUDIBLE]

PRESENTER: I'm not sure I understand the question.

AUDIENCE: Can you run [INAUDIBLE]

PRESENTER: Oh. Well, that would be-- I think it's called meta optimization. And I don't think that is possible with Refinery.

AUDIENCE: [INAUDIBLE]

PRESENTER: Not in one process, no. So you would mean find the perfect location. And then within that location, find the optimal, right? But both at the same time. So you don't have to decide.

PRESENTER: You could set an optimization routine inside the desks that would optimize the layout of the equipment on the desks. And then, lay out the desks on the space. As long as the desks are a consistent value, I don't see why it wouldn't work. I haven't tried it with anything of significance.

PRESENTER: But I think what you mean is that both are depending on each other. You can't run them apart or after each other. But depending on the position of the first, the optimal position of the second varies, right? Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: Oh, yeah. That would be possible to run it one after the other. That's of course possible. Yeah. OK. I think that if there are no more questions to this example, we're going to continue with [INAUDIBLE]

PRESENTER: OK cool. You can hear me OK, right? Yep. Good. And so, we're going to continue a bit in the metrics area and we're going to talk a little bit about what metrics are again. We already covered it a bit. Metrics are basically the things that we measure, like what we've been doing in these few examples.

We also call them objective. And we create objective functions to measure something. So this is a quote from the Refinery primer. Is anyone familiar with the Refinery Primer? All the Autodesk people are. Great. Refineryprimer.org, I think so. Something like that.

AUDIENCE: Dynamo Refinery Primer.

PRESENTER: It will show up. And it's this really awesome cool e-book where you can read all about generative design and Refinery and how to do all of these things. But what it says is that if we add more metrics, obviously it becomes way more complex problem then we have to take more things into account.

But it also makes our optimization more realistic. So we need to find some kind of balance on adding enough metrics, but not adding so many that the problem just becomes so complex that we can't even compute it. And so, what we want to do now is we want to look at how can we add some more.

We already have a lot of metrics in this one, so maybe we shouldn't add more. We're going to do it either way. So you guys think of anything that could be interesting to look at in a office layout again.

AUDIENCE: Light.

PRESENTER: Light. Yeah, maybe. We're going to do that in the next thing. Some thought that's the one I was thinking about. We're going to see light as well today. Anything else?

AUDIENCE: [INAUDIBLE] for a specific piece of equipment [INAUDIBLE].

PRESENTER: So like minimizing?

AUDIENCE: [INAUDIBLE] on big giant [INAUDIBLE]

PRESENTER: So you want to minimize the distance to the plotter from each desk or to the coffee machine or something like that, right? Yeah. That'll be awesome.

Cool. Yeah. Good examples. So another thing that we could look at is something like measuring views to outside, which is what I'm trying to show over there with this cool little note. But anyways, let's go forward.

So I think some of you guys already noticed the Refinery Toolkits. And some of you asked where it is and how to get it. But for those of you that don't know, the Refinery Toolkits is a package that you can download for Dynamo. It's not on the package manager yet, but it is ready to get on the package manager.

And so right now you can get it on GitHub. Under Dynamo Repo, there is a Refinery Toolkits where you can go and get it. It should be on the package manager soon, so maybe just wait till it's there.

But what the Refinery Toolkit is is right now it's two packages. So right now, there's a space planning toolkit and then there's a massing toolkit. And the Space Planning toolkit is all of these things here. I couldn't fit any more weird gifs in it.

But it does a lot of things that helps you create metrics. So it's not creating your entire workflow. But it is helping you analyze specific things. So there is something like measuring how much you can see of an area, for example.

Like this guy down here in the corner, you can see it shows how many of these points can you see. So you can use that as a metric if you want to make sure that you can see a lot of this area, for example. There is a shortest path node, a [INAUDIBLE] node.

You can do BIM packing and, like, packing rectangles inside of a bigger rectangle. You can pack cubes inside of a bigger cubes. So we'll optimize these things. So you can use these things in your generative workflows.

So go check that out if you are doing these things. There's a lot of cool notes in these packages. We're going to use one of them now. So we're going to have you guys work.

And I'm going to shut up. Otherwise, you're going to fall asleep. But the next met the next challenge is creating a new metric. So what we want to do is we want to calculate how much of a desk view, of a 360 degree view, is 2D outside.

So in the same Revit file that you've all been in, we're going to continue in that. We're going to continue in the same script that we have. And I'm going to come back to that and show you which one you should use. But what we want to do is we want to calculate the views to outside from each desk. And we want to make that into a metric that we can use in Refinery.

And there is a few helpers here. Because this is kind of a complex one, but I packaged it down a bit. So again, as we talked about in the Dynamo kickstart, I'd, like, try to start from the end. So what is it that we want to do-- which is measure the views to outside.

So figure out how to do that. The Refinery Toolkits has a node called disability of line from origin. And we need to figure out which inputs that node needs, right?

And you can see it's going to need some lines and some obstacles and a boundary and stuff like that. I'm going to show it to you in just a minute. And then, work backwards from there. See how can we get all the things that we need.

Let me show you. If you go to the folder, the 03, nope-- that's not it-- there. So if you go to the 03 Dynamo Refinery Revit, and you go to-- then files, challenges, new metric, views to outside, there is a script called views to outside metric.

So open it from there. Because there is custom node in here that you need. And you'll only see that if you actually open it from there.

So let's open it up here. Again, BIM files, challenges, new metric, views to outside. And then it's the open office layout, AU 2019 views to outside challenge.

Probably the graph was in automatic mode when we opened it, which is why this is taking-- or maybe not. No? Cool.

So anyone having trouble finding it?

AUDIENCE: What's the name of the file, again?

PRESENTER: Open Office Layout 2019, Views to Outside Challenge. Couldn't think of a longer name. OK. Cool.

So you'll see here we have all of the nodes. And I tried to make it-- because this is not something that you just jump on and it's super easy. But this guy here is actually-- we need to plug in the results of our views to outside calculation to this. Because this is, like, converting into a number that we can actually use inside of Refinery. So keep that in mind when you get a bit further.

And this guy here is the one that you want to use to calculate the views to outside. And it takes in an origin, which is, obviously, the point of the desk. This is where we want to measure the views to outside from.

It has some target lines. And target lines is just-- because we've tried to make these nodes generic, right? So [INAUDIBLE] don't have to be windows, something like that. And in this case, this would be the windows.

The boundary would be the boundary of the floor plan. The obstruction is all of the internal obstruction that might block the view to outside. So in this case, in this layout, we only have this room or whatever this is that can actually obstruct anything.

We could maybe say that another desk was an obstruction, as well. But we're not going to do this here. We're only going to take this one in as an obstruction.

So in order to do that, you have this little view segments by location point. So you can use that to create the view segments, the target lines. So this is actually just taking the windows from Revit and making them into something that we can use inside of Dynamo.

And there's a few things about the data.remember nodes. And it's already been explained a bit. And it is kind of, like, this annoying little thing, which is pretty cool still, but mostly is just annoying.

When we need to use this is when we have some Revit operations, right? How many of you have used Sandbox before? All of the Autodesk people, great.

AUDIENCE: [INAUDIBLE]

PRESENTER: Sandbox is a standalone version of Dynamo. Right? So you can use Revit nodes inside of Sandbox. You can use any nodes that are specific to some kind of platform like Revit or Civil 3D or whatever.

So that means that we can't use any Revit-related nodes without the data.remember node. And it's not only like Revit-specific nodes. If a node is from a package like this [INAUDIBLE] node here, that's from a package. And that package has Revit nodes in it, meaning you can't open it in Sandbox, meaning we need a data.remember node after it.

Yes, a little bit complicated. So I already hooked those up and I'm trying to see if you can figure out why these data.remember nodes are in there. This is a custom node. So if you double click it, you'll see everything that's going on inside of it.

See, this is just a very complicated thing, just to translate some window points, if you want to have a look at it. If you don't want to, you don't need to. And so that was a lot of talking. Get back to this one.

So you see, I kind of highlighted these things here of what we want as the boundary and what is the obstruction for a node. So try and see if we can figure that out or do we need to do this together? Well, tired, thinking about beers.

[INTERPOSING VOICES]

PRESENTER: Let's do it together.

[LAUGHTER]

OK.

[INTERPOSING VOICES]

PRESENTER: Nope. Ah. OK. That's cool. So again, as I said before, let's try and start from the end, right?

So this guy here is basically what we want to do. We want to calculate all of these and the views to outside from this node. And the way we want to do that is we need, as I said before, this is just because we know it, we need this guy to actually create our target lines. And this guy takes in floor plan curves.

And I made it so that we already have these floor plan curves, which is just the curves coming from the room that Jacqueline also showed before. These are just the same curves. Let me try and run this, actually, so we can see the outputs.

So you can see these are all of the curves. So these are the boundary curves. And also, it has the obstruction curves, or the internal obstruction.

So we need to somehow figure out how to split these two up. Because we need, when we look at this node here, we need the boundary and we need the obstructions. Right now, we just have a list of everything. But we need to split that off some way.

And this is what's really cool about Dynamo was all of the packages that people create. The node here is from a custom package called Archi-lab. If you've been working with Dynamo, you'd probably know it.

And this node basically just group curves. So it figures out which curves are-- what's called connected, right? And then it'll split it up.

So if we connect this to here and run this and look at the output here, you'll see we now have these curves grouped as we want them. Now this is where we have to have that data.remember node. Because Archi-lab package has Revit nodes. So it has nodes related to Revit.

Meaning that when Refinery spins up all of its other Dynamo [INAUDIBLE], it won't be able to import that package and won't be able to use them. So we need to remember the output of this. Because this output won't change, because we're not changing anything with the boundary lines or anything like that. So we have the data.remember nodes so Refinery knows what this is actually going to be.

And just to split these things up-- or actually, if we look at this node, if you hover over it, you'll see what kind of data type the node needs. So the boundary has to be a list of polygons. Right? And the obstruction has to be a list of polygons, as well.

So we can't just put in a list of curves. Then the node will tell us that we're doing something wrong. So we need to change these and make them into a polygon. And this is just done in DesignScript here. If someone who's familiar with DesignScript-- AutoDesk people-- yes!

Some other [INAUDIBLE] great. Basically, we can use all of the same things in DesignScript. That's the nodes, right? So this one I'm calling a method called polygon.ipoint. This has a node, as well.

So we could just do like this, [INAUDIBLE] points. So this guy is exactly the same as this guy. The cool thing about doing these in [INAUDIBLE] that we can make it a bit more compact. And we can do more things inside of the same line.

So here, because we're creating a polygon by points, we need to take the start point of each of these curves. Right? And when we have to start point of each of these curves, we can make a polygon out of these points. So instead of having to do this in more nodes, we can just do it like this and split it up.

So I can put in these curves to this one. And you'll see we now have-- if we put a watch-- we'll put a watch node here. We'll have one polygon there and another polygon there. And this is just the boundary this one here, which is this outline of the room and the internal, like, the internal obstruction, which is what we need to calculate these.

So now we have the two last of the inputs. So let's just try and connect them, the boundary and the obstructions. Cool.

So next thing, let's try and-- yep. Sorry?

AUDIENCE: [INAUDIBLE] polygon versus [INAUDIBLE].

PRESENTER: Sorry. Could you say that again?

AUDIENCE: How does the code [INAUDIBLE] determine whether it's an internal versus external polygon?

PRESENTER: It doesn't. I do. I know that the internals are at location 1. You could set up a-- like, measure the distance. Because the polygon of the boundary would typically be longer, right? So you could do some kind of logic there.

In this case, this is very simple. There's only two. So I just said, this one is the internal and this one is the boundary. Yeah.

AUDIENCE: [INAUDIBLE]

PRESENTER: Yes. Yes. Yeah. So it takes in a list of polygons. So you just need to figure out how to turn your obstructions into polygons. And then you can put in as many as you want. Yeah.

Cool. So next thing, origin-- the origin is a list. It's a point. So it actually only takes in a point. But we want to calculate this on a bunch of points. So we need to find all of our desks.

And we should have a node somewhere. Do we not? Desk polygons, right? So this one is just connected to the desk rectangles, which is-- a rectangle is also a polygon. So we can use that as the input.

So let's take this one down here. And this is the first step. We have a rectangle now.

And this is our desk. We now want to find the center of that desk. Because that's the point we want to measure the views to outside. So we can do this. So if you connect the desk polygons to the polygon [INAUDIBLE] center, you'll see we get a center point of all of these desks, right?

So these are our origin points. So let's put this in here. And the last part we want is the target lines. And the target lines, in this case, are the windows here. Because that's our views to outside.

So the thing about this node right now is that it only works in 2D. So it doesn't take into account if the window's, like, tall, or anything. It only takes the width of the window. So that's what it's measuring right now.

And so what we need to do for this right now is we need to feed in some windows. And we'll get them like we've done a lot today, categories, all elements of categories. Let's just connect these two guys.

You see we get seven windows. And we'll put them into Windows.

And the last input this needs is just a list of curves, right? We can see this here, which is the floor plan curves. And we're lucky enough to have a node here that says floor plan curves. So let's try to see if that works.

And let's run that. And nope-- if you can see, this node just visualized the windows, as well. So you can see these blue things here. This is just showing the windows.

So we now have all of the windows that we need. And again, we need the data.remember node because we have Revit things going on inside of this node. So we need to remember today the output of this node. So again, just remember, you need the data.remember node whenever you have a Revit operation.

And let's try and plug this into our target lines. Yeah. And let's run it, see what happens.

So what you'll see is that we have a bunch of different outputs from this node that you can use to different things. So we have a percentage visible, which is just saying out of a 360 degree view, how much of that view is to the outside. So this one has 16% of the view where it's, like, to an outside view. Does that makes sense? Yeah?

And we can then see how much of each of the different target lines is visible. And we get the actual visible line. So for example, some of the line, some of the views might not see all of the window. Right?

So the target, the line we'd get out here is actually just that part of the line that is actually visible. So if you have a window that's this big, we might just get the target like this, the visible items like this. So it would give you the actual, visible thing.

But for what we want now, we only want to deal with the percentage visible. And in order to use this a bit easier inside of Refinery, [INAUDIBLE] is not working.

There we go. So first thing we want to do is we want to normalize these percentage numbers, just because we don't want to see 16. We just want to have a number between 0 and 1. That's easier to work with.

And so we do that just by dividing it by 100. And we get the number between 0 and 1, right? So 16% becomes 0.16, pretty simple. And then, in order to combine all of these numbers and get, again, a value from between 0 and 1 we can use, and we want to get kind of, like, the combined score of this, so we take the maximum result that we can get, which is just the count of value.

So the maximum result that we will be able to get is that every single point has one, right? Because that would mean 100% of the views to the outside, which would mean we were in a glass box. Right? So that would be the maximum result that we can get.

We then calculate the actual sum that we have, which is in this case 3.7. And we'll then do a calculation and see how much is the actual result in percentage of the maximum result. And that is going to be our output that we're going to use in Refinery. So this is the score that we want to optimize inside of Refinery for the views to outside.

So let's just put this into our group. And let's get rid of these. We don't want these. We already have them there. Cool. So in order to use this in Refinery, what do we need to do?

AUDIENCE: [INAUDIBLE]

PRESENTER: Nope. So in order to see this in Refinery, what do we have to do about it?

AUDIENCE: [INAUDIBLE]

PRESENTER: [INAUDIBLE] output, yes. So let's check and right click it. OK. It's already as output. Cool.

So just remember that we need to do this every time that we want to work with some outputs in Refinery. And cool. So what we can do now is we can export this graph, just like we've done before. Burn it. Export it.

AUDIENCE: [INAUDIBLE]

PRESENTER: Oh, yeah. So yeah, we can actually delete these guys. There were just to show. So let's just get rid of those. We don't need them. That was what you meant, right?

AUDIENCE: Yes.

PRESENTER: Yes. Cool. And so as you export it, launch Refinery again.

AUDIENCE: [INAUDIBLE]

PRESENTER: Sorry?

AUDIENCE: You might want to Save As.

PRESENTER: Might want to Save As? Yes.

AUDIENCE: [INAUDIBLE]

PRESENTER: Yes. But let's do a Save As and see if we can add more characters to this.

[LAUGHTER]

Views-- it's a good name. Nope. OK. And let's export it again. And just one thing to note, again, is that every time you do a change, if you have exported your graphic to do a change, export it again before running it in Refinery again.

Don't export. Right? Let's fire up Refinery.

Oh, it's already there. And if we now do a new study and find Views, we'll see we have the new metric, right? Views to outside score-- and we want to maximize this, as well as all of the other ones.

And let's just leave the population and generation to 20 and 10. And let's try and generate this. Any questions about this while it's running? No?

Looks like my Refinery is getting a bit tired here. Oh, waking up.

[INTERPOSING VOICES]

PRESENTER: Because we, again, now have so many metrics, it's very hard to display a minute in a good way. These scatterplots are mostly great when you have two objectives that you want to compare to each other. You can still do it like this and you can have, maybe, you can visualize up to, like, three in a good way. Right?

So now we just have the number of desks on the y-axis. And we have the area utilization on the x-axis. And then we're setting the size with the views to outside score. So we can see that this guy up here has a better views to outside score than this guy, for example, based on the size.

But normally, I would prefer looking at this one when you're dealing with so many different objectives. Because it's just easier to have everything on the same view. And you can filter it based on that.