Adaptive Components


A fluid connection between Grasshopper and Revit seems to be within reach, and several computational designers in the parametric modeling community have offered powerful plugins to streamline this workflow. This post focuses on the pros and cons of using adaptive components to import Grasshopper geometry into Revit.

Chameleon appeared a few months ago and has proven to be an effective tool for adaptive components. The interface is intuitive on both the GH and Revit sides and we are yet to find any serious bugs with it. Another recent plugin is named Hummingbird (keep track of all these animals), a similar program which accesses the WhiteFeet Modeler to import adaptive components as well as Revit primitives (this has a lot of potential and will be discussed more in a future post). Take your pick, these are both great plugins.

The test case we are using is a preliminary curtain wall design for a project in our office. This expansive curtain wall plays a crucial role in how the building is perceived and experienced; and while it’s designed to minimize the formal ‘sculpting’ of the glazing, it has an irregular form due to the building geometry and program requirements. Warped surfaces create a fish-scale pattern which delaminates from a more typical curtain wall. While the early design concepts were studied in Grasshopper, we wanted the file in Revit to provide for material takeoffs and documentation. Dumb geometry won’t cut it here. We recently completed Design Development and are moving right along into CDs, where Revit/GH coordination becomes increasingly crucial. Chameleon/Hummingbird allow for a smooth transition without losing the intelligence of the model.

The wall’s complexity is defined by its grid and panel edges. We’re setting this up in grasshopper and then utilizing Revit’s adaptive component to provide detail. The Grasshopper definition remains flexible while the Revit file provides the added documentation and geometry. This is an exciting step towards having the programs complement each other, and one which helps us better understand the complexity and feasibility of our designs.


A perspective view of the design concept

But let’s not get carried away, sometimes the two programs just don’t want to get along. There will inevitably be issues with the first few attempts at importing adaptive components, but these can all be fixed with a better understanding of each program’s data sets and modeling methods. Keeping a proper point order in grasshopper is essential to having the adaptive component construct correctly. Also, adaptive components get even trickier when thickness is added to a family (now you’re dealing with extrusion directions and work planes). Here’s a quick walk through of steps we used to get the desired results:


First, we put together our curtain panel adaptive component family. This is a double skinned wall and is generated by 4 vertices. The parameters of frame profile, glazing thickness, etc. are all controlled within Revit while panel vertices are controlled within Grasshopper.


Here we are in Rhino, where we have four panels of the curtain wall. Constructed on a curved surface, 3 vertices of each panel are creating a plane while the fourth vertex is projected onto that plane, creating the fish scaling effect.


Using the brep explode battery in Grasshopper, we’ll select specifically the bounding surface on the outside of the wall.


Now that we have this surface, using Grasshopper’s sort along curve component (new to GH .9), we can sort the panel vertices along the bounding box surface. Turning on the point display shows us that we have the vertex order we’re looking for.


By toggling the Chameleon component and connecting to Revit, we have the panels imported. All done!

After getting all of our geometry into Revit, we created a sheet of diagrams for the curtain wall in order to better understand the geometry for detailing. We’ve set up a scope box to create a drawing at the major intersections of the wall, and if our Grasshopper geometry changes, we just do another import and the sheets will update accordingly.


This process is working great from Grasshopper to Revit, but the reverse could use improvement. To update adaptive component points, we’re deleting the old adaptive families and importing new ones. While Chameleon has a decent Edit Params tool, it would be equally as helpful to see an Edit Vertices tool. That way we could update the same Revit instances without creating new ones. Hummingbird also has potential for updating Revit IDs with WhiteFeet, but the plugin is still under development. Either way, hats off to the developers for putting these tools together. They’re really helping to enable our designs.

Here are a few notes which helped us with the process:


The Grasshopper panel here shows that we’re creating a tree branch for each panel and an item for each vertex. The plugins also allow for modifying instance parameters, but we don’t have any instance parameters in this case.

Back to Revit, an important step: since all of the adaptive components are extruding on custom planes, be sure to check that the adaptive component’s orientation is “orthogonal in family”. This will ensure the extrusion direction is normal to its plane.


The columns here are serrated to support he fish-scaled panels. These are constructed as adaptive components with 20 points. Just for proof of concept, the two images above show that the panel family does not need to resemble the final object whatsoever. As long as it’s constructed with the same logic, the adaptive points will shape the geometry while the family editor is strictly used to set up parameters and materials.

8 Comments

  1. Thanks a lot for sharing the information! How are you using Hummingbird in this case? I only see Chameleon exports and imports to Revit. Did you use the White Feet modeller? Are both tools complementary or is there a lot of overlaps?

  2. ekatzenstein says:

    Hi Arthur,

    Hummingbird and Chameleon are complementary here, we just went with Chameleon in the demo. From what I’ve noticed, Chameleon is a little faster on the adaptive component generation, while Hummingbird has more options for dealing with primitives. White Feet Modeler is used with Hummingbird (it uses the same code from Excel), but not Chameleon.

    -Erick

  3. Ashley Reed says:

    Thank you for the Chameleon tips. Might you be able to offer any guidance on how to include instance parameters from Grasshopper?

  4. ekatzenstein says:

    Ashley, I’d be happy to help with instance parameters, but I’ll need detail as to what you’re struggling with. Have you plugged values into the parameter input of the adaptive component battery? Make sure parameter data paths and point data paths are the same.

Leave a Comment