The Building Coder

Sweep Family Performance Enhancement

Now I am back at work again, enjoying the queries coming in from developers, postponing other important things such as my own long-term class and presentation preparations etc. Addicted to helping, that's me.

Anyway, here is a piece of doubly good news, in that the developers mentioned below did a good job of helping themselves, in addition to achieving a radical speed improvement from 40 hours down to 3 minutes, i.e. just 0.125% of the original time, to programmatically generate some Revit families.

Question: The problem was initially reported by Hu Zhao in a recent comment:

I have 80,000 elements to generate, now I use sweep; do you know which is faster of sweep and extrusion? Which can offer a better performance for the computer?

It took 40 hours for the sweep operations.

Is it possible to accelerate this?

In Rhino script, only 10 minutes is enough for this operation.

Hu's colleague and Revit API blogger David Tan clarifies:

Zhao's scenario is to create about 80,000 sweeps in Revit in one shot. Per his test, it will take about 20 hours, while his workmate can achieve it in Rhino within 10 minutes. Zhao expects that Revit could do faster.

As Zhao's test was done in an open family document (with UIDocument), I tried to use in-memory document but it still take about 18 hours to draw all 80K sweeps.

Zhao noticed that although all the drawing work is done in a single transaction, it seems that Revit tries to regenerate the document after there are sweeps created already automatically. We did set the RegenerationOption to be Manual. We say it because we saw Revit progress bar in the bottom-left corner indicates it.

Our questions:

1. Can we prohibit Revit's automatic regeneration?
2. More straightly, do we have any approach to get the job done faster?

Thanks a lot! And Happy Chinese Snake Year!

Answer: There may be a stray regeneration happening in sweep creation.

If you can demonstrate that (with a sample that creates something less than 80,000 sweeps, please :-), please provide a reproducible case for further analysis.

It is also worth asking what the use case is for 80,000 sweeps in one family. Are you possibly modelling things so detailed that that a building model with multiple instances of this will have performance problems?

Maybe you could add an image of what you are creating to motivate the development team by helping them understand.

Response: Here is an image showing what we are trying to achieve:

Each sweep corresponds to a single wooden roof in the image.

Here is also Hu Zhao's source code. We used an in-memory document and added a StopWatch to measure the time consumed.

The source code implements an external command in Program.cs. It will pop up a window and let you select a XML file, which contains creation data of all the sweeps. You can find the XML file along with the .sln file. To make things simple, I only put 2000+ sweeps creation data in the XML file.

Finally I want to share the good news from Hu Zhao. He resolved the performance problem by splitting all sweeps into 24 families and then combining them together. It only takes 3 minutes now. Of course, the cost is the reduced granularity; the model now no longer has individual roofs with embedded family instances. But as he is OK with it, we can say we have found the solution.

Hu added the following more detailed project description:

I am now working in a project plan team for the design of Arch_Tec_Lab in ETH Zürich (youtube link).

The parametric roof is generated in Rhino by my colleague, and the wooden beams will be assembled by robotic arms.

Before I joined this team, they imported the roof (including roof wooden structure) in DWG format, which did not display correctly in some plan and section views. In 3D view, it led to Revit crash because of too many triangle meshes in this imported format.

So I wrote a plugin to import the wooden beams (around 80k) of the roof.

We choose XML to exchange the position information, and I choose sweep instead of extrusion to generate each beam.

For now, the roof structure is divided into 7 parts of XML, which generates 7 families. It took me about 20 hours by using 3 dell precision computers.

Because the roof will be modified several times in the following days, I am now searching for a way to reduce the generation time.

I found that the speed of sweep is slower when the amount increased, and the regeneration that I cannot avoid is especially slow when the amount is above 1500.

Yesterday I found a way to accelerate the generation greatly.

I did like this: divided each 1 part into 24 pieces sections with the mark in XML, then generate each section into single family, and then combine them into a major family. These actions are all made by the plugin.

This is much more quicker.

Let me introduce our project once again.

The Arch_Tec_Lab is a role model project of department of Architecture, ETH Zürich. The team includes most important professors in the Institute of Technology in Architecture. The project aims to realize the BIM control in the life circle. Now we are using Revit to an extremely detail, and we enjoy the cloud rendering in Autodesk 360, except we wish it would also support animation rendering. Now we are working on the construction drawings in Revit.

In Switzerland, few architects use Autodesk products, because of the majority of the MAC users. But we want build a model for the architects and the students in department.

Many thanks to David and Hu for their research and sharing this remarkable performance enhancement!

Addendum: For completeness' sake, here is the slow source code and the complete fast solution. Hu clarifies: the code we posted yesterday is the slow version. The 'slow source code' shows how it works. The 'complete fast solution' is the quicker version.

There are 8 parts to generate. I finished all the work above in 20 hours using 3 computers, and now I can generate the smallest part in 3 minutes. Actually, the bigger part took about 6 hours by the slow method, and now takes about 50 minutes.

The time depends on how many parts I separate. I never test all the 80000 sweeps in one run, maybe it will cost one month ~:D – because the speed runs slower when time goes.

Basic File Info and RVT File Version

I presented an initial solution in Python for determining the version of an RVT file on disk from outside Revit making use of its OLE document Structured Storage format back in 2008. David Echols later shared a more full-fledged C# Revit OLE Storage viewer listing more information and displaying the preview image.

Since then, the Revit API added support for reading basic RVT file info through the BasicFileInfo class.

Victor Chekalin now presents another C# console application showing how some of this data can be accessed independently of the Revit API.

Before looking at that, here are some other topics that also came up in the past day or two:

• Building Setout Points used commercially
• Screen recording with Camtasia on the Mac
• Sustainable Autodesk Offices
• Reading the RVT file version without using the Revit API

Building Setout Points Used in a Commercial Application

I am glad to say that one of the sample add-ins I am particularly happy with now made its way into a commercial application.

Here is an excerpt from the current Australian ARSoftwareSolutions newsletter:

A recent meander through the TheBuildingCoder website led me to a routine for marking the corners of structural concrete corners. Once marked the points could be scheduled and provided to the builder as a file of set out point coordinates. These can then be established on site using various surveying tools. This seemed like something a lot of companies could benefit from so I set about including it in my software. (Please refer to http://thebuildingcoder.typepad.com/blog/rst for more complete details. Thank you to both Paul Hellawell of GHD and Jeremy Tammik for the idea and some of the coding.)

Of course I couldn't just leave it the way it was so I expanded on the concept, added extra functionality, and this now forms a part of ARUtils - Leader.

The basic concept is to mark all structural concrete corners with a "SetoutPoint" family. Critical setout points can then use a "Major" type of that family to indicate they are a critical point. Alternatively other points can be automatically designated as minor, centre points of curves, control points of splines, or just intermediate points along curves. Points can be promoted to Major or demoted to Minor as required for construction or changing needs.

When automatically placed at a point, each marker has the X,Y, and Z coordinates assigned to the marker. Once this has been done, the families can be scheduled and the points exported for use by the builder. The routine also keeps track of the item that generated the points so points can be grouped on a generating object basis.

Points marked. Diagram shows Major, Minor, Centre, Control and Curve following points.

Tagged points

Scheduled Keypoints

Schedule - All points

The interface

Note: You can automatically mark all structural concrete items, or pick specific items of any type to have markers placed.

Note: Should the project location change the coordinates can be automatically synchronised using the "Renumber / Update" option.

I am happy to see my efforts helping people and making their way out into the world :-)

Screen Recording on the Mac

On a completely different topic, I have been struggling a bit the past few days to set up a proper screen recording environment for myself to create a canned presentation.

I want to show some Powerpoint slides, record my narration, and also make use of Revit and Visual Studio for add-in demonstrations.

I planned to use Camtasia for this, as I have past experience with it and it does a good job.

The Revit and Visual Studio requirements led me to believe that I had to install Camtasia in my Windows virtual machine.

When I did that, I discovered that the Windows version that I had installed was European and therefore lacked the Windows Media Player, which caused Camtasia to fail. It took a while to find out, though.

I went off and downloaded a US version of Windows, created a new virtual machine, installed Revit, Visual Studio, Camtasia, and some other bits and pieces on it.

After doing all that, I discovered that the Camtasia output quality from this setup is suboptimal, and there are often problems with the audio getting lost completely.

After struggling a bit more with that, a colleague told me that the easiest thing to do is just to use Camtasia in the native Mac system and record the full screen. I can display the Powerpoint slides in full screen, record my narration, and switch back and forth to a full-screen virtual Windows machine at any time. So I wasted a lot of time there. Now I can get going with my recording just as soon as I finish this post.

Sustainable Autodesk Offices

Back to the architectural realm, two new case studies on the green office design of the Autodesk offices in Milan and Farnborough are now live on the Autodesk Sustainable Design Center:

• Farnborough
• Milano

These projects were implemented by Morgan Lovell plc and Goring & Straja Architects, respectively. The case studies describe the projects, challenges, solutions, results and learning experiences made.

I hope you find this interesting, useful and feel inspired to pursue the same kind of greening efforts in your own company :-)

Determining the RVT File Version Without Revit

Back to the main topic that I started discussing above.

This came up again prompted by a comment by Victor Chekalin, or Виктор Чекалин, on the original post.

He points to a stackflow discussion thread: How can I get the Revit file version using the Revit API?

Question: In the Revit API I know that I can get the version of the Revit instance that is currently running:

• ControlledApplication.VersionBuild
• ControlledApplication.VersionName
• ControlledApplication.VersionNumber

However, I would like to get the version of a Revit file itself before I open it. This way I could stop the automatic upgrade dialog that shows when a user opens an older Revit file in a newer version of Revit. I'm using Revit 2013 and expecting files from 2011, 2012, and 2013.

Answer from skeletank: I took a closer look at the discussion group posting from my question and found that the version information is actually human readable among the other gibberish of the file. The ".rvt" file is stored in OLE format so you can see the content if you use a tool like Structured Storage Viewer. It will be located under BasicFileInfo.

If you wanted to then you could probably use an OLE library for .NET to read the data but I used a StreamReader and a Regex instead.

Here is the regular expression:

Revit\sArchitecture\s(?\d{4})\s(Build:\s(?\w*)\((?\w{3})\)\)

Here is the code:

private void ControlledApplication_DocumentOpening(
  object sender,
  DocumentOpeningEventArgs e )
{
  FileInfo revitFileToUpgrade
    = new FileInfo( e.PathName );
 
  Regex buildInfoRegex = new Regex(
    @"Revit\sArchitecture\s(?<Year>\d{4})\s"
    +@"\(Build:\s(?<Build>\w*)\((<Processor>\w{3})\)\)" );
 
  using( StreamReader streamReader =
    new StreamReader( e.PathName, Encoding.Unicode ) )
  {
    string fileContents = streamReader.ReadToEnd();
 
    Match buildInfo = buildInfoRegex.Match( fileContents );
    string year = buildInfo.Groups["Year"].Value;
    string build = buildInfo.Groups["Build"].Value;
    string processor = buildInfo.Groups["Processor"].Value;
  }
}

This will allow you to get the year, build number, and the type of processor. Notice, however, that my version checks specifically for Architecture so you will need to modify it for MEP or Structural.

Answer from Victor Chekalin:

As you said, Revit file format is a Structured Storage document and information you need is stored in the BasicFileInfo stream.

Within the Revit 2013 API you can use the SavedInVersion method of the BasicFileInfo class.

Here is the full console application demonstrating how to extract BasicFileInfo data without the Revit API.

Unfortunately I don't now the format of the BasicFileInfoStream. But if you read it as string you can get version in which file was created.

Reading only the BasicFileInfo is much better than reading the whole file. Imagine if the Revit project is over 500 MB. You will read the whole file into memory when you call

  string fileContents = streamReader.ReadToEnd();

Also, Regular expression on the huge file works slow.

I think you should use

  var rawString = System.Text.Encoding.Unicode
    .GetString( rawData );

from my sample and use Regex in the rawString instead the whole file.

For your convenience, here is the full source code of Victor's solution:

using System;
using System.IO;
using System.IO.Packaging;
using System.Reflection;
using System.Runtime.InteropServices;
 
namespace ConsoleApplication1
{
  class Program
  {
    private const string StreamName = "BasicFileInfo";
 
    static void Main( string[] args )
    {
      string pathToRevitFile = ( 1 == args.Length )
        ? args[0]
        : @"pathToRevitFile";
 
 
      if( !StructuredStorageUtils.IsFileStucturedStorage(
        pathToRevitFile ) )
      {
        throw new NotSupportedException(
          "File is not a structured storage file" );
      }
 
      var rawData = GetRawBasicFileInfo( pathToRevitFile );
 
      var rawString = System.Text.Encoding.Unicode.GetString(
        rawData );
 
      var fileInfoData = rawString.Split(
        new string[] { "\0", "\r\n" },
        StringSplitOptions.RemoveEmptyEntries );
 
      foreach( var info in fileInfoData )
      {
        Console.WriteLine( info );
      }
    }
 
    private static byte[] GetRawBasicFileInfo(
      string revitFileName )
    {
      if( !StructuredStorageUtils.IsFileStucturedStorage(
        revitFileName ) )
      {
        throw new NotSupportedException(
          "File is not a structured storage file" );
      }
 
      using( StructuredStorageRoot ssRoot =
          new StructuredStorageRoot( revitFileName ) )
      {
        if( !ssRoot.BaseRoot.StreamExists( StreamName ) )
          throw new NotSupportedException( string.Format(
            "File doesn't contain {0} stream", StreamName ) );
 
        StreamInfo imageStreamInfo =
            ssRoot.BaseRoot.GetStreamInfo( StreamName );
 
        using( Stream stream = imageStreamInfo.GetStream(
          FileMode.Open, FileAccess.Read ) )
        {
          byte[] buffer = new byte[stream.Length];
          stream.Read( buffer, 0, buffer.Length );
          return buffer;
        }
      }
    }
  }
 
  public static class StructuredStorageUtils
  {
    [DllImport( "ole32.dll" )]
    static extern int StgIsStorageFile(
      [MarshalAs( UnmanagedType.LPWStr )]
      string pwcsName );
 
    public static bool IsFileStucturedStorage(
      string fileName )
    {
      int res = StgIsStorageFile( fileName );
 
      if( res == 0 )
        return true;
 
      if( res == 1 )
        return false;
 
      throw new FileNotFoundException(
        "File not found", fileName );
    }
  }
 
  public class StructuredStorageException : Exception
  {
    public StructuredStorageException()
    {
    }
 
    public StructuredStorageException( string message )
      : base( message )
    {
    }
 
    public StructuredStorageException(
      string message,
      Exception innerException )
      : base( message, innerException )
    {
    }
  }
 
  public class StructuredStorageRoot : IDisposable
  {
    StorageInfo _storageRoot;
 
    public StructuredStorageRoot( Stream stream )
    {
      try
      {
        _storageRoot
          = (StorageInfo)InvokeStorageRootMethod(
            null, "CreateOnStream", stream );
      }
      catch( Exception ex )
      {
        throw new StructuredStorageException(
          "Cannot get StructuredStorageRoot", ex );
      }
    }
 
    public StructuredStorageRoot( string fileName )
    {
      try
      {
        _storageRoot
          = (StorageInfo)InvokeStorageRootMethod(
            null, "Open", fileName, FileMode.Open,
            FileAccess.Read, FileShare.Read );
      }
      catch( Exception ex )
      {
        throw new StructuredStorageException(
          "Cannot get StructuredStorageRoot", ex );
      }
    }
 
    private static object InvokeStorageRootMethod(
      StorageInfo storageRoot,
      string methodName,
      params object[] methodArgs )
    {
      Type storageRootType
        = typeof( StorageInfo ).Assembly.GetType(
          "System.IO.Packaging.StorageRoot",
          true, false );
 
      object result = storageRootType.InvokeMember(
        methodName,
        BindingFlags.Static | BindingFlags.Instance
        | BindingFlags.Public | BindingFlags.NonPublic
        | BindingFlags.InvokeMethod,
        null, storageRoot, methodArgs );
 
      return result;
    }
 
    private void CloseStorageRoot()
    {
      InvokeStorageRootMethod( _storageRoot, "Close" );
    }
 
    #region Implementation of IDisposable
 
    public void Dispose()
    {
      CloseStorageRoot();
    }
 
    #endregion
 
    public StorageInfo BaseRoot
    {
      get { return _storageRoot; }
    }
  }
}

For your even greater convenience, I am also providing RevitBasicFileInfo.zip containing the full Visual Studio solution that I created to test it.

Here is the result of running this on a sample model on my system:

Many thanks to Victor for his clear explanation and solution!

Addendum: To get access to the StreamInfo class you need reference the WindowsBase.dll assembly.

The question marks displayed in the result console above are due to the fact that one part of BasicFileInfo is encoded in Unicode and another in BigEndianUnicode.

The second part is rendered legible by accessing it like this instead:

  var rawString = System.Text.Encoding
    .BigEndianUnicode.GetString( rawData );

Here is the same file information presented twice, once in standard little endian and once in big endian decoding:

This is a summary of the resulting readable text fields:

• Little-endian:
• Autodesk Revit 2013 (Build: 20120716_1115)
• C:\j\tmp\rvt\floor_slab.rvt
• Big-endian:
• 00000000-0000-0000-0000-000000000000
• Worksharing: Not enabled
• Username:
• Central Model Path:
• Revit Build: Autodesk Revit 2013 (Build: 20120716_1115)
• Last Save Path: C:\j\tmp\rvt\floor_slab.rvt
• Open Workset Default: 3
• Project Spark File: 0
• Central Model Identity: 00000000-0000-0000-0000-000000000000
• Locale when saved: ENU

Delux Database Enabled Loading and Updating

This paper by Steven Rowland, Interior BIM Manager in a hospital in Stockholm, Sweden, describes a novel method to extend database functionality for a "smart" loading and updating process in very large Revit projects.

The method is designed solve a somewhat unique problem, but the resulting solution has interesting possibilities for other projects of all sizes. Here it is:

Database Enabled Loading & Updating eXperiment – DELUX Copy/Paste

By Steven Rowland and Fredrik Sjödén.

This short paper describes a novel method to extend database functionality for a "smart" loading and updating process in a very large Revit project. It builds upon the white paper on database integration by Miroslav Schonauer of Autodesk.

Summary Description

The DELUX copy/paste method uses an external database definition to duplicate floor plans, in whole or in part, to multiple Revit models or floor plans, with the ability to update changes as required. This includes walls, doors, windows, generic models, detail groups, etc., as well as associated annotation. The resulting duplicated floor plans can be updated or refreshed from the database definition as changes occur in the source file. All Revit content in the copied floor plans is live, i.e. nothing is grouped or in links.

Project Description

It is important to understand the kind of project that this was developed for, because we had special circumstances that pushed us towards finding the kind of crazy solution that we developed. We have a very large hospital project, with over 300,000 sq. meters of new construction. The project was divided into 17 main Revit model files, and several more supporting model files. Each of the main Revit files hover between 300-800 megabytes.

In addition, the project is a "fully loaded" project, meaning that all equipment, furnishings, and building elements are loaded into every room (11,000+ rooms). In addition, various other data types are fully implemented into the BIM model. We are required by contract to not use typical floor plans, even where floor plans are repetitive. Also, it is good to understand that this is a live model, which is actively being used for construction and coordination during the design process over several years of continuous design and construction. Eventually the fully loaded BIM model will be handed off to facilities management.

The Problem

The problem we had was this: we have numerous (14) floor plans that are identical or nearly identical with minor differences. These repetitive floor plans are spread across multiple Revit models (4 models). Because of the "fully load" requirements I described above, we were required to fully document each plan completely. On normal projects, this would be accomplished by using Revit Groups or Links. However, both of those methods were unavailable to us, because we have extensive database connections and collaboration methods (IFC, Navis) that do not cooperate with the limitations of Revit Groups or Links. We needed a method that would allow us to have "live" Revit content on multiple plans (no groups or links), and manage the repetitive floor plans in a time efficient way. We wanted to quickly and accurately duplicate entire floor plans and manage change during the design process in an efficient BIM way. We don't like to do the same thing more than twice, and 14 times over is simply too inefficient.

DELUX Copy/Paste

Step one – Mark elements for the database definition – On a Source Plan, we marked each model element with a DELUX parameter to identify that it was a member of the database definition. We included all doors, windows, walls, openings, generic models, furniture, casework, equipment, etc. (Note: ceilings were not included because of API limitations. Also note that room objects are not included.)

Step two – Create a relative coordinate system – We added a simple annotation object to mark a base point that we would measure x,y coordinates from. We could have used the project basepoint, however we felt that a relative coordinate system would offer more flexibility.

Step three – Export to a database –We programmed an add-in that would identify all the members of the DELUX group, and use the relative base point to measure x,y coordinates. The add-in exports all information associated with the model elements, including x,y coordinates, all parameter values, sizes, shapes, rotations, checkboxes, worksets, and everything else we could find through the API. The exported information is formatted as binary code. We had a database available that we use for other purposes, so we put the DELUX information there also. The add-in also adds another parameter to all of the source model elements – UniqueID. We will use this UniqueID parameter later for the updating process. (Note that all annotation for any given model element is exported from all views, and not just the active view. Also note that we are not exporting dimensions yet, but we are looking to explore those possibilities also.)

Step four – Target Plan – We prepare the target plan by placing a target annotation family to mark the relative coordinate. In our project we used a stairwell as the common base point. Any model elements that we wish to replace with the database definition are then marked with the same DELUX parameter that was used in the source file.

Step five – Initialize and precheck – The DELUX add-in does two things when it starts. First it checks for and then adds any missing shared parameters to the target Revit file. Second it performs a precheck to ensure that all required families are present in the target file. We have systems that can automatically load most types of families, however the precheck generates a pop-up and text file that lists the missing families, if any. At this point the user can either proceed with insertion or cancel out of the function and manually load the missing families into the target Revit file.

Step six – Press the shiny button – Now we can tell the add-in to begin inserting the database definition. We begin with the walls, and the function uses the API to insert them according to the relative coordinates we provided. Then it proceeds with doors, windows, and openings. After that all other Revit families are added. All content is inserted in the correct location, orientation, workset, etc., with all parameters and options preserved from the source file. (Note: walls are inserted relatively slowly on the first insertion. This can depend upon the size and complexity of the model, and is constrained by Revit calculating room bounding. We have tried to find various ways around this constraint, and, while there are possibilities, the walls are the slowest to populate from the database definition. In our experience on large model files (500+mb) the insertion rate is about 20 walls per minute. This is accelerated substantially when updating, as I will discuss later.)

Step seven – Annotate – We have a second add-in for inserting annotation. Upon initializing, the user chooses the DELUX group, and the interface shows which annotation views are available from the source file. The user then chooses an active view to receive annotation and presses the shiny button. All annotation from the selected source view is inserted in the correct position and orientation. This can be repeated multiple times for as many source/target pairs as are required.

Step eight – Update – As previously noted, each source model element receives a UniqueID parameter. The same UniqueID parameter from the source is written to each model element in the target plans. By using this parameter we are able to evaluate and match the source and target elements. The update process is similar to the insertion process. If we make changes to the source plans, we export the DELUX group again to the database. In the target file, we run the insertion function same as before; however this time the function uses the UniqueID parameter to compare each element to the new database definition. If the element has not changed, then it is ignored for updating. If the element has changed then it is removed and a new element is inserted in its place. It continues until the floor plan is refreshed. This process is much faster than the initial insertion process.

Implications

That is the entire function, with a few more features that I have not described here. It is still under development, so we have hope for expanding and refining it in various ways. The beauty of this system is that it allows us to manage multiple identical target plans from one source plan, and be certain that any changes are reproduced accurately across multiple Revit files without using Revit Groups or Links. Extending this to annotation opens the possibility of substantially reducing the time required to prepare documentation. This can all be updated over time, and doesn't interfere with our collaboration methods, or other database linkages; in fact we have found ways of using it to reduce work in other areas by leveraging the matched-up UniqueID of source/target. All of this is accomplished through the use of external database connections, and some very clever coding ;)

So what do you think? In some ways we are reinventing the wheel – however we had special needs that led us to this solution. I'd love to hear your opinion, if you have time.

Addendum: I continue to imagine more ways of extending the method. There are, of course, some limitations with our current approach. The biggest one is that the update process is currently a “remove-and-replace” approach, meaning that the new updated content has a new GUID, which can cause problems. The source GUID is written to a parameter on each target element, thus providing the source/target pairing. In the future I would like to provide the option to update parameters or x,y location only, without removing and replacing the content. This will require us to make some changes in how we store information in the database, but could work.

Now, let's return to a couple of other interesting items...

Autodesk University 2012 Classes Now Available

The Autodesk University 2012 classes are now available, both from the live Las Vegas and the AU Virtual conferences.

They are provided at no cost via the class catalogue on the AU website, available to anyone with an AU account.

If you don't have an account, you can sign up for free at any time.

Here are all the details.

Setting a Structural Framing Tag Leader Arrowhead

In a recent AEC DevBlog article, Saikat Bhattacharya demonstrates how to set the leader arrowhead for a structural framing tag.

His sample code first retrieves all arrowhead definitions, which are ElementType instances whose family name is "Arrowhead". They are obtained using a filtered element collector and a parameter filter testing the built-in parameter ALL_MODEL_FAMILY_NAME for that value. Once the desired arrowhead is found, the IndependentTag built-in parameter LEADER_ARROWHEAD is set to its element id.

Using DMU to Track Changes to a Custom Project Parameter

Another of Saikat's articles discusses the implementation of a dynamic model updater for project parameters. It checks whether a specific shared parameter has been attached to the door category. If so, a dynamic model updater is created and set up to be triggered by changes to that specific parameter on door instances.

Thank you for these two nice posts, Saikat!

The Useful Log4Net Logging Tool

Sometimes you need to obtain information about what you add-in is actually doing, possibly even from a customer, e.g. if something unexpected happens.

For this purpose, Rudolf Honke recommends using log4net. It comes equipped with a very helpful tutorial as well.

The BIM 360 Glue Viewer and REST API

As you certainly know by now, Autodesk provides a range of powerful cloud-based solutions, specifically Autodesk 360, PLM 360 and BIM 360 Glue (reference).

Of special interest to AEC developers, the BIM 360 Glue platform includes support for programming interfaces and a software development kit, the BIM 360 Glue SDK, providing a set of tools for developers to interface with it.

The programming support consists of two distinct components:

1. Display component: embeddable 3D viewer to provide visual access to models within custom third party web applications.
2. Web services API: REST based service data access to users, projects, models, etc.

Display Component

The Glue Viewer is an embeddable component used to show 3D models from the Glue platform

Viewer parameters allow control of the GUI, i.e. application controls such as navigation, display lists, etc., so the viewer experience can be customised by developers.

The viewer currently supports Windows 32 and 64 bit platforms, just like the Glue web application.

Web Services API

The Glue web services API provides a RESTful data access interface to query and modify data and return JSON or XML.

It enables developers to integrate external applications, e.g., project management systems, accounting systems and custom developed solutions with the BIM 360 Glue platform.

Glue stores information about user interactions within the system. These operations are referred to as 'Actions'. Typical Actions can be:

• Uploading a model
• Creating a view
• Adding mark-ups
• Creating a clash report

The Glue Web Service API returns many of these actions in API responses.

Actions can be loaded to the viewer to show the user the exact view and state of a model when the action was performed.

Structure of a Client Request

For a typical REST API request, the client sends a HTTP/HTTPS request, POST or GET, depending on the particular service call. Required parameters are sent to the server for authentication. An example URL for a login request could be something like:

https://bim360.autodesk.com/api/security/v1/login.json

The server responds with an HTTP Status of 200 for success and appropriate other codes for failures.

The Glue web service API provides the following service groups:

• Security Service: Responsible for security management of Glue user accounts.
• Project Service: Manage projects within the Glue platform.
• Model Service: Manage 3D models within the Glue platform.
• User Service: Manage user information.
• Action Service: Access and manage action records.
• System Service: Retrieve information and check availability.

Here is an example of a web services API call to the Model Service to retrieve information of a given model specified by the model_id:

https://bim360.autodesk.com/api/model/v1/info.json?
  &company_id=autodesk_jt
  &api_key=c7e595c69a35422c8414e51736f67761
  &auth_token=f79462fc5a5346ba9dbd4f395781f9b4
  &timestamp=1349801232
  &sig=de4c1771541d4789a1e63762c60b34f1
  &model_id=53c41451-49e7-4b0a-919c-1499604d10c6
  &sterm=
  &pretty=1

So what can we do with this?

With the SDK, partners and customers can build a variety of fully interactive web based custom applications and integrations taking advantage of the Glue platform.

A simple call flow for a custom application might be:

• Perform user authentication.
• Query and list available models.
• Use the Glue viewer to display the model within the custom application.

This enables tasks like system integration, project management, accounting, etc. The web services API provides full data access to system objects:

• Users
• Projects
• Models
• Actions

An application can automatically update projects, models, etc. with information from external systems.

Basically, we are looking at the following architectural hierarchy, from bottom to top:

• BIM 360 Glue Platform @ Amazon
• Internet Connectivity
• BIM 360 Glue API Server
• BIM 360 Glue API
• System Integrations Enabled via Glue API

Where do I start?

Download the BIM 360 Glue SDK,

You will need an API Key and an API Secret. These are unique identifiers assigned for each user, company, or partner.

Furthermore, a Glue developer account is required, a user name and password. A normal user account can be converted to a developer one on request.

There are even further levels: a default developer account works within the privileges of normal glue user, whereas a privileged developer account can perform requests on behalf of other users as well.

The authentication to the BIM 360 Glue Platform starts with an API key and secret assigned by Autodesk. Once you have these two pieces of information, API calls can be authenticated to the BIM 360 Glue Platform in one of two ways:

• User name and password; using the API key and secret, a signed request including the user name and password is sent to the BIM 360 Glue Service, which returns an authorisation token.
• The authorisation token is used for all subsequent calls.

Here is a quick reference to further sources of information and two examples:

• SDK overview
• Detailed web service API documentation
• Viewer support – file formats
• Integration with project management system – CMIC
• Glue embedded within a web application – Maximo

I am looking forward to hearing what you come up with using this, and to exploring it in more depth myself anon. Have fun!

Boost Your BIM and Dance with an Elephant

Advent, advent! Yet another Revit API focused blog is born!

Harry Mattison, ex Revit API development team, has initiated Boost Your BIM and kicked it off with a series on using the built-in SharpDevelop development environment Revit macros to resolve duplicate tags:

1. Finding elements
2. Finding only family instances
3. Get & set parameter values
4. Transactions and wrapping up

Thank you, Harry, and the best of luck to you and your new blog!

Dances with Elephants

Also, for a more high-level strategic vision of things, don't forget to take a look now and then at Jim Quanci's Dances with Elephants.

Jim analyses how small companies can leverage big ones to help build their business, useful tactics eminently applicable to many Revit add-in developers.

He recently posted a number of exciting new essays, so I encourage you to go take a gander.

The Champions Roundtable at AU

Tuesday we held a DevLab at AU successfully exploring and resolving a bunch of interesting issues. I hope to get around to documenting and sharing some of them soon, before being overwhelmed by other new exciting stuff. The most pressing priority first, though: sharing the notes from the Revit API roundtable session.

My first session at AU was a very pleasant, comfortable and fun one, being a roundtable providing a free-for-all exchange of questions, views and feedback between the audience and a bunch of Autodesk employees. The Autodesk side included developers creating the Revit API, ADN developer supporters supporting people in making use of it, and consultants who actually use it themselves. The audience was you guys.

We tried to keep the questions and answers short and to the point, and I tried to take notes of everything said. They are provided below, only very slightly edited for readability, and possibly cryptic for those of you who did not attend the session. I wish you some enjoyable head-scratching trying to decipher what we actually meant.

Before we dive into the notes, here are its AU catalogue entry and a very few slides listing the goal of this meeting and the panellists answering the questions:

CP4109 – Revit API Round Table: Meet the Champions

Class Summary

• Interact with a panel of Autodesk Revit API experts
• Ask questions and discuss topics of your choice
• Get to know the people who shape the APIs you work with better
• Explain your views, ideas and problems directly face to face

Learning Objectives

At the end of this class, you will have

• Interacted with a panel of Autodesk Revit API experts
• Asked questions and discussed topics of your choice
• Got to know the people who shape the APIs you work with better
• Explained your views, ideas and problems directly face to face

Panellists

• Arnošt Löbel, Revit Developer
• Augusto Gonçalves, ADN
• Jeremy Tammik, ADN
• Miroslav Schonauer, Consulting
• Saikat Bhattacharya, ADN
• Steven Mycynek, Revit API Engineer

Learning More

• Revit Developer Center: DevTV and My First Plugin Introduction, SDK, Samples, API Help
• Developer Guide and Online Help
• API trainings, webcasts and archives > Revit API
• Discussion groups > Revit Architecture > Revit API
• API training classes
• ADN AEC DevBlog
• The Building Coder Revit API Blog
• ADN and ADN Open, The Autodesk Developer Network
• DevHelp Online for ADN members

Almost Unedited Notes from the Session

Here are my session notes in a rough and almost verbatim Q&A format:

What is coming up in future versions? We cannot talk about that here. Please join ADN for more info, sign an NDA agreement.

Why are you guys using Macs? No Autodesk or Revit-specific reason.

What are some common themes or requests for API app development? Hard to say, depends on company; high level: getting data from Revit, enterprise wide integration, setting up a BIM enterprise structure, company specific needs...

How can I effectively run a batch operation to open successive work shared Revit files and run an external command on them? Keep track of the processes; expect to handle failure and recovery. What do you want to achieve? You can use journaling, but not recommended. Open file, close file. No problem in theory. We are not leaking any memory. Managed stuff gets garbage collected eventually. To launch command automatically, install an external application and register for the OnDocumentOpenend event. Lots of communication pipelines available, various messaging mechanisms. What do you want to achieve? Export data to SQL, for example. One app doing this in a batch process, download file from Revit server. Ensure that the app provides feedback on what it is doing, log the events, be able to study log file. Maybe 1000 files process well and one of them fails. Saikat created a plug-in of the month which batch processes RVT files to upgrade them to a newer version doing SaveAs; it also logs all events and writes to text file. You can also look at the progress notification introduced in Revit 2013, that provides more feedback

General organisation of elements inside Revit: family dictates behaviour, categories, etc. this limits some things, pretty strict structure. Will this change? No, not significantly. We can take this as feedback.

External RealDWG application creates 3D drawing using Revit API? Develop Revit external application which queries external data source, query it regularly to write feedback... Revit threading model does not allow for directly attaching, need to use some kind of messaging model. An external program cannot directly access the Revit API.

AutoCAD provides the command console allowing data access without GUI... is anything similar coming for Revit? That would be a nice enhancement. Originally there was no API for Revit, it was highly user focused, and the thought was it would never need an API.

It is currently not possible to access the Revit database without opening Revit. What is the reason for that? You are always opening an application to access its complex internal data structures. It may be happening in the background, invisibly. We should be able to provide some kind of RealDWG-like access sometime in the future to RVT as well.

We would like to parametrically change the model to run different energy simulations on it; changing one parameter affects many other ones, creating a new model to export, but I do not want to see the changes, just change the model without visual feedback. How can this be achieved? The Revit model is parametric, you cannot even query it without regeneration, and it is in an invalid state until regeneration, e.g. transaction committed, half-baked until then. You can open documents in the background, then they are not visualised. Call OpenDocumentFile, it opens in the database but not in the UI. Later we added OpenAndActivate, which does both. Regeneration is smart. Revit updates only the minimal set requiring it. If you regenerate twice in a row, the second call does nothing.

Do I need to commit the transaction to ensure the model is correctly updated? Technically yes, but sometimes no. Sometimes the transaction needs to be committed to propagate the changes fully, sometimes simply regenerating is sufficient.

The API is great at customising the ribbon, but a more important aspect of Revit is its parameters, and there is little help there for users. Is there any way to improve this? We looked at putting a real API around parameters. Talk with the product managers, they need to balance requirements. Parameters could definitely be easier to use.

Managing large numbers of large Revit project files, it is difficult to keep everything up to date. Some people create a new local file every day, even update the central file. How stable is the program? Do I need to do anything to protect my model? We only create small test models. Some people create huge files. Stability is getting better all the time; regression tests improve all the time. Best practices improve. Most Revit problems have to do with not following best practice. The Revit API and every add-in always needs to respect best practice, not fight it. Completely different from other CAD systems. Big investment, understand the product and best practice.

Managing Revit server effectively? What are the best practices? It may be ok to update users every year, but painful to do so for servers, it is painful to update servers every year like Revit users. Is Revit server on the same release cycle as the Revit product? What would the alternative be? The file format should not change every release.

Can we edit a group in the API? No, you have to ungroup and regroup. There are some blog posts on this. If multiple instances of the group exist, you have to replace all the instances.

The dynamic updater framework can display a missing updater warning. Can I suppress that? There is an option to suppress that screen. When you register the updater you can set it as optional, so the end user is not bothered by the message if it is missing. Before that option appeared, you could just open the file without the updater, choose to ignore the missing updater, and save the file before sending it to someone else. Now you can control it as the updater implementer.

Some families have options for how they look in different views. Can I make other categories do the thing? Some families will only allow plan view. Can you achieve this from the UI? No. In that case you cannot do it programmatically either. Now I have to go and tag every damper in the section. The aim is to provide API access to everything available in the UI.

Issues with shared families. A family with no instances placed creates an instance of its geometry even if it is not placed. If an instance is placed which conflicts with the geometry, it can cause a 'cannot make type' error. How can this be worked around? This is a regeneration issue. Query noted.

How can I check what Revit is doing? Use the progress notification, which tells you all the sub-steps happening during transactions. You might have to do some primitive benchmarking.

Are processes that occur during regen behind the scenes documented in the journal file? Some stuff is, it is up to the individual programmer. They can check a journal coming back from a customer. The content may be cryptic and does not explain. Sometimes debugging significantly impacts performance, of course.

When I open a transaction on a work shared model, should I verify that all elements can be modified before committing the transaction? I don't think you can check whether an individual element is modifiable. There was a plan, maybe, for that. This kind of feature has been requested. Currently the transaction will be rolled back. Actually you can check this somehow, maybe.

DesignScript is now integrated in AutoCAD. Are there any plans for providing this in Revit as well? We would like to create parametric masses. DesignScript looks as if it is open enough to be integrated into Revit. No new language integration is simple, but it looks as if it might fit and be useful.

What are the most prominent issues you run across, the most common things that pops up? Install RevitLookup, explore the model. Driving from external process, use Idling event. Daily requests: multithreading, 100% API coverage of worksharing functionality, integration and speed. When we get several similar requests, we blog about them, either on The Building Coder or the ADN AEC DevBlog. Why do you ask this, actually? Just for sharing and discussing here together. Also we keep receiving recurring issues. It helps to know the real good solution. Another common issue: how to get data from Revit and export to Excel or Access, and reimport. It is easy, but customers face many challenges, lots of countrification needs. People coming from other CAD systems and used to the sketch plane modelling and create feature are a bit surprised by Revit family editor and constraints and dimensions etc. It is possible to create a dimensioned family and make it parametric through the API. That is not intuitive, that is a challenge. Take a few steps back, look at how Revit does things, and then reproduce that relationship programmatically. Revit is not mechanical engineering. Understand the UI first, and then move on to API.

Do you follow the Autodesk discussion forums? Yes.

Can I use formulas to establish parametric relations between different families, e.g. if I want the width of family A to be driven by the height of family B? Good question, not currently supported.

Can I access the document warnings? There is the failure API, but no access to the warnings. There are ways to get rid of failures. Install the failure processor at application level. You get called when transaction ends and if there are failures your processor is called and you can decide how to handle them. I get a model and it has 300 warnings in it. Can I get that list? The failure processor does not give you that list? No, probably not. If you go to look at warnings in Revit, you can export that list to a text file. It would be nice to be able to fix warnings such as the 'line off axis', provide tools and options to fix this, or an option to leave it as it is.

Every column I touch is part of a phase and design option. Currently the phase mapping is not part of the Revit API. I run into problems trying to match phases when they differ between linked and host model. We have a link API in 2013 and a list of additions, I think something more will be coming in that area. The goal for the API is to provide 100% access to all end user features. Right now all new features are automatically exposed to the API as well.

C# versus VB? It all goes to the same place. It all compiles to IL and can be decompiled as well.

Dispose is inherited through the class hierarchy from APIObject. Do we need to dispose of all the objects we use? It is probably good practice. It happens eventually through the GC. We have scoped objects, everything with a start and an end, e.g. transaction. If you dispose that, it is automatically ended. The easiest way is to use a 'using' block. You must call Commit, Rollback or Dispose. APIObject is only a very thin wrapper. Dispose does not actually do anything. If you need to clean up memory and access a lot of data from Revit, you may want to call Dispose yourself in between loop iterations, e.g. If you do not call Dispose, Revit will hold on to the object even if GC is called. If you call Dispose, then we let go. When the command ends, everything is disposed. Revit elements can have an unpredictable lifetime. It is always safer to hold on to an element id rather than an element. Native pointers are invalidated. You can test whether an element is invalid. You can modify an element, then delete it, undo the deletion, and the element pointer will go from valid to null and back to valid again. You do not have to refetch the element, actually, Revit handles its validity. The API creates a managed wrapper around the native pointer.

Error reporting. When a user has an error and we do not have all the info. Is there a central file location where more error reporting is available? Beside the journal there is something worksharing related log file, extension 'slog', monitoring activity between local and central, meant for programmers, not customers, that might provide some hints. Same folder as central file.

Insight into eTransmit? Visit Arnošt's AU session on Wednesday.

Unique id? Working with linked files, the unique id can actually be the same for different files. Looking for a view n a linked file, the view in link and host has the same unique id. Element id yes, of course, they only work within the session, and might change due to worksharing session, but unique id should be stable and unique. If you see a duplicate unique id, please report it to us.

What are the coolest projects you have seen? The ruby scripting plugin and its installer. ZoomToAwesome, which basically consists of one single line of code.

A plugin can bring down Revit. This should not happen. Revit builds in protection in the external command framework that should shield Revit and the end user from all misbehaviour. Dynamic updaters as well. App can cause exception within exception, very hard to protect against. We make it as robust as possible, and still try to open up wide and give you all the options. Example: call a command, do something bad, invalid geometry, try to commit transaction, failure handling, try to resolve, you have a failure resolver, this causes another exception, things can get really bad. A point about add-ins, which is a limitation of .NET and Windows: if your add-in uses COM interop and dereferences an invalid pointer, we cannot protect against that. Unsafe code and p/invoke cannot be protected completely.

Reload the keynotes text file from the API. Not supported, sorry.

Building is data. Can we tap into that without dB link? Direct query?

Thank you for a very interesting discussion with numerous insights on both sides! Have fun using the Revit API!

Survey and Project Base Point

Happy Thanksgiving!

I am on the road to Las Vegas now, gearing up for last-minute AU preparations. No actually, I am pretty much set to go. Other upcoming developer conferences still require some work, though.

Meanwhile, here is some useful information on survey and project base points gathered by my colleague Joe Ye:

Question: We need to work with the project base point and the survey point to design platforms in real-world coordinate systems and load survey data from DXF and DWG files containing geo-referenced coordinates. We therefore wish to use the Revit API to work with the project base point and the survey point.

Could you please explain how to programmatically achieve the following?

• Get and set the location of the project base point and the survey point.
• Get and set their parameters (shared coordinates).
• Lock and unlock these points.

Additionally, here are a few further questions to improve our understanding of this topic:

1. In Revit we are limited to a distance of 10 kilometres. Does this mean that it is necessary to move the survey point together with the shared coordinates of real coordinate systems? I successfully placed a platform into a project 25.000 kilometres distant from the project base point (0,0,0) and the survey point (0,0,0).
2. What is the relation between the shared site (the parameters of the point) and the location of the survey / project base point?
3. Am I right in my assumption that the survey point changes it's parameters (shared site) when moved depending on whether it is "locked" or not?

Answer: The Revit API for shared coordinates is currently still a bit limited. Here is some of the available functionality:

• Document.ProjectLocations will return all of the ProjectLocations (sites) in a project.
  • These provide Name and ProjectPosition properties that can be used to change the name or position of the site.
• The base point and survey point can be retrieved through a FilteredElementCollector for BasePoints.
  • The BasePoint whose IsShared property is true represents the survey point.
  • Each BasePoint has a Location property that you can set to move the point.
  • The clipped/unclipped state of the base and survey points cannot be set via the API. You can pin them using the Element.Pinned property.
• You cannot currently access the shared location of a Revit or DWG instance via the API.
• You cannot establish a shared-coordinates relationship with a link instance via the API. If the link is already using shared coordinates, then moving the survey point will move the link.

To answer your other questions:

1. The distance limit restricts you from moving the coordinate system origin point more than 10k away from its origin. It is still permissible to place Elements far away from the coordinate origin.
2. There isn't necessarily any relationship. Sites are locations you define as you like. They can be placed anywhere.
3. Yes. If the survey point's clipped, then it is 'attached' to the world, and when you move it, you move the world with it. If you want the survey point to represent some location other than (0,0,0), you can unclip it to move it and nothing else.

Many thanks to Joe for digging this up!

BIM for Infrastructure White Paper

Talking about survey points and stuff like that, a new white paper has just been released explaining the use and advantages of BIM for infrastructure: BIM for Infrastructure: A vehicle for business transformation discusses BIM as the vehicle by which the business of planning, designing, building, and managing the world's infrastructure will be transformed to deliver higher productivity, quality, and cost-effectiveness.

ODBC Export

A recurring topic is programmatic ODBC export.

Here is a typical query on this topic with an answer by Saikat Bhattacharya:

Question: Is there a way to export the whole Revit database to an external database such as MSsql via the ODBC link, similarly to the manual process or using DBLink, but avoiding all the dialogues for choosing the ODBC connection etc.? I would like to set up the connection programmatically in .NET instead.

Answer: The Revit API provides direct access to the underlying data. You can implement your own export functionality to any external database including MSsql. How to implement this is completely up to you to decide.

The API provides access to the data in the model that might need to be included in the export. With the data available, the connection can be set up and desired data exported to any external database.

The Revit 2010 SDK still included the RDBLink sample, so that code is available in case of interest. Due to its size and complexity, it was later promoted to a subscription feature and removed from the SDK. If you like, you could migrate the old Revit 2010 code to the current version and use it as a basis for your own implementation.

Here are a couple of discussions related to this topic:

• RDB Link tool on Autodesk Labs.
• Integration with a database or ERP system.
• In-depth analysis of integrating with external databases and other data sources.
• Adding a column to RDBLink export.
• Exporting parameter data to Excel, and re-importing.

Many thanks to Saikat for putting together this overview!

Porting an AutoCAD Application

AutoCAD and Revit are very different animals, as we already pointed out a couple of times in the past.

Exaggerating just a little, you might say that Revit manages a BIM and ensures its consistency at all times, so there are no exceptions to anything ever, meaning nothing can be overridden. Moreover, almost all Revit geometry is parametrically driven, so there is no way to tweak the model geometry either, except of course by changing the official parameter values.

This is obviously a challenge to developers with existing AutoCAD applications. Here is another example of some typical considerations of an application developer with an existing full-blown AutoCAD application, wondering whether there is any way to start supporting Revit as well:

Question: We have customers using our software and asking if we could port our AutoCAD.NET application to Revit.

In our current implementation, we override line functionality to display special walls. We need to modify subcomponents individually, manipulate grip points, split them, add more components, etc.

Intersections between walls affect neighbouring walls and their subcomponents.

We have therefore currently overridden grip points, snap points, graphics, properties, a custom ribbon is regenerated then an object is selected and so on.

Is it possible to implement something similar with Revit? I guess we probably need to customize the functionality of some wall type? What is best place to start if this is possible?

Answer: I am afraid that the answer is definitely not that you can simply port your existing application.

The Revit API is completely different from the AutoCAD one.

More than this, the entire underlying principles, workflows and paradigms are utterly different and almost beyond comparison.

In fact, one of the biggest stumbling blocks to learning the Revit API is being caught up in preconceptions coming from AutoCAD or other non-BIM APIs.

In Revit, almost all the functionality you list above cannot be overridden, because Revit manages a building information model, BIM, and ensures that it remains consistent at all times.

The proper approach in Revit would probably be to define an appropriate family and family types.

I am not at all a product expert, though, so I cannot advise you at all about how best to implement your specific model in Revit. You need to consult with application engineers and product experts about that, and above all understand the existing Revit functionality in depth before you even start considering creating an add-in application, which may easily end up reproducing or even fighting against the recommended Revit paradigms and workflows.

What I can tell you with a hundred percent certainty is that your existing AutoCAD application cannot simply be ported to Revit, and that your best approach will almost certainly require reconsidering the whole implementation from scratch.

What I can also say with conviction is that it will probably be well worth your while in the long run to start learning and understanding the Revit BIM concepts and researching how a useful add-in for that domain might look, to enable you to start work on a BIM-compatible implementation, in which you will certainly be able to reuse a lot of your existing know-how and continue supporting your customers as they gradually migrate to BIM usage.

If you have customers knowledgeable in Revit who are interested in cooperating with you to drive such a project, I would take that opportunity with great gratitude if I were you.

Best place to start? Learn the product functionality, and do your best to forget AutoCAD for a moment.

Response: Thank you for a great answer!

I think at this point we have to stick with AutoCAD due the limitations or the concept of Revit. The main interest of our customer in using Revit was using IFC for integration with thermal calculation applications.

Of course Revit would also save us having to implement a number of additional objects like openings, roofs etc. that are not available in AutoCAD.

I believe we will continue implementing the functionality on top of AutoCAD but still continue to research Revit at the same time. Perhaps at some point we could implement some kind of separate editor for our model, maybe using a WPF dialogue user interface that plays with normal walls in Revit. If I read the API documentation correctly, we can still store additional info to wall objects.

Answer: Your approach sounds very feasible and sensible to me.

Implementing additional functionality in a separate WPF dialogue interacting with Revit would work fine.

Please be aware that you can also maintain your existing AutoCAD functionality and access that in the background, invisibly to the user, from your Revit add-in.

For example, you can read the relevant data from the Revit model, process it in the background using your existing application, and display useful results in your own WPF dialogue in a way that supports an efficient Revit workflow. That might enable you to achieve a near perfect solution with little effort.

And yes, absolutely, you can store any additional data you like on walls and any other elements using the extensible storage functionality.

Importing SAT into Revit

People now and then ask about programmatically importing a SAT file into Revit.

You can export a SAT file using the API and import an SAT file from the user interface, simply by going through Insert > Import > Import CAD > ACIS SAT Files.

However, the Revit API Import methods only take options for DGN, DWG/DXF, gbXML, and images.

One obvious workaround is to implement an intermediate step to generate a DWG file from the SAT one.

This can be achieved either using RealDwg or AutoCAD itself, if it happens to be installed on the same machine.

In either case, the description of implementing ACISIN and ACISOUT in .NET might come in handy to achieve this.

ElementTransformUtils and Family Instance Creation May Force Regeneration

If you are facing performance problems generating or manipulation largish models, please be aware that you need to watch out a bit with the ElementTransformUtils class. Some of its methods contain built-in regeneration at the end, which is executed regardless of your other regeneration actions. Family instance creation can also force regeneration at times. As always, some research and lots of benchmarking is advisable.

AU Registration Savings End October 14

The end is near!

Oct 14 is the last chance to save $500 on the Autodesk University 2012 registration.

Prepare thyself and register now.

Hope to see you there!

IFC Export Area Calculation and Other Enhancements

Here is a typical question that may arise when working with IFC export and shows the importance of the extension possibilities provided by the IFC export open source project:

Question: How are the areas and volumes of walls, rooms, floors, etc. calculated for the IFC export? Are any standards being used?

Some examples of values and parameters in question when we export IFC files from Revit:

• For rooms IfcSpace under BaseQuantities: GrossFloorArea, NetFloorArea; these values are the same in my trials.
• Base quantities of walls are missing for IfcWall but present in IfcWallStandardCase; why is this?
• For IfcWall under dimensions (IfcPropertySet): Area, Volume, Length.
• For IfcWallStandardCase under BaseQuantities (IfcElementQuantity): Height, Length, Width, GrossSideArea, GrossFootPrintArea, GrossVolume.

Some other CAD products define other parameters as well; for example, a wall may provide both GrossSideArea and NetSideArea, GrossVolume and NetVolume.

Can we get this from Revit also? Would this require us to modify the export, e.g. through the open source project, calculate net parameters, and so on?

Answer: Good questions!

• Regarding the rooms IfcSpace BaseQuantities GrossFloorArea and NetFloorArea: I think currently they point to the same internal area, which of course is not ideal. Revit only has one type of room area calculation at a time, so it is a bit difficult to get multiple areas from the same room.
• Some of the wall areas are calculated based on the extrusion that is generated on output. Generally, for IfcWall, there is no extrusion, so we can't calculate the particular values. That said, we can re-examine to see if there are more properties that can be retrieved directly from the original Revit element.
• Regarding 'more parameters from other products': I'll summarize how it currently works, and what could be done:
  1. We generally export the parameters that Revit already calculates. The IFC export intentionally does not implement a lot of its own 'QTO' (Quantity Take-Off) calculations.
  2. Since the IFC code was originally written for QTO, it is possible that more Revit quantities have been added to the project since then. Adding to the open source project would easily write out those quantities to the IFC file.
  3. For others, we would have to do some calculations. These could be done as part of the open source project, requested from the Revit development team, or implemented as a separate Revit add-in, e.g. by adding custom parameters or extensible storage data to the model, which the IFC export could pick up and handle if it is found.

If you are thinking of amending the open source code and you make changes that you think would be beneficial to the entire community, we'd appreciate if you considered 'donating' your changes to the project.

Async and Await Easily Enable Asynchronous Interaction

Continuing our cloud and web service ruminations, here is an interesting little hint on asynchronous interactions:

If you are thinking of implementing asynchronous interaction in your web service, which is often a very commendable and necessary thing to do in order to ensure responsiveness and avoid user frustration at a program that just hangs and does nothing, you can save yourself a lot of effort by looking at the async and await keywords provided in the .NET Framework 4.5 Beta.

The asynchronous programming model used in last few years requires a lot of careful attention while coding, which is tremendously simplified by the async features in the latest versions of C# and Visual Basic.

For a very readable overview of this new feature, here is an MSDN article by Brandon Bray, Async in 4.5: Worth the Await, and an async and await FAQ by Stephen Toub.

Unfortunately, as far as I can tell, .NET 4.5 cannot be used with Visual Studio 2010, so I cannot play with this until I move on a bit, which I will try to postpone until I get a new machine, which should happen any time now. I recently installed MVC 4 and thus proved first-hand that it works with VS 2010, which in turn proves that that does not require .NET 4.5.

Cancel Family Creation and UK NBS and BIM News

Let me begin directly with some Revit API sample code today.

Here is a little external application showing how you can optionally prohibit family creation by subscribing to the cancellable DocumentCreating event:

class App : IExternalApplication
{
  void OnDocumentCreating(
    object sender,
    DocumentCreatingEventArgs e )
  {
    DocumentType typ = e.DocumentType;
 
    if( DocumentType.Family == typ )
    {
      TaskDialog d = new TaskDialog( 
        "Open Family Editor?" );
 
      d.MainInstruction = "Creating a new family "
        + "document... would you like to proceed?";
 
      d.MainContent = string.Format( 
        "Document type: {0}\r\nCancellable: {1}",
        typ, (e.Cancellable ? "Yes" : "No") );
 
      d.CommonButtons = TaskDialogCommonButtons.Yes 
        | TaskDialogCommonButtons.No;
 
      d.DefaultButton = TaskDialogResult.No;
 
      if( TaskDialogResult.No == d.Show() )
      {
        e.Cancel();
      }
    }
  }
 
  public Result OnStartup( 
    UIControlledApplication a )
  {
    a.ControlledApplication.DocumentCreating 
      += new EventHandler<DocumentCreatingEventArgs>( 
        OnDocumentCreating );
 
    return Result.Succeeded;
  }
 
  public Result OnShutdown( UIControlledApplication a )
  {
    return Result.Succeeded;
  }
}

Surprisingly short and simple, isn't it, and the code speaks for itself, does it not?

Here is CancelFamilyCreation.zip containing the full source code, Visual Studio solution and add-in manifest of this little add-in.

The UK National BIM Library and NBS

For some little less hard-core UK-related BIM news, Stephen Hamil of RIBA Enterprises pointed out a couple of interesting titbits related to NBS and the National BIM Library, a free resource for the UK construction industry:

• The free NBS for Revit tool has been released.
• Report from the first BIM user day with a number of big Autodesk users such as HOK, BDP, LOR, Balfour Beatty, Ryder, Ramboll...

Thank you, Stephen, for the note.

dpStuff Add-ins

Finally, I took a quick look at the free dpStuff Revit add-ins ChangeTextCase and NumberStuffByDirection, which look both useful and interesting. Thank you, Dima Chiriacov, for sharing these!

Create a Pipe Cap

Happily mixing the different Revit versions, let me follow up my work on the Revit MEP 2013 API and the updated AdnRme sample by another MEP related topic.

Before getting to that, though, here is a brief heads-up for a new technology preview on Autodesk Labs:

BIM Coordinator

The effective organization of project data in shared or related coordinates is essential to effective collaboration across disciplines and good quality project information. BIM Coordinator for AutoCAD Civil 3D and Revit is a technology preview that assists project team members with building and site grids.

Here is a brief overview taken from the labs:

Building grids are generally selected based on the layout and shape of the building, usually using the lower left corner of the selected orientation as a reference point. Building grids are established by the lead designer of a project for use by all members of the building design team. This grid ensures that different disciplines' building designs use the same reference for purposes of building analyses, drawing production, and other tasks requiring coordinated building data.

Site grids are generally based on Northing and Easting coordinates. They are usually established for a region; although arbitrary grids can be established for a single project or site. For example, in the UK most sites are related to the Ordinance Survey (OS) grid. Site elevations (levels) are also based on an OS benchmark or other site/project benchmark.

BIM Coordinator automates the more error-prone manual steps in the coordination of site and building grids between the AutoCAD and Revit environments, currently for the 2012 versions. The tool specifies one common XYZ point and its orientation in the XY plane between the two coordinate systems. This reference point defines the relationship between the building and site grid.

Miroslav Schonauer will be explaining some background and sharing source code from this utility at the upcoming AEC DevCamp in Waltham June 6-7.

Create a Pipe Cap

Back to the Revit MEP API, I presented an example to create a pipe cap in Revit 2011 over a year ago.

Now Mick Kulik of Hydratec, Inc. discovered that the existing sample code did not work in his case, and worked together with Saikat Bhattacharya at the AutoCAD DevLab in San Rafael to fix this issue for Revit 2012.

Here is the original problem and its solution:

Question: Following the post about creating a pipe cap, I was not able to get a cap to connect to a pipe in Revit MEP 2012. The Error is "Line is too short". Is there a new way to connect caps to pipes in Revit MEP 2012?

Answer: Saikat came down to give us a hand last week at the AutoCAD DevLab in San Rafael. He had some sample code to attach caps to sloping pipes. I was able to massage his code to fit our needs, and have attached his CapAtStartOfPipe.zip containing the entire source code and Visual Studio solution implementing this command.

Saikat's code worked on all the cases we tested except when trying to connect the cap to a non-sloped vertical pipe, so I built in a case to handle it which worked for my test cases:

  // rotate the cap if necessary
 
  // rotate about Z first

  XYZ pipeHorizontalDirection 
    = new XYZ( dir.X, dir.Y, 0.0 ).Normalize();
 
  ConnectorSet c2 
    = fi.MEPModel.ConnectorManager.Connectors;
 
  Connector capConnector = null;
 
  foreach( Connector c in c2 )
  { 
    capConnector = c; 
  }
 
  XYZ connectorDirection 
    = -capConnector.CoordinateSystem.BasisZ;
 
  double zRotationAngle 
    = pipeHorizontalDirection.AngleTo( 
      connectorDirection );
 
  Transform trf = Transform.get_Rotation( 
    start, XYZ.BasisZ, zRotationAngle );
 
  XYZ testRotation = trf.OfVector( 
    connectorDirection ).Normalize();
 
  if( Math.Abs( testRotation.DotProduct( 
    pipeHorizontalDirection ) - 1 ) > 0.00001 )
  {
    zRotationAngle = -zRotationAngle;
  }
 
  Line axis = doc.Application.Create.NewLineBound( 
    start, start + XYZ.BasisZ );
 
  ElementTransformUtils.RotateElement( 
    doc, fi.Id, axis, zRotationAngle );
 
  // Need to rotate vertically?
 
  if( Math.Abs( dir.DotProduct( XYZ.BasisZ ) ) 
    > 0.000001 )
  {
    // if pipe is straight up and down, 
    // kludge it my way else
 
    if( dir.X == 0 && dir.Y == 0 && dir.Z != 0 )
    {
      XYZ yaxis = new XYZ( 0.0, 1.0, 0.0 );
 
      double rotationAngle = dir.AngleTo( yaxis );
 
      if( dir.Z == 1 )
      {
        rotationAngle = -rotationAngle;
      }
 
      axis = doc.Application.Create.NewLine( 
        start, yaxis, false );
 
      ElementTransformUtils.RotateElement( 
        doc, fi.Id, axis, rotationAngle );
    }
    else
    {
      #region sloped pipes
 
      double rotationAngle = dir.AngleTo( 
        pipeHorizontalDirection );
 
      XYZ normal = pipeHorizontalDirection
        .CrossProduct( XYZ.BasisZ );
 
      trf = Transform.get_Rotation( 
        start, normal, rotationAngle );
 
      testRotation = trf.OfVector( dir ).Normalize();
 
      if( Math.Abs( testRotation.DotProduct( 
        pipeHorizontalDirection ) - 1 ) < 0.00001 )
      {
        rotationAngle = -rotationAngle;
      }
 
      axis = doc.Application.Create.NewLineBound( 
        start, start + normal );
 
      ElementTransformUtils.RotateElement( 
        doc, fi.Id, axis, rotationAngle );
 
      #endregion
    }
  }
 
  doc.Regenerate();
 
  // pick connector on cap:
 
  ConnectorSet connectors 
    = fi.MEPModel.ConnectorManager.Connectors;
 
  Debug.Assert( 1 == connectors.Size, 
    "expected only one connector on pipe cap element" );
 
  Connector cap_end = null;
 
  foreach( Connector c in connectors )
  { 
    cap_end = c; 
  }
 
  // pick closest connector on pipe:
 
  connectors = pipe.ConnectorManager.Connectors;
 
  Connector pipe_end = null;
  double dist = double.MaxValue;
  foreach( Connector c in connectors )
  {
    XYZ p = c.Origin;
    double d = p.DistanceTo( start );
    if( d < dist )
    {
      dist = d;
      pipe_end = c;
    }
  }
  pipe_end.ConnectTo( cap_end );
 
  doc.Regenerate();
 
  // After ConnectTo, the cap size is double, so 
  // need to change the nominal radius to half.
 
  if( fi != null )
  {
    ConnectorSet pipeConnectors 
      = pipe.ConnectorManager.Connectors;
 
    Connector pipeEnd = null;
 
    foreach( Connector c in pipeConnectors )
    {
      pipeEnd = c;
    }
    double radius = pipeEnd.Radius;
 
    Parameter para = fi.get_Parameter( 
      "Nominal Radius" );
 
    if( para != null && !para.IsReadOnly )
    {
      para.Set( radius );
    }
  }

Here is a screen capture of the result of testing caps on a vertical pipe:

Many thanks to Saikat and Mick for providing this new sample!

Keep Dialogues Modal!

Today is the winter solstice, the shortest day of the year, at least in the parts of the world I normally frequent. Just as the sun reached the end of its descent, we finally reached the end of our conference tour, here in the UK. I am exhausted and very much looking forward to returning home. There will be only rather a short time left to prepare for Christmas and my children's visit when I arrive.

Meanwhile, here are a couple of items that showed up in my in-box:

• Village BIM
• Dynamically served WebGL content using the FBX Python SDK
• Keeping dialogues modal

Bienvenu a Village BIM!

A new BIM and thus Revit related blog in French language has been launched by group of French AEC technical specialists, Alexandre Mihalache, Emmanuel Di Giacomo, Julien Drouet, Olivier Bayle and Stephane Balmain: Village BIM.

Dynamically Served WebGL Content Using the FBX Python SDK

Are you interested in FBX? Want to be impressed by the power of Python? How about dynamically serving WebGL content over the web from an FBX file? This can be easily achieved using the FBX Python SDK, as demonstrated by this description including a short video.

Keep Dialogues Modal

Here is a piece of very important advice on the topic of modeless versus modal and asynchronous communication with Revit by Mario Guttman, AIA, LEED AP, Senior Associate and Design Applications Research Leader at Perkins+Will:

I want to share something with you which you may find interesting. A lot of my work entails presenting the user with a dialog box and then taking action based on their choices on the dialog box. Recently I have been using this pattern to drive actions that use the on-screen selection methods 'Autodesk.Revit.UI.Selection.PickObjects' and 'Autodesk.Revit.UI.Selection.PickElementsByRectangle'. The problem is that I want to leave my dialog box during the pick process and then, optionally, return to it when the user has finished making selections.

For a while I was using a non-modal dialog but got some odd behaviour and then learned at AU that this was not a good idea at all unless I was going to really manage the threads with an Idling event. I did some research around this issue and even went to Arnošt Löbel's class CP5381 on Asynchronous Interactions and Managing Modeless UI on this topic. It's all pretty complicated for us mere mortals.

What I realized, however, is that all of the discussion I was hearing was about ways of keeping a non-modal dialog visible while the user was working on the screen. I don't really need that, in fact I'd rather not have the dialog in the way. I could close the dialog before taking action but then I would have to remember all the settings and code the action in a separate file. The solution that I found is to just keep the dialog form alive but just not open. This means that all of the settings, commands, etc. can be kept in the code file associated with the dialog, even though I am calling it from outside. This also makes it easy to reopen the dialog if needed after the user is done interacting with the model.

Here is InterfaceStudy.zip containing a simple example that illustrates this idea.

Jeremy adds: as said, this is really relevant advice, so please pay heed!

Families Guide

A long time ago, in the far distant past, before the advent of the Family API, Revit API developers and family content creators were two entirely separate camps with their own secret arts and magic charms. Since then, we have been given programmatic access to the family creation functionality, and the synergy in the union of these two camps is growing.

This makes it all the more important for any developer to have an in-depth understanding of the family creation process. One effective way to build this kind of understanding is to work through the Revit Families Guide. The latest version provided is for Revit 2010. It includes readme files, documentation, and datasets for hands-on exercises, all of which are provided in fourteen languages and both metric and imperial versions. Strongly recommended for anyone diving into Revit customisation or programming in any depth.

Here is also a short (8 minute) live training tutorial:

For further study, there are also some commercial training sessions and DVDs available for purchase, for instance from Paul F. Aubin, CADclips.com and Steve Stafford's AEC Advantage.

Many thanks to Pawel Piechnik, Autodesk Sr. Structural Product Manager in Krakow, Poland, for highlighting this to us!

The Value of BIM

Here are some other videos and documents that may be of interest to you highlighting the value of BIM for MEP and structural engineers.

• Revit Structure and Robot Structural Analysis video demonstrating BIM for analysis
• Engineers guide to Retrofits
• What can BIM do for you?
• Bringing analysis and simulation to the forefront of an MEP engineers workflow
• Engineers Look at Building Information Modeling as a Science

Another useful asset is the Project Storm for Revit Structure, which was recently published on Autodesk Labs, and for which an update is now available. Here are two short press reviews on it in Modern Steel and Construction and The Revit Kid.

BIM Apps, Project Galileo, and Piotr's Plug-In

Here are a couple of interesting news items that cropped up in the past few days:

Introducing BIM Apps

Emile Kfouri used to lead the Revit API development team and is now the Autodesk BIM Application Development Manager. Emile started up a new blog, BIM Apps, devoted to API applications for Autodesk's BIM tools. He is starting a two month trial period to 'test the waters' and determine whether or not the BIM community would value a blog devoted to this topic. Blog traffic will be used as the primary indicator of longer term success. If you are interested and wish to contribute, please have a look at his first few posts and take the survey to help Emile better understand the potential audience.

Project Galileo

Project Galileo is a new technology preview available on Autodesk Labs, developed for 3D city modelling, conceptual design and visualization in the planning phase of city-scale infrastructure projects:

It is an easy-to-use planning tool for creating 3D city models from civil, geospatial and building data, and 3D models. It enables users to sketch conceptual infrastructure ideas within the 3D city model. It can be downloaded and used freely as a technology preview which will operate until August 15, 2011.

Just from the videos on it, it seems to me that it might be based on Revit, just like the Project Vasari that we looked at last year. The really interesting thing about that was that the full Revit API is available inside the product. Maybe that is the case for Project Galileo as well?

Piotr's Plug-In

Piotr Zurek recently described his solution to refresh the Referencing Sheet parameter. Just to completely close the topic, he has now published his own blog post about the workaround and his plug-in making use of it, my first Revit plug-in on piotrzurek.net. Thanks again to Piotr for his research and sharing the results!

Bienvenue à StructureBIM

A new French language Structural Engineering BIM blog is born: StructureBIM.

It is mainly focused on Autodesk Revit Structure, Autodesk Robot Structural Analysis, AutoCAD Structural Detailing, and authored by Alexandre Mihalache, Olivier Bayle, Stéphane Balmain and Emmanuel Lagardette.

Welcome to the Revit blogosphere!