As amazing as Autodesk Revit is for modeling and documenting a building, there is no question of the fact that it’s not exactly the strongest when it comes to animation. in this tutorial, we’ll go over a few techniques within Dynamo that will allow us to animate “almost” anything in Revit. now I should also mention the fact that not everything is programmatically adjustable in Revit but the general convention is that if you can edit something in the user interface, then you’ll probably be able to animate it (of course there might be exceptions to this; hence the word “almost” in the title of this blog post).
If all you wanna do is to create a simple walk-through by animating the camera and it’s target, then it would be foolish not to use the builtin walk-through creation tools offered by Revit. but if you’re after something more specific with a greater level of control of the parameters of every family instance, then this tutorial is for you. I should also point out that the methodology described here is very much inspired by a custom Dynamo package called Dynanimator which is developed by BadMonkeysTeam. although you do not need to install the package in order to be able to follow along with this tutorial, keep in mind that the general approach that’s explained here is borrowed from Dynanimator and is modified to suit our needs. feel free to download and install this excellent package and experiment with it. now without further ado, let us get started.
Steps:
creation of the animation_function node.
Creation of the animation node.
assembling the graph and feeding in the required information.
Step 1: “animation_function” node
this is the heart of the code, this is where we define our rules and every time that we wish to re-purpose our graph to animate something else, we’ll do it here. the big idea is that, we’ll lay the ground work of the changes that we’ll be making to the model here with a simple twist, we want the changes to happen one after the other for every single iteration (frame). so the general order of execution is as follows:
read which iteration we’re at.
read the input information.
execute change number 1.
execute change number 2.
execute change number 3, 4 etc….
and finally execute the last command: exporting the frame to a user-defined directory with proper naming.
the changes can be anything, this is exactly why this method is so useful, we have so much freedom over what is required to be animated and how. please keep in mind that the changes should be governed by the “iteration” value since we’re trying to generate the frames of an animation. for the purposes of this demonstration, we’ll be animating “object rotation” but the same principles with minor tweaks and changes can be applied to animate other aspect of the model, here is the graph for animation_function.dyf:
Change #1: rotating the instance based on this particular time-step. we determine the angle of each iteration based on a few factors (total number of iterations, current step and user defined angle). this is the formula: 1 / iteration * step * angle.
Final command: exporting the frame: here we use String.Concat to assemble a string variable using some of our input nodes, notice that the “step” input node is used to make the names varied and thus prevent overwriting of files during the export process. this also makes it easy to find particular frames later on.
We plug the last node of every action into a Transaction.End node to close their transactions. we finally feed those into a Function Compose node.
Step 2: “animation” node
there is really nothing special about this node, all that it ever does, is prepare the input information and iteratively run a given function (animation function node) for a total of n times. with n being the user-defined number of iteration or in other words the total number of frames in the whole animation. here is the graph for the custom node animation.dyf:
Here we place our animation_function custom node that we just created. notice how every slot has a corresponding input assigned to it except for “step”. leaving this argument unassigned turns our node into a function which can then be applied to a range of values using a List.Map node.
Outputting the results using an Output node.
Congratulations! our custom Dynamo node is now finished! all that is left to do is to feed in the required input arguments and click enter. a series of .png files will be exported to our defined directory which can then be processed into a video file quite easily:
using the custom node “animation” that we just created.Rotation animation (demonstrated in this post)animating family parameters
with the latest technological advancements in the field of smart building and kinetic architecture, today we’re able to design and document and erect buildings that are not only aware of their surrounding climactic and geographical context, but are in fact able to analyze and intelligently respond to those factors by a variety of ways, including physical modification of their individual architectural components for higher levels of optimization.
one such example of a kinetic building is the Kiefer Technic showroom located in Bad Gleichenberg, Austria. apart from the aesthetically interesting and visually pleasing collective form of the external parametric shading devices, the building’s smart facade also play a tremendous role in regulating the amount of solar radiation that the building is exposed to throughout the day, and all year long. this kind of design allows for higher flexibility during the building’s design phase, as well as providing well studied and deeply optimized solutions to the natural lighting and thermal comfort design problems. another extremely well known example of kinetic architecture is Al-Bahar Towers in Abu dhabi, UAE. in this blog post we’re going to explore the idea of kinetic architectural elements inside of Revit by creating a solar responsive facade that takes Geo-location, time and date information from our Revit model and adjusts itself in accordance to these parameters. so without further ado, let’s get started.
Kiefer Technic Showroom located in Bad Gleichenberg, Austria. it’s dynamic facade can be changed and altered in accordance with the external weather conditions, as well as individual user preference.
Required steps:
Modeling the kinetic facade units as an adaptive component inside of Revit.
Applying the facade elements to the building mass using Dynamo and Lunchbox.
Collecting Geo-Location , date and time data from Revit and importing it into Dynamo.
Using the ladybug package to calculate the sun path and sun’s angle of incidence on our building.
Extracting orientation data from each instance of our panels family.
Adjusting the adaptive component’s “openness” value based on it’s orientation and it’s angle with the sun.
ordinary adaptive components not corresponding to the sun…Result: Smart panels that adjust according to sun’s position…
Step 1: modeling the adaptive component
We’ll start by creating the adaptive component family. the reason for choosing an adaptive family as opposed to a curtain panel family is that generally, adaptive families allow for more advanced and complex geometry, since they’re not dependent on a planar curtain wall to be deployed, the user can deploy them however they want with four clicks (once for every adaptive point). but in our case we’ll use Dynamo to programmatically place our components so it’s even easier. creating families in Revit is a rather wide topic on it’s own and well outside of the scope of this tutorial, so the reader is expected to have a basic knowledge of how adaptive families are created and how they’re controlled parametrically . with that being said, let’s get started. once we’re in the adaptive component modeling environment, proceed with creating the skeleton using a collection of points and reference lines as demonstrated in the figure bellow.
skeleton model for the adaptive component.
Now is a good time to introduce parameters, and the way they’re involved in the behavior of this family:
the parameters which drive this adaptive component and their formulae.
So we have about 7 vital parameters ( apart from aesthetic ones such as thickness and glass material). now we’ll understand each parameter’s purpose as well as their formula.
Direction line Length: this line exists for data inquiry purposes only (we’ll get the panels’ orientation data from this). the length is irrelevant we’re only interested in the line’s direction, thus a value of 10mm is sufficient in our case.
Offset: this parameter controls the height of the joint. it’s directly related to how “opened” the panel is. it’s calculated using the following formula: (length of the panel / 4) * openedRaw.
Report (Length of the panel): this is a reporting parameter, meaning that it does not directly affect the family. rather, it provides us with important dimension information that will be used to calculate the other parameters. this particular reporting parameter provides the total length of the panels.
Fold Parameter: this controls the position of the folding edge along the reference lines. it has the following formula: 0.5 * (1 – openedRaw)
fold half: this is the position of the elbow along the reference curves, it’s always half the amount of Fold Parameter. it has the following formula: Fold parameter / 2.
opened: this is a parameter between 0 and 100 that governs how “open” the panels is. it has no formula since this is the user input.
openedRaw: this is the raw data that will be used in the other formulae, in other words this is the mapped version of Opened. it’s calculated using this formula: (opened – 0) / (100 – 0) * (0.75 – 0) +0(the zeros are for demonstration purposes, but please do keep in mind that (0 to 100) is the range of user input and (0 to 0.75) is the allowed input range of the panels. I have mapped it in order to further streamline the process)
Now that we have all the parameters set correctly, the panel should be able to respond to user input ( Opened parameter):
Opened = 0%
Opened = 50%
Opened = 100%
Step 2: programmatically applying the panels to face
In this step, we’ll be using a custom Dynamo package called Lunchbox that mostly deals with surface tesselation. dividing a face into quads is still doable without this tool but it would take a considerable amount of time and effort. so I really recommend that you use this workflow instead:
Programmatically subdividing our surface into quads and applying our panels
Selecting the desired faces.
Creating a list out of them.
Using Panel.PanelQuad from Lunchbox to tessellate the faces with the desired U and V values.
Flattening the list with an amount of 2.
feeding that list into AdaptiveComponent.ByPoints node in order to place our panels.
Sometimes we need to shift the indices (to rotate the panels) or revers the list (to mirror the panels) based on the context.
Step 3: Collecting date, time and Geo-location data from Revit
In this stage and the next one, we’ll heavily rely on a custom set of Dynamo tools Called Ladybug. we’ll be using it to generate a sun path diagram within dynamo. this will enable us to conduct complex solar studies for our project. but before that could happen, we’ll have to extract some vital information from the model first:
Generating the location is relatively easy, all we have to do is to use a Construct Location node from Ladybug and feed the required information into it using built-in Dynamo for Revit nodes. the only problem here is that there is no readily available node to acquire the time zone. so we’ll have to resort to using some python code to do that. this is the required python script:
# Enable Python support and load DesignScript library
import clr
#not needed in this case
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
#extracting time zone information from sunSettings
sunSettings = IN[0]
timezone = sunSettings.InternalElement.TimeZone
OUT = timezone
Now that we have our location information, it’s time start working on our date and time data. for that we’ll be using a SunSettings.CurrentDateTime node. once we a have DateTime object, the rest is just a matter of extracting the right kinds of information using some more python:
# Enable Python support and load DesignScript library
import clr
#extracting the month
dateTime = IN[0]
month = dateTime.Month
OUT = month
#extracting the day
dateTime = IN[0]
day = dateTime.Day
OUT = day
#extracting the hour
dateTime = IN[0]
hour = dateTime.Hour
OUT = hour
#extracting the minute
dateTime = IN[0]
min = dateTime.Minute
OUT = min
Now we’re able to feed all of that newly acquired information into a Calculate HOY node from Ladybug and we’re ready to conduct our solar studies.
Step 4: Generating sun path and calculating sun’s angle of incident
Here we use our Location and HOY information to generate a sun path diagram using Ladybug’s Sunpath node.
We normalize the sun’s directional vector by dissolving it into it’s X and Y components and regenerating another vector with zero as it’s Z component.
Generated sun path diagram within Dynamo, we also acquired sun’s directional vector.
Step 5: Acquiring orientation data for every instance of our panel
Everything we’ve done up until now is useless if we don’t know which way our panels are facing, there are many ways to tackle this problem, finding the panel’s centroid and then extracting the normal of the original face at that point is a perfectly viable option, but I wanted something more universal, I didn’t want to deal with the surface on which our panels are hosted since that can get really laborious really fast. a better alternative is to store every panel’s orientation information in it’s geometry. remember we created a tiny 10mm geometrical line when modeling our panels? were you wondering what it’s purpose was? well, this is exactly why we created that line in the first place, to find out the panel’s orientation later on. now you might be asking why couldn’t we just process the whole geometry for every instance of the panels and use a normal vector on one of it’s forward oriented faces? well technically we could do that, but as you can imagine that would take a really long time to run, since we’d have to process a whole bunch of geometry, even those that we don’t really need. obviously this is not a very efficient way of solving this problem. therefore we’ll dive a little deeper into the Revit API in order to extract the line geometry only.
Orientation information of every panel
Prompting the user to select a single instance of the panel.
Finding the right family type for the selected element.
Acquiring every instance belonging to the selected family type.
flattening the list.
Pyhton Code: looping through every element and acquiring it’s Curve based geometry only.
Getting the start and end point of every line.
generating vectors representing the orientation of every panel using Vector.ByTwoPoints.
Here is the Python code used to extract Curve based geometry from the panels:
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
clr.AddReference("RevitAPI")
from Autodesk.Revit.DB import *
clr.AddReference("RevitNodes")
import Revit
clr.ImportExtensions(Revit.GeometryConversion)
elements = IN[0]
lines = []
for element in elements:
element = UnwrapElement(element)
opt = Options()
geo1 = element.get_Geometry(opt)
enum1 = geo1.GetEnumerator() ; enum1.MoveNext()
geo2 = enum1.Current.GetInstanceGeometry()
for obj in geo2:
if isinstance(obj, Curve):
lines.append(obj.ToProtoType())
OUT = lines
Step 6: Adjusting the “openness” parameter of every panel based on their angle of incidence with the rays of the sun
Now that we have the sun’s direction as well as the direction of every shading device, we can easily calculate the angle that they have with one another. we’ll later map this angle to the minimum and maximum values that the Opened parameter can accept (0 and 100). this way we can adjust every panel based on how much of an angle it has with the normalized vector of the sun.
calculate the angle between the sun’s directional vector and the orientation of the panels using Vector.AngleWithVector.
get the minimum and maximum angles and map the remaining values to somewhere between 0 and 100 using Math.MapTo.
edit the Opened parameter of the elements based on the values that our solar studies have generated.
Every time the user changes one of these parameters in the Revit model: location of the project, date and/or time of the day, the facade updates itself to better correspond to those changes.
Selecting Erbil, Iraq as our Project location inside of Reivt
We selected Erbil, Iraq as our project location for this example and generated results for the following hours of the day on July 22nd 2020:
7:00 am
9:30 am
12:00 pm
2:30 pm
5:00 pm
7:30 pm
As you can see It’s now extremely easy and efficient to generate different results with a few simple clicks. with this we come to the end of this blog post, I really hope that you gained something useful from this long read and that this will serve as an inspiration for you to keep on creating!
In the previous blog post, we touched upon an interesting idea by creating a parametric facade generator that had the ability to analyse an Image file and then convert it’s pixel data into a usable form. which would later be used to determine the overall look of an architectural facade. in that project we used a non-destructive approach. this means that once the code is written, the user can run the program indefinitely, as many times as they wish with a number of different image files to achieve different results. this is useful when slow and gradual fine tuning of the original design is desirable. if you haven’t read that blog post yet, I highly recommend checking it out by clicking here.
But today, we’re going to be working on a whole different project. in this blog post, I’ll walk you through the process of creating an automated Dynamo Graph that would generate a parametric facade element from a given image file. in other words the designer would “model” this parametric three dimensional form in a two dimensional photo editing environment such as Adobe Photoshop or a similar application, and then use this workflow to transform the flat image into 3d. and finally import the geometry right into Revit for visualization and further documentation. The process consists of four separate steps, and since we’re going to generate our geometry from an image file, naturally the first step is to select, analyze and prepare our bitmap related information. then we can use our newly acquired pixel data to generate an array of points that will later be used to create the final form. so with all that out of the way, lets get coding already!
Although the same results can be achieved with traditional modeling techniques, but the main advantage of using Dynamo is the fact that, once the code is written, generating different results is super fast and extremely efficient.
Step 1: data extraction
This stage includes defining a fixed number of samples that we’re going to extract from our bitmap, it ensures that the code can run smoothly on high definition image files since it eliminates the need to loop and iterate through each and every pixel. here we also implement a mechanism that allows our code to programmatically detect the aspect ratio of the image file and assign a suitable number of samples in both X and Y directions.
Acquire image width and height using Image.Dimensions.
Input node for the max amount of samples. (100 in this case).
boolean code block (W >= H) reports whether the image is portrait or landscape.
Python script: assign smaller number of samples to the shorter side of the image file.
“If”code block: assign max samples to the longer side of the image file.
Image.Pixel: extract the pixels based on the given number of samples.
we want pixel columns as opposed to rows therefore we transpose the list.
using Color.Brightness to get the brightness value of each pixel.
here is the python script used in the graph above (we could’ve just used another If node and just alternate the “true” and “false” input slots).
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
check = IN[0]
#simple if statement
if check == True:
OUT = IN[1]
else: OUT = IN[2]
Step 2: generating array of points
In this step we’ll generate an array of geometrical dynamo points using Point.ByCoordinates node, but to do that we’ll need X,Y and Z coordinates of each point (we’ll acquire those from the pixel data we generated in the previous step with the help of a few Python nodes). lastly we’ll use an additional piece of Python code to add two more points to each sub-list of points. one in the beginning and one in the end of each column to close the loop (note that these additional points are always located of the XY plane, in other words they always have a Z coordinate of zero).
Three Python code snippets, one for generating each coordinate for it’s respective point.
mapping the z values to a user defined range ( this will allow the user to control the height of the geometry).
using Point.ByCoordinate to generate the list of points.
additional Python Code to add the remaining points needed to for a closed loop.
Here is all the Python code that was used:
#Pythone code X
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
zdepth = IN[0]
filteredX = [[] for i in range(len(zdepth))]
columnNumber = 0
for column in zdepth:
for z in column:
filteredX[columnNumber].append(columnNumber)
columnNumber += 1
OUT = filteredX
#Python code Y
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
zdepth = IN[0]
filteredY = [[] for i in range(len(zdepth))]
columnNumber = 0
for column in zdepth:
zIndex = 0
for z in column:
filteredY[columnNumber].append(zIndex)
zIndex += 1
columnNumber += 1
OUT = filteredY
#Python code Z
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
zdepth = IN[0]
filteredZ = [[] for i in range(len(zdepth))]
columnNumber = 0
for column in zdepth:
for z in column:
filteredZ[columnNumber].append(z)
columnNumber += 1
OUT = filteredZ
# Python code Additional Points
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
lists = IN[0]
for pts in lists:
if pts[0].Z != 0:
pointS = Point.ByCoordinates(pts[0].X,pts[0].Y,0)
pts.insert(0,pointS)
if pts[-1].Z != 0:
pointE = Point.ByCoordinates(pts[-1].X,pts[-1].Y,0)
pts.insert(len(pts),pointE)
OUT = lists
Step 3: generating solid geometry
Now that we have the much needed list of points, the rest is just a matter of generating the relevant kinds of geometry, this is a rather painless process thanks to the amazing geometry generation tools offered by Dynamo.
Generating curves that run trough each of our point sub-lists.
joining the curves into PolyCurves.
closing the curve loop using PolyCurve.CloseWithLine.
Generating surfaces from the curve loops.
turning the surfaces into solid Geometry using Surface.Thicken.
Step 4: exporting to Revit
Now all that’s left is to export the geometry back to Revit. there are many approaches to do so, in a real world project you might wanna import the geometry in the form of a family, but in this demonstration I’ll use a simple ImportInstance.ByGeometries node for the sake of simplicity.
Removing potential problematic instances using Manage.RemoveNulls, this is a protective measure against importing errors down the line.
Importing the geometry into Revit using ImportInstance.ByGeometries.
And… we’re done! bellow are some examples designed using this very graph that we just wrote together, this was a rather long blog post but I personally had a ton of fun creating it. thank you so much for your time and I really hope that this tutorial was of some value to you. take care and keep creating!
In this blog post we’re going to use some fundamental Revit and Dynamo skills as well as a builtin Dynamo image processing library to create a workflow that converts an ordinary image into an amazing architectural facade in a matter of minuets (or even seconds depending on your hardware). we’re going to be using curtain walls and custom parametric curtain panels to model this. thus naturally creating the curtain panel family is the first step. after that we’ll learn how to use an image processing library inside of dynamo in order to extract all kinds of useful data from the image file. and last but not least, we’ll use that extracted pixel information to parametrically alter the facade in cool and interesting ways. so without further ado lets get started!
So the first step is to create the parametric curtain panel, the design and geometry for this element are rather simple since we will be placing thousands of these and we really don’t want to push our hardware too far (geometrical detail in the individual family instances is not that important anyways since each instance of this family represents a single pixel which together they create the final impression collectively).
So we’ll start by creating a new family, we will use the template “Metric Curtain Wall Panel”. now we’re good to go… open the exterior view and start by changing the distance between the reference lines (we want to have a 500mm x 500mm panel). once that is done create an extrusion. while in sketch mode, create a rectangular shape and constrain it to the existing reference lines as shown in the image bellow. then draw another rectangle within the first rectangle. we need to constrain this one using an instance parameter. add dimensions to the second rectangle as shown in the second image below, and associate those dimensions with an instance parameter. lets call this parameter “width” for now. once those steps are done, click create form. it’s a good idea to keep the extrusion end at around 100mm.
Constraining the first rectangle to the reference lines…
Constraining the inner rectangle with an instance parameter (width)…
You could also try and create another 20mm extrusion and constrain it to the inner rectangle to represent the glass but we’ll keep things simple for this demonstration. create a new architectural project and import the new family into it and we’re good to go. now that the custom panel family is complete we can move on to the next step and work on our curtain panel. for this demonstration we’ll be using a 50m x 50m curtain wall with 0.5m x 0.5m panels, effectively giving us 10,000 panels (pardon the unrealistic dimensions, this is for educational purposes only). after selecting our custom panel family as our curtain wall panels, we can move on to dynamo.
An image processing library will allow us to manipulate image files and extract valuable data from them. luckily for us, Dynamo happens to be very flexible in this regard, since it allows us to easily import .Net framework libraries and tools, we can even write custom nodes for Dynamo that use external C# libraries using Zero touch (more on this topic soon). but for the purposes of this tutorial we can use a builtin Dynamo node to extract the pixel data as shown in the graph bellow.
Extracting data from selected Image file (note that the image is 100 x 100 pixels) Click Here for high resolution.
Get the file path to the image file
Get file from file path
Read image from file
Get pixel data from image
Get brightness of each pixel
Map the values to our panel’s “width” min and max (0.02 and 0.24 in this case).
Reverse the list
The graph above should be simple enough, I trust that you can easily follow through with it. now that we have extracted pixel brightness values and stored them in a 2 dimensional list (100 lists each containing 100 pixels), we’re ready to move on to the final stage of assigning those values to the relevant panels. selecting all the panels is easy enough but we need some simple list manipulation to get the lists of panels correspond to our data from the image. the following graph does just that.
Selecting and sorting all the panels in this project (Click Here for high resolution)
Selecting the panel family type
Getting all instances of the family type (10,000)
Get the bounding box
Get it’s centroid
Python code: getting the Z coordinate
Using “GetItemAtIndex” and “Chop” nodes in conjunction with the Z and X coordinates to sort the panels.
The python code block simply loops through the list of points to get their Z coordinates. of course just like the X coordinate, Z coordinate could also be obtained easily using a builtin dynamo node, but I thought that this was a good opportunity to demonstrate the freedom that the python code block offers us. so using it is completely optional, here’s the code:
# Enable Python support and load DesignScript library
import clr
clr.AddReference('ProtoGeometry')
from Autodesk.DesignScript.Geometry import *
#creating variables to store the lists of points
pts = IN[0]
z = []
#looping through the list of points and getting their Z component
for pt in pts:
z.append(pt.Z)
#outputing a list of Z components
OUT = z
Now all that is left is to assign the values to the panels using a “SetParameterByName” node:
Hit run in dynamo and…. voilà! the facade is complete! I really hope that this tutorial was somewhat useful and that you have enjoyed reading this blog post. keep creating and don’t forget to give something back to the universe!
Done!
The image has been accurately transferred onto our facade!
CodedBIM 
