Ramp It Up—Advanced Corridor Design in AutoCAD Civil 3D

ANDREW MILFORD: Good morning, everyone. I guess it's 8:00 now. So I think we'll probably look at getting a start. So this is a really good turnout. This is my first time speaking at AU, so it's good to see such a large number of people on a Thursday morning.

My name is Andrew Milford. I'm an AEC Technical Consultant for Autodesk Australia and New Zealand. I've only been with Autodesk for about 18 months. Prior to that I've spent about 25 years in industry, working for companies such as AECOM, Arcadis, and Jacobs Consulting. So my background is heavy infrastructure, road design, geometric design, major roads, highways, interchanges.

I also contribute to a blog, "From the Ground Up." Has anyone actually visited this in the past? Yep. Junction Jack Strongitharm was kind enough to invite me along to write about this. So I'd like to give it a distinct Aussie flavor. I like to call it "From the Ground Downunder" just to localize it for the Australian market.

So we'll get into the session. We've actually a lot of material to cover today. If you downloaded the notes, the presentation notes, you'll see that there is actually like a 55, 56 page document. That's actually a much more comprehensive list than what we're going to go through here today since we've only got 90 minutes to condense it.

So what we're going to run through today, this exercise is going to split into four parts, four exercises. Each one is going to be split between Subassembly Composer, where we're going to introduce new concepts. And then we're going to apply those in the Civil 3D environment in a real world scenario.

The first example is going to be exit ramps. This is going to be an introduction to subassemblies. We're going to take the basic four layer pavement generic subassembly that ships with Civil, and we're just going to extend its functionality. We're also going to look at creating what I like to call a slow projection, where we can start to manipulate our crossfalls and match slopes from existing surfaces.

Exercise 2, we're going to build upon what we learn in Exercise 1. We're going to take and look at the concept of transitioning across our regions in Civil 3D. Now, when I first moved to Civil 3D, I found this really difficult to do, getting that whole concept of batter transitions. We're also going to look at the concept of linked corridors. So we can actually break our model up into a much more manageable components but still keeping the corridors linker in the event of change.

Exercise 3, pram ramps and kerb laybacks, we're going to build upon what we picked up in Exercise 2 with the transitioning formula. And we're going to actually apply it to a real world pram ramp and kerb layback scenario.

Traditionally I see these things modeled up using feature lines in Civil 3D. I'm pretty lazy. I don't like to actually do that. I like things that are dynamic and are going to stay linked back to my parent corridor. So we're just going to build this and actually use it as part of our corridor.

And finally, the behemoth, we're going to bring it all together and create some complex batter slope transitions. We're going to use the concept of linked corridors, auxiliary alignments, offset alignments, to build out a multi-bench batter slope configuration that you're going to have complete control over and be able to edit and manipulate very easily.

So if there are any questions we'll hold them off until the end. Because we've got a lot of material to cover. So that's my standing up part. I'm now going to sit down and start to drive. I don't like PowerPoint. Oh yeah, at the end of this class-- you guys have all read that. Haven't you?

So we're just going to really run through applying the alternate modeling techniques, what I like to call a linked corridor technique. We're going to create some complex transitioning. And we're going to explain some of the [? mattes ?] behind it and how we can actually use it, not only for things like batter slopes, but for any kind of component within subassemblies.

We're going to look at how we can create, edit, and reuse these using Subassembly Composer. Is there anyone here using the Subassembly Composer? For those that aren't, definitely check it out. I've actually included all of the packet files in today's demonstration on the website.

Download them. Pull them apart. Play with them. Make them better. They're not perfect by all means, but they do work. But you can certainly take them and make them your own.

And, yeah, to me it's all about reducing the rework time. Maybe a little bit of upfront cost in the set up, but downstream when the changes occur, and as civil engineers, they change all the time. We have models that can actually respond to that change very quickly.

So the first exercise we're going to look at an exit ramp scenario. And we're going to look at modeling this up just using first principles techniques. The difference between this exit ramp-- and this is just a shot of an exit ramp that we use in Australia.

You can see here we've got some tapers down here. This is the one we're going to be focusing on. We've got our gore area. It shoots off at a 1 in 15 taper. Gets a little complex. But what actually is going to make it more complex in Civil is the exercise we're going to do-- we're actually going do it on the outside of a curve.

So we're going to be developing super elevation in between this area here. So how do we actually create multiple corridors that can actually talk to one another and still maintain that relationship with the slope?

So to do that, we're going to-- this is our first of our two subassemblies. This is the six layer pavement. All I'm doing in this exercise is taking the four layer pavement that ships with Civil 3D. I'm adding an extra two layers because we use-- I don't know. We use quite a few more layers in Australia. We use slick material, base, sub base, plus multiple pavement layers. And we're going to add some marked point functionality, so we can actually work from the outside in, not just from the base line out.

The second is a really, really simple one. But it's going to show some of the real power of Subassembly Composer. This is called a-- I just call it a slope projection. All it's going to do is take two points on the surface and return a value, which we're going to use via parameter referencing to control the slope of our tilting roadway.

So I'm just now going to jump into Civil-- no, Subassembly first. And this is actually, at the moment, five lanes. If you haven't actually played with Subassembly Composer before, it's really just a case of grabbing your points, links, and shapes, dragging them across, and editing them from here.

What I like to do is always like to put a version output parameter here. And I do this in every single one of my subassemblies. So I've got version control. So when I ship it out and push it out to users in the teams I'm working with, they can always know if I've got the latest version or not. And make sure, most importantly, everyone is on the same version.

We're going to use a-- this is called a defined variable. We're actually taking the lane slope calc here. At the moment it's set to a value, down here as you can see, of minus three. We're going to plug a formula in here. You see on the list here, we have all the input and output parameters. Now, I've actually enabled control for point codes and link code. So the users can actually enter their own point codes as opposed to just using the stuff straight out of the box.

The lane slope calc-- I'm going to cheat a little bit here and just grab a formula. Because it's actually quite long, But quite simple when you break it down. So instead of minus three, we're going to take this. You just extend this. And all this is saying is, if this parameter here, called U super elevation, is equal to the left inside a left outside lane, and it actually has super on it, use that value.

This is just using Subassembly API at the moment. If it doesn't actually, if that does not conform, if it's no, then go down to this line, and so forth, and so forth, and so forth.

It's set up just like you doing in Excel if-then statements. The only real key here is, when you get to the end, saying if there is no super elevation, use this default slope value. That's all it's doing. And our default slope value is a parameter sitting down here in our input outputs.

Don't be frightened off by the C type double. All that's saying is, the super elevation value is a double. The default slope, as you can see over here, is a grade. All we're doing is converting that type of a grade into a double.

So when you're actually doing these formulas, you need to make sure that both the true and the false condition statements are of the same type. In this case they're going to be a double value.

So once we run that in, we can feed it into the top layer here. What I'm going to do in this case is-- this is how it originally ships out of the box. I've already set up a condition statement saying, do I want to use a marked point?

That is actually driven by this yes-no parameter. So if I'm going to use a marked point, I'm going to actually re-hook-- that's a nice one to see. And just undo that. I'll take these links out. Move that across. And connect into that.

So we're calculating the super. Are we using a marked point? No we're now. We're just going to use a standard-- let's just move that out there. We're just going to use a standard super elevation value. Then all we're going to do is connect it back in to create the geometry down here.

If we do want to use a marked point, I come over here, and I use this marked point instead. What I like to do when I'm designing these is I love to actually just either sketch them out by hand first, either on a piece of paper or in CAD so I know what parameters I'm going to be dealing with.

The Subassembly Composer does not let you move these up and down. That's the problem. So it's nice to have them all in sequence first so it's just nice, and neat, and clean for your users at the end. So you can see here, I've got an error warning. It's telling me that my link isn't working so I need to make sure I'm hooking up between P-1 and P-2, error goes away.

We connect back in here. And then we just continue down the chain. So we're just working in a very sequential order here. So pavement five, what we're going to do is now-- this is how easy it is to use. We copy and paste all of those elements. And we're going to make a sixth pavement layer.

All we're doing here in this decision is saying, if the pavement depth is equal to zero, don't give me any thickness if it is. Give me pavement depth. So we run those in through there.

And you can see we've already got the sixth pavement. But the one thing we haven't got here is-- I just need to make that pavement six. Is we just need to change the points they're linking off. So I P9 goes to P11 So you get this interactive feedback here on the side. P10 becomes-- we want that off P12. And we want to move that link, you can see there's a bit of overlap there-- and we just want to run that between P15 and P16.

So there's our sixth, sixth layer. So we can build up as many of these as we like. 10, 15 layers, if you want to put in your binding layers, which I've seen people do. I don't know why, but they have.

And then to create the shape, we just select, come in here. subassembly Composer is pretty intuitive. I could just start typing in link values between L20, L24, 23, 22. I'm just going to click Add Link a few times. And it picks it up. So we've now driven the shape within there. So that's really all there is to that component of the subassembly.

The next one I wanted to show-- and this one is really, really simple-- is the Slope Projection Tool. This doesn't actually return any geometry. It's just going to return a value. That value then we feed in, through parameter referencing, into future subassemblies when we line them up in our final assembly.

So all we're doing is putting two auxiliary points up here on the left-- on the right, sorry. I'm just going to link that in to there. Now, within these two sample points, AP1, AP2, all we need to do is a simple calculation to work out what's the slope between the two that we can then feed downstream to control our geometry?

So to do that, I'm going to use a define a variable. I'm going to call this existing slope. So we can give the variables a name. I'm going to call it Type Double.

And the formula here, this is actually using the Subassembly Compose API. the Help on it is really comprehensive. It's really good. So hit F1, by all means, and just start looking at it. It's AP1 dot slope 2, open bracket, quote, AP2.

Let's get that. That should, theoretically, go away. Nope. That formula there is just going to go and get the slope between those two points.

And when you're actually driving that slope, these two AP1 points are actually sitting on target surface. So when we set it up, we need to assign the target surface. It'll just go and grab those points for us.

And I'm going to show you how we can now apply that. Better hook up my point here. SA.IsLayout, this is just another quick one. And if that equals true, SA.IsLayout is really saying, what's it going to look like when I put my subassembly into model space? So I always like to put one of these at the top of most of them. Just so I can control the final look of the subassembly.

If it's false, we're just going to output that value, called Out Lane Slope. It's going to push that value out. And that's really all there is to this one. But it's really easy and really good to use.

So we'll jump into Civil 3D now. Make sure I got the right drawing. And we'll start to look at how we can build out this ramp.

Now this drawing here-- actually I'm going to just pull this across to here. Everyone see that all right? Yeah.

We have our through lane here. It's actually got super elevation applied to it. You can see we've got some super elevation values down here.

I've got my exit ramp control coming out here. And I've already built out a lot of this, because a lot of it's just basic corridor modeling. The tricky part is through here, where we're going to be rolling out super elevation through a widening area with multiple base lines.

So a few ways we can go about this. I've already built out a temporary planes model here. Does everyone work with auxiliary corridors and temporary planes doing it this way?

The concept behind it is, you build up these temporary planes. This is just two generic links that are using the super elevation values. I'm creating a working surface. And all I'm doing is creating a surface in there that's linked back to the master alignment.

What I'm going to do is drive the geometry of this exit ramp control here by projecting it onto that surface. So this is my MC30 control at the moment. I've got my existing program profile. This is the MC10 line that's being projected onto that view.

Now I'm just going to turn on the surface in here, the temporary plane surface. If I hit apply and OK, you could see, that is our temporary plane surface running through there. So you can see our super elevation is actually rolling between negative 3% and positive 3% through that area.

All I need to do now is actually start designing off one of these points here as I exit the gore area, once I get past the nose. So I'm going to turn on my design control as well, just in the interest of time. So should my alignment move at all, this purple line you see here is going to move and follow it as well. So all I need to do then is just pick out my exit ramp string and just adjust it accordingly.

So back to the corridor model, I'm going to look at-- I've already got a section in here. I'm going to use the MC30 base line to extract levels from the through road super elevation. First though, I'm just going to look at this taper that we're looking at here.

Now I'm not going to use a custom subassembly for that. I'm going to use what we call a number transform. And this was built into ANZ country kit earlier this year in 2016. So coming to our subassemblies, I'm going to use this thing called the Exit Ramp Diverge Taper. This is just going to show some of the flexibility of parameter referencing and how we can get some transitioning on, not just slopes, but pavements as well.

So you can see here, I've got my two through lanes. Let me just drop the scale on that. It's gets a little cluttered. That's my exit ramp pavement. And that's my shoulder.

What I want to do is transition from-- there's my two through lanes with my shoulder. I want to transition from here out to here. So to do that I need to actually insert this thing called a number transform. Now all this is going to do, if I look at the parameter here, it's going to give me value 1, value 2, and a transform type.

I'm going to start at 0 offset. I'm going to finish at 3 1/2. And I'm going to insert it just after that second through lane pavement. Now it looks a little bit odd. But all we need to do is come into our assembly properties. And this number transform, I like to give it a name. So I'm going to call it Widen Value [? zero ?] three and a half linear.

Now I need to make sure that my actual land ramp configuration is going to inherit the values of that transitioning number. So my width, currently set to 1 1/2 meters, I'm going to override it with that output value.

So I'll show you what this does when we actually apply it. So I'm going to select this. I'm going to add the region into the corridor. And I'm just going to put it in that range there. And it's the Exit Ramp Diverge Taper. Now I'm going to put my final existing ground. And I don't actually need to fill in any of these.

So you can see what's happening there. That lane that was 1 1/2 meters wide is actually transitioning from zero over here-- move that across-- up to 3 1/2 meters there. The great thing about this is, because it's a region, I can see that's actually too wide. If I need to change that or move it, I just simply do that. And my taper changes. So we can apply these sorts of ranges to practically any subassembly feature within any subassembly within Civil 3D.

So I'm just going to come into my corridor properties and turn on my second region. So this is actually a-- you can see this one's actually being built out specifically to use line marking as well as solid pavements. So what I need to do now is just add this final piece through here.

If I just come up and show my sections, you can see what's going on through here. I always like my section string. So we're at negative 3% through here at the moment. If I run this through, you can see we're actually starting to develop the super elevation through this area.

Now to try and match MC30's super elevation to that value and get it to line up exactly, it's going to near impossible. So what I'm going to do is actually use the values of these temporary planes and that slope projection tool to actually drive the slopes through that curve.

So that's what we're using this here. I've already built out the two components. This here is the-- I'll just [INAUDIBLE] that back. This is the slope projection tool that I mentioned earlier. I haven't actually hooked it up with the parameter referencing. So up In our assembly properties-- that's the parameter referencing, sorry-- that's the slope projection tool that's currently used. At the moment it's sampling two points, one meter, zero, so it's sampling it on the baseline. And the sample point offset one meter away.

I just need the shoulder here. I need its default slope to inherit those properties. So I'm going to take the lane slope of that. And down here on the right hand side, I need to do it again. So, take the width-- sorry, take this slope. And take that slope value from the previous section.

Is anyone using parameter referencing here at the moment? The rule with parameter referencing is you need to have this slope can only inherit values from subassemblies that are higher up in the hierarchy. So if you put it below, it will not pick up those values. And you cannot select them. That's the only real rule to apply there.

So with this, I'm going to add another region into this corridor, which is my MC30. I'm going to use this exit ramp section. I'm just going to use this alignment here. I'm just going to run out-- so you can see there, I've got a little annotation point there. That's what I'm going to use to carry my super elevation on into the exit ramp, once I reach that point.

Exit ramp at gore. Now my batter transition, I'm just going to batter to existing ground. The only thing we need to take care of in here is, obviously I've set up the slope projection. But it needs a surface to drive the levels from. In this case, it's going to use the temp planes model that I've generated underneath. That temp planes model is the one you can see here over on the right, this big, this red line that's following through. So it's going to pick up the levels on the surface there and push through.

And I just need to change that one there. Because I'm picking up another string. Select my layer.

So you can see it's pushed all the geometry through there. I'll add it to the section here. Let me just pop that on. MC30 exit ramp, and I'm going to make sure it's-- I like to annotate it at the actual cut points.

So you can see, just by taking those levels through there, if I come back through here, you can see it's actually projecting through. There's my temporary plane surface. It's actually picking up the levels on that surface and actually driving the geometry through there

So any changes I make to this alignment now, it's going to be fed through and automatically update. So I don't have to bother recalculating my super elevation through that area

Clear as mud? There's detailed descriptions in the document. I'm sorry if I'm going through quickly at the moment.

OK, we'll head back to the slide show. This is just some of the examples of the number transform subassembly that I'll use first. I say it's a really powerful tool. I highly recommend using it. You can get some really cool results out of it. I only use the linear one up at the top there. But as you can see you get parabolic out, parabolic in, reverse parabolics. You can control practically any kind of curvature through those transitioning regions.

So we're going to move into Exercise 2, which are batter slopes and transitions. This is where we're going to take the concept of transitioning. We're going to explore the formula used to actually generate the transitioning code. And what we're going to do is we're going to build up a batter slope configuration that can--

We're going to add some decisions in Subassembly Composer. So we're going to determine first, are we in cut? Or are we in fill? But not only that, we're going to add additional conditions to determine are we in shallow fill or are we in deep fill? And we're going to adjust our day lighting of sub grade accordingly.

It sounds pretty complex. But it's actually not too bad. Typically when I like to model my roadways-- now you can see the transition. You can already starting to see what we can do with it. When you are traditionally modeling a roadway, it's actually rather-- the roadway component itself is the easy part. Yeah, you've only got a handful of regions that you can be using throughout the entire process.

Everything that's complex happens from the hinge point to the batter point. So I don't know how it's done here in America. But in Australia, we do a lot of transitioning. We have two to ones, four to ones, five to ones, depending on the conditions we're in. We could use civil 3D's stock daylighting subassemblies.

We could use targets. But what happens when your alignment moves? Your targets become obsolete. How do you know if you're getting exactly two to one? How do you know if you're getting exactly four to one?

So the subassembly we're going to build out here is actually going to give us complete control of not only the values, but where we can actually place them. And it's going to break the model up into a much more manageable components, and I'll show you how we can do that through the use of a linked corridor.

So this is a quick look at the batter transition subassembly. You can see, we've got the slope running down here. This is a high fill situation. We've got a depth parameter that we're going to be adopting. And we're going to have a slope on the road. And we're going to apply some automatic daylighting of subgrade.

So we're going to dive back into Subassembly Composer for a brief moment. And we're just going to look at some of the formulas.

OK, once again, for the input-output parameters, we've got Slope 1 which is the start transition, and Slope 2, which is the final transition. You can see here. There's not many parameters involved. But this thing does an awful lot in terms of giving you control and flexibility over the transitions.

The slope of the road, that the slope of our subgrade. I could be a bit clever with that. I mean, you could make it actually follow the super elevation of the road just by using a super elevation parameter. I was a bit lazy in this case. It works.

So the first thing we're going to do, we have an AP1, which is our auxiliary point sitting on the surface. And we have this delta slope variable that we're declaring. This value at the moment, we need to get really just the delta between what's the difference point Slope 1 and Slope two? It's just going to form part of the final calculation.

So that's just going to be Slope 2, which is this value over here, minus Slope 1. Once again, we've got the subassembly is layout equals true. Everything here you see cutting off to the left from the decision tree, that's all going to-- if I come to layout mode up here and fit to screen, that's really how it's going to look when I place it into model space. That's all it is.

If the layout is false, we're going to come out here and create-- we're going to change this delta slope value to calculate the actual final transition value at a specific baseline station. So to do that, we've defined the variable. Now we're just going to set that variable value. We're going to basically reset it.

So this variable-- just need to first connect that in. And it's picking up the delta slope. So we're going to change it. So this is the magic formula, as I like to call it. Cause when I found this, it just opened Civil 3D up to me completely. It just completely changed everything.

Double the open bracket, this is the subassembly API. Once again, baseline, being your baseline, dot station. So this is the parent station value. Minus baseline dot region start. I'm not expecting you to remember this. It's all in the documentation. I'm just typing it out to remember myself. Baseline dot region end minus baseline dot region start. Close bracket, close bracket.

So all that's doing is saying, the current baseline station, the distance from the baseline station from the start of the region over the entire length of the region. It's going to give us a percentage between 0 and 1.

And then all we're going to do is multiply that value times the delta slope. OK, so then we feed that into the new point here, Point 1. Need to come up to my roadway mode. So there's Point 1 sitting on my new-- just sitting above AP1. You can see here we have a target surface parameter There is fill. There is cut.

So the first of our decisions in here-- all we're saying at this point here is-- you can see this formula down here, AP1.Y, which is here, basically the zed value. So is AP1.Y greater than this point here at our hinge point? If the answer is true, we go into cut, which is just over this side here, where we're going to daylight to existing surface.

Now you can see here, nothing's happened. The condition is true, but it's not happening. When you're doing these sorts of formulas, you have to actually bypass the calculation just in order to get a better visual look when you're designing this. So I'm just going to bypass it temporarily. And you can see now that cut situation is true.

If I come down here, obviously if it's false, we're going to head into fill. And we're going to head down into this component down here. We're branching off. So you see here, there's the target surface. We've got out depth, our slope, and our auxiliary point. So we're actually intersecting. This is going to be our subgrade daylighting.

Now obviously, if we're in shallow fill, we can't obviously go and create a point out there. So we have to treat it slightly differently. So I'm going to drag in another decision here. And it seems to actually automatically connect up somewhere for some reason.

And all we're going to do is add another decision. Are we In shallow fill? Or are we in deep fill? So to do that is AP3 going to be deeper than P2. So they're the two parameters we need to look at.

So in the decision here, we just need to say is AP3.Y going to be less than Point2.Y. And if it's false-- I always like to annotate these-- we're in high fill. And if it's true, we're in shallow.

So if it's true, we're in shallow. And we come out here. So let me just drag that out. Oop, let me just connect it up first. So all we're doing in the shallow fill is taking down our depth, boxing out, and just dropping a line straight from the intersection point [INAUDIBLE].

If it's false, and we're in high fill, say somewhere down here, we're just going to use a few intersection point tools here just to create a new point, create some links, create some shapes. So what we're got now is pretty robust batter slope tool that's completely configurable. So within these parameters, we also have point code, link codes, that the user can actually enter their own.

So now we're going to apply it in Civil 3D. And we're going to use the concept of a linked corridor. And once again, this is one of those eureka moments when I was playing around with it. I just thought this is awesome. So what we've got here is a road alignment. We've got a road here. that's just using one simple subassembly.

It's just one region from start to finish. It's got conditional horizontal targets. So if we find the target, we're going to put in what we call an SO type drain in Australia. This is just a dish drain, a meter wide 200 mils deep, collects a bucket load of water.

I'll show you briefly what this subassembly does. This is using-- just go at control one. If I didn't like that type of kerb, I've got a list here that I've already created some predefined standards from our libraries. Users don't need to change it. They don't need to muck around with it. They just select the one they want from the list, and away they go.

If the target isn't found, effectively we're in fill. I'm going to put in a standard fill situation. That is actually going to be controlled by standard AutoCAD poly lines. So, yeah, that's this roadway here. What I'm going to do first is I'm going to actually fix up the subassembly and just add it to the list.

I've already got a bunch of them here. I've got my five to one. I've got my two to one. This is my transition five to one to two to one. What I'm going to do is I'm going to introduce the concept of a subsidiary string. Has anyone actually used invisible links before? Yep, a couple? Cool.

So what we're going to do is add a generic link, an invisible link. I'm just going to call it the point code EH, because we use two string labeling conventions. We're a bit restrictive on that. I'm just going to add it to this point here. So you can see it's just created an invisible link. That's going to be the hinge point where we're going to start our new corridor off the hinge point of the main line corridor.

And I'm going to add a AU2015, the batter transition subassembly. I'm just going to hook it onto that point there. I can come in here and say I want to two to one to five to one, which is actually what I want to do. If I want to make it 10 to 1, I could do it that way. So we can plug in whatever values we want.

So that was two to five. So now when it comes to modeling-- just pull this across. How good is it, we can actually move view ports now? Man, I screamed about that for years. What we're going to do now is we're going to create a link feature line on this hinge point.

It runs the whole length. And we're going to link it, make it dynamic to the corridor. So any changes we make to the corridor are going to be rippled through to the batter slopes. So from feature line, credit line from a corridor-- I'm going to give this a name, MC10 LHS Hinge. Always good practice to do that, but I always keep forgetting. I'm going to use the current layer. And I'm going to turn off smoothing. I don't want it automatically smooth. I want it to actually match the facets of the alignment.

Make sure we create a dynamic link. That's critical. So there's our auto corridor feature line. So what we're going to do now is add to the-- I've already generated [INAUDIBLE] the corridor off here. I'm going to come and select it. I'm going to add a region. So I'm just going to start it from here. I'll run it through to about-- that looks good.

I'm just going to do a simple left hand side two to one batter slope. OK, existing ground, that's our final daylight surface. These two here are substrings. So all we're going to do here is use the feature lines that we've just set up, the left hand side hinge. I'll do that for both horizontal and vertical. And I'll Now select it from the drawing.

OK. So what we've got now is a two to one batter slope running the entire way through, linked onto that corridor hinge line. The great thing about this is, it's fast. So I can leave my roadway as is. And all I've got to do is must move my grips and start to drag them around.

Now what I want to do, I can see there's my cut fill line. I want to make it five to one through there. I want to just sort of roll it back and then roll it back up into steep [INAUDIBLE], once we reach a certain depth.

So to do that, standard Civil 3D tools. I'm going to split the region, say between there and here. I'm going to come into my region properties and just swap that out from LHS2 to LHS5. Done.

So you can see there, that looks pretty wonky. There's no way any contractor is going to want to see a model like that. Contractors these days, they want everything down to the nearest cubic meter. So that's why modeling is actually becoming so much more critical, especially in bin workflows.

So what I'm going to do is split this region again, split it between say there, yep. And same approach, region properties. This one I'm going to go from two to one to five to one. As soon as I go OK, you can see that there's the transition between two to one and five to one.

Now you can see there, I'm outside the boundary-- let me just turn this on-- big fat red line, outside the boundary, no good. How do we control that? We pick up the grips and we move it.

So we've got complete control over that. You can see how fast that's updating. So we don't have to regenerate the corridor every single time. We're only taking care of that one component. That's the part that you're going to be doing most of your work in.

You can see here as well, there's my SO drain. It's actually finishing in a cut. Obviously that won't work. It's not going to drain out. We need to tail it out. So in this case, I'm going to take this and just extend it beyond my cut fill line. Now I'm going to regenerate my MC10 main line.

You can see now, I've actually pushed that out. It's obviously out of date now, because that linked feature line affects what's going on here. Just rebuild that. And we're done.

I can do the same on this side. I'm just going to transition it once again between five to one and two to one. So once again, split region. The good thing is, I'll show you another good way to do this. Region properties, and this is going from five to two.

So once again, grip drag. You could come into your corridor properties and enter property changes. But, honestly, this is just so I quick, it amazes me. What I can do now, I'm back to two to one here. If I want to go two to one to five to one again, I could drag it across and keep splitting. But to be honest, a quicker way I find is just grab the corridor, copy a region. There's my tow to one to five to one. Run it between there and there, done.

If I want to do it again, there's my five to one. Copy, paste, done. So once it's all set up and in place, you're good to go. You're firing.

Just to show how it looks from a perspective view, I'm going to risk it here and go orbit. It didn't crash, yeah. Yes, people have done that. Haven't they? So we'll just sort of pan down here. You can sort of see how it looks. So there's our five to one sort of transitioning back in.

You can see it's really smooth. It looks great. We've even got our daylighting of subgrade through there as well. So volumes, no problems.

Anyone seen that before? Does it make sense? Yeah. I liked it. I thought it was really good. I've actually shown a lot of people in Australia this technique, and they really like it. It's saving them a lot of time.

So just going back to the slide show, there's the formula there. It's just a little basic description on how it all works. Don't really need to know how it works. If you've got the formula there, you can just repeat it over and over again. And you'll be right.

Just a nice shaded view. Looks pretty.

OK, we're halfway. So what we're going to do now is take the concept that we've just looked at with the transitioning, and we're just going to take it up an extra step now. So we've got a transition from point A to point B across the region. What we're going to do now is take a bit more control over that.

Do people here model pram ramps and kerb laybacks using feature lines? Sorry?

AUDIENCE: [INAUDIBLE].

ANDREW MILFORD: Pram ramps? Sorry, am I speaking too fast?

AUDIENCE: No.

ANDREW MILFORD: Must be my accent. So yeah, kerbs and pram ramps, all we're going to do is take the concept of that transitioning we looked at before and we're just going to apply it, almost mirror it, over each end of the corridor region.

And so we'll jump in and have a quick look at this. We're going to use the exact same modeling techniques as we just saw then with a linked corridor. So we can actually just move along and place kerb laybacks or pram ramps wherever we want.

This is a typical pram ramp detail that we'll be looking at. Once again, RMS-- I don't think I explained that before. That's the Roads and Maritime Services. That's a state government authority for New South Wales in Australia. So these are the guys that call the shots. So we've got to do what they say.

So we're going to look at this top left corner here. So effectively our region is going to start about here and finish about here. And we're going to transition up at a nominated offset, or a nominated distance, which we're going to let the user configure as well.

And then we're going to provide a full width for x amount of distance. And then transition it back in at the other end. And it's going to be all dynamic. It's going to be all built as part of the corridor.

This is just a quick example on how it looks. And you can see, it's not that complex. I've seen some of the standard subassemblies that ship with Civil 3D. And they just blow my mind. I mean, I like to keep things simple. But it does an awful lot. It's pretty handy.

So we'll just jump into-- back to the subassembly, pram ramp. OK, once again, we got versioning. This one's got a few more parameters going for it. We've got, effectively, three links.

So we've got our gutter line. I've got to get used to the terminology. We call it the face of kerb. Then we're going to have a top and a back string. So this string you're seeing here at the moment, currently in, it's our face of kerb. It's basically the dish that collects the water.