Making Revit Views and Sheet Layouts in Dynamo

Ian Keough has mixed the cauldron and made some excellent new Dynamo functionality that I think you will really like.  Essentially, we now have lots of new view creation tools, including a node that lays out and packs automatically created views on sheets.  The result is that you can derive perpendicular views from model elements to automate flat layout.  Here is an example that Ian put together:

While there are a lot of directions I think people can take this, fabrication  is definitely one.  But I think this is significantly different than the general method of actually drawing new geometry to create cut sheets, and much more BIMy.  

Very curious to get your reactions to the new tools,  what else can you do with them?   

You can get at it from the fresh baked builds here (scroll to the bottom for the latest):
as it is not yet in the “last stable” build. 

If you download the most recent builds, also download these files and have a look at the workflow shown above.  Keep in mind, you have to use Revit, as there are no Sheets in Vasari.


Surface Remixing with Dynamo

Buildz is very pleased to Welcome Andreas Dieckmann for this guest post.  I met Andreas in Spring of 2012 at the WoodStEx Autodesk European Student Experts conference in Spain.  This meeting was a exhausting and jittery time (the conference was sponsored by Redbull) and I had a pretty solid case of jetlag.  A handful of people also got food poisoning, so that was fun.  The students were fantastic, engaged and ready to learn, and Andreas was presenting these meticulous matrices of divide and repeat functionalities that blew me away.  Since then we have collaborated on presentations and been sharing work and ideas around parametrics, building technology, and teaching.  Andreas teaches BIM and Parametric Design as the Chair for Computer Aided Architectural Design (CAAD) at RWTH Aachen University / Germany.

Surface Remixing with Dynamo
Last year, I had the privilege and the pleasure to teach an AU2012 class together with Zach called "Echo Chamber: Complex Parametric Arrays in Autodesk Revit" (http://au.autodesk.com/au-online/classes-on-demand/class-catalog/2012/autodesk-revit-for-architects/echo-chamber-complex-parametric-arrays-in-autodesk-revit). At the very end of the class Zach showed a method to map the distance between two arrays of nodes of two separate divided surfaces on the second divided surfaces and create an entirely new form in the process. To make this work, he made use of an adaptive component, some reporting parameters, some formulas and the divide/repeat functionality introduced in Revit 2013:

And here's an image of the resulting form when you map a torus onto a sphere (BTW: My boss's first reaction was: "Oh nice, now we can also make turds with Revit!"):

Enter Dynamo. I had been following the project's progress ever since Zach posted about it in 2011 (http://buildz.blogspot.de/2011/10/dynamo-hum.html). In early summer this year, I started working with Dynamo (again) on a regular basis when a bug was fixed that had previously made it rather hard to work with on a computer with German regional settings. I was thoroughly impressed with all the new functionality that had been added to it in a relatively short amount of time, so I decided I would create some examples for my upcoming parametrics class in fall. This is one of them.

Dynamo has a lot of nodes that allow you to work with XYZ coordinates. In order to learn more about how all of these XYZ nodes interact with each other I set out to recreate Zach's AU2012 TurdMakerTM without the use of smart (i.e. reporting parameters & formulas) adaptive components. I ended up not only doing that, but also creating some more functionality because it was just a matter of adding a few extra nodes. Here's an overview of what I came up with:

The basic idea of this definition is to select two faces, go through some additional settings and then have Dynamo create a new surface for you based on the inputs, hence surface remixing. Although I am not a big fan of the term “form finding”, this really is just a tool for form exploration (and maybe for learning a little something about Dynamo in the process).

So how does it work? First we need XYZs, so I built a custom node called XYZGridFromFace to create coordinates from both selected faces – it also provides us with the surface normals at those coordinates (which we might need later on):

We can then perform some basic operations on those XYZs: Invert the XYZs if we so choose – which is basically a point reflection through (0,0,0) – and scale them, i.e. increase the magnitude of one surface's XYZs versus the other surface's XYZs to make one surface more dominant than the other.

When combining the XYZs of both faces, we can choose between four different methods:
a) Add the XYZs of face #2 to those of face #1
b) Subtract the XYZs of face #2 from those of face #1
c) Use the cross-product of both XYZs
d) Measure the distance between a set of points on both faces and use it to drive the offset of new XYZs over the normals of face#2 (and that actually is Zach's original method described above)
To accommodate all of these options I used a set of nested IF nodes and Boolean switches – I hope that at some point in Dynamo's future this can be solved more elegantly with a switch that allows you to select several (custom) options.

As I had previously tried to recreate the functionality of the Parameter Values From Image plugin in Dynamo (http://autodeskvasari.com/forum/topics/parameter-values-from-image-for-dynamo), I thought I might as well include the option to further deform the resulting face based on an image in this definition as well. This includes the ability to invert and mirror (horizontally and vertically) the image data. Apart from all the above, there are also some other settings available like an overall scale for the resulting form and the ability to move the form in X, Y and Z direction.

Finally, the resulting XYZs are fed into a Watch 3D node. Once we've found some settings that we like, we can connect it to either one of two series of nodes, one of which will create a lofted form while the other will create quadrilateral adaptive components. The latter option should always work, but not every resulting form can be lofted as the resulting geometry might self-intersect. When the geometry cannot be created, try changing the loft direction (U vs. V) – sometimes it helps.

To wrap this up, here are some images of various resulting forms based on Zach's original setup (sphere & torus). As you can see, turds come in all shapes and sizes. ;-)

Download the full dataset here.

Watch this short video to see how to operate the files

Andreas Dieckmann teaches BIM and Parametric Design at the Chair for Computer Aided Architectural Design (CAAD) at RWTH Aachen University / Germany. You can find CAAD on Facebook (https://www.facebook.com/pages/CAAD/252048391538317) as well as on YouTube (http://www.youtube.com/user/caadtv).


Sequences and Ranges in Dynamo

Usually when a person is making stuff in Dynamo, they aren't making just one or 2 things.  More often than not, you are actually making a ton of stuff, series or related ranges of items.  This can require inputting lists of numbers to position and arrange your stuff.

Some standard nodes exist for this, namely Number Range and Number Sequence

But you can also insert ranges and sequences directly into certain nodes following this syntax

0..4 will yield  0,1,2,3,4

0..4..2 will yield 0,2,4

0..1..#5 will yield 0, 0.25, 0.5, 0.75, 1

Start..#List Length..Interval
0..#4..10 will yield 0,10,20,30

Additionally, you can insert variables within the ranges and sequences like 0..#a..50


Dynamo 0.6 Released

Dynamo 0.6.0 takes a big step into the future with the ability to easily share functionality between users. Dynamo already had the ability to create custom nodes by collapsing collections of functions into single nodes.  This allows users to create their own libraries of repeated or more generic workflows that they do not want to rebuild over and over.  The Package Manager enables users to share these repeatable workflows with others, and do it directly through the application.

Here's the Package Manger in action:

So, what kind of things can you find on the Package Manager?  One example, Andreas Dieckmann has added a "Highest Value" custom node, which iterates through a list of numbers and extracts the highest one
It's not a complicated custom node, but it is elegant, and now you don't have to make it yourself

Another from Andreas takes a small Python script and embeds it in a custom node to Sum a list:

With recursion and other higher level computation that is allowed through custom nodes, advanced users can also significantly enhance the "out-of-the-box" functionality.  Stephen Elliot's Serpinski Arrowhead creates a fractal design that might not be buildable by the casual Dynamo user.

Take a look around.  I have some basic form generators (look for "Box" and "Cylinder"), and a couple tools for organizing point collections into Quadrilateral sets ("Quads from Rectangular Grid"), and a replacement for the old Parameters from an Image addin ("Parameters from Image").  More to come, hopefully from you too!

Moving forward, we have the infrastructure in place for users to subscribe to nodes or authors to find updates to Custom Nodes, as well as the ability to see how popular nodes are and to vote up or down a particular functionality.  We also hope to expand the Package Manager to allow for the distribution of more complex libraries and references to build out the functionality of Dynamo.

Download the latest build and look in the Packages dropdown menu to get started.

More improvements in Dynamo 0.6
- Can now use material parameters (Get Material by Name node)
- Intersection nodes return more granular results
- Adaptive Component By Face and By Curve nodes
- Default values for some nodes
- Root finding nodes
- Convert anything to a String (To String node)
- Is XYZ Zero Length & XYZ Length nodes
- New Slice List node (get a sublist from a given list)
- Custom nodes differentiated from built in nodes in search
- Domain node (specify a domain by Min and Max)
- For Each node
- Multithreading nodes
- Nodes to perform explicit lacing (Lace Shortest, Longest, Cartesian)
- Divided Surface Selection node (returns a list of hosted components)
- Add basic instrumentation infrastructure to report usage
- Allow writing a range of data to excel
- Face Face intersection node
- Default value capability for ports

For the full list of Fixes and Improvements, see the ReadMe for 0.6


David Wood on Dynamo

For those of you who are looking at visual programming using Dynamo, please take the time to visit David Wood's very awesome bimwood blog (formerly the Revitator).

He is covering some very good territory around applications and concepts of visual programming in BIM in language that should be accessible to all.

Thanks David!