As Grasshopper seamlessly integrates with Rhino, there are occasions when you need to transfer geometry and data between these two tools. While Grasshopper does provide methods for such transfers, the process can often be finicky and inconsistent.

Elefront, a Grasshopper plugin, solves this by offering a range of components that standardises the way you read and write data to and from Rhino. It becomes a crucial plugin for the “Distributed Data Model” or for anyone wanting consistency in their Rhino/Grasshopper data management.

It is important to note that I have no affiliation with FrontInc, the company behind Elefront. I am solely a passionate advocate of this plugin as it provides immense value for any Grasshopper user.

Traditional Reading

Before we explore Elefront, let's take a moment to understand the native functionality for exchanging data between Rhino and Grasshopper.

To pull in Rhino data into Grasshopper, you need to use a “Container” and reference in the data that you want using the right-click menu.

While you can use this way to exchange your data, it does have its limitations. One of them is that if any changes are made in the Rhino file, you will need to re-reference your data again. This additional step can be cumbersome and error-prone, forgetting to re-reference your data can lead to errors.

Traditional Writing (Baking)

To write Grasshopper data back into Rhino, a process referred to as "baking," you can use the same right-click menu. This time you don’t need a container, you can just right-click on the objects and select the “Bake” option.

You then get a prompt to choose a layer to bake your geometry in Rhino.

The native baking works well for simple cases but it has a few caveats. Firstly, you must create the corresponding layer in Rhino before you can bake objects into it. Secondly, you cannot assign metadata to each geometry element during the baking process.

While these native methods do work in principle, the overall experience can be made more consistent and less cumbersome by leveraging the power of Elefront. Let’s take a look at how to read and bake using Elefront.

Reading with Elefront

Elefront addresses the inconvenience of manually re-referencing data by offering a range of flexible patterns for referencing Rhino geometry. These patterns provide consistent and automated ways to establish and maintain the connection between Rhino and Grasshopper.

One of the most frequently used components is the "Reference by Layer" component. This leverages the Rhino layer system to pull in any geometry that resides on a specified Rhino layer.

By leveraging Rhino layers, you are encouraged to maintain a more structured and consistent organization of layers in your Rhino file. The advantage of the “Reference by Layer” component, is that any changes made to the Rhino file within the same layer can be automatically brought into Grasshopper without manually re-referencing the individual objects.

It also opens up the possibility of using different Rhino files for the same Grasshopper file, as long as the layer structure and geometry are similar.

Fuzzy Reading

To make referencing even easier, Elefront comes with fuzzy search. Meaning as long as your name follows a pattern, you can use wildcards to reference in your geometry.

For example, if I had layers with the names “Level 1”, “Level 2” and “Level 3”. I can pull all the geometry by passing in “Level *“ into the “Reference by Layer” component.

Type Filtering

Once you have referenced your Rhino geometry into Grasshopper, you can further filter the objects based on their properties. While there are a few properties for you to choose from, I used the “Filter by Type” component the most.

This is just so I can ensure that I am working with the right kind of geometry.

Baking with Elefront

Then once we are done with our operations in Grasshopper, we can bake geometry Rhino using the “bake” component in Elefront. All you have to do is plug in the geometry you want to bake and hit “Activate”.

But you might notice that if clicked on “Activate” multiple times, you get duplicates of your geometry.

This is because without any other inputs, the “bake” component behaves like the right-click menu bake option, it just adds the geometry to the layer. But you can get Elefront to delete any existing geometry and then bake in the new ones by making use of a “BakeName”.

A “BakeName” is a name that you can give to the set of geometry that you want to bake. Elefront will use the “BakeName” to determine what geometry to delete and replace.

By default, the Elefront "Bake" component will place your geometry into the currently active layer in Rhino. However, you can exercise greater control over the baking process by defining the object attributes before performing the bake operation.

You can specify the layer name in the “Object Attributes” component.

Note: If you plug a “ValueList” into the “[]L” input, you will get a list of all the current layers.

Additionally, the Elefront "Object Attributes" component offers more than just control over the layer name. It provides a means to attach additional data and attributes to your geometry, such as materials, user data, and more.

Let’s quickly walk through each input.

Name

The 'N' input allows you to attach a name to the set of objects that you are baking. Although it may seem confusing, this feature differs from the 'BakeName' earlier. The 'Name' attribute serves as an additional label for your geometry. This becomes particularly useful when dealing with overlapping geometry, as the assigned name helps you differentiate and select the desired objects.

Colour & Material

The “C” and “[]M” input stands for “Colour” and “Material” respectively. They let you control the appearance of your geometry when you bake into Rhino.

I can turn the circles red by plugging in a red swatch.

I can do the same for the material input, but the effect of materials only applies to the “Rendered” view.

Note: Similar to “[]L“ if you plug a “ValueList” into the “[]M”, you will see a list of active materials that you can choose from

User Data

But perhaps the most crucial inputs of the 'Object Attributes' component are the 'K' and 'V' inputs, as they allow you to attach metadata to your geometry. They provide a powerful way to associate any relevant information with your geometry.

For instance, if you were an engineer, you could attach analysis results directly to your model.

But an even more useful application for metadata is attaching data-tree paths and indices to your geometry. This allows you to preserve your current data structure, so that when you read the geometry back into Grasshopper, you can reconstruct your data structure.

To reconstruct the data tree, simply read the paths and indices for each geometry and reconstruct the tree.

Final Thoughts

Hopefully you can see that Elefront revolutionizes the data transfer process between Rhino and Grasshopper. By leveraging its components like "Reference by Layer" and "Object Attributes," Elefront offers enhanced control, consistency and a programmatic solution in data management.

With the use of Elefront, you can start to introduce more structure and consistency to the way you handle your Rhino files. Especially, if you are following the distributed data model approach.