Transcripts
1. Intro: Hello there. This is
Josan Afsha architect. In this course, we are going to learn about modeling a
parametric wall in Reno and also we're
going to learn how to prepare construction
documents from the model. So here's the challenge. From a modeling
perspective alone, after you learn the
commands making a wallet, this is not that challenging. The real challenge is in
producing the TD documents. The actual Treaty
model itself cannot directly be used for
construction, and therefore, we need a two D file containing all the sections which
can be well over 100 and we have to use
that file with a CNC or laser cutting
machine to cut the pieces. And doing this manually is
extremely time consuming. Of course, an alternative is to use tools like grasshopper, but that requires
additional skills, and some architects and designers don't
have those skills. So to solve this challenge, we are going to work
with Reno's own tools, and I'm going to introduce
some commands and combinations of commands to automate this
process as much as possible. So this is the main
takeaway of the course. Automation without using tools like grasshopper,
and in doing so, we are going to learn
alternative ways to model the actual wall in three D space and
also alternative ways to automate the process of
making the two D documents. And all of this is done in a
totally practical context. So actually, you can use the
end result of the course in a CNC machine to cut the pieces and actually
construct the wall yourself. So this is basically what
we do in this course. So I invite you to join me
in this practical project.
2. the modeling process: In this video,
we're going to take a look at the general process that will follow to model the parametric wall
inside of Rhino. If you look up parametric
interior wall, you're going to see a lot
of results like this. And these are quite common when it comes to
parametric modeling, where you have an object that is cut using
straight sections, and these sections are usually vertical, but not necessarily. And we're going
to see how we can model one of these
inside of Rhino. Before we start, let's take a look at the general steps
that we are going to take. So we're going to start
with a base model, and this is basically
the organic model that we are going to use to cut
away two D profiles from. After we get those
two D profiles, they exist in three D space. We need to transfer them to the two D space or
in simple terms, we need to lay them out
on the ground plane because that is required by the CNC machine or laser
cutting machine to be cut. And after that, we have to add some numbers to the
profiles because that will assist the people who are
in charge of assembling the pieces to assemble
them in the correct order. And finally, I'm going
to mention some tips for exporting that can help to enhance the quality
of the final result. In the yellow boxes down here, you can see the names of some Rhino commands that we are going to use
in our process, and you're going to learn
them in a practical way. I also use other
simpler commands, but I'm not going to
explain them very much because I'm assuming that you already know the
basics of Rhino and, for example, know how
to draw a line or a curve or how to move
objects in Rhino. Um, when I designed
this process, my emphasis was on
increasing our speed and also avoiding repetitive
tasks as much as possible. For example, when we are arranging these profiles
on the ground plane, we are not going to
move and rotate them individually and put them into position. That would
take a lot of time. Instead, we are going to use a combination
of these commands to automatically perform all of these operations on all
of the objects at once. Lastly, I have to mention that the best tool to use in this scenario would
be grasshopper, the algorithmic environment
instead of Rhino. However, we are not
going to use it in this course because it requires
its own set of skills, which I'll cover
in another course. For now, we are going to
focus on simplicity and doing everything using
native Rhino commands. Now we know what we want
to do, so let's begin.
3. the base model: In this video, we are going
to create the base surface, which is an organic shape
with a wavy pattern. So the first method
involves using a plane and directly manipulating
the control points on that plane to
get our pattern. So let's see how it's done. So let's maximize the viewport
here and draw a plane. I know that the
wall is vertical, but for the sake of simplicity, let's draw this on
the ground for now and we can rotate it later. And for the measurements, I'm going to give it a length of six and a height of three, a standard size when you want to design this
for interior wall. So I'm going to place it here and hit F ten to check
out the control points. Now, we need more control
points to be able to precisely modify the
shape of this surface. So I'm going to select it, and from the surface tools menu, I'm going to click
on Rebuild surface. Now here we have the
option to change the number of control
points for the surface. And I'm going to go with, for example, five
in each direction. Now, let's hit F ten and manipulate a couple
of these points. I'm going to move them
upwards like this. And as you can see, I can easily create a
smooth surface here. But the problem is, we
need more precision, and we need to create at least several wavy
patterns on top of this. And this number of control
points is not enough. So let's hit Control Z
and rebuild it again. And this time, I'm going to
give it a higher number, for example, like 30
in each direction. Now, this does give
us more control, but it introduces a new problem, and that is we have to individually select these points to be able to modify them. And an additional problem is that once we create only
a couple of points, the transition between
the higher points to the lower points is
not as smooth as we want. You know, it's so abrupt. And somehow we need to fix
these problems as well. So at the one hand, we lose precision, and
at the other hand, we are faced with a process
that is time consuming and does not offer the
same smoothness as before. So let's take a look at a
way to solve this challenge. So let's hit Control Z, and now we're going
to take a look at a command in Rhino that
can solve this problem. So going into the
transform menu, we have a command here
called soft Move. And this basically is a command that can
move a lot of objects together in a way the further we get from the
center of movement, the less the objects
are going to move. And what that means
is that it can create a smooth
effect in the shape. So let's see that in action. So I'm going to hit
F ten and select all the control points and
deselect the object itself. Now, we only have the
control points selected. And from this drop down, I'm going to select the second item here,
which is soft move. And it asks me for a
point to move from. So I'm going to click here, and now it wants a radius. So I'm going to click somewhere, and then I can drag my mouse
up and down and click here. Now, it gives me a preview of what it's
going to look like. And as you can see, the further we go from the
center of movement, the less these points are
going to move upwards. We still have some control
before we confirm the command. So for example, we can
change the position of it or we can change the height if we go into a side view
like this and so on. So if I hit Enter now, you can see that it transformed these
points and therefore, the surface itself
in a smooth way. So now let's take a
look at how we can move them according to a wavy pattern
and not just the points. So I'm going to hit Control Z, and let's run the command again. And you can see that before
I click for a point, it has several options up here, and one of them is curves. It basically means that
I can use some curves as a guide for moving this point. So let's cancel out of here and draw some curves
on the surface. So going to the top view port, I'm going to just draw some
simple curves like this. You know, to resemble
a wavy pattern here. Well, I can delete one of these points to make it
smoother and like that. So now let's go back here
and repeat the command. So I'm going to hit F ten. And as a trick, if I drag here, I have to deselect the object
itself and the curves. But I can also use a command called select control points, which is typed like
cell control points. And once I do that, it selects all the
control points that are visible
in the viewport. So it saves some time. And now I can run the soft move command and select the curves option and click
on my curves and hit Enter. Now, it wants the
same radius here, and I'm going to go with this. And now when I move the mouse, you can see that it is following the curves
in the transformation. And I can click here and
it gives me the preview. And let's change the
radius a little bit. Also, we can move the effect,
allowing the surface. So whenever we are
satisfied with the result, we can just hit Enter, and there we have the surface that is transformed
in a wavy pattern. However, the result is still looking somewhat crude
and needs more finesse. And also, the endpoints
here are a little bit sharp and need to blend in
with the flat areas better. So I'm going to test the
command here called a smooth, which smoothes out these
parts a little bit. So let's run the
command called smooth. And what this command does is basically it tries to
reduce the difference between the angles of
the faces angles between the control points and also tries to minimize the height difference
between different parts, which gives us a
smoother result. But as you can see, we're going to lose some detail. And this is not what we
are after in this case. So I'm going to hit Control Z. Uh, although shapes like this might be desirable
for some scenarios, in this case, we want
to have more precise control over the waves. So we're going to look at an alternative method to
model this parametric wall. So now let's delete this, and I'm going to explain
the loft command. You can find the loft command in the surface tools tab and
towards the left here. So let's go to a side view to draw a couple of curves to test how the loft command works. So I'm going to
draw a wavy curve, for example, like this and another one with a
different wave like that. And let's also put
some distance between them like this and
run the loft command. The first thing you want
us is to select the curve. So I'm going to select
these and hit Enter. And you can see it gives us a preview and also some options. So it presents us with some
styles as it calls it. And once I change them, you can see that nothing
changes in the viewport. So the reason is because these options become activated once we have more
than two profiles. Now, in case of two profiles, the only thing it does is to connect a straight line
between the two profiles. So let's cancel and copy this profile to
the right as well. So now we have three profiles. I'm going to repeat
the loft command again and select these. And now you can see
that it connects them. But this time,
instead of a line, it connects them
with a smooth curve. And this is pretty much
what we are after here, but let's explain the
other options a little bit so you understand
what they're about. So the first one, normal is basically this basically passes a surface through the
curves in a smooth way. And the second one, loose, basically does the same thing. Only the intermediate curves are not exactly passed through. It places some control
points along this curve, but the surface itself
looks smoother, but also loses some detail and so makes it not
ideal for our work. Another option that we have
here straight sections. This connects them
with a straight line. So this is not ideal as well. We got two other options here which are not very useful here, and they got some differences
that make them suitable for special scenarios that we are not going to cover here. So let's put it back on normal. And it also has an
option down here to rebuild the surface based on a number
of control points. Once I activate it, for example, with
five control points, you can see it gives
me a smoother surface, but again, loses detail. So I'm going to accept
the defaults and set it on Do not simplify and hit okay. Now, so this is basically
how the loft command works. Now that you have seen this, let's draw our wall
using the loft command. Okay, let's delete this and
draw other curves here. So I'm going to draw a
curve with the wall height. So a vertical line with
a height of three. Now, this is just a guideline, so I can draw my curves according
to this in a side view. So I'm going to go to the front and start the curve command. And I'm going to start from here and start drawing
a wavy pattern. I'm going to finish
it right here. So this is one profile,
and for the other one, I'm going to do the
same process only this time a little
bit different. For example, like this. Let's also draw a third one
to make it more complex. Okay. So going back
to perspective view, let's separate these profiles. I'm going to put it here. So let's draw another guideline, with a length of 6 meters. And I'm going to
put one of these at the end and another
one in the middle. So let's see how the loft
works on these profiles. So let's bring loft
and head enter. Okay, it does give us
some wavy patterns, but it's not smooth
as we want it. So one of the things
that I want this shape to have is that when
it reaches the end, it has to transition
into a straight line. So let's control Z, and I'm going to bring these profiles towards
the center here. And at the two sides, I'm going to just put some
two straight lines like this. So now let's repeat
the loft command. Alright, now it looks
better than that, and they are smoothly
transitioning to a straight line. But still, these bulgy areas are continuing up to the end. So let's also copy
another line here. To have more straight
parts inside of this loft. So let's select
this and hit Enter. Alright, now, I think
we are getting there. So now we have a wavy pattern, but we can still make it more intricate and
add some detail, edit the curves and so on. Okay, let's delete the surface and make some changes
to the curves. So I'm going to hit F ten and select these control points and using the scale tool here, I'm going to scale them a little bit to make
them more pinchy. Let's also do the
same with this curve. And yeah, let's see
how that looks. Okay, that's interesting, but we can still do more changes. So now we are facing
a new challenge, and that is whenever we
are making a small change, we need to perform the
loft command again, and each time we
need to delete loft, delete loft, and so on. So there is a way we can save some time here and
automate the process. Rhino has an ability, and that is the record
history mode down here. Now, what this basically does is that whenever
we run a command, it records the process. So when we change the inputs, for example, in this
case, the curves, it repeats the command
automatically and gives us the result immediately instead of having to manually
do it ourselves. So in the case of our loft, for example, let's activate
it here by clicking it. Of course, you can
right click it and set it on always
record history, which means that it becomes
activated by default. I don't want to activate
it all the time, so let's just activate it
for this specific command. Now, if I run the loft command again and just as
usual and hit Enter, you can see that it goes off again after the
command is finished. But now the difference is that whenever I change
the input curves, for example, change a
control point like this. Loft itself updates
based on my change. So I can do a lot of
trials and errors and see the result immediately
reflected on the surface. So let's do a couple of these changes with
history enabled. So I'm going to
bring it down here, make it more bulky here, and I want to add another
wave in the middle of this. But you see the number
of control points is not enough or not
enough for that. So what I can do is to use another command called
Insert Control Point. Now, I can select my curve
and click anywhere on it and add these control points
like that. Very simply. So you can see it also
updates the surface, and now I can click it, click the curve, and drag the control point in the middle to make a small wave here. Beautiful. So now we
are getting there, and we get this nice pinchy
effect in the middle where the curves where the waves
are reaching together here. Let's disrupt this
pattern and make this one a little
bit larger, yes. And let's also create some
small disruptions down here, which looks too flat now. So I'm going to insert
some more control points, for example, here and here. And okay, these two
are very close, and let's bring one of them
out here like that and bring this one up and
a little bit more. So you can see, we can
make these kinds of changes very easily with a combination of history mode and changing the control
points on these curves. Now, I want to explore another
scenario where we want to add some detail in
another direction. So, in addition of passing through these
curves, for example, I want them to pass
through a certain path when looked from the plan view. If we do this with
the loft command, we have two options. One of them is to add profiles between the
ones that we have, which is time consuming and is not the optimum
solution for our work. Another one is to add
some horizontal profiles. For example, the ones that pass from up here and down
there and kind of dictates the path that
the surface should pass through in the plan view. But there is a
problem with that. The loft command
does not work well when there is a sudden change in the direction
of the profiles. So to see what happens, let's delete this and use
the loft command again. Only I'm going to go through
this and this and then select the horizontal line here. You can see that it gives me a very odd surface
because it tries to pass through them in order in the order
that I click them, and it cannot find a smooth transition between
these three curves. So that's why it
self intersects. So let's take a look
at another command in the surface tab that can take care of
this problem for us. Now, this command is
called network surface, which basically
can make a surface from curves that exist in
two different directions, which basically gives us more control over where exactly the surface
is passing through. So to see how it works, I'm going to draw
some curves between these vertical
sections that we have. So let's draw curves that
pass through these points. And I'm going to delete that and copy this one
down here as well, because it has more
control points. And now let's make some changes to it, for
example, like this. As you can see, it
doesn't even have to pass through the
other profiles exactly. So I'm going to make
these two changes. And now let's bring network surface and
select all the curves. And when I hit Enter,
you can see that it created a surface that
passed through my profiles, but also tries to pass through the horizontal profiles
that I have here. Now, sometimes it doesn't
exactly follow that curve. And the reason is because I have this curve here and
another one that I just draw that I just drew and it cannot possibly be at two
positions at the same time. So it tries to place the surface
somewhere in the middle. And the best scenario happens when we pass these curves
exactly through those points. So let's see what
happens if we do that. I'm going to hit
Control Z and insert some additional control
points for these lines. Now, I want to keep
these points intact, and I'm going to add some intermediate
points here as well. So when I drag these points, nothing happens to
the placement points, placement points on
the previous profiles. And I'm going to bring
this inside instead, and this one out. Okay, I'm going to bring the other one and
this one as well. Okay, that's I'm going to
bring it here. That's good. So now let's run
network surface again. And as you can see, now it's passing
through them better, but still there are some differences between the profile curves
and the surface. Now, let's play around
with the options that it gives us to see how we can
fit it with the curves. Now, it has some
tolerance values, and if I decrease the tolerance
to a very low number, you can see that it fits better. It's the equivalent of increasing the number of
control points, basically. So for me, a number like
this is pretty okay, there are still some
small differences here, but at the same time, I don't want to
increase them too much because that can
slow down rhino. And another thing is that
sometimes it can introduce some strange anomalies in the surface when we have an extremely high number
of control points. So basically, I'm
trying to balance smoothness with
precision here until I get the optimum solution or the optimum surface
that I'm looking for. So I'm going to hit OK here, and you can see that it
passes through every curve. However, for our purposes, we are looking for a wavy
pattern that basically passes from left to right with some
variation in the middle. So I guess loft would be the best option from among these three options
that I introduced. So I'm going to go with loft
to model this wall now. Okay, so let's delete this and also the top
and bottom curves. And I'm going to do another loft with the record history mode on. And now let's make some
adjustments to this. So it looks like a wavy pattern with a squeezed
part in the middle. So I'm going to select a
the control points here. And sometimes, when
you want to select them while the object
itself is showing, a trick is to put the object in another layer and lock that layer or lock the
object individually. So I'm going to just middle
click and select Lock here, so it won't be selected. And now I can hit F
ten and, for example, move all of these control
points up there a little bit, and the surface updates for me. So let's also use the scale tool to bring
them together a little bit. You can see I can do
that very easily here. And also, I'm going to
modify these control points. Let's move them down a
little bit and expand them. So there's a contrast between the middle part and the sides. So I'm going to
do the same here. And expand them. I can also move the
profile itself. For example, I can increase the distance here to have
a different pattern. And let's also contract it a little bit and
move it, sorry. Let's contract it a little
bit and move it upwards here. So the two sides are
not symmetrical. And let's also bring
this one down. Okay. And now let's
take a look at it from the side and
make sure that we haven't overdone anything here. I guess this part is a
little bit exaggerated, so I'm going to move it
back a little bit more. Okay. And this part also needs to go back a little bit and the top
part here as well. So I'm going to select these
two and bring them in. And this one looks a
little bit too large. So let's bring that
one in as well. And it's looking
pretty good now. And actually, I think it's a good idea to
add a little bit more control points down here and make it a small wave that
passes through here as well. So I'm going to insert some
control points here and here. And I'm going to bring
it out like this. So you can see there's
a small wave like this. So I guess this is pretty
acceptable for now. I can return to it later and
make further adjustments, and it will update
automatically on the surface. Finally, let's also talk about some construction details that can affect the rest
of the process. Now, in reality, this
is not just a surface, and we also have a backside here that is
connected to the wall. Basically, these
vertical slices are bolted or glued to a back
panel or to the wall directly, and it has a small thickness
behind the surface. So let's model that as well. I'm going to go with
a very small number like 5 centimeters, one from the top and
one from the bottom. Like that. And let's
also connect them together and join them. And now let's extrude it all the way to the
other side of the wall. Now we have this backside, and the next step is to
join it with the surface. And the reason I'm joining it is that when we cut our
profiles from the wall, it should give us one
closed curve instead of several open curves that are exploded or not
joined together. And this facilitates
our workflow. So I'm going to
join them together, and as you can see, Rhino gives me a message that the joint command broke
history on one object. This means that the curves no
longer update the surface, which is okay in this case, because we have no
surface anymore. Now we have a
polysurface that is comprised of a surface
and a backside. So I'm going to hit Okay, and in the future, if I need to return to this and
make some changes, I'm going to delete the surface and create another one
by lofting these curves. So now we have an
open polysurface. And the reason
it's not closed is because the two sides
are still open, and it's not really important
here because all we care about is that when we cut our profiles from
these directions, it gives us a continuous
and closed curve. So that's what we are going
to do in the next video, and we're going to cut our
curves from this base model.
4. the 2d profiles: In this video, we
are going to create our TD profiles from
the Treaty model. And to do that, I'm going
to introduce two commands. The first one is called section. It's a very simple command, so let's see how it's done. I'm going to type section. And it asks me for
objects to cut. So I'm going to select
my wall and hit Enter. Now, all I have to do is to just draw a line that passes
through the object, and once I click, you can see I get my
section as simple as that. And we notice that the
command still stays active, meaning that I can draw
additional lines and get other sections
within the same command. So I can keep drawing lines like this and
get other sections. Notice how the sections are oriented in the direction
of the line that I draw. So that's the basic
functionality of the command. And once I hit space or
enter, I get my curves. So this is the result
of the command. Now, notice that
the direction of these sections that
these sections are produced is perpendicular
to the Cplane. To see that better, let's
change our Cplane a little bit. For example, I'm going to run the Ciplane command
and rotate it in the direction by 45
degrees, like so. And let's repeat the
section command. And draw a line here. And now you see
that the section is rotated to be perpendicular
to the construction plane. So any additional lines that I draw will have
the same direction. So now that we understand
how this works, let's get back and explain some of the options of
the command briefly. So I'm going to reset
my sea plane by going to the word sea
plane and the top view. Now, let's start
the command again, and I'm going to select
my object and hit Enter. Now we are presented with
some options up here, and the first one is called extend section,
which is set to no. So let's enable that and
draw another line here. You can see now that I no longer have to pass my line
through the entire object. So what this does is basically it draws an
infinite line based on the direction that I specify and uses it for cutting
the sections. Now, sometimes I want to specify exactly which part to be cut, but in other cases like
this, it doesn't matter. So I'm going to leave
it on because I don't have any objects
in the scene and also it facilitates
our workflow. So the next option is
called assigned properties, which is set to
by current layer. And what this means is that the newly created
sections will end up in the same layer that is
activated currently in Rhino. So if I, for example, activate layer one now, all the new sections will
end up in layer one. So if I hit Enter, you can see that some of the
sections are red and some of them are black, which means that the
first ones went into the default layer
and the new ones after I change the option, went into layer one. So let's control Z and
repeat the command again. The other option
that we have here, if you click it is
by input object. Now, this means that they go in whatever layer that the
input object exists. For example, because our wall exists in the default layer, the sections will also
go into the default. I'm going to set it by
current layer because this is more manageable and
easier to select later. And now let's take a look at the third option, the output. This is set to curves only. Actually, we don't
need to change that. And what this does is it has
the ability to also produce hatch from the sections in case we have a section style
applied to our object. In our project, we only
want the profile curves. So I'm going to
leave it at here. And lastly, the option group objects by section
plane is set to know. What this option does is that in case we have
several objects that are cut by the same line or we have objects
with holes in them, it produces several
closed curves. Now, if we enable this, it puts all of those
objects in the same group. Now we are going to
use this ability later when we are
arranging our sections. But for now, I'm going
to leave it at no. So now that we know the options, let's use the command to produce some sections
from the wall. Now, I want my sections
to be evenly distributed, meaning that the
distance between two consecutive
sections needs to be the same all
throughout the wall. And to make sure of that, let's do a trick here. I'm going to draw a line in the same
direction as the wall. And let's divide this line. For example, let's
give it 15 or 20. I'm going to go with 15, and this makes sure that if I start the
sections from here, the distance between the
sections will stay the same. So now let's start the
section command and select our object and just
start drawing lines. I'm also going to
activate Otome to make sure they are perpendicular
to the object itself. Now because we have
extent section enabled, we don't have to pass the lines through the entire object. So we can quickly draw
lines and get our sections. Okay, that was a
pretty quick process, but this is actually not
the spacing that we want. We want it to be much smaller, and as a result, the number of sections would
be much higher. And that can become
quite time consuming. We have a much faster
way to do this. So let's introduce
the contour command. You can think of the
contour command as an automated version of
the section command, and they are actually
very similar. So let's see how it
works in action. I'm going to delete these
and type in contour. And select my object
and hit Enter. And now it asks me
for a base point. This is the point from
which the sections begin. So I'm going to align this point with the beginning
of the wall here. And actually, it doesn't have
to lie on the wall itself. It just has to be
aligned with it. So I'm going to click
somewhere here, and next it wants me to
specify a direction. And unlike section
where this line would determine the
section orientation, and it would be aligned
with this line, contour, the actual sections or contours will be placed
perpendicular to this line. So if I draw this
parallel to my wall, the resulting sections would
be perpendicular to it. So this is the good direction. So I'm going to click
somewhere here, and the length of this
line doesn't matter. It just is used to specify
a general direction. I'm going to click
here, and next, it asks me for a distance. And this distance is basically the distance between two
consecutive sections. So I'm going to use a very small number here,
like 10 centimeters. And it enter. Now, you can see that it
produced sections across the object with a ten
centimeter spacing, and it did it all in one go. So you can already see
why this command is better compared to section because it takes care of
the hard work for us, and we don't have to individually
create these sections. And from a design perspective, this is ideal because we often
have to go back and forth and explore different options before settling on a design, and we want this to be
as fast as possible. So now that you have seen how this command works,
let's delete this. And now let's see what options
we have with this command. So let's run the command again. And select our
objects, hit Enter. You can see that we have the exact same options
as the section command up here with the
addition of the range option. Those other three work
exactly the same, so I'm going to skip
them and click on Range. Now, it wants us to
specify start point, so I'm going to pick here
and also an end point. So let's pick here. And I'm going to accept
the distance that we had already and hit Enter. Now, what it did is that it created sections only
between these two endpoints, and it skipped the
rest of the object. And that's the difference.
Normally, the contour produces sections throughout
the entire object, but here we have the ability to specify which part of it is cut. And this is desirable
in many situations, but in our case, we want the entire
wall to be cut. So I'm not going to
use this option. So let's delete these and
run the command again. And select our object, our base point and
our direction. And for the distance, I want wooden slices with
a width of, let's say, 4 centimeters and the
gap between them for, let's say, 3 centimeters. So it would be a total
of 7 centimeters. I'm going to type 0.07, hit Enter, and there
we have our sections. Now we are pretty
much finished here, and we can proceed in the next
video by talking about how to lay them out on
the ground plane and ways to automate it. But as a finishing
touch for this video, let's see how this
looks in three D. So I'm going to extrude all
of these by 4 centimeters. Okay, so now it's extruded, and it took almost 40
seconds to finish. A tip on reducing
this time would be to extrude them part by part, so they won't take as much time. Okay, so now let's
take a look at these in D in the rendered mode. And let's also change this
color so we can see it better. Now, the parametric
wall looks quite okay. So I'm going to accept this and proceed in the next video.
5. arranging the profiles: Now that we have our model, we are going to create some
construction documents from it by placing the profiles
on the X Y plane. In this way, we can export to the document that can
be used for cutting. So to demonstrate, I'm going to manually perform this operation
on two of these profiles. So let's copy them here. Basically, what we want to
do is we have to rotate them once around the Z axis and
once again along the X axis. And also, we need to create
some spacing between them like this so
they don't intersect. And finally, we have to
place them on the XY plane. So to do that, normally, we have to drag the gumball type zero
and hit Enter like that. I'm also going to introduce another command to
facilitate this later. So that's the manual method, and this is quite
time consuming. So let's explore two ways that we can automate this process. The first method involves using a command called distribute. So before using it
on the profiles, let's see how it works. So I'm going to draw a
couple of boxes here. And let's perform the command on these boxes and then
explain what it does. So you can find the command on the transform in line objects. And it's actually down here and it's called
distribute Objects. However, I'm going to run it by using the shortcut
because it's faster. So just type distribute, hit Enter, and now it presents
us with some options. I'm going to pick this
x here, and that's it. What it basically did was to equalize the distance
between these objects. And let's control Z and perform it again to
see the other options. Now, the first four options are basically dealing
with direction. We can pick any direction
we want for distribution, but it already has X
Y and Z directions. And in our case, we're
looking for the Y direction because our profiles are
arranged in the Y direction. And the next option called
mode is now set to center. The other option is gap. So if you change the mode, it switches between
gap and center. And the difference between
them is that in gap mode, the spacing is measured
between the objects, but in center mode, the spacing is measured between the centers
of the objects. In other words, it ignores
the thickness of the objects. So let's see how
each of these works. So if I set it to gap
and pick an axis, now let's measure the
distance between the objects. And as you can see, the
internal distance between these two objects is
now exactly 5 meters. However, if I repeat the command in center
mode and pick the axis, now, that five meter distance is measured from
center to center. And as you can see,
it's exactly 5 meters. And the final option, spacing is basically
self evident. So you can type any number here and the spacing
becomes that number. However, it has another option, and once you click it, it presents you with
the automatic option. Now, what this does is that it preserves the position
of the first and the last item in
these objects and tries to distribute the others between them with
the same spacing. So let's select it and
pick the axis here. And you can see that it space the objects evenly between
these two endpoints, and instead of a number, it automatically determines
that spacing here. So that's how this
command works. And now that we know that, let's perform it on our
profiles and see how they look. So let's select our objects
and the select these. And for good measure, I'm
going to make a copy of these profiles here and run
the distribute command. I'm going to accept
the spacing of five and pick the Y axis. And now our objects
are distributed evenly across the
wide direction, and that's pretty
much how we use the distributed command to
evenly space our profiles. However, this is not the
only way to do this, and we also can use the flow command to
perform this operation. So let's see how it works. I have to mention that the flow command is a very
powerful command in Rhino, and covering the entire range of its applications is beyond
the scope of this course. Here, we only use its
simple application in arranging some objects along a curve or a line in this case. So with that being said, let's demonstrate how it
works with a simple example. So I'm going to the
top board here, and let's add a text here, for example, with this default
text that we have here. And I'm going to
draw one line behind it beneath the text
and another one here. Let's also explore this
to get curves here because the flow command
requires geometry objects. So let's see how it
works in action. I'm going to run flow,
select my objects, hit Enter, select the base
curve and the target curve. And that's pretty
much what it did. So it basically transforms objects from a base
curve to a target curve. And to see a better example, let's draw a non linear curve. For example,
something like this. And if I repeat the command, only on this target curve, you see that the text is pretty much warped along that curve. And that's what makes it ideal for modeling
some complex geometry. For our purposes, we need a very simple version of this without deforming
the objects. So in our case, in
our example here, I would run the flow
command. Select the objects. But here we have an
option called rigid, and I'm going to
check that option. It means that the
objects won't be deformed and select my base
curve and target curve. And as you can see, it preserved the structure
of the objects, of the individual letters here. And instead of letters, now we are going to
give it our profiles to distribute along a
line here for us. So before using it
on our profiles, let's also explore
another option that has to be checked
before we use it. So let's select the
objects hit Enter. You also have to make sure that the stretch
option is set to yes. Otherwise, it won't distribute it across the
entire object here, and only it will go as far as the base curve length
is drawn here. So, for example,
if I set it to no and set rigid to yes,
that's how it would work. So with that being said, let's see how it works
on our profiles. I'm going to the
perspective view. Let's delete the
ones that we had here and let's draw a line. So for example, like this, let's select our profiles
and run the flow command. So for the base curve,
I'm going to use the lower edge of
our wall model here. So I'm going to select this and make sure a
stretch is enabled, and rigid also is enabled, and select a target curve. And that's it. So it distributed our profiles along
this curve or line, and that's another way
that we can distribute objects so now that we know
how these two methods work, let's talk about how to fix the rotation of these profiles
once we distribute them. So for our purposes, I'm
going to undo this and use the distribute command
here because it gives me more control over
the spacing of the objects. So let's select them again, make a copy, run distribute,
and pick the axis. So that's what we have so far. So now let's introduce
the box edit command, which allows us to
individually rotate objects without losing their
position in the process. But before introducing
the box edit command, a logical question is, why not use the gumball itself
to rotate these objects? And it actually works
in some scenarios, but not for all the
rotations that we need. For example, if I rotate
them around the Y axis, the green one, it's going to work because they all
share the same axis here. For example, I can rotate
them by 90 degrees and they all become horizontal. However, in the next step, I have to rotate them again so that the profiles
are facing upwards. And for that, I need to rotate
them around the X axis. However, if I do that, you can see that they all
share the same center, and in other words, we lose the correct positioning that the objects had
after distribute. And basically what we should do is to take
individual objects here and rotate them by 90 degrees and keep repeating this for
every individual profile, which is time consuming. So that's why we need to find another way to rotate these
objects other than the Gumbo. So I'm going to control Z here. And let's now introduce
the box edit command. To run this command, we
can just type box edit. Or alternatively, we can come to the transform tab and
look for this icon, a sphere caged in a box. So either way, once we click it, we are presented
with this tab here. So instead of some options
appearing up there, it gives us an entire tab, and this tab actually
has a lot of options. So it's best to dock
it somewhere so we can see all the options
together like this. And right now it's grade out. So it requires us to
select some objects. And let's select our profiles. And now that it's activated, let's talk about
how this tab works. Basically, it gives us
the ability to perform several transformations
in one big step instead of performing them in different commands or steps. So instead of moving our
object first and then rotating it and then scaling
it in different commands, we can just type
numbers for each of these transformations here and it gives us a preview of it. And once we are satisfied, we can click Apply and it
applies it on our geometry. But the specific reason
that we are using this tab here is this checkmark, transform
objects individually. This basically means
that instead of rotating all of our objects
using a shared center, each object is
treated separately and is rotated around
its own center, meaning that the
relative position of the objects won't be changed, and that is ideal for our
purposes because we want to keep the order of the
item placement here. Before we use that option, let's see how the command
works in general. So let's give an
arbitrary rotation to every object in here. And you can see it gives
us a gray colored preview. I'm also going to move them
a little bit like that, and let's also scale them
a little bit, as well. And once we are satisfied, we can just click Apply and
it changes our objects. So that's the basic
functionality of this tab. So let's control
Z, and this time, I'm going to check this option, and let's also zoom in on one of the profiles so we can see
better what's happening here. Now, we need to find
the correct combination of rotations to perfectly
place them on the ground. Now the challenge here is once we rotate the
objects in one axis, the relationship between
the three axes can change, and we need to do
a little bit of trial and error to find the
correct combination here. So let's start with
the Z axis here. Okay, it seems to
be the correct one. So I'm going to rotate
it by 90 degrees here, and you can see that
every profile is rotated around its
own separate axis, which is calculated by the
bounding box right now. So and that is the first angle. For the second one, let's rotate them around
the y axis, the green axis. And in this case, we need to rotate them by negative number. So let's give it -90 degrees. This is because once we
look at from the top view, we want the profiles to be exactly in the
correct orientation. And this is ideal. So now that we are satisfied, we can just click Apply and
it finishes up the command. But before that, we also need to place them on the
ground plane as well. Right now, they are hanging
in the air somewhere. So we can do that later
with another command. But box edit also
offers this option. So because we already know that the base of the
wall is on the ground, we can change one of these
options here, for example, set a Z to minimum, and this basically means that it considers the minimum point of the bounding box for performing the rotations
and not the center of it. However, right now,
you reset the command, and we have to type in
these numbers once again. So let's type them again here. And now you can
see that they are rotated and placed
on the ground. So we can click Apply and that finishes
the transformation. And that's it. So if
I go to the top view, you can see that the
profiles are now placed on the XY plane. The only problem is that
they are on the Y axis. So I want them to be on
the horizontal axis, and for that, I can just do
a simple rotate command, for example, round rotate
and for the center, I'm going to type
zero to rotate them around the origin
of the file here. So I'm going to rotate them
by 90 degrees, and that's it. And that concludes our video on arranging these
profiles on the XY plane. So to recap, we took care of the spacing between the profiles using the distribute command. We also can do it using
the flow command, which is a more
advanced command, but a simple implementation of that advanced command
can do this for us. And next for fixing
the rotation, we use the box edit
command to perform this transformation on all
of the objects at once.
6. numbering: Okay, so now we have laid out
our pieces into the space and we can export these and
use them for construction. However, there is a challenge. When people are
assembling the pieces, they need a way to tell the correct order which
piece comes after the other. And to help with that, we have to add some numbers to the pieces to indicate
that correct order. And this number should fall inside the piece because we
want to carve that number from the actual wooden piece so that people can read it and sort the pieces
before assembling. So let's see how it's done. Before anything, let's make a new layer for our text
objects and call it text. And we're going to add
our text to this layer. So I'm going to run the text command and
call the first one, the number one and
place it here. So let's also fix the size and give it a size of 0.2 or 0.3. And let's place it here. So it falls inside the piece
and it should be okay. And next, we have to
copy this in all of the pieces and make sure that
they fall inside the piece. So I'm going to use array here, and for the number
in the direction, let's count the number of
profiles that we have. And all we have to do
is to just select them, and it tells us that we
have selected 86 curves, one text, and that's it. So we got 86 curves
or profiles here, and I'm going to
use this number. So in the X direction, I'm going to type 86 and one in the other ones
in the other directions. For the spacing, I'm going to use this straight
line at the back of our wall as a reference point because it stays fixed
in all of the profiles. And I'm going to array
this and click here. Now, before we
confirm the command, let's check the preview and make sure that all the pieces
are actually inside, sorry, all the texts are
actually inside the pieces. Okay, we got some texts
that are outside. Let's also check from
the middle here. Okay, a possible reason for this might be because of
the box edit command. Remember, we use
the bounding box when determining the
center for each object. And because our objects have different thicknesses
or widths here, that causes them to have
different center positions, and this disrupts the spacing that we have specified in
the distribute command. So we get some slight
differences like this in the placement
of our pieces. To fix that, we need to
redo the box edit command, but use a fixed point that
exists in all of the pieces. And for our work, I think the ideal point would be the edge of the left
edge of our pieces, which is the straight
line that exists in all of our pieces that
are cut from the object. So that's the way
we should do it. Otherwise, we have to
manually move all of these text objects
inside the profiles, which would be time consuming
and actually defeats the purpose of all this
automation that we are doing. So let's cancel that out
here and try to do that. So I'm going to the
perspective view, and let's distribute
these profiles again. So I'm going to select them. Just make sure not
to select these. I have to delete them later, but I'm going to keep
them now for comparison. So let's make a copy
here and use distribute. And so I'm going to set the spacing to five
and use the Y axis. Now, this time when we
use the box Edit command, I'm going to use these
options here to make sure that this edge is used as the
pivot point for rotation. So I'm going to also
set the minimum X here. The Y location, actually, it doesn't matter because object these objects don't have any thickness in
the Y direction. So I'm going to do the
rotation again and this time, you can see that it
actually rotates around this straight line
here, like a door hinge. So let's set it to 90 degrees and set
the other one to -90, just like we did
before and apply this. Now, this should
fix our problem. So I'm going to rotate all
of these by 90 degrees. Like, so, and let's move them down here to compare them
with the previous profiles. Just making sure that they
are rotated correctly. Okay, so I'm going to take this number
and copy it up here. And place it in my profile. Now, logically, this should fall inside all the
profiles because all of them share this five centimeter
thickness wall behind them. So let's use the
array again and type 86 and start copying. Okay, so now let's check the other pieces.
Seems to be working. And also, let's check
some of the ones from the middle of the array from some of the middle
profiles that we have. Okay, it's perfectly aligned
inside the profile here. And let's check some
of the last ones. That's pretty good. So
I'm going to accept this, and in this way, we can solve this issue
that we had before. So let's delete
the other profile It works better in
the top viewpoard. So I'm going to select
these and hit delete. And let's also bring
these down a little bit. And something that we have
to be careful about is that as the number increases, it becomes two digits. So for example, the last
piece for the last piece, the number is 86 here, and you can see that this six
falls outside of our piece. So we need a smaller font
here, font size here. So let's select all of our
text using cell text command, since we know that we have
no other text in the file. And going to
decrease this number until it falls inside of our range, inside
of our profile. And that seems to be okay. So let's also check a couple
of other profiles here. And here comes the
next challenge. Now, this is where
we hit a limitation on using Rhino without
grasshopper or any other plugins. We have to manually change each of these numbers
consecutively. So we have to actually
select these and type one, two, three, four, so on. And actually, if
you do this fast, it can take a couple
of minutes only. However, if you're planning on using this process for
other objects as well, you might need a way to
automate this as well. So let's take a look at a slightly more advanced
way of doing this. You probably have heard about scripts in treaty softwares, and that is one way
we can automate repetitive tasks inside Rhino. And, of course, there are
other ways, for example, using plugins that do this or using grasshopper that
can do this in a breeze. But since grasshopper requires additional skills which
are beyond this course, and also we don't want to use
any outside plugins here, only native Rhino tools. So this is a good excuse
to actually take a look at the Python script
editor. And don't worry. We're not going to teach
scripting here because that requires its own full course and is a totally
different skill, and learning it is
actually harder and more difficult than
using grasshopper. So I'm going to use AI tools to give us a very simple script that can take care of
this problem for us. So it's an advanced solution, but very easy to do. So let's first see how
the Python editor looks. So I'm going to type Python and you can see that
two commands come here. We're looking for the second
one, Edit Python script. And here we are presented
with a blank screen with a blank page here or file that requires us
to type something here. This is where the code
goes. And don't worry. Even if you don't know
the basic concepts of programming, for example, what a variable is, what a function is, so on,
you don't need any of this. So we are assuming that we are designers who are
not familiar with programming and just want to use a very simple
script to take care of a simple yet
frustrating problem for us. For this, I have
used an AI tool. So I used copilot here, but you can use any
other AI engine, and the general results
should be the same. So the thing about writing a prompt for getting a piece of code is that you have
to be very specific about it and tell it
exactly what you want. So let's start with this. I'm using Rhino. I have several text objects arranged in the X direction. Okay. And I want a Python script that allows me to select a specific text objects and turn them into
consecutive numbers from left to right,
starting from one. Now, that's a very
specific prompt. So let's see what
it comes up with. So here's the piece of code, and it also offers some
interesting explanations, which in this case,
we don't need. So let's just copy
the code here. And back in Rhino, let's paste the code here. And without any explanation, let's just run it and
see how it works. So for running the code, you need to click this
green arrow here. And it wants us to select
text objects to re number. So for this, I'm going to select all the objects inside the
text layer and hit Enter. And if I close this, you can
see that it did the job. This is one, two, three, and so on. So let's check some of the
numbers from the middle here, 31, 32, and let's
check the last ones. The last one is
86, 85, and so on. So that worked perfectly. So this is a very interesting
example of how you can use AI tools to automate things that can otherwise
take some time. We use this code without
understanding how it works, and that's totally okay because
we are not programmers. But for people who want to know a little bit more about it, let's break down the general structure of
the code a little bit. So I'm going to bring up
the Python editor again. And in here, we
basically are selecting some objects and showing
this prompt to the user. So basically, you can change this string or text to
anything that you like. Then we sort these
objects based on the coordinates, and finally, we go through every
item in that list and change the text to a consecutive number that
is increasing one by one. And that's all there is to it. That's the general steps. The rest of the code is just some bureaucratic
steps, so to speak, that you get to know once
you understand the basics of the Python language
and also study the documentation
of Rhino scripting. So, for example, even if you are a professional
Python programmer, you still need to study the documentation to understand the names of the libraries. And know which functions
exist inside of them. And that takes a lot of time. That takes a lot of
patience and time to learn the syntax of the language
and how to work with it. But for non professional
people like myself who want to occasionally use a simple script to take care of a
very specific need, a great idea would be
to study code samples and take a look at
those or ask AI. And in this case, we can just reverse engineer these
samples and, for example, understand the
names of libraries or in case we forget how to, for example, define a
loop inside Python. I can just take a look
at it and remember it. And this is just
some general tips for people who are
interested in it. But apart from this, we don't need to deal
with these details. So now that we are done with numbering the pieces
here, the next video, we are going to talk about how to export these and the options that we have that can enhance the quality of these exports.
7. exporting: In this video, we're
going to talk about some export options that can affect the quality
of the final result. So Rhino supports many formats, including formats
for treaty printing and laser cutting and so on. And there are also some general formats that can be read by many
different softwares, such as the DWG format, which is the standard
autocat format, and also the DXF format, which stands for drawing
exchange file that is specifically designed
for facilitating exchange between
different softwares. Now, this format is also quite popular with CNC and
laser cutting machines. So we are going to focus on this format and the
different options that it has to enhance the
quality of the export. And by quality, I mean ensuring the
correct scale and also making sure that the curves preserve their smoothness
after the export. So let's export some objects and take a look at the result. I'm going to select
all my profiles here and just make sure not to select the actual treaty
object to the left. So from the file menu, we're going to use
Export Selected. And it presents us with
a dialogue where we can specify the location
and also the format. So because I have
used DXF before, it shows me the format here, but you have to use this drop
down and actually find it. So let's choose it and give
it a name and hit save. Once you do that, it presents
you with an options menu, and this is where we determine
the quality of the result. So right now it is set to one of the templates, 2007 lines. Let's hit Let's
click on Edit scheme here to change the
settings in detail. Basically, it has two
tabs, general, and curves. In general, it deals with some options regarding
treaty objects. So I'm not going
to deal with this. The only option that matters to us is the autocat version, which means the lowest version
that can read the file. Actually, 2007 is a good version because it's not too old to lack some capabilities
and not too recent so that some people
cannot open the file. So I'm going to
leave it at here. But in the curves menu, we have options on how to translate rhino objects
to autocat objects. As you know, curves in Rhino are infinitely precise because
they are nerves objects. And the equivalent of a nerves curve in autocat
is called a spline. And this is a default setting. And our objects, however, are several joint curves which are called
polycurves here. So these are translated
as polylines in autocat, and polyline is basically a collection of lines that
are connected to each other. So we can set these two splines to have
infinite precision here. However, some CNC machines
do not support splines, and they require us to
give them polylines. So I'm going to leave
it at polyline, and we're going to explore some settings here and see how they
affect the result. For now, let's accept the
defaults here and okay. Now let's open autocat and take a look at
the result there. So let's open the file here
and take a look at it. I'm going to double click
the middle mouse button to zoom on the objects, and let's zoom in here and
take a look at this profile. It looks pretty smooth here. So once we hover over it, you can see it's
a two d polyline. And when we click it, you can see that it
has a lot of vertices. Or in other words, it is
comprised of many lines. This is actually a good sign, which means that the
object has a high quality. So I guess this is an
optimum settings for export. So to compare, I'm going to
change the settings a little bit to lower the quality and then compare it with this file. So let's get back to Rhino. I'm going to export
again and this time, I'm going to change the
settings a little bit. So in the curve section, we got some options to
change the curve quality. And this is called curve
tessellation parameters. And we can change this
in three different ways. The first one is maximum angle, and I'm going to use this one. So how we should interpret this is that
the higher the angle is, the lower the quality of the
curve we're going to get. So I'm going to set it to
a pretty high number like 50 degrees and temporarily save this into the
template and hit okay. So let's get back to AutoCAD and see how it affected the result. So let's open file number two and take a look at the profiles. Okay, so you can
see it already has a much lower quality
compared to the other ones. So I'm going to copy a couple
of these and put them next to the profiles in the first file so you can
see the difference better. So the reason these are smooth is because it has
a lot of vertices in it, and the reason this is low
quality and jagged is because it has a much fewer lines and vertices that
comprise the object. And that's the main difference. So to fix it, back in Rhino, we have to make sure
that when exporting, we set this option, the curve destilation
parameters to a proper amount. So before this, it
was set to two, which is a good
quality for export. So that's it for the options. And if you pay
attention to this, we're going to have a
high quality export. Another thing to keep
in mind here is that sometimes the CNC machine requires objects in millimeters, while in Rhino, we might
have modeled them in meters. In this case, it's always a good idea to double check this scale before sending
the file for cutting. So I'm going to measure this. It's right now three units, which means it's in meters. So we have two options here. We can either scale it
in Rhino or in AutoCAD. So either way, it gives
us the same result. So I'm going to do this in
AutoCAD and just apply on a scale with a factor of
thousand to the objects. So that they are
measured in millimeters. Now, if I measure the length
of this profile here, it reads 3,000, which is the correct scale,
and that's it. So finally, we are done. In this course, you
learned how to model the parametric wall inside of
Rhino and more importantly, how to prepare it
for construction. And all of these
steps were done using only native Rhino tools without any help
from grasshopper. And I hope that this course
was able to increase your proficiency in using
Rhino. Thank you for your time.