Faceted Brep Conversion for IFC

In Ifc2x3 data exchange, only a primitive model is required as the vast majority of implementations are developed with the use case of coordination in mind.   If a shape representation isn't an extrusion, then commonly it's meshed into faceted faces with 3 or 4 edges.  I'd really like to see revolutions used more commonly as the impact on many file sizes would be dramatic.

But a faceted brep can have any number of edges, and nominate internal bounds for openings.
Refer to this image and this description. 



We've been recently working pretty hard on ensuring that we can generate compact and efficient faceted breps from the accurate physical nurbs geometry in Rhino/Grasshopper so that a Building Information Model can also be provided within the IFC2x3 model schema.  We've decimated file sizes from the order of 200MB (when using the rhino mesher) to 30MB.  If IFC4 models could be used, there is an even more efficient polygonal faced representation or advanced breps could define the objects as IfcAdvancedBrep with nurbs faces and trims that could be roundtripped to Rhino.

Here's a grasshopper test case of the conversion.  You can access this if you update to the latest ggRhinoIFC plugins from the downloads page at www.geometrygym.com/



If you test on your own models and have any feedback, would be great to hear it.

OpenBIM just became more Open

The core c# classes developed by Geometry Gym to import and construct IFC (Industry Foundation Classes) have been released as an Open Source project under the MIT license.

The source code is being hosted on GitHub, https://github.com/jmirtsch/GeometryGymIFC
I've uploaded the compiled dll to https://www.nuget.org/packages/GeometryGymIFC/

Note this isn't the entire IFC code base that Geometry Gym has developed, the interfaces to Grasshopper, Revit, Rhino, Navisworks, Tekla and the various structural analysis software remain closed source (for at least the time being) as the revenues provided by these projects support the full time development of this code base.

Example code for using these classes will be posted to this project,
https://github.com/jmirtsch/GeometryGymIFCExamples
and you can also refer to the Building Smart examples at
https://github.com/BuildingSMART/IfcScript (but a little more work is needed to enable this to directly use the opensource tools).

Documentation is sparse, but you can reference Building Smart material online such as  http://www.buildingsmart-tech.org/ifc/IFC4/Add1/html/

Prior to deciding to open source, I studied the capability and state of existing dotnet projects I could find.
Some key advantages I believe this project will offer above these include:
MIT License (Permissive license permitting use of code for many purposes)
Simultaneous of multiple schemas such as Ifc2x3, Ifc4 and Ifc5 (infrastructure)
Pure dotnet library.
Easily extensible for developing custom classes and custom interfaces with other software.
Advanced constructors for classes to permit easier generation of Ifc files (other projects require explicit setting of every relationship requiring more intimate understanding of the IFC framework).

The motivation for this move to opensource the code is support of the Uniform Object Library, and I have also discussed the possibility of using the tools for other open and closed source developments with others.

Note also there are two initial variations of the classes to reference.  The core code has no dependencies and reference, and an extension to this with references to RhinoCommon (OpenNurbs) geometry.  The RhinoCommon flavour is still work in progress with more code to be ported into the opensource project.

If you are interested in utilizing this project, please don't hesitate to get in touch to discuss any aspect of this.  Also if you have suggestions for improvements, or wish to contribute, this is greatly appreciated.

Geometry Gym Mac Plugins

It's a historic day, I've added a RhinoMac download area to the website, http://www.geometrygym.com/downloads

I believe these are the first plugins developed for RhinoMac, and it's an exciting new era.

Initially the two plugins available are BullAnt, and ggRhinoIFC (to import and export IFC files).

You need to install the WIP (Work in Progress) build of RhinoMac, you can download from here:
http://www.rhino3d.com/download/rhino-for-mac/5B/wip

Commands will then be available starting with gg (no toolbars yet).  You can open/import IFC files from the file menu.  You can run rhino command ggZZLicenseRequest to activate an evaluation license for the plugins.

Note that there are still improvements on the way (including features in RhinoMac) such as property panels .  I also plan to release mac versions of other utilities.  A lot of the other plugins I've developed for Rhino Windows probably aren't required on MAC as they link to Windows software.  Exceptions are the gbXML plugin and if you wish to see a build of another, then let me know.

I look forward to hearing feedback and suggestions.

The Poppy - Shrine of Remembrance Melbourne

Here's a stunning success of the Grasshopper to Analysis/BIM workflows with the assistance of the Geometry Gym tools.

John Noel of Irwin Consult in Melbourne emailed me earlier today with some images of a stunning feature recently added to the Melbourne Shrine of Remembrance.

Here's some images by John Gollings which are featured on the Irwin website and this article.
http://architectureau.com/articles/shrine-of-remembrance/

I look forward to visiting this in my pending return to Victoria.  You can read more about the details of this project at the  ARM Architecture website and Irwin Consult website.  Grasshopper, GSA and Revit were involved in the design and documentation of this stunning feature.

Congratulations to all involved.  If you've work that's published/built and it involved the Geometry Gym tools, please let me know and I will be glad to promote it on the blog.

IfcScript Introduction

It's an honour to have the work I've done as an early adopter of IFC4 recognized by Building Smart International.

With the library of c# code that I have for importing and exporting IFC4, I've been working on a project for Building Smart to generate sample IFC4 files.  These are small unit tests that highlight a particular aspect (or comparison) of the schema, concentrating on new features and aspects of IFC4.  This includes shape representations such as nurbs and triangulated face sets, cardinal points, reinforcing and new standard case classes.  Now that the bulk of the project has been set, it should be easy to add many more.

Here's an introduction to the project.

It's using my c# library as a means to generate and export the IFC files, but the scripting aspect of it is opensource on github, you can access it here.  https://github.com/BuildingSMART/IfcScript

What's nice with the scripting approach to generating the examples is that examples can be kept in a consistent style, with common changes swept through them.  The scripts can also be built across different schema (including IFC2x3, IFC4 and IFC4 addendum 1) although I still need to enable some exceptions to be thrown when invalid classes are called on.

It's been a good opportunity to polish my library as an API, and it also serves as some good examples of how to use my c# library as an API.

If you'd like to get involved or test this, please don't hesitate to contact me.  And if you have more requests/suggestions for further examples, then do let Building Smart or myself know.

Publishing Geometry Gym Samples to GitHub

I've been asked many times about a manual for the Geometry Gym plugins, particularly Grasshopper to Revit.  I've hesitated a few times.  The plugins are still evolving fairly rapidly and I've been reluctant to spend time on something that might quickly be irrelevant.

I also find this post by David quite relevant.  And there's also the question about what format help documentation should be in and how it could be contributed to by a wider user group.

My opinion has been that the best format for user guidance should be example scripts (which is why I've populated my blog with lots of short examples.  But this can be hard to search and find, and maintaining lots of files takes some effort.

I've recently been using Git (and in particular GitHub) more and more when working with others on projects (and for my own code management).  So I'm going to try hosting an example script of the Grasshopper to Revit functionality there.

If I save it as a .ghx (which is xml) that means it can be versioned and tracked, branched and a wider group of users can participate in it (even if it's just subscribing to updates).  I do intend to also note upcoming features etc in the definitions.

I've posted it here.
https://github.com/jmirtsch/GeometryGym
If you're not so familiar with GIT, then using the github windows application should make things much easier.

Initially it's just Grasshopper to Revit, but I do plan to add other examples such as the various structural analysis software.  I look forward to hearing feedback and suggestions from those that try it.

Karamba to GSA and Robot

I've advanced on the first version of the Karamba exporter, and been testing it with Oasys GSA and Autodesk Robot (which were the most popular early requests).  If you'd like to test this with other software, let me know.

Here's an explanation and demonstration.

And here's some Karamba files to test it on.

Truss

ShellAndBeam

SuspensionBridge

I'm still to implement releases and other attributes, but if you need them please let me know and I'll prioritize the development of them.

Karamba Exporter to GSA, Robot, SAP2000, Sofistik etc

I'm seeking out Karamba users (and potential users) for a new workflow for this grasshopper plugin.  For anyone that doesn't know Karamba, it's a structural analysis plugin for Grasshopper.  GeometryGym has developed various plugins to allow generation of structural analysis data within Grasshopper, but then has the overhead of having to export the data out of Grasshopper to the external software, and then import back the results.

Karamba works as a solver entirely within Grasshopper, and should perform faster as a result.  But more traditional software has advantages of being proven and trusted, and often project requirements mandate particular software or certifications for detailed design.  At present, many users are generating the Karamba model for preliminary design, but then rebuilding the model using Geometry Gym equivalent components to export the model out for refined analysis or advanced assessment.

I've been discussing with the Karamba developer Clemens (and advancing on) a utility to extract the Karamba Structural Analysis model so that it could be verified or advanced in alternative commercial structural analysis software.  I know that Karamba can presently export to RSTAB, but I'm working on enabling this further for a wider range of software.  The exporter for Karamba would save users on generating, maintaining and coordinating multiple components if desired to use the data downstream.
At least initially the primary options are the software that I have developed plugins for.  This includes Oasys GSA, Autodesk Robot, SAP2000, Sofistik, Spacegass, Strand7/Straus7 and hopefully shortly SCIA.  The way this exporter would work also means that any structural analysis software recognizing the structural analysis aspects of IFC could also be utilized.

This would permit verification of the model results, and often projects have mandates on using specific (often certified) software for detailed design calculations.
If you're interested in participating in the early testing and advancing of this feature, please get in touch.

Also refer to this forum post for discussion and details.

Thanks,
Jon

Making Grasshopper to Revit Easier

I was very fortunate last week to be able to attend the McNeel event for Rhino Resellers and Developers.  It was an amazing event and fantastic to be able to meet in person so many of the Rhino3d community in person for the first time.  It was also great to see many others that I have met before again.  I'd like to publically thank McNeel Europe for arranging such a wonderful meeting, and can only hope it happens again in the near future.

I took the opportunity during this very brief venture back to Europe to meet with a couple of clients (apologies to those that I missed) and the feedback had one common thread.  The IFC functionality for OpenBIM export from Grasshopper has great functionality, but was confusing to new (and experienced) users as to how to put together the components.

Given that the vast majority of the users are transferring Grasshopper to Revit, I've decided to develop a new front end for the plugin using Revit phrases, terms, conventions and relationships.  This should make it a lot more intuitive for new and experienced users alike.  In the back, it's still doing the same as the existing components.  It's just I can condense 2 or 3 IFC components into 1 specific revit version, and a lot of the "optional" or additional features of IFC that don't really relate to Revit can be masked.

Here's a screen capture of the initial components I've got working in the past 3 days.  A lot more should quickly follow.

If you'd like to be involved in the early testing, or request particular functionality, then please get in touch.  Any feedback welcome.  Initially these components will be included into the existing IFC plugin, but I plan to spin it out into it's own file some time soon.

It should be noted that the IFC generated can still potentially be used with other software (although I advise to use IFC4 for it's new features and this has barely been implemented by anyone).  I will also consider other application specific components if there is sufficient demand.

One other strong theme of the meeting was Rhino for Mac, which will be available "soon".  After the session by Steve Baer about developing plugins for Rhino Mac, we sat and tested with a compiled version of the IFC importer.  It loaded and the commands were available (but not quite executing with some user input not collected) but we can be confident it might be something users can start testing very "soon" (even if not officially supported initially).

Getting Geometry into Revit

I've been having a few requests recently about getting Rhino/Grasshopper geometry into Revit, and haven't really posted many examples of what is (and isn't) possible so thought I'd add some new examples to the blog.

Some of this functionality has been available a while, but I've refined it recently so update rhino and revit plugins from http://www.geometrygym.com/downloads

With the release of 2015, Revit has enabled some more generic solid generating functionality.
At the moment it enables plane faceted objects (with straight edges) and extrusions.  I've been putting forward requests for further improvements (including masking of internal edges with co-planar faces adjacent) and if more users do so, the faster we'll see this materialize.

Grasshopper is a fantastic tool for projects such as sports stadia, so here's a slightly simplistic example of generating some seating tiers.  You can use the IfcFacetedBrep shape representation with a categorization of an IfcSlab object (as a floor).  Here's an image of the resulting Revit import.  Note that it's not really possible to edit the object downstream (although I am working on improvements for updating the model).

It would also be really great to be able to fix walls to the underside of the objects.  To facilitate the ability to do something similar, it is possible to generate a revit extruded roof (subject to various constraints on what revit can do with this).  You'll find an example of this on the inner ledge.  Just note when using a stepped shape, you need to be careful that revit doesn't have thick roof types loaded in the project/template (but you need at least one).  Revit has a bug that crashes if the roof is generated with a proportionally thick type.  You can test with this blank project (download from here).  Here's the Grasshopper file (Rhino document units should be mm) and here's the resulting IFC file.

So this works for faceted objects with plane faces and straight edges.  If your shapes don't meet this criteria, one of the few options remaining for the time being is to import a SAT (or DWG) into a generic model family.  My tools can automate this process, allowing automation of categorization and assignment of parameters/properties.

Here's an example file to demonstrate this.  Rhino  Grasshopper (Grasshopper model with new Revit Components)  Note you can right click on the ggBake component and set the .SAT generation of IfcRepresentationMaps.  Also make sure you're using IFC4 if nurbs are applicable.  An IfcRepresentationMap is similar to a block in Rhino or a family symbol in Revit, ie a master geometry that is defined in the project/model as transformed instances.  Here's the resulting IFC file.

If you have suggestions for improvements, please let me know (enabling more categorization is on my todo list).  The more that also contact Autodesk asking for more and more functionality to generate geometric objects the more likely we'll see earlier implementations of improvements.

Revit Shaft Openings

I was reminded by a user request today of a feature I added to the Grasshopper IFC plugin to generate shaft openings in Revit.

Note this is one of the few areas where IFC doesn't really define an equivalent to Revit, where an opening can cut any object that intersects it's location.  So the IFC this generates is not compliant with the schema, and won't be recognized by any other IFC software other than my revit importer.

Here's a sample file and image to demonstrate the use of it.

Parametric IFC

This example is a little crude, but hopefully it starts to demonstrate how powerful IFC might be if it was implemented to it's existing capability.

Here's a video demonstration which was part of my presentation at the Revit Technology Conference earlier in the year in Melbourne.  Sorry for the audio quality.  It demonstrates round tripping a revit family through IFC, preserving types and dimensional constraints.  At this point in time I've only implemented specific attributes for this prototype, but certainly I am keen to advance this much further if the demand is there.

The potential is huge.  Revit content could be converted intelligently into content for ArchiCAD, Digital Project, AECOSIM etc etc and vice versa.  Content could potentially be downgraded for specific versions of software.

If you've suggestions or feedback, I look forward to hearing it.  You can download the Revit plugin from http://www.geometrygym.com/downloads  Here's the Revit Family and resulting IFC file.

Building Smart International Award

Any GeomGym users out there using the IFC tools (and of course anyone using OpenBIM) are encouraged to enter into this award scheme from Building Smart International.
More details at http://www.buildingsmart.org/bsi-award-2014

BIMDayOut IFC4: The Shape of Things to Come

The BIM Day Out in Perth last year was a fantastic event, attracting presenters and attendees of a wide spectrum within the AEC industry.

Having been caught in the rain and cold (not really expected in Perth) earlier that week, my voice nearly disappeared (apologies, but the audio captured isn't too bad).



The presentation above primarily demonstrates the utilization of OpenBIM IFC to turn Grasshopper into BIM authoring software (and then receiving and utilizing the models in other software such as Revit or Tekla).

It aims to motivate software users (of all BIM enabled software) to demand more of the IFC implementation of their software, and hopefully shows a capability of IFC to convey intelligent models capable to use downstream in other software.



Congratulations and thanks to BIM Day Out committee for their work in arranging BIM Day Out, looking forward to many more of these events in the near future.

IFC exchange of Curtain Panels

An area that's been on the back burner for longer than I'd like, and that is the exchange of curtain panel plates from Grasshopper to Revit (etc etc).  Some potential clients evaluating the tools for this purpose led me to implementing some ideas and strategies for this.

Note that this isn't means to rationalize or divide surfaces into panels (there are other plugins such as paneling tools for this) but as a means to generate the curtain panel plates in Revit having already conducted the paneling process.

Update to the latest plugins for Rhino and Revit IFC from http://www.geometrygym.com/downloads to test these.

I've implemented a means to represent the panels as surface objects (not extruded to thickness).  If the perimeter is planar, and has 3, 4 or 5 edges linear edges, then the Revit plugin will initiate an adaptive component family that generates an equivalent object.  Material needs to be manually altered in the family if appropriate.

Here's a sample GH definition creating a random array of planar panels and here's the generated IFC file.

I've also been looking at means to generate non-planar panels.  If the panel is an loft from one end curve to the other, then I've implemented a means to again generate a revit equivalent.

Here's a sample gh definition and here's the resulting IFC file.

I'm also investigating a means to create a non-planar panel with 5 edges.  I'd also really like to able to define master "families" of the same shape panels, and then propogate instances in Revit.  But the Revit API seems to be lacking fairly fundamental functionality to do this.

If you've requests, suggestions or questions, don't hesitate to get in touch.

Navisworks 4D IFC

At the BIMDayOut event earlier this year (great event, hope it runs again next year) I presented some 4D IFC workflows from Grasshopper to Constructivity (still the only other software I know of reading and writing IFC4).  It was really encouraging to be able to show a virtual construction sequence in Constructivity but I found the software had issues with large scale geometry and strict requirements for the way data is defined.

What I've been working on now is an IFC import enhancement for Navisworks Manage 2014.

At this point in time, you can't create products in Navisworks from the API, but if you import the IFC using the native importer (IFC2x3 only), then you can run my IFC enhancer (plugin can be downloaded from http://www.geometrygym.com/downloads ) which can generate the timeliner tasks and identify the ifc products by their unique identifiers.

Grasshopper Definition  IFC file

I hope to improve further the sequencing calculations and add cost data.  If you have requests or suggestions, let me know.  I will also consider developing a similar utility for VICO or other software if the demand is there.

AECOSIM and ISM

We were lucky to return back to London recently for my brother's wedding.  Being August and summer, it was a great time for a wedding but not the ideal time to try and meet lots of existing and potential users of the Geometry Gym tools.  I did manage a few meetings and Simply Rhino organized 4 computer lab sessions for those interested to not only view but try hands on application of the tools (This worked quite well and is something I'll look to repeat if I'm visiting other cities).

I was asked a few times about model exchange Grasshopper to AECOsim and it's something I've made a start on testing.  As per all BIM software, they do have IFC coordination import/export, but I've made a start on using the ISM as a basis of generating structural model data from IFC (grasshopper generated or not) into AECOsim and various other software interacting with ISM.

Here's some prototype models.  Curved members are coming quite well into AECOsim.

I tried my klein building slabs and they preview well in ISM viewer, but causes some errors when importing the ISM into AECOsim (Bentley will hopefully advise soon).

If you're interested in testing this work flow, please get in touch.  Initially this will be structural based but I am keen to enable other disciplines and data if demand is there (ISM has provided a fast means of getting started with a strong overlap of IFC structural data).   Of course Bentley have Generative Components as a very similar tool to Grasshopper, but freedom to exchange models across platforms can enable very powerful work flows.

Parametric IFC

There's been a few private and public discussions about Parametric IFC and IFC for Content.  As a prelude refer to http://mdradvies.blogspot.nl/2013/10/ifc-for-content.html and perhaps we need a twitter hash tag?
Manufacturers and suppliers are caught in a difficult situation at the moment about generating BIM data and leveraging the best value (and success) in doing so.

There is obviously a cost in preparation and there is little choice at the moment but to either generate pick which BIM software that native content can be created for or generate IFC as neutral data.  Budget, time and expertise constraints make it highly unlikely anyone will author native content for all BIM software (and is a lot of duplicated effort).  Current BIM software capability with IFC is presently leads to a lot of frustration and poor performance, but I don't think it has to be that way and will try to convey that with this blog post.

Let's start with the cistern family that Martijn refers too.  You can download this as an IFC file or Revit Family from http://www.nationalbimlibrary.com/generic/exposed-cistern
Martijn comments that the IFC file has 2640 lines of IFC to define it (actually the version I just downloaded has 2118).  The authors at National BIM Library have used the faceted brep  shape representation to define the geometry which is pretty typical of IFC files to date.  The geometry is effectively meshed into planar faces.  When you do this, you loose the parametric and intelligent aspects of the geometry (ie, if I want to now make the flush pipe change diameter, it's a near impossible task to relocate all the vertex accurately into the new positions.  Perhaps some manufacturers/suppliers prefer this as it means the content is "protected" but it does come at a cost.

I haven't sought permission to "edit" this file (if someone has a problem, let me know), but I substituted the geometry for extruded area solids and swept disk solids which retain parametric geometry.  You can download this IFC file here.  By replacing the shape representations with more intelligent and accurate shape representations I reduced the file to 357 lines of IFC of which a lot are property values.  If you've had bloated IFC files gigabytes in size, a lot of this can be attributed to meshed hand rails and the like (Please request to your BIM  software developers to implement and utilize swept disk solids).  I actually did simply the shape of the cistern a little, not because IFC isn't capable, but because certification requirements of IFC software do not require the implementation of IfcExtrudedAreaSolidTapered which would more accurately and efficiently the tapered cistern.  This would have added about 30 more lines to the IFC file (and I can post if requested).

Now, here's where using IFC gets frustrating.  We have this more intelligent and accurate IFC file, and it doesn't work very well in trying to use it.  I tried all the IFC software I have to hand, Revit, Archicad, Tekla Bimsight, DDS Viewer, Solibri, Constructivity and all of them displayed non or only the cistern part of the geometry.  I put this file through the Building Smart verification tool which indicates only inherited errors (that didn't prevent the original file being used).  The fact none opened the file suggests it might be a problem with the file and I will be most grateful to anyone that can identify this (maybe it's my curve parameterization, I'm aware that my IFC is not yet perfect).  You can of course test the file with my rhino3d importer. http://www.geometrygym.com/downloads

Now if you wanted to change the geometric diameter of the pipe, you could open the ifc file in a text editor like Notepad, and set line
#3674= IFCSWEPTDISKSOLID(#3675,15.0,$,0.0,94.0000000000002);
to something like
#3674= IFCSWEPTDISKSOLID(#3675,40.0,$,0.0,94.0000000000002);

Download the revised file here.  In one quick step I changed the 2nd field for radius from 15mm (30mm diam) to 40mm (80mm diameter).

Now, what we really want to do is drive content as we can in Revit (and I understand, GDL in Archicad) from parameters.

An IFC pipe segment (or type) can have a  property value stored in the common property set for "Nominal Diameter"  What would be nice is to change this value (akin to changing a parameter on the family in Revit) and have the geometry and any calculated values update to this change.
IFC as presently defined does not have this capability, but there is a very interesting proposed extension for IFC to do just that. http://www.buildingsmart-tech.org/future-extensions/ifc-future-extensions/project-proposals/pa-1-parametric  I don't know any software that has implemented it (really users are going to have to demand it) and I thought I'd implement file exporting to demonstrate it.

Download the IFC file here.

So if you read the IFC, you see I've bound the property single value to the circle hollow profile def radius, with a formula to adjust by a factor of 0.5 (to adjust from diameter to radius).  It would be possible to define formula relationships and the like (akin to Revit and to my knowledge GDL) and have them converted from the IFC file into the native equivalents.  (Grasshopper definition if you want to test, the components are hidden from the menu at this stage).

So, if the industry wants to generate more intelligent model content, and use it in a wider variety of software and contexts, it would seem a good idea to get on and implement (and improve) this extension.  Note also this extension can provide provision for constraint relationships.

To quickly address the comment from Martijn about "IFC is meant for Projects), this is perception rather than technical intention (Refer definition of IfcProject here). IFC4 does improve this situation, where a project can declare "types" without populating an instance of this in space.

I state all the time, IFC isn't perfect.  But it is capable of a lot more than implementation demonstrates at this point in time.  And before we can really work on improving it, we really need to be able to test and utilize what it is already capable of to identify improvements and shortfalls.  I look forward to discussing further.

More D's for Grasshopper BIM

Recently I've been working on enabling more dimensions to Grasshopper BIM, primarily Planning and Costing.  I've just posted an installer (http://www.geometrygym.com/downloads ) that's capable of generating the attached program example (which is just like a Gantt chart just in Grasshopper format).

Grasshopper 0.9.0056 Definition Grasshopper 0.9.0014 Definition IFC4 created
This example creates a residential project construction program.  It demonstrates nesting tasks inside others, nominated precedence dependency (including lag time and start-finish or start-start type relationships) and nominating task duration.  It's also possible to assign task to work calendars defining working times  or exceptions (such as holidays or rostered days off).

At the moment there's not components to provide feedback such as collated/aggregated scheduled finish time etc, but this is certainly something I'll pursue.  Of a higher importance is probably to develop an importer for existing management software such as Microsoft Project (or other suggestions made by users) so that gantt charts (in a more typical/recognizable format) and reports can be generated there.

I've also started work on costing and resourcing metrics which I'll be posting soon.  I think what would also be impressive/useful with this is assigning products to tasks and creating a virtual build construction sequence within Grasshopper (or other software).

And remember this is all being managed within the IFC OpenBIM framework, so if you already use software capable of importing the model data, it's a really powerful opportunity.  At present I'm only generating IFC4 models as there are significant improvements in this area (but also means significant differences from IFC2x3) but if existing software only using IFC2x3 can be used I'll look at enabling "equivalent" IFC2x3 where possible.

Look forward to hearing suggestions and requests.

OpenBIM Scripting : Python IFC

Goswin posted to the Grasshopper forum a week or so ago about the possibility of scripting IFC data from Python (Rhino Python to be exact).  I hadn't had much of a chance to try Python to date, but I've tested GH Python today (Rhino python should work just the same).

You can download the sample GH def here.

Note there is also the possibility of using my c# libraries (from C#, VB.Net, Python or other compatible languages) outside of the Rhino/GH environment.  Get in touch if you would like to learn more.  Also not everything is enabled, but I can quickly do so.  Grasshopper is really a graphical programming language, so what is available there is certainly easy to provide in the API.