Whoops 404

page not found bruh.

Install v0.0.701

- {{githubLink}}
- {{bitbucketLink}}

External Dependencies

Currently the only dependencies are ghpython which is a single gha that you can drag and drop into your grasshopper workspace one time.. It is expected for you to have grasshopper and dynamo installed. This tool has been tested with Dynamo v1.0, Revit 2016 and Grasshopper 0.9, but should hopefully work with lower and higher versions of these softwares.

• Dynamo Latest
• Grasshopper Latest
• ghPython (gh)

For Dynamo Components

For dynamo components, currently you can install directly from Dynamo's Package Manager. Search "Cms Dope Custom Nodes" and Install. Alternatively you can grab it from the {{githubLink}} or {{bitbucketLink}} source.

For GH Components

For gh components, Grab it from {{githubLink}} or {{bitbucketLink}}. Currently they are just clusters for you to drag and drop, but should be updated to a true assembly soon.

What is Best Friends?

INTEROPABILITY

Best friends is an interoperability toolkit by Chris Malcolm. "Interoperability" is basically the communication and exchange of data between softwares, in our case Revit and Rhino. Revit is a great documentation/BIM tool but often difficult to control geometry. Rhino allows for easier modeling, but often not used for Documentation.

Interop basically allows for one to exchange data between the two in order to take advantage of both softwares' best usecases, I.E updating geometry in rhino and pushing to revit or grabbing data from revit to use aas studies in rhino.

UPDATE NOT REPLACE.

Although there are quite a few interop plugins and toolkits out there, most of them operate on the "wipe replace" method. Best friends is built on the idea that when the position or attributes of panels change, we should be able to "update" existing curtian panels and adaptive components, rather than regenerating them. This allows us to retain existing attributes,dimensions, tag,etc in revit.

This is done by using references for elements from revit and mapping them to attributes and panel pts so when edited in rhino, revit can know which elements are what. With this a constant feedback loop is created between rhino and revit allowing one to read/modify/update to happen at any desired time.

Feedback Loop

The way it works is you export panel data (pts, element reference, params) straight out of revit. Then Rhino can read it, manipulate it, and send it back.

FEATURES / GOALS

• No Rhino Maintenence - Get Panel Geometry from Revit without needing a maintained Rhino or Crazy Grasshopper File.
• Update Pts and Params - Edit points (adaptive components) and Instance parameters on objects
• CSV Readable Data format - Data is stored in a 3 column csv, which is human readable and the same format for both from rhino and from revit.
• Minimum Dependencies - Aside from ghPython for grasshopper and the nodes themselves, there is no external packages needed!

FUTURE IMPROVEMENTS

• Updates to Revit Elements only - add and remove to come
• Adaptive Components and Curtian Panels Only - (pts updates not permitted on Basic Curtian Panels) More families to come.
• CSV and revit Element count must match to properly sort. Smarter datamapping to come as well as more documentation on data references.

KNOWN ISSUES

• Filter panels in GH.Read - neads to clean out empty trees
• Curtian Panel Vertices - Some curtian panels are being read as more than 4 points due to removing mullions.

---

An Example Use Case

Below is an example use case where we take 10 adaptive components representing our "facade" and update some parameters as well as the position of them.

Boring Adaptive Components

Here we have some 10 panels that have two instance parameters.. "sawtooth_offset" and "glaz_length". Pretty boring right now, but lets see if we can change that. Also make sure you have looked at the install page to grab the grasshopper package and installed the dynamo nodes!

#1: Extract Revit Data (DYN.WriteToCSV)

After grabbing our elements, we plug that in the elements input of the Interop.Dynamo.WriteToCSV Node in Dynamo. And also our two params so we can access that data in rhino. Then we set "write" to true to save it out to a CSV location.

#2: Read Data Into GH (GH.ReadFromCSV)

So now we can grab that data directly into grasshopper without anything in our rhino file with the Interop.Dynamo.ReadFromCSV Node. As you can see, by providing the CSV that we just saved, we get access to the panel pts, parameters, and reference (by default Element Id.)

Making into panels

Just to see whats going on, we can show the panels by connecting the points as a surfaces and then label them with the reference Id. As you can see the params and references match the points coming in!

Guide Curve and attractor

We know we want to change the shape of our facade so lets drive that with a guide curve. Then we'll use an attractor point to control the glazing width and the sawtooth depth.

I wont get into how we make those custom nodes, but this is basically where you would use existing or the panel geometry and getting some metrics that you want to pipe back in.

Manipulate the pts

Here I moved the points based on our curve with some grasshopper (I wont get into that, as the manipulation would be up to you :) ). Looks dope! We now have points we can pipe back into revit!

Get some values for the parameters

Remember those parameters.. "sawtooth_offset" and "glaz_length"? To get some variation I did a basic attractor script. Although there is some visual feedback in this example, for revit this isn't necessary. what we really need is those numeric values, which is output as well.

Update the Params

So from the csv, the parameters are serialized (which means they're encoded into a key=val;key2=val2; format). This makes it easy to transfer via text back and forth. You can definitely write your own node to edit this but we have a few helpers called SetParam and GetParam built into the toolkit for easily updating the params. This is what we do here. The output of SetParam is the new serialized keys and values.

#3: Write Data to GH (GH.WriteToCSV)

So now we have both our points and params. We use the GH.WriteToCSV to write our parameters and points. Now our reference are those original element Ids. But optionally you could use a reference point or a custom id in "parameter=value" format.

Similar to the DYN write we add a csv path to save this file out to and hit bake. Note that you could opt out of providing either points or params updates, as both might not be necessary for your project.

#4: Read Data to Revit (DYN.ReadFromCSV)

Back to revit, we use dynamo with the same elements and the Interop.Dynamo.ReadFromCSV node. Plugging in that reference to the csvFilePath and toggling the "read" param..we can already see our points being displayed on the screen.

SUCCESS

Now to update this you simply toggle the "UPDATE" to true. Now its important to do this only once, and then recheck it off so it isn't constantly updating the revit space.

Congrats you successfully updated the model! All of those panels would retain their previous parameters and properties, with only the modifications we did as changed! Neat.

{{#each ~ as objId, obj}}
• {{#if obj.name}} {{obj.name}} {{else}}

  {{objId}}

  {{#partial nodeNav, obj}} {{/if}}
{{/each}}

{{#each ~ as inputId, input}} {{#if input.name!="--"}}
• {{input.name}} {{#if !input.required}}Optional{{/if}}
  ({{input.type}}) {{#if input.defaultVal}}
  
  Default: {{input.defaultVal}}
  {{/if}} {{#if input.example}}{{#if input.defaultVal}} {{else}}
  
  {{/if}} Example: {{input.example}}
  {{/if}}
  {{input.description}}
{{/if}} {{/each}}

News

Check here for all the latest news regarding best friends

About

Project Developed by Chris Malcolm

Grab + Contribute: github

This project is not affiliated with Autodesk or McNeel Associates.

This work is licensed under a Creative Commons Attribution 4.0 International License.