The Building Coder

Melbourne DevLab

The last few days I started walking on foot from Flinder Station to Queen's Road. I can enjoy lush green grass, beautiful huge trees and strange birdsong in morning sunlight all the way past the Shrine of Remembrance. It takes just ten minutes longer than waiting for the overfilled noisy slow tram, in which I am forced to stand and therefore can't look out through the windows due to my height.

The Melbourne Revit API training day one and day two were followed by a DevLab.

A DevLab is an open event where developers roll up bringing their current work and issues and continue developing side by side with one or more ADN DevTech engineers, in this case poor old me.

We had three days to play with and achieved some quite exciting and impressive results. Here are some of them:

• Delete all 3D views.
• Retrieve specific views: GetNicksViews.
• Find unnamed reference planes using a parameter filter.
• Delete reference planes not hosting any elements: DeleteUnnamedNonHostingReferencePlanes.
• Find elements which have had certain information added, so they can be deleted and updated.
• Automatically create setout points for on-site location and construction of structural elements.

The first couple of items were things I worked on with Nicholas Broadbent of COX Architecture, who is also involved in a whole bunch of other exciting projects, such as:

• A Navisworks clash detection data importer for Revit.
  • Save Navisworks clash detection data into the clashing elements in Revit.
• A link between Rhino (using the Grasshopper plug-in) and Revit.
  • Draw Revit straight and arced beams from points exported from Rhino.
  • Place family instances and adaptive components using the same exported data.
  • Avoid using SAT files. A known issue is that they can crash Revit.
• Exporting a Revit model to the Unity Gaming engine.
  • Looking up Revit data in an Access database based on a Revit element id.
  • Display Revit data in the Unity gaming engine when you click on an element.
• FBX C++ API
  • Modify an FBX file, renaming and merging nodes.

The second and third days I spent most of the time together with Paul Hellawell of GHD working on a full-blown end-user-capable little application for the automatic creation of setout points for on-site location and construction of structural elements. I'll say a little bit about it below and we plan to post the full description, add-in and support files sometime soon.

After DevLab, we went off on a visit to a pub or two which is right now starting to turn into a crawl. Here are The DevLab Boys at the Loop:

This place calls itself an architectural and experimental space and used to be the venue of Revic, the Revit Users Group of Victoria.

From there we moved on to Siglo, in the same house as the Supper Club that I visited just a few days ago:

Retrieving Specific Views

Actually, we have had a couple of beers by now, and both Nick and Paul are enjoying 40 dollar cigars (credit: Nick bought), so I will simply post this with no further comment:

[Transaction( TransactionMode.Manual )]
public class Command : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Application app = uiapp.Application;
    Document doc = uidoc.Document;
 
    List<ElementFilter> a
      = new List<ElementFilter>( 4 );
 
    a.Add( new ElementClassFilter( typeof( View3D ) ) );
    a.Add( new ElementClassFilter( typeof( ViewDrafting ) ) );
    a.Add( new ElementClassFilter( typeof( ViewPlan ) ) );
    a.Add( new ElementClassFilter( typeof( ViewSection ) ) );
 
    LogicalOrFilter f = new LogicalOrFilter( a );
 
    FilteredElementCollector col 
      = new FilteredElementCollector( doc )
        .WhereElementIsNotElementType()
        .WherePasses( f );
 
    foreach( View view in col )
    {
      //Debug.WriteLine( view.IsTemplate.ToString() 
      // + ":" + view.ViewType.ToString() + ":" 
      // + view.ViewName.ToString() + ":" 
      // + view.Id.ToString() );
 
      Debug.Print( 
        "{0} : {1} : {2} : {3}",
        view.IsTemplate, view.ViewType, 
        view.ViewName, view.Id );
 
      if( !view.IsTemplate ) 
      {
        // . . .
      }
    }
 
    return Result.Succeeded;
  }
}

Delete Reference Planes Not Hosting Any Elements

A complex model can contain a pretty huge number of useless reference planes.

Nick proposed deleting all reference planes that

1. Have not been assigned a name, and
2. Do not host any elements.

To maximise performance, we use a parameter filter to check that the reference plane name is non-empty. That is about twice as efficient as just filtering for all reference planes and then using LINQ or an explicit loop in .NET to check for a non-empty name.

Once we have found all the reference planes with a non-empty name, we need to check for each whether it hosts any elements. This topic has been covered several times in the past, e.g. looking for generic object relationships (also available for VB).

The simplest approach that I am aware of is to delete it and check the number of element returned by the Delete method. This list should include at least the element id of the reference plane itself, if the deletion succeeded. If its length is larger than one, other elements were affected, which in this case probably means that they were hosted by the plane.

So, if the number of deleted elements equals one, we are happy and have deleted a reference plane hosting no other elements. If the number is larger than one, it probably hosts something. In that case, we can simply abort the transaction to undo the deletion attempt.

The deletion including the commit or rollback is achieved by the DeleteIfNotHosting method:

bool DeleteIfNotHosting( ReferencePlane rp )
{
  bool rc = false;
 
  Document doc = rp.Document;
 
  Transaction tx = new Transaction( doc );
 
  tx.Start( "Delete ReferencePlane " 
    + (++_i).ToString() );
 
  // Deletion simply fails if the reference plane 
  // hosts anything. If so, the return value ids 
  // is null:
 
  ICollection<ElementId> ids = doc.Delete( rp );
 
  if( null == ids || 1 < ids.Count )
  {
    tx.RollBack();
  }
  else
  {
    tx.Commit();
    rc = true;
  }
  return rc;
}

If you look carefully, you'll notice that we number the transactions that we generate so that they can be differentiated in the user interface undo list.

Actually, during debugging, I noticed that the deletion simply fails if the reference plane is hosting any elements, so the approach that I originally envisaged is not working. However, the failed deletion attempt returns a null collection of element ids instead of one containing more than one element. I added the null check and roll back the transaction in that case also, and all is fine.

Since the deletion fails anyway for a reference plane hosting anything, we could just as well commit the transaction, I suppose, but I prefer to roll it back. Given more time to play, I could check which is faster or uses less resources, rolling back or committing. In AutoCAD ObjectARX, rolling back is significantly more expensive than committing, but I assume that is a special case.

This method is driven by the mainline Execute method which implements the parameter filtering for non-empty reference plane names:

  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Application app = uiapp.Application;
    Document doc = uidoc.Document;
 
    // Construct a parameter filter to get only 
    // unnamed reference planes, i.e. reference 
    // planes whose name equals the empty string:
 
    BuiltInParameter bip
      = BuiltInParameter.DATUM_TEXT;
 
    ParameterValueProvider provider
      = new ParameterValueProvider(
        new ElementId( bip ) );
 
    FilterStringRuleEvaluator evaluator 
      = new FilterStringEquals();
 
    FilterStringRule rule = new FilterStringRule(
      provider, evaluator, "", false );
 
    ElementParameterFilter filter
      = new ElementParameterFilter( rule );
 
    FilteredElementCollector col 
      = new FilteredElementCollector( doc )
        .OfClass( typeof( ReferencePlane ) )
        .WherePasses( filter );
 
    int n = 0;
    int nDeleted = 0;
 
    // No need to cast ... this is pretty nifty,
    // I find ... grab the elements as ReferencePlane
    // instances, since the filter guarantees that 
    // only ReferencePlane instances are selected.
 
    foreach( ReferencePlane rp in col )
    {
      ++n;
      nDeleted += DeleteIfNotHosting( rp ) ? 1 : 0;
    }
 
    Debug.Print( 
      "{0} unnamed reference plane{1} examined, {2} of them were deleted.",
      n, (1==n?"":"s"), nDeleted );
 
    return Result.Succeeded;
  }
}

Here is DeleteUnnamedNonHostingReferencePlanes.zip containing the source code, manifest file, and Visual Studio solution.

Automatic Setout Points

Why are we doing this?

It has been known to mankind for the following kind of situation to occur:

A large complex structure is constructed off-site. When assembled on site, it does not fit. The workers continue nonetheless and force it into place. The error is discovered later and corrected using brute force and post adaption. Overall cost of exercise: several days of delay and tens of thousands in cost overruns.

Here is Paul's description of this:

The Challenge: Provide a way to find the real world coordinates, for the corners of potential elements we want to set out in the field, automatically from the model. In this example, concrete structural elements. Ideally display these points in a Revit schedule, so that they can be formatted and placed on a drawing sheet. Then define which of the points could be used as set out points list them in a schedule, preferably numbered sequentially for readability.

In Practice: Initially we could get the points listing, all from the API, but transferring this information into a schedule proved to be not possible. Instead we created a family that contained shared parameters to hold the data we required for scheduling. Then we place the created family at the points we have extracted from the geometry. Through the API it is then possible to populate the parameters with the X, Y, Z coordinates we have extracted from the geometry, and then add these values to the extracted project location, to convert the values to real world coordinates.

Initially one type was used in the set out point family. However this did not enable the ability to select which points we want as scheduled set out points. For this two types were created within the family, SetoutPoint_Major and SetoutPoint_Minor. This allowed two separate schedules to be created, one capturing all the points, another to capture points defined as major points for use on a drawing sheet for set out. The 'all points' schedule is useful for export to a CSV file for import into a surveying device such as a Trimble allowing site set-out directly from the model.

To be continued...

Melbourne Day Two

On the second day of the Revit API training here in Melbourne, we addressed a number of further interesting issues, both basic and beyond. Our sample code ended up demonstrating the following functionality:

• Revit MEP model creation: place a duct.
• Geometrical analysis: retrieving unique geometry vertices from a selected element.

Besides that, we looked at extensible storage, and I compiled an updated version of the RstLink sample for Revit Structure 2012.

I also received interesting comments on a previous post on finding the Revit parent window that is worthwhile sharing here.

After the training, I went for a quick climb with Rob at Hardrock, marvelling at yet another grading system.

Here in Australia I went for the easy grades 16 to 18. No idea what they compare to in European or American grading systems.

After that, I had a sandwich in the Siglo roof-top bar on 161 Spring Street above the Melbourne Supper Club in the same house. These two places share an extremely sympathetic anonymous entrance, a simple brown wooden door with no sign whatsoever. If no-one told you they are there, you would never find them.

Placing a Duct

One thing we talked about was creating new elements in the model.

As a very simple example, we created the code to place an HVAC duct:

[Transaction( TransactionMode.Manual )]
public class Command3 : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication uiapp = commandData.Application;
    UIDocument uidoc = uiapp.ActiveUIDocument;
    Document doc = uidoc.Document;
 
    XYZ p, q;
 
    try
    {
      Selection sel = uidoc.Selection;
      p = sel.PickPoint( "Start point: " );
      q = sel.PickPoint( "End point: " );
    }
    catch( RvtOperationCanceledException )
    {
      return Result.Cancelled;
    }
 
    DuctType ductType
      = new FilteredElementCollector( doc )
        .OfClass( typeof( DuctType ) )
        .Cast<DuctType>()
        .FirstOrDefault<DuctType>();
 
    if( null == ductType )
    {
      message = "No duct type found.";
      return Result.Failed;
    }
 
    //Duct duct = new Duct(); // OO approach, not supported
    //Duct duct = Duct.Create( doc );
 
    Transaction tx = new Transaction( doc );
    tx.Start( "Add Duct" );
 
    Duct duct = doc.Create.NewDuct( p, q, ductType );
 
    tx.Commit();
 
    return Result.Succeeded;
  }
}

We also played with creating a mechanical system. That needs some fittings a well, because their connectors provide the required duct system type information.

Look at the AutoRoute and AvoidObstruction SDK samples for more details.

Retrieving Unique Geometry Vertices

We then explored geometry extraction, and especially the identification of unique points with in it, since this bring up a number of issues regarding units and precision etc.

Here is a simple command that prompts me to select an element and accesses its geometry. It processes it as well towards the end; ignore that for the moment:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Application app = uiapp.Application;
  Document doc = uidoc.Document;
 
  Element e;
 
  try
  {
    Reference r = uidoc.Selection.PickObject(
      ObjectType.Element,
      "Please pick an element." );
 
    e = doc.get_Element( r.ElementId );
  }
  catch( RvtOperationCanceledException )
  {
    return Result.Cancelled;
  }
 
  Options opt = app.Create.NewGeometryOptions();
 
  GeometryElement geo = e.get_Geometry( opt );
 
  Solid solid = null;
 
  foreach( GeometryObject obj in geo.Objects )
  {
    GeometryInstance inst = obj as GeometryInstance;
 
    if( null != inst )
    {
      geo = inst.GetSymbolGeometry();
      break;
    }
  }
 
  foreach( GeometryObject obj in geo.Objects )
  {
    solid = obj as Solid;
 
    if( null != solid )
    {
      break;
    }
  }
 
  if( null == solid )
  {
    message = "Unable to access element solid.";
    return Result.Failed;
  }

  Dictionary<XYZ, int> corners = GetCorners( solid );
 
  int n = corners.Count;
 
  Debug.Print( "{0} corners found:", n );
 
  foreach( XYZ p in corners.Keys )
  {
    Debug.Print( PointString( p ) );
  }
 
  return Result.Succeeded;
}

The next step we looked at is identification of all unique vertices in the geometry. For this, we need to somehow implement a fuzzy method to distinguish between points that really are different, but detect that points that are nearly the same should in fact be treated as identical. We can achieve this by implementing an XYZ equality comparer, e.g. like this:

class XyzEqualityComparer : IEqualityComparer<XYZ>
{
  const double _sixteenthInchInFeet 
    = 1.0 / ( 16.0 * 12.0 );
 
  public bool Equals( XYZ p, XYZ q )
  {
    return p.IsAlmostEqualTo( q, 
      _sixteenthInchInFeet );
  }
 
  public int GetHashCode( XYZ p )
  {
    return PointString( p ).GetHashCode();
  }
}

As an almost-equal tolerance we are using a rather large value, because Revit uses this pretty rough number in several places itself, e.g. to limit the limit the minimum line length.

You must be careful to also define a hash code that does not return different values for points that you wish to compare equal, or every single point will be considered different, possibly even when a point is compared with itself. In this case we are using our two-decimal string representation to define a hash code, so many points that are considered different by the comparison operator will actually generate the same hash code. In a perfect world, the hash code generator would be a bit more appropriately chosen to match the equality comparison precision.

We can easily implement a short and sweet method to extract all the unique corner vertices of the solid geometry by using the vertices themselves as keys in a dictionary based on our equality comparer like this:

Dictionary<XYZ,int> GetCorners( Solid solid )
{
  Dictionary<XYZ, int> corners 
    = new Dictionary<XYZ, int>( 
      new XyzEqualityComparer() );
 
  foreach( Face f in solid.Faces )
  {
    foreach( EdgeArray ea in f.EdgeLoops )
    {
      foreach( Edge e in ea )
      {
        XYZ p = e.AsCurveFollowingFace( f )
          .get_EndPoint( 0 );
 
        if( !corners.ContainsKey( p ) )
        {
          corners[p] = 0;
        }
        ++corners[p];
      }
    }
  }
  return corners;
}

The dictionary returned includes a count of how many times each vertex was encountered.

This is something very important that I have looked at numerous times in the past. I already presented the fundamentals for handling this when looking at nested instance geometry, which also implements a GetVertices method similar to the above, and reused it for toposurface point classification and accessing the top faces of a sloped wall.

Extensible Storage

Here is the documentation and sample code from my Autodesk University 2011 class and lab on this topic, which says it all:

• CP4451_tammik_estorage.pdf: handout document
• CP4451_tammik_estorage.zip: sample source code
• CP6760-L_tammik_estorage.pdf: handout document
• CP6760-L_tammik_estorage_lab.zip: exercises

Revit Structure Link 2012

Long overdue, I finally updated the RstLink sample for Revit 2012 and AutoCAD 2012. I provided a brief description of the analytical link sample two years ago, and updated the sample last year for Revit Structure 2011. Now here is RstLink2012.zip containing the entire Visual Studio solution for the following projects:

• RstLink: helper DLL shared by both AutoCAD and Revit client.
• RstLinkRevitClient: Revit command implementations: RSLinkImport, RSLinkExport, RsLinkLiveLink.
• RstLinkAcadClient: AutoCAD command implementations: RSImport, RSExport, RSMakeMember.
• RstLinkAcadClientDynProps: Dynamic Revit OPM properties for AutoCAD objects.

In fact, most of these are provided for both C# and VB, so it ends up including the following projects:

• RstLinkCs
• RstLinkVb
• RstLinkRevitClientCs
• RstLinkRevitClientVb
• RstLinkAcadClientCs
• RstLinkAcadClientVb
• Miro: a C++ project to generate the RstLinkAcadClientDynProps ARX application

Revit Parent Window

Finally, to wrap up this information overflow, Victor Chekalin, or Виктор Чекалин, offered a very useful and interesting suggestion for a new and easier way to obtain the Revit parent window:

1. Add a reference to the AdWindows assembly, located at the same place as the RevitAPI assembly, and set its Copy Local property to false.
2. Get the Revit main window handle using the static property ApplicationWindow of the ComponentManager class in the Autodesk.Windows namespace.

Now, you can use only one Property – ComponentManager.ApplicationWindow – instead two methods – get current process and main window handle.

Melbourne Day One

These days right now represent a unique time in our life history. Venus and Jupiter are in a stunning conjunction, closer together right now than they will ever be again for the next two hundred years. If you have a chance, don't forget to look up at the sky in the evenings!

In another unique and far-away event, at least from my normal habitat, we completed the first day of the Revit API Training here in Melbourne.

Talking about being far away from my everyday habitat, I went for a walk with my hosts Kim, Rob, Erika and Lewis and their friends Geoff, Vivienne and Alice up the Anakie Gorge in the Brisbane Ranges National Park last Saturday, enjoying the wonderful Australian flora:

Back in the city and the Autodesk training room in Queen's Road we are a nice mix of participants, many with significant Revit product and some Revit API experience, others with zero of both, but decades of professional application development behind them and a wish to make use of it within the Revit API.

On the first day we went through the basics of the Revit API, all of which are also covered by the materials provided by the Revit Developer Center and described in more detail in the hands-on training preparation suggestions.

Command Instantiation and Element Picking

One little sample command that we ended up developing together simply demonstrates interactive element selection and changing the name of an element type. In the case of a wall, the attempt to change the name of the wall itself throws an exception, because the wall instance is actually just reflecting its type name. For other instances it throws no exception but has no effect either. Changing the code to modify the name of the element type instead of the instance works in both these cases.

While playing around with this, one interesting and previously unanswered question that we stumbled across was on the instantiation of the external command implementation class.

In AutoCAD.NET, a separate instance of a command implementation class is created for each document, and then reused for future command invocations in that document. How is this handled in Revit?

The code required to explore and answer this question is very simple: just implement a public constructor for the class which counts and prints out the number of invocations.

  [Transaction( TransactionMode.Manual )]
 
  public class Command : IExternalCommand
  {
    static int _instance_count = 0;
 
    public Command()
    {
      Debug.Print( "{0} instances.", 
        ++_instance_count );
    }
 
    // . . .
  }

As it turns out, a new instance of the command class is created every time the command is launched.

Oops. Looking in a bit more depth, we discovered that this is in fact clearly stated in the developer guide, which says: "When a command is selected, a command object is created and its Execute() method is called. Once this method returns back to Revit, the command object is destroyed."

This confirms what every careful programmer would do subconsciously anyway: keep your command class implementation as light as possible, since it will be re-instantiated for each call of your command.

If you need to store any large amounts of data, then do so either in static variables, or, more cleanly, in separate singleton classes elsewhere.

The code we ended up with to select an element and rename its type looks like this:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Application app = uiapp.Application;
  Document doc = uidoc.Document;
 
  Element e;
 
  try
  {
    Reference r = uidoc.Selection.PickObject( 
      ObjectType.Element, 
      "Please pick an element." );
 
    e = doc.get_Element( r.ElementId );
  }
  catch( RvtOperationCanceledException )
  {
    return Result.Cancelled;
  }
 
  using( Transaction tx = new Transaction( doc ) )
  {
    tx.Start( "Rename Element" );
 
    ElementId id = e.GetTypeId();
 
    Element type = doc.get_Element( id );
 
    if( null != type )
    {
      type.Name = "Melbourne " + type.Name;
    }
 
    tx.Commit();
  }
  return Result.Succeeded;
}

We used this to discuss a number of basic aspects of add-in creation:

• Referencing the Revit API assemblies and setting the copy local flag.
• Implementing the basic application skeleton code.
• Using attributes to define the journaling, regeneration and transaction options. Journaling we might return to tomorrow, regeneration is trivial, since there is only one single option nowadays, and transaction is important to understand: automatic, manual or read-only, of which I generally recommend using only the latter two.
• Creating the add-in manifest and GUID and other add-in manifest features.
• Using the Revit add-in wizard to handle all that automatically.
• Selecting an element using PickObject and handling the exception thrown by user cancellation.
• Transaction management and element modification.
• Instances versus types.

Filtered Element Collector and Using Parameter Filter for Non-Empty String

In a second step, we had a look at a filtered element collector to access the Revit database contents.

We decided that parameter filters are of special interest, and explored how to filter for an empty and a non-empty string value.

Here is the code that we ended up with:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Application app = uiapp.Application;
  Document doc = uidoc.Document;
 
  BuiltInParameter bip 
    = BuiltInParameter.ALL_MODEL_MARK;
 
  ParameterValueProvider provider
    = new ParameterValueProvider(
      new ElementId( bip ) );
 
  // Filter for an empty string:
 
  //FilterStringRuleEvaluator evaluator 
  //  = new FilterStringEquals();
 
  // Filter for an non-empty string:
 
  FilterStringRuleEvaluator evaluator 
    = new FilterStringGreater();
 
  FilterStringRule rule = new FilterStringRule( 
    provider, evaluator, "", false );
 
  bool inverted = false;
 
  ElementParameterFilter filter
    = new ElementParameterFilter( rule, inverted );
 
  FilteredElementCollector col
    = new FilteredElementCollector( doc )
      .WhereElementIsNotElementType()
      .WherePasses( filter );
 
  foreach( Element e in col )
  {
    Parameter p = e.get_Parameter( bip );
 
    Debug.Print( "'{0}': '{1}'", 
      e.Name, 
      (null==p? "null" : p.AsString() ) );
  }
 
  return Result.Succeeded;
}

In its current, final state, it uses a parameter string filter to retrieve and list all elements with a non-empty Mark parameter value.

To do so, we search for any string values greater than the empty string "".

We also tried using a null value instead of the empty string, but that throws a rather inelegant exception in the FilterStringRule constructor saying

• ArgumentNullException: "The input argument \"ruleString\" of function `anonymous-namespace'::FilterStringRule_constructor or one item in the collection is null at line 1193 of file n:\\build\\2012_ship_inst_20110916_2132 \\source\\api\\revitapi\\gensrc\\APIFilterRule.cpp. \r\nParameter name: ruleString"

We also tested searching for all empty string values using a FilterStringEquals evaluator, and that worked fine as well.

Evernote and a Revit Product and Family Tutorial

During our explorations, we underlined the importance of families and the family API. I mentioned the Autodesk Revit 2010 Families Guide several times in the past. It is free and covers the basics well together with Google, especially some important Revit MEP content best practices.

For more background, especially on Revit MEP, the Learning Autodesk Revit MEP 2012 video training by Simon Whitbread, Don Bokmiller and Joel Londenberg is recommended.

One neat little non-Revit-API topic that popped up was the handy and free little Evernote utility for storing and sharing notes across the cloud and various mobile devices.

Retrieve Geometry in Element Coordinate System

I am travelling rather further afield than usual today, and actually have been doing so all day yesterday as well. My normal paths remain inside of Europe, with occasional trips once or twice a year to the USA, for AEC DevCamp and Autodesk University. Now, exceptionally, I am on my way to Melbourne, Australia, to present a Revit API training and DevCamp next week.

Meanwhile, here is an interesting little issue brought up by Olli Kattelus, software developer of MagiCAD for Progman Oy in the context of IFC export of MEP ducts and pipes. It is a teeny weeny bit tricky and can yet be solved quite easily using the geometrical tools provided by the Revit API.

Question: My problem in brief:

I can't get positions of the geometry primitives of the duct/pipe etc. in the instance's own coordinate system. Or is it possible?

More in-depth explanation:

For standard family instances such as air terminal, fitting, etc., I CAN retrieve the geometry primitives (faces etc.) and their coordinates in the symbol's own coordinate system. I also can transform them to the global coordinate system by using the transform provided by the GeometryInstance class.

For system families, however, things are different. The first obstacle is that ducts/pipes etc. don't have any GeometryInstance as their geometry. When I fetch their geometry primitives, they are returned in the global coordinate system.

I would really need to get them also in the "symbols" own coordinate system.

The reason I need this is that I'm working on an IFC export. In IFC, the geometry is exported only once per object type, or at least that is much preferred. The coordinates of geometry must be therefore be given in the element coordinate system because when the IFC file is read, the location and orientation of the object tells the IFC interpreter where to place the resulting geometry.

If the geometry is exported using the global coordinate system, things go wrong. Some geometry transformation methods are provided by the ExporterIFCUtils classes, but unfortunately I can't use them because I'm not using the Revit API to create the export.

Answer: Here is a suggestion for an approach:

1. Determine the duct or pipe start and end points in the global coordinate system GCS.
2. Define what you mean by "instance's own coordinate system" ICS, for instance start point equals origin, duct or pipe direction equals X axis, something or other equals the Z axis etc.
3. Determine the transformation T from the GCS to the ICS.
4. Obtain the duct or pipe geometry primitives and apply T to them to place them in ICS.

Probably the easiest way to determine the transform from GCS to ICS is to first create the inverse one from ICS to GCS.

This can then easily be inverted using the Revit API Transform.Inverse property.

To create the transformation from ICS to GCS is also normally easy, since you can decide for yourself how you consider it should be set up. For instance, for a duct, you could say that the ICS is located at its origin and has cardinal X, Y and Z axes.

To define the appropriate Revit API Transform instance, you just have to plug in the coordinates of the GCS start and end points appropriately into the Transform basis properties, cf. the description of the Transform.Basis property in the Revit API help file. You may have to fiddle around a bit to get it right, but it should work.

Response: Thanks A LOT for your instructions! I had kind of tried this at some previous point but I wasn't sure whether it could work this way. After your encouragement I had enough 'faith' to try until it worked :-)

As you said, I had to 'fiddle' a little bit with those but eventually managed to get it work in most of the cases.

I ended up with this kind of scenario:

For all the objects (generally system families) whose geometry primitives are required in ICS, I define origin, direction and normal as follows similar to the approach used in IFC, using the given element and its 'end connector' coordinate system:

  coordSys = m_revElem
    ->endConnectors[0]
    ->CoordinateSystem;

  org = coordSys->Origin;
  dir = coordSys->BasisZ->Negate();
  norm = coordSys->BasisY->Negate();

Sorry that this is not pure Revit API code, but as said 'm_revElem->endConnectors[0]' simply means some connector on the element.

To get the geometry to work correctly in our IFC output, I created the following transform:

  Transform ^tf = Transform::Identity;
  tf->BasisX = coordSys->BasisZ->Negate();
  tf->BasisY = coordSys->BasisX;
  tf->BasisZ = coordSys->BasisY->Negate();
  tf->Origin = coordSys->Origin;
  tf = tf->Inverse;

So this really DID help a lot. Thanks again for this!!

Chinese New Year Impressions

On Monday I mentioned the Chinese New Year of the dragon. In fact, the whole of this week is a holiday in China and our offices there.

Here is a special post just to share some impressions of the Chinese New Year from my colleague Joe Ye in Beijing, to give you an idea of what they are up to over there during this week, to help more people better understand China and this aspect of its culture.

There were many traditional activities for the New Year celebrations, such as

• Lotus boat performance
• Dragon performance
• Lion performance

Here are some pictures to give you an impression:

Lotus boat performance:

tieba.baidu.com/p/823383772

Dragon performance:

www.hudong.com/wiki/%E8%80%8D%E9%BE%99+%E2%80%94%E2%80%94+%E5%85%83%E5%AE%B5%E8%8A%82%E7%9A%84%E6%9D%A5%E5%8E%86

Lion performance:

difang.cri.cn/461/2012/01/04/181s12815.htm

There are two men in each lion. The back end one has to bend always, which is very tiresome. Also, the two men have to cooperate very well to perform difficult actions, for example jump onto a high table:

www.izy.cn/travel_photo/a70/56790.html

In addition to these activities, plenty of nice food is necessary for every family. We also prepare the most sumptuous feast for the most important day, the last day of the lunar year.

Firework and cracker is also necessary to make the festival joyful. Most families would like to prepare and light fireworks and crackers.

People who work outside their home town try to go home to spend the holiday with their parents.

During the holiday, people visit their relatives and family. Except for the New Year holiday, everybody is busy, and don't have time to see each other. People always visit all their important relatives, even if they are far away. We call it Bainian. And the relatives always use the delicious food to treat the guests. The adult always gave red envelope (containing money) to children. If a child has many adult relatives (who are working), he can get a lot of envelopes :-)

My eldest brother and his family visited my family yesterday. He gave a red envelope to my daughter, and I also presented one to his son.

As my daughter is young, I didn't go to my home town to celebrate the New Year. So most of the time, I stay home to accompany my daughter. Oh, yes, my eldest brother visited us yesterday; we didn't see each other for 2 years.

Quite busy holiday. That's why I call this is the 'biggest' holiday in China.

For more information, here is an entire article about the Chinese New Year.

Finding a Development Partner

I was able to recuperate a bit from the previous weeks' travels and conferences in Milan this weekend, where I did very little except feel exhausted and ill. Now I am fine again, though, and arrived safely for the developer conference and DevLab here in Farnborough in the UK. The plane last night was late, of course, so I checked in way after midnight, but at least we all made it here this year :-)

Now and then, people ask me how they can locate a Revit developer to implement something for them, either for personal use or as a commercial application.

One thing that I can point you to is the official Autodesk list of ADN developer partners at partnerproducts.autodesk.com > Professional Services.

Another place you can look and also post a request for proposals is the Revit API discussion forum at forums.autodesk.com > Autodesk Revit > Autodesk Revit API.

Then we have a number of well-known independent developers, many of whom have both asked questions and contributed solutions to this blog, such as Guy Robinson (NZ), CADWorks, NTI CADcenter and CAD-Q (Scandinavia), GEM Team Solutions (Germany), BIMWare, CADSoft, etc.

You can also obviously post a comment below and see whether anyone responds to that, regardless of whether you are offering some Revit API development service or if you are searching for some or have a RFP.

Some additional general advice: when hiring someone to perform a service, you might want to ask for contact details of three prior customers of theirs, so that you can talk to them. Hiring a consultant is not that much different from hiring an employee, so it is prudent to perform a careful interview and check the references.

Obviously, check for existing built-in functionality and existing applications before you even start dreaming let alone thinking of creating a custom solution. BIMapps may help with the latter.

Good luck!

Loading an Inventor ADSK Component

We held the DevLab in Munich yesterday before rushing off to get to Milano in the evening.

I slept a little bit in the taxi and plane on the way here. I was still dead tired on arrival at the hotel just before ten, but thought I absolutely must get out and have a teeny weeny little sniff of Italy anyway before going to bed. I went to a bar right next door and committed the deadly foreigner sin of having a cappuccino, which it is almost a criminal offence to drink except at breakfast time. Quite soon the very friendly couple at the neighbouring table, Agnès and Max, informed me that a free concert was going to start shortly next door. Agnès and Max are both a photographers, just like Dima, whom I met in Jerusalem last Thursday, so Thursday seems to be my meet-a-photographer day right now. Check out Agnès' site and blog and Max' photos and blog.

The concert was really great, by the Italian singer Folco Orselli. I liked it so much I bought his CD, asked for the very first autograph of my life, and ended up in bed rather late, or early, depending on your point of view :-)

Loading an Inventor Component ADSK File

One of the many interesting topics raised at the DevLab came from Martin Schmid, our MEP expert, working with both AutoCAD and Revit. He brought an ADSK component file created in Inventor with the goal of loading it into Revit.

I tried one or two things to achieve this which failed before finding a successful solution, so you might want to skip straight to that if you are not interested in the blather.

Failed Attempts

The first thing we tried was the LoadFamily method, which simply does not work at all and is not intended to do so either:

  const string filename 
    = "C:/a/doc/revit/blog/src/LoadAdsk/Part1.adsk";
 
  // Load ADSK using LoadFamily does not work;
  // rc is false, and f is null:
 
  t = new Transaction( doc );
  t.Start( "Load Adsk" );
  Family f = null;
  bool rc = doc.LoadFamily( filename, out f );
  t.Commit();

This does not cause any error, but 'rc' is false and 'f' remains null.

The second attempt was trying to open the component as a document using OpenDocumentFile:

  Document adsk_doc = app.OpenDocumentFile( filename );

This should achieve the same result as dragging and dropping the component onto the Revit window, which opens it in the family editor. It does actually successfully open the ADSK in the family editor but it also displays an error saying "Attempted to read or write protected memory. This is often an indication that other memory is corrupt."

I am not yet sure whether this message is erroneous. Maybe you can simply ignore it and automatically dismiss it through the API.

Anyway, after those two failed attempts, we went on to find a solution which really works:

Successful Workflow using OpenBuildingComponentDocument

Scott Reinemann pointed out that we should try the OpenBuildingComponentDocument method, and that works fine.

Here is the code that achieves exactly what we want:

• Open the ADSK component family file.
• Load the component family into the project.
• Retrieve a family symbol from it.
• Place an instance of the symbol.

  Document adsk_doc 
    = app.OpenBuildingComponentDocument( filename );
 
  Debug.Print( 
    "Opened component document {0} with path '{1}'",
    adsk_doc.Title, adsk_doc.PathName );
 
  t = new Transaction( doc );
  t.Start( "Load ADSK component document" );
  Family f = adsk_doc.LoadFamily( doc );
  t.Commit();
 
  Debug.Print(
    "Loaded component family {0}",
    f.Name );
 
  FamilySymbol symbol = null;
 
  foreach( FamilySymbol s in f.Symbols )
  {
    symbol = s;
    break;
  }
 
  t.Start( "Place ADSK component document" );
  FamilyInstance i = doc.Create.NewFamilyInstance( 
    XYZ.Zero, symbol, StructuralType.NonStructural );
  t.Commit();
 
  Debug.Print(
    "Placed component family instance {0}",
    i.Name );

Here is the Part1 symbol defined by the component family appearing in the project browser after being loaded:

This is the family instance placed in the project origin:

Right now the PathName property remains empty, but the Title property is set as expected, so the messages printed to the Visual Studio debug output window say:

Opened component document Part1 with path ''
Loaded component family Part1
Placed component family instance Part1

This implementation automatically places the family instance hardwired at the origin and does not mimic the placement of a family when using the user interface, which displays a preview of the symbol at the cursor.

To have that, you can make a call to PromptForFamilyInstancePlacement instead.

Here is LoadAdsk.zip containing the source code and complete Visual Studio solution for this command as well as a sample component file Part1.adsk to play around with.

AVF Displays Intersections and Highlights Rooms

We held a DevLab in Gothenburg yesterday with lots of interesting things to discuss with our Scandinavian developer guests. Today we are in Munich, Germany. So is Kean :-)

One of the topics that came up yesterday is a thing I have been wanting to write about for over a year now and never gotten around to, the use of the AVF or Analysis Visualisation Framework to display temporary geometry to the user.

I used it myself to display a live webcam image on a building element, and Saikat used it in the AVF part of his structural AVF and DMU sample, although I only documented the DMU or Dynamic Model Update aspect of it in detail.

This kind of use of the AVF is also demonstrated by the Revit SDK sample GeometryCreation_BooleanOperation. It creates geometry solids using the GeometryCreationUtils and BooleanOperationUtils classes and displays them in a view using AVF.

FindColumns Using Geometry Creation and Booleans

Transient AVF visualisation was used very impressively in the presentation of new geometry functionality at the developer conferences last year. You may and should be aware of the FindColumns example of using the FindReferencesByDirection method to determine collisions between walls and columns in a situation like this:

As I mentioned in the DevDays 2010 Online with Revit 2012 API news, it was converted to use the exact wall and column geometry instead of the original approximate ray tracing approach, and the results are displayed exactly by hiding the wall and column categories in the view and displaying their intersection solids using AVF instead.

It defines two commands:

• HighlightIntersectionsCommand to determine and display the intersections, and
• RestoreViewCommand to restore the view afterwards, i.e. reset the wall and column category visibility in the view.

Here is the original 3D view of the situation:

Running HighlightIntersectionsCommand performs the following steps:

• Hide the wall and column categories in the current view.
• Set up an AVF view.
• Collect all walls and column elements.
• Query them for their solid geometry.
• Calculate their intersections.
• List and display the results.

Here is the list of the resulting intersections:

This is what the intersection geometry looks like in AVF:

As said, you can call RestoreViewCommand afterwards to restore the view by resetting the wall and column category visibility in the view.

For your reference, here is Geometry2012.zip containing the C# sample code and Visual Studio solution together the suitable sample model to run it in.

So all of that is really important stuff from last year that I have been dying to publish for such a long time and never gotten around to. Finally!

Highlight Rooms Using AVF in VB

I passed the geometry sample on to Betina Mette Zimmermann of NTI CAD Center A/S in Denmark, and she converted it to VB and modified it to highlight the room geometry returned by the Room.ClosedShell method instead of wall and column intersections within half an hour:

#Region "Namespaces"
Imports System
Imports System.Collections.Generic
Imports Autodesk.Revit.ApplicationServices
Imports Autodesk.Revit.Attributes
Imports Autodesk.Revit.DB
Imports Autodesk.Revit.DB.Analysis
Imports Autodesk.Revit.DB.Architecture
Imports Autodesk.Revit.UI
Imports Autodesk.Revit.UI.Selection
#End Region
 
<Transaction(TransactionMode.Manual)>
Public Class Command
  Implements IExternalCommand
 
  Private schemaId As Integer = -1
 
  Public Function Execute(
    ByVal commandData As ExternalCommandData,
    ByRef message As String,
    ByVal elements As ElementSet) _
  As Result Implements IExternalCommand.Execute
 
    Dim uidoc As UIDocument = commandData.Application.ActiveUIDocument
    Dim doc As Document = uidoc.Document
 
    Dim transaction As Transaction = New Transaction(doc)
 
    Try
      Dim col As FilteredElementCollector _
        = New FilteredElementCollector(uidoc.Document)
 
      col.WhereElementIsNotElementType.ToElements()
      col.OfCategory(BuiltInCategory.OST_Rooms)
 
 
      Dim value As Double = 1.0
      For Each room As Room In col
        Dim geo As GeometryElement = room.ClosedShell()
        Dim solid As Solid = GetGeometry(geo)
        If Not solid Is Nothing Then
          PaintSolid(doc, solid, value)
        End If
        value = value + 1
      Next
 
      transaction.Start("Hide Walls")
 
      Dim categories As Categories _
        = uidoc.Document.Settings.Categories
 
      SetCategoryInvisible( _
        categories, BuiltInCategory.OST_Walls,
        uidoc.ActiveView)
 
      transaction.Commit()
 
      Return Result.Succeeded
 
    Catch ex As Exception
      message = ex.Message
      Return Result.Failed
    End Try
 
  End Function
 
  Public Shared Sub SetCategoryInvisible( _
    ByVal categories As Categories, _
    ByVal bic As BuiltInCategory, _
    ByVal view As View)
 
    SetCategoryVisibility(categories, bic, view, False)
 
  End Sub
 
  Private Shared Sub SetCategoryVisibility( _
    ByVal categories As Categories, _
    ByVal bic As BuiltInCategory, _
    ByVal view As View, _
    ByVal visible As Boolean)
 
    Dim category As Category = categories.Item(bic)
    category.Visible(view) = visible
 
  End Sub
 
  Public Function GetGeometry( _
    ByVal geomElem As GeometryElement) As Solid
 
    For Each geomObj As GeometryObject In geomElem.Objects
 
      ' Walls and some columns will have a solid 
      ' directly in its geometry
 
      If TypeOf geomObj Is Solid Then
        Dim solid As Solid = DirectCast(geomObj, Solid)
        If solid.Volume > 0 Then
          Return solid
        End If
      End If
 
      ' Some columns will have a instance 
      ' pointing to symbol geometry
 
      If TypeOf geomObj Is GeometryInstance Then
 
        Dim geomInst As GeometryInstance _
          = DirectCast(geomObj, GeometryInstance)
 
        ' Instance geometry is obtained so that the 
        ' intersection works as expected without 
        ' requiring transformation
 
        Dim instElem As GeometryElement _
          = geomInst.GetInstanceGeometry()
 
        For Each instObj As GeometryObject In instElem.Objects
          If TypeOf instObj Is Solid Then
            Dim solid As Solid = DirectCast(instObj, Solid)
            If solid.Volume > 0 Then
              Return solid
            End If
          End If
        Next
      End If
    Next
    Return Nothing
  End Function
 
  Private Sub PaintSolid( _
    ByVal doc As Document, _
    ByVal s As Solid, _
    ByVal value As Double)
 
    Dim app As Application = doc.Application
 
    Dim view As View = doc.ActiveView
 
    If view.AnalysisDisplayStyleId _
      = ElementId.InvalidElementId Then
 
      CreateAVFDisplayStyle(doc, view)
    End If
 
    Dim sfm As SpatialFieldManager _
      = SpatialFieldManager.GetSpatialFieldManager(view)
 
    If sfm Is Nothing Then
      sfm = SpatialFieldManager _
        .CreateSpatialFieldManager(view, 1)
    End If
 
    If schemaId <> -1 Then
      Dim results As IList(Of Integer) _
        = sfm.GetRegisteredResults()
 
      If Not results.Contains(schemaId) Then
        schemaId = -1
      End If
    End If
 
    If schemaId = -1 Then
      Dim resultSchema1 As New AnalysisResultSchema( _
        "PaintedSolid", "Description")
 
      schemaId = sfm.RegisterResult(resultSchema1)
    End If
 
    Dim faces As FaceArray = s.Faces
    Dim trf As Transform = Transform.Identity
 
    For Each face As Face In faces
      Dim idx As Integer _
        = sfm.AddSpatialFieldPrimitive(face, trf)
 
      Dim uvPts As IList(Of UV) = New List(Of UV)()
      Dim doubleList As New List(Of Double)()
 
      Dim valList As IList(Of ValueAtPoint) _
        = New List(Of ValueAtPoint)()
 
      Dim bb As BoundingBoxUV = face.GetBoundingBox()
      uvPts.Add(bb.Min)
      doubleList.Add(value)
      valList.Add(New ValueAtPoint(doubleList))
      Dim pnts As New FieldDomainPointsByUV(uvPts)
      Dim vals As New FieldValues(valList)
 
      sfm.UpdateSpatialFieldPrimitive( _
        idx, pnts, vals, schemaId)
    Next
  End Sub
 
  Private Sub CreateAVFDisplayStyle( _
    ByVal doc As Document, _
    ByVal view As View)
 
    Dim t As New Transaction(doc)
    t.Start("Create AVF Style")
 
    Dim coloredSurfaceSettings As _
      New AnalysisDisplayColoredSurfaceSettings()
 
    coloredSurfaceSettings.ShowGridLines = True
 
    Dim colorSettings As _
      New AnalysisDisplayColorSettings()
 
    Dim legendSettings As _
      New AnalysisDisplayLegendSettings()
 
    legendSettings.ShowLegend = False
 
    Dim analysisDisplayStyle As AnalysisDisplayStyle _
      = analysisDisplayStyle.CreateAnalysisDisplayStyle( _
        doc, "Paint Solid", coloredSurfaceSettings, _
        colorSettings, legendSettings)
 
    view.AnalysisDisplayStyleId = analysisDisplayStyle.Id
 
    t.Commit()
  End Sub
 
End Class

To test this, I created the following Revit model of a cow hotel, implemented according to a design suggested by Jim Quanci in the Gothenburg airport:

Here are the resulting highlighted rooms using AVF:

Here is HighlightRooms.zip containing the VB code and complete Visual Studio solution for this command.

Many thanks to Betina for implementing and sharing this!

Copy a Model from a Revit Server

Yesterday evening we had dinner together with developer partners at Heaven 23 again, the same place we visited last year, with its unique reflection-accessible cloud.

Today we are holding a DevLab here in the Autodesk office in Gothenburg in Sweden, providing an opportunity for developers to come visit us with their day-to-day work in progress and current issues.

Meanwhile, here is a question related to the Revit Server and its API:

Question: How can I copy a Revit file out of Revit server 2012 to a network location? I need something similar to the RevitServerViewer sample, but instead of just relaying the information of the file I would like to get the actual file definition, assign it to an object in .NET, and use standard I/O operations to copy it to multiple other servers.

Answer: Look at the Application.CopyModel method.

  public void CopyModel(
    ModelPath sourceModelPath,
    string destFilePath,
    bool overwrite )

It copies an existing model to a new file, which can then be copied elsewhere as needed.

It takes the path of the file and does not require opening the file. It accepts the path of the server (or file) based source file and the destination path, besides a Boolean specifying whether you wish to overwrite the destination file or not.

If you have to copy multiple files, you can call this method multiple times specifying different source and destination information for each file.

This method is a Revit API method, so it does require Revit to be up and running and must be called in a valid Revit API context. As you can see in the "Revit Server REST API Reference.pdf" in the Revit Server SDK, the REST API supports copying or moving a specified folder or model to another folder within the Revit Server without starting up Revit, but not copying a model to a network location outside of the server.

Top Faces of Sloped Wall Update

On Saturday we left Paris and arrived in Göteborg, or Go:teborg as the local tourist office appears to like spelling it.

On Sunday we went for a trip on one of the public transportation ferry boats out to Vrångö. From right to left you see Jim, Partha, Philippe, and me, and Adam is taking the picture:

Fittingly enough, I also had some correspondence on a Revit API issue with a Swedish developer on the same day: Henrik Bengtsson of Lindab submitted a comment on the retrieval of the top faces of a sloped wall:

When I tried parts of this code, I discovered that the .Normal function of the PlanarFace object sometimes shows incorrect values for faces with a positive or negative z-direction.

This especially affects the code part:

if( f is PlanarFace && PointsUpwards( ((PlanarFace)f).Normal ) )

A solution that so far has given me correct values is to replace the .Normal function of the PlanarFace object with the .ComputeNormal function.

I found problems when analyzing faces that had a positive or negative z-value of its normal. So, not only the boundary faces of the wall but also top and bottom faces of its openings...

Henrik also sent me a simple model with two simple quadrilateral sloped walls in which the existing CmdWallTopFaces command implementation fails:

The command reports zero top faces:

0 top faces found on Walls <194639 Lindab FR E120/120 202 M0 c450>
0 top faces found on Walls <195080 Lindab FR E120/120 202 M0 c450>

This is obviously false:

Henrik implemented the following improved solution in VB calling ComputeNormal:

  For Each f As DB.Face In Solid.Faces
    '
    If TypeOf f Is DB.PlanarFace Then
      '
      Dim pf As DB.PlanarFace = f

      Dim p As XYZ = pf.Origin

      If pf.ComputeNormal(New DB.UV(p.X, p.Y)).Z > 0 Then
        '
        Dim faceVertices As IList(Of DB.XYZ) _
          = pf.Triangulate().Vertices

        For Each v As DB.XYZ In faceVertices
          '
          If sideVertices.Contains(v, comparer) Then
            '
            If Not ret.Contains(f) Then
              '
              ret.Add(f)
              '
            End If

            Exit For
            '
          End If
          '
        Next
        '
      End If
      '
    End If
    '
  Next

He says:

I tried the .ComputeNormal function and it helps solving the problem. The .Normal function shows an incorrect x as well as z value for the walls that was in the project file.

Depending on the vector of the top face, I am sure that x, y and z-directions will be incorrect.

The function that this routine is implemented in looks like this (more or less a VB copy of your blog code):

I have tried a couple of walls and sometimes a wall works correct, then if I run a mirror command on it, the new one becomes incorrect.

A positive or negative top face slope has showed to have an impact as well.

If there are openings inside the wall they can have an incorrect .Normal value as well. That was actually how I discovered it. The top face of a wall was pointing upwards and ended up in my collection as well.

I decided I might as well clean up this command a bit more to ensure that top faces are really found.

If we make use of the Face.ComputeNormal method instead of the planar face normal vector, we might as well remove the restriction to planar faces at the same time.

To handle all kinds of faces, I can use the following simple method to determine whether a given face is facing upwards:

• Determine the face UV bounding box.
• Pick a UV point in the middle.
• Call ComputeNormal to determine the face normal vector at that point.
• Check whether it points upwards.

This is still an extremely simplistic test, so there is no guarantee that it will handle the general case. For instance, if the face has holes or a complex boundary, the middle point calculated may not belong to it at all. It is up to you to test it for the cases you need.

The command already implements a bunch of other stuff to eliminate faces that belong to openings, and thus are not top faces of the wall, but just faces into the wall openings. I left that part completely untouched.

I first replaced the line of code that I was previously using which was only checking for planar faces by a call to this new method which does the same thing:

  /// <summary>
  /// Super-simple test whether a face is planar 
  /// and its normal vector points upwards.
  /// </summary>
  static bool IsTopPlanarFace( Face f )
  {
    return f is PlanarFace
      && PointsUpwards( ( (PlanarFace) f ).Normal );
  }

I then went and implemented the new more general approach described above like this to replace it:

  /// <summary>
  /// Simple test whether a given face normal vector 
  /// points upwards in the middle of the face.
  /// </summary>
  static bool IsTopFace( Face f )
  {
    BoundingBoxUV b = f.GetBoundingBox();
    UV p = b.Min;
    UV q = b.Max;
    UV midpoint = p + 0.5 * ( q - p );
    XYZ normal = f.ComputeNormal( midpoint );
    return PointsUpwards( normal );
  }

Lo and behold! Running this on the simple model provided by Henrik returned the two faces, just as expected:

Problem apparently fixed, a least for this simple case.

I also ran the command on rac_basic_sample_project.rvt again, like I did the first implementation. It now reports 119 walls selected with 34 top faces when I select all walls in the Level 1 plan view, and 605 walls selected with 47 top faces when I do it in 3D view. These results are both different from what I found in the simplified model last time, but I am not going to worry about that.

Anyway, here is version 2012.0.96.2 of The Building Coder samples including the updated command. I am looking forward to hearing what new issues you run into with it.

Many thanks to Henrik for prompting this improvement!

REX Content Generator

I had an absolutely magical experience in Israel before leaving Tel Aviv Thursday afternoon. Among many others at the developer conference on Wednesday, we met with Dima Brickmann of Omnitech, and he suggested going for a short visit to Jerusalem before returning to the airport, which is located between Tel Aviv and Jerusalem. Partha and I decided to join him. Dima has a very special relationship with the city and a deep philosophical and photographical view of it, so he was a unique and wonderful guide. His tour focused more on feeling and experiencing the magic of this deeply religious place, which brings out so many extremes in all the different religions, and yet simultaneously enables them to coexist in an extremely confined area. I was really touched.

By the way, Dima has more recent photos with some short philosophical texts on the Russian photoreporting news web site newsru.co.il, e.g. this beautiful photo series on Jerusalem between black and white:

I went and installed a translation add-on for my browser to be able to read the Russian text. It works very well, and the photos are really and truly deep and beautiful.

Click on the link at the bottom saying 'ПРОДОЛЖЕНИЕ ФОТОРЕПОРТАЖА' to proceed to the rest of the photos in the series.

Thank you, Dima!

I would never have believed you could experience so much in such a short time, both in the three hours that we spent with Dima in Jerusalem and in the two days we spent in Israel.

On Friday we held another developer conference in Paris, and today we are already en route to Gothenburg in Sweden.

And my backlog of interesting blog posts is growing far faster than I can publish them.

REX Content Generator

One really astounding revelation at the DevLab at AU was the REX content generator sample.

It is provided with the REX framework and its other samples as part of the standard Revit SDK. I had not looked at it previously in any depth, since I have not used REX myself yet. I tend to avoid any additional frills, and the plain vanilla Revit API keeps me fully occupied all on its own. But this sample really bowled me over!

A DevLab participant showed me some of its features, and it looks like an astonishingly powerful tool. Here are a few notes I made from his demo:

The content generator provides the following functionality:

• Read existing families into a data structure.
• Create families from the data structure.
• Determine the section of a beam or column and display a shaded 3D preview of its solid extrusion.
• Interface to external structural databases to generate sections and families with these objects.
• Recognition which tries to match the current element to an existing database entry. If the user accepts the match, the content generator can switch the types by creating a new family based on the database record and replace all of the old instances by the new family.

Impressed?

I was!

The family API enables us to create new families step by step. In contrast, the content generator allows you to load an existing family, tweak and change it, and immediately generate a new family.

There is no need to install the Revit extensions to ensure that the basic REX framework is in place and the REX API is available. The content generator can be used even without Revit Extensions installed, since the framework is part of the regular Revit installation and is installed in a way transparent for the user.

To run the content generator sample, simply select a structural element, e.g. a column, and launch the command. It takes a little while to start up, because it reads the three databases: standard, steel and structural.

I asked Emmanuel Weyermann for a short description, and he provided the following brief yet full picture of Content Generator and this sample application:

What is Content Generator?

The Content Generator is a component which is part of the Revit Extensions Framework installed with Revit 2012.

It provides tools for content management. This component is strongly connected with standard databases shipped with Revit (over 130 databases).

Advantages of the Content Generator:

• Generation of Revit families: database sections, parametric sections, materials, user generic types.
• Interpretation of Revit families: database sections, parametric sections, materials.
• Getting data from standard databases.
• Searching elements in standard databases.
• Standard database browser dialogue.
• A mapping system.

More information may be found in the "User Manual for Extensions SDK.pdf".

Content Generator basic types

The idea of Content Generator is very simple. It provides its own representations of specific types (e.g. sections) and two converters which communicate with each other via these types:

• RVT Converter – responsible for communication with Revit
• REX Converter – responsible for communication with standard databases

Content Generator provides 4 types:

• Database section
• Parametric section
• Material
• Generic – defined by the user.

Code sample

The code below presents how to generate a particular section taken from the Rcatpro database:

  // Initializing the rex converter.
 
  REXFamilyConverter rex = new REXFamilyConverter();
 
  // Database identification data.
 
  string alias = "HEA 100";
 
  string directory = rex.GetDatabaseDirectory(
    ECategoryType.SECTION_DB );
 
  string dbName = "Rcatpro";
 
  // Getting the REXFamilyType from the database.
 
  REXFamilyType_DBSection famDBSection
    = rex.GetFamilyDBSection( EElementType.BEAM,
      EMaterial.STEEL, alias, dbName, directory );
 
  // Initializing the RVT converter.
 
  RVTFamilyConverter rvt = new RVTFamilyConverter(
    m_CommandData, true );
 
  // Getting Revit element.
 
  Autodesk.Revit.Element el = rvt.GetElement(
    famDBSection );
 
  FamilySymbol famSymbol = el as FamilySymbol;

Over twenty further samples are provided in the "User Manual for Extensions SDK.pdf".

ContentGeneratorWPF SDK sample

In Extensions SDK may be found the ContentGeneratorWPF sample. It allows examining a selected beam or column and changing its type to a new one (generated by Content Generator).

The sample demonstrates some of Content Generator key features:

• Revit FamilySymbol interpretation as:
  • Parametric section – shape is recognized and dimensions are calculated.
  • Database section – the element is recognized and match with appropriate section from database.
• Revit FamilySymbol generation:
  • Parametric section – there are three types available (in CG there are over 22): rectangle, angle and I section.
  • Database section – the user is able to point section from available databases.
• Database browsing.

The sample runs database browser which allows exploring available databases:

Where is Content Generator used?

• As a standalone application which generates different types of Revit content (part of Revit Extension for RAC and RST - Extensions ribbon->Tools).
• In different integration tools: Revit – Cloud computation (Storm), links Revit – RSA, Revit – ASD, and for some files import/export extensions Revit – CIS, Revit – SDNF.
• In different Revit Extensions: steel connections, reinforcements, timber framing, structure generator (recently mentioned) etc.

Many thanks to Emmanuel for this overview!

If you are interested in Revit Structure and structural databases, I strongly encourage you to take a deep look at this if you have not already done so.

Interior Side of a Wall

I really enjoyed my little outing in Tel Aviv on Tuesday evening to the 5Rhythms City Wave offered by Rivi Diamond.

Confusing Ramat Gan with Tel Aviv and First Hebrew Characters

Getting there turned out to be unexpectedly adventurous, because while I assumed that I was walking around in Tel Aviv, I was in fact in the neighbouring city Ramat Gan. Two parallel streets named Jabotinsky and Arlozorov span both of them, and I was running around in the area between them asking people for directions. I only had a map of the Tel Aviv part, and everybody pointed in completely different directions. Extremely confusing, if you don't know the deal.

I have since heard that it can get even worse, and that there is someplace nearby where two different Jabotinsky streets start at the same point, both with number 1, obviously, and head off in opposite directions. Anyway, I got there in the end, by bus.

I spent Wednesday back in conference space and meeting our local developer community here, followed by a very enjoyable evening with Hemi and Rani and my colleagues Partha, Adam, Philippe and Jim in the restaurant Boya in the Tel Aviv port area.

Hemi showed me how to say and write אני לא מדבר עברית (ani lo medebare ivrit, I don't speak Hebrew) and לחיים (lechaim, for life, cheers). To rescue me from having to pervert my pure ASCII HTML by saving it in Unicode format, I converted these characters to HTML escape codes using an online Unicode character map that I discovered when visiting Cairo.

Afterwards, I walked (and ran) back to the hotel in Ramat Gan so the remaining people could squeeze into one single car (and we could save the taxi). It also enabled me to enjoy a bit of exercise and the almost full moon.

Revit Timeline

One interesting topic that came up at dinner with Jim Quanci and my other colleagues on Monday night in Moscow was the history and origins of Revit. I am still searching for more information on this, and so far Anthony Hauck very kindly pointed out the an AUGI thread listing the Revit Timeline. A more verbose and descriptive but less precise and exhaustive listing is given in the history section of the Wikipedia article on Revit.

Wall Orientation

Here is a simple question and succinct answer on the orientation of a wall, which we discussed in more depth when looking at wall compound layers, highlighting a simple fact that was not explicitly mentioned there:

Question: How can I determine which side of a wall is on its interior?

Answer: Query the wall for its LocationCurve. When you are standing at the wall start point and looking toward the end point of its location curve, and assuming the wall's Flipped property is false, its interior side is on the right-hand side. If the Flipped property is true, then the interior side of the wall is on the left.

Many thanks to my colleagues Joe Yes and Katsuaki Takamizawa-san for pointing this out so clearly!

Export Solid to ACIS

Today we are en route to Tel Aviv in Israel after the successful conference held in Moscow yesterday. In Tel Aviv I even have a personal activity lined up, besides the official reason for going there to hold another conference on Wednesday: a 5Rhythms City Wave is offered very Tuesday evening by Rivi Diamond and fits my schedule perfectly. That will provide another wonderful change from airplanes, taxis, hotels, and conferences.

Meanwhile, here is a sweet little question on exporting a Revit solid to ACIS raised yesterday by Ishwar Nagwani and answered by Miroslav Schonauer and Emmanuel Weyermann:

Question: Is there any way to programmatically create an ACIS file from an individual solid?

For example, AutoCAD ObjectARX provides the method AcDbBody::acisout to achieve this.

As far as I can tell, the Revit API only supports exporting entire views to ACIS.

Answer: You can programmatically create a 3D view, loop through all the visible elements in the view to set the individual element visibility ON for your desired solid element and OFF for all others, and export the view to the SAT file format.

The whole operation can be encapsulated in a transaction that is never committed and aborted afterwards so the database is not affected by this operation.

I can confirm that this works, because we have actually used this exact strategy ourselves.

Many thanks to Ishwar, Miro and Emmanuel for raising and resolving this issue!

Unit Conversion and Display String Formatting

AU went very well for me, and I think this was the one I liked most of all so far, to my own surprise. Now I am already at the next conference in Moscow, from where I continue to Tel Aviv tomorrow. December is always my monster travelling month, and I never get to prepare for Christmas or enjoy the dark and cosy celebration of Advent. But I really did have fun and enjoy AU in Las Vegas.

Sunday morning my colleague Marat Mirgaleev invited me to join him in his weekly volleyball game, which was a wonderful break from the conference presentation preparation. Marat is also a member of the ADN DevTech team and spelled Марат Миргалеев in Cyrillic. Another Autodesk colleague who also joined was Rustam Ibragimov, Рустам Ибрагимов. Here are Rustam, Marat, I and our all-time star, the volleyball herself:

Here we are now in the Autodesk Moscow office:

Fittingly enough, here is a question from Russia, by Victor Chekalin, or Виктор Чекалин in Cyrillic, on formatting a floating point number as a display string using the current project units. This issue has cropped up several times recently, and various solutions based on the same principle have been suggested, among others by Joe Offord of Enclos, who already shared insights on accessing curtain wall geometry, speeding up the interactive selection process, mirroring in a new family and changing the active view, and constructing a planar face transform.

All of the solutions to this problem I have seen revolve around stuffing in the value to format into an unused parameter picked up from some arbitrary database element and then calling the AsValueString method on it. The Parameter class provides this functionality, but unfortunately the API does not include any stand-alone access to it. Here is Victor's initial query:

Question: I need to convert a numeric value to a corresponding display string honouring the current Revit ProjectUnit setting. I cannot find how to do it in the Revit help and began search the answer in your amazing site. I found the Unit Conversion tool and thought it would fulfil my need, but I was wrong :(

Looking at the Unit Converter code, I discovered that retrieving scale factor to internal units is not easy and you used some trick to get it: you change ProjectUnit, write "1" to family parameter, read value from this parameter, change ProjectUnit back. It works but is really hard and is not an official way.

Answer: Try something like this on some otherwise unused length parameter 'p':

  Dim value As String = "=2' + 4'/3"
  Dim t As New Transaction(doc, "Format Length")
  t.Start()
  p.SetValueString(value)
  value = p.AsValueString
  t.RollBack()
  Return value

In fact, Joe provided the following helper methods based on this idea implemented in VB:

• StringValueString – Converts a string to AsValueString equivalent.
• DblValueString – Converts a double to AsValueString equivalent.
• ValueStringDbl – Converts a ValueString to a double.

All three of these methods create and then roll back a temporary transaction to perform their task.

Here is the full implementation of the first of these, StringValueString:

  Public Shared Function StringValueString( _
    ByVal doc As Document, _
    ByVal value As String) As String
 
    ' Locate the arbitrary Length parameter
 
    Dim p As Parameter _
      = doc.ProjectInformation.Parameter( _
      "Parameter Name")
 
    If p Is Nothing Then
      TaskDialog.Show( _
        "Revit", _
        "Missing Project Parameter: Parameter Name")
      Return value
    End If
 
    Dim tr As New Transaction(doc)
    tr.Start("Format Length")
 
    Try
      p.SetValueString(value)
      value = p.AsValueString
    Catch ex As Exception
 
    End Try
 
    tr.RollBack()
 
    Return value
 
  End Function

For the second, DblValueString, simply replace the input argument by a floating-point value 'ByVal value As Double' and the two lines to perform the actual conversion by

    p.Set(value)
    sValueString = p.AsValueString

Finally, for the third, ValueStringDbl, the input argument 'value' is again a string and the conversion to the floating-point return value is performed by

    p.SetValueString(value)
    dValue = p.AsDouble

Response: Thanks for the answer.

I wrote some simple extension methods for the Revit API Parameter class to get value in project units and in meters value. Now it works with Length, Volume and Area (now I don't need any more). It would take much time to add support for all unit conversions.

Here is the entire implementation of my ParameterUnitConverter class. It defines the following methods and data:

• AsProjectUnitTypeDouble – Parameter extension method to retrieve double value parameter in ProjectUnits.
• AsMetersValue – Parameter extension method to retrieve double value of parameter in meters unit, i.e. length in meters, area in square meters and volume in cubic meters.
• ConvertParameterTypeToUnitType – static method to return the corresponding UnitType for a given ParameterType.
• _map_parameter_type_to_unit_type – a dictionary mapping ParameterType enumeration values to the corresponding UnitType ones.

Here is the complete implementation of this:

public static class ParameterUnitConverter
{
  private const double METERS_IN_FEET = 0.3048;
 
  public static double AsProjectUnitTypeDouble( 
    this Parameter param )
  {
    if( param.StorageType != StorageType.Double )
      throw new NotSupportedException( 
        "Parameter does not have double value" );
 
    double imperialValue = param.AsDouble();
 
    Document document = param.Element.Document;
 
    UnitType ut = ConvertParameterTypeToUnitType( 
      param.Definition.ParameterType );
 
    FormatOptions fo = document.ProjectUnit
      .get_FormatOptions( ut );
 
    DisplayUnitType dut = fo.Units;
 
    // Unit Converter
    // http://www.asknumbers.com
 
    switch( dut )
    {
      #region Length
 
      case DisplayUnitType.DUT_METERS:
        return imperialValue * METERS_IN_FEET; //feet
      case DisplayUnitType.DUT_CENTIMETERS:
        return imperialValue * METERS_IN_FEET * 100;
      case DisplayUnitType.DUT_DECIMAL_FEET:
        return imperialValue;
      case DisplayUnitType.DUT_DECIMAL_INCHES:
        return imperialValue * 12;
      case DisplayUnitType.DUT_FEET_FRACTIONAL_INCHES:
        NotSupported( dut );
        break;
      case DisplayUnitType.DUT_FRACTIONAL_INCHES:
        NotSupported( dut );
        break;
      case DisplayUnitType.DUT_METERS_CENTIMETERS:
        return imperialValue * METERS_IN_FEET; //feet
      case DisplayUnitType.DUT_MILLIMETERS:
        return imperialValue * METERS_IN_FEET * 1000;
 
      #endregion // Length
 
      #region Area
 
      case DisplayUnitType.DUT_SQUARE_FEET:
        return imperialValue;
      case DisplayUnitType.DUT_ACRES:
        return imperialValue * 1 / 43560.039;
      case DisplayUnitType.DUT_HECTARES:
        return imperialValue * 1 / 107639.104;
      case DisplayUnitType.DUT_SQUARE_CENTIMETERS:
        return imperialValue * Math.Pow( METERS_IN_FEET * 100, 2 );
      case DisplayUnitType.DUT_SQUARE_INCHES:
        return imperialValue * Math.Pow( 12, 2 );
      case DisplayUnitType.DUT_SQUARE_METERS:
        return imperialValue * Math.Pow( METERS_IN_FEET, 2 );
      case DisplayUnitType.DUT_SQUARE_MILLIMETERS:
        return imperialValue * Math.Pow( METERS_IN_FEET * 1000, 2 );
 
      #endregion // Area
 
      #region Volume
      case DisplayUnitType.DUT_CUBIC_FEET:
        return imperialValue;
      case DisplayUnitType.DUT_CUBIC_CENTIMETERS:
        return imperialValue * Math.Pow( METERS_IN_FEET * 100, 3 );
      case DisplayUnitType.DUT_CUBIC_INCHES:
        return imperialValue * Math.Pow( 12, 3 );
      case DisplayUnitType.DUT_CUBIC_METERS:
        return imperialValue * Math.Pow( METERS_IN_FEET, 3 );
      case DisplayUnitType.DUT_CUBIC_MILLIMETERS:
        return imperialValue * Math.Pow( METERS_IN_FEET * 1000, 3 );
      case DisplayUnitType.DUT_CUBIC_YARDS:
        return imperialValue * 1 / Math.Pow( 3, 3 );
      case DisplayUnitType.DUT_GALLONS_US:
        return imperialValue * 7.5;
      case DisplayUnitType.DUT_LITERS:
        return imperialValue * 28.31684;
 
      #endregion // Volume
 
      default:
        NotSupported( dut );
        break;
    }
 
    throw new NotSupportedException();
  }

  public static double AsMetersValue( 
    this Parameter param )
  {
    if( param.StorageType != StorageType.Double )
      throw new NotSupportedException( 
        "Parameter does not have double value" );
 
    double imperialValue = param.AsDouble();
 
    UnitType ut = ConvertParameterTypeToUnitType( 
      param.Definition.ParameterType );
 
    switch( ut )
    {
      case UnitType.UT_Length:
        return imperialValue * METERS_IN_FEET;
 
      case UnitType.UT_Area:
        return imperialValue * Math.Pow( 
          METERS_IN_FEET, 2 );
 
      case UnitType.UT_Volume:
        return imperialValue * Math.Pow( 
          METERS_IN_FEET, 3 );
    }
    throw new NotSupportedException();
  }
 
  public static UnitType 
    ConvertParameterTypeToUnitType( 
      ParameterType parameterType )
  {
    if( _map_parameter_type_to_unit_type.ContainsKey( 
      parameterType ) )
    {
      return _map_parameter_type_to_unit_type[
        parameterType];
    }
    else
    {
      // If we made it this far, there's 
      // no entry in the dictionary.
 
      throw new ArgumentException(
        "Cannot convert ParameterType '"
          + parameterType.ToString()
          + "' to a UnitType." );
    }
  }
 
  static Dictionary<ParameterType, UnitType>
    _map_parameter_type_to_unit_type
      = new Dictionary<ParameterType, UnitType>()
  {
    // This data could come from a file, 
    // or (better yet) from Revit itself...
 
    {ParameterType.Angle, UnitType.UT_Angle},
    {ParameterType.Area, UnitType.UT_Area},
    {ParameterType.AreaForce, UnitType.UT_AreaForce},
    {ParameterType.AreaForcePerLength, UnitType.UT_AreaForcePerLength},
    //map.Add(UnitType.UT_AreaForceScale, ParameterType.???);
    {ParameterType.ColorTemperature, UnitType.UT_Color_Temperature},
    {ParameterType.Currency, UnitType.UT_Currency},
    //map.Add(UnitType.UT_DecSheetLength, ParameterType.???);
    {ParameterType.ElectricalApparentPower, UnitType.UT_Electrical_Apparent_Power},
    {ParameterType.ElectricalCurrent, UnitType.UT_Electrical_Current},
    {ParameterType.ElectricalEfficacy, UnitType.UT_Electrical_Efficacy},
    {ParameterType.ElectricalFrequency, UnitType.UT_Electrical_Frequency},
    {ParameterType.ElectricalIlluminance, UnitType.UT_Electrical_Illuminance},
    {ParameterType.ElectricalLuminance, UnitType.UT_Electrical_Luminance},
    {ParameterType.ElectricalLuminousFlux, UnitType.UT_Electrical_Luminous_Flux},
    {ParameterType.ElectricalLuminousIntensity, UnitType.UT_Electrical_Luminous_Intensity},
    {ParameterType.ElectricalPotential, UnitType.UT_Electrical_Potential},
    {ParameterType.ElectricalPower, UnitType.UT_Electrical_Power},
    {ParameterType.ElectricalPowerDensity, UnitType.UT_Electrical_Power_Density},
    {ParameterType.ElectricalWattage, UnitType.UT_Electrical_Wattage},
    {ParameterType.Force, UnitType.UT_Force},
    {ParameterType.ForceLengthPerAngle, UnitType.UT_ForceLengthPerAngle},
    {ParameterType.ForcePerLength, UnitType.UT_ForcePerLength},
    //map.Add(UnitType.UT_ForceScale, ParameterType.???);
    {ParameterType.HVACAirflow, UnitType.UT_HVAC_Airflow},
    {ParameterType.HVACAirflowDensity, UnitType.UT_HVAC_Airflow_Density},
    {ParameterType.HVACAirflowDividedByCoolingLoad, UnitType.UT_HVAC_Airflow_Divided_By_Cooling_Load},
    {ParameterType.HVACAirflowDividedByVolume, UnitType.UT_HVAC_Airflow_Divided_By_Volume},
    {ParameterType.HVACAreaDividedByCoolingLoad, UnitType.UT_HVAC_Area_Divided_By_Cooling_Load},
    {ParameterType.HVACAreaDividedByHeatingLoad, UnitType.UT_HVAC_Area_Divided_By_Heating_Load},
    {ParameterType.HVACCoefficientOfHeatTransfer, UnitType.UT_HVAC_CoefficientOfHeatTransfer},
    {ParameterType.HVACCoolingLoad, UnitType.UT_HVAC_Cooling_Load},
    {ParameterType.HVACCoolingLoadDividedByArea, UnitType.UT_HVAC_Cooling_Load_Divided_By_Area},
    {ParameterType.HVACCoolingLoadDividedByVolume, UnitType.UT_HVAC_Cooling_Load_Divided_By_Volume},
    {ParameterType.HVACCrossSection, UnitType.UT_HVAC_CrossSection},
    {ParameterType.HVACDensity, UnitType.UT_HVAC_Density},
    {ParameterType.HVACDuctSize, UnitType.UT_HVAC_DuctSize},
    {ParameterType.HVACEnergy, UnitType.UT_HVAC_Energy},
    {ParameterType.HVACFactor, UnitType.UT_HVAC_Factor},
    {ParameterType.HVACFriction, UnitType.UT_HVAC_Friction},
    {ParameterType.HVACHeatGain, UnitType.UT_HVAC_HeatGain},
    {ParameterType.HVACHeatingLoad, UnitType.UT_HVAC_Heating_Load},
    {ParameterType.HVACHeatingLoadDividedByArea, UnitType.UT_HVAC_Heating_Load_Divided_By_Area},
    {ParameterType.HVACHeatingLoadDividedByVolume, UnitType.UT_HVAC_Heating_Load_Divided_By_Volume},
    {ParameterType.HVACPower, UnitType.UT_HVAC_Power},
    {ParameterType.HVACPowerDensity, UnitType.UT_HVAC_Power_Density},
    {ParameterType.HVACPressure, UnitType.UT_HVAC_Pressure},
    {ParameterType.HVACRoughness, UnitType.UT_HVAC_Roughness},
    {ParameterType.HVACSlope, UnitType.UT_HVAC_Slope},
    {ParameterType.HVACTemperature, UnitType.UT_HVAC_Temperature},
    {ParameterType.HVACVelocity, UnitType.UT_HVAC_Velocity},
    {ParameterType.HVACViscosity, UnitType.UT_HVAC_Viscosity},
    {ParameterType.Length, UnitType.UT_Length},
    {ParameterType.LinearForce, UnitType.UT_LinearForce},
    {ParameterType.LinearForceLengthPerAngle, UnitType.UT_LinearForceLengthPerAngle},
    {ParameterType.LinearForcePerLength, UnitType.UT_LinearForcePerLength},
    // map.Add(UnitType.UT_LinearForceScale, ParameterType.???);
    {ParameterType.LinearMoment, UnitType.UT_LinearMoment},
    // map.Add(UnitType.UT_LinearMomentScale, ParameterType.???);
    {ParameterType.Moment, UnitType.UT_Moment},
    ///map.Add(UnitType.UT_MomentScale, ParameterType.???);
    {ParameterType.Number, UnitType.UT_Number},
    {ParameterType.PipeSize, UnitType.UT_PipeSize},
    {ParameterType.PipingDensity, UnitType.UT_Piping_Density},
    {ParameterType.PipingFlow, UnitType.UT_Piping_Flow},
    {ParameterType.PipingFriction, UnitType.UT_Piping_Friction},
    {ParameterType.PipingPressure, UnitType.UT_Piping_Pressure},
    {ParameterType.PipingRoughness, UnitType.UT_Piping_Roughness},
    {ParameterType.PipingSlope, UnitType.UT_Piping_Slope},
    {ParameterType.PipingTemperature, UnitType.UT_Piping_Temperature},
    {ParameterType.PipingVelocity, UnitType.UT_Piping_Velocity},
    {ParameterType.PipingViscosity, UnitType.UT_Piping_Viscosity},
    {ParameterType.PipingVolume, UnitType.UT_Piping_Volume},
    //map.Add(UnitType.UT_SheetLength, ParameterType.???);
    //map.Add(UnitType.UT_SiteAngle, ParameterType.???);
    {ParameterType.Slope, UnitType.UT_Slope},
    {ParameterType.Stress, UnitType.UT_Stress},
    {ParameterType.TemperalExp, UnitType.UT_TemperalExp},
    {ParameterType.UnitWeight, UnitType.UT_UnitWeight},
    {ParameterType.Volume, UnitType.UT_Volume},
    {ParameterType.WireSize, UnitType.UT_WireSize},
  };
}

I used some functions from the Unit converter. Here is an external command sample to test it by iterating over and applying it to all floating point valued parameters on a selected element.

Hope you'll find this useful.

Many thanks to Joe and Victor for putting together and sharing these nice solutions!

I added the ParameterUnitConverter class to The Building Coder samples and defined a new external command CmdParameterUnitConverter based on Victor's code to test it. Here is version 2012.0.96.0 of The Building Coder samples including the new utility class and command.

This is the output generated by the command in the Visual Studio debug output window on selecting a wall element in the rac_basic_sample_project.rvt sample model:

Parameter name: Top Extension Distance
  Parameter value (imperial): 0
  Parameter unit value: 0
  Parameter AsValueString: 0.0

Parameter name: Length
  Parameter value (imperial): 45.5
  Parameter unit value: 13868.4
  Parameter AsValueString: 13868.4

Parameter name: Base Extension Distance
  Parameter value (imperial): 0
  Parameter unit value: 0
  Parameter AsValueString: 0.0

Parameter name: Top Offset
  Parameter value (imperial): 0
  Parameter unit value: 0
  Parameter AsValueString: 0.0

Parameter name: Volume
  Parameter value (imperial): 455.9586023831
  Parameter unit value: 12.911309795985
  Parameter AsValueString: 12.911 m³

Parameter name: Unconnected Height
  Parameter value (imperial): 18.0446194225722
  Parameter unit value: 5500
  Parameter AsValueString: 5500.0

Parameter name: Base Offset
  Parameter value (imperial): 0
  Parameter unit value: 0
  Parameter AsValueString: 0.0

Parameter name: Area
  Parameter value (imperial): 694.880910031848
  Parameter unit value: 64.5565489799251
  Parameter AsValueString: 64.557 m²

Here, the parameter value labelled 'imperial' is the internal Revit database unit, e.g. feet for length. Please note that not all internal database units are imperial. In fact, only length is measured in feet, and thus also area and volume. Other internal units are SI-based.

Project Structure Generator on Autodesk Labs

I arrived safely in Las Vegas after a 12:40 hour flight to Los Angeles, 3:30 hour wait, und another flight of 1:05 hours. Pretty crazy. I had a headache after that, but not too bad, and I slept well out in the desert. Just like in previous years (08, 09, 09b, 10), my daytime jetlag therapy consists of climbing in Red Rock, this time with Sergio Colombo again, whom I first met and climbed with in 2008.

We did the Great Red Book trad climb, completing it this time, and I led two 5.9s in the black corridor.

Meanwhile, here is yet another Revit related project published on Autodesk Labs:

Project Structure Generator

Project Structure Generator for Revit Architecture and Revit Structure is available on Autodesk Labs.

It generates real structural models from mass objects.

Project Structure Generator is a technology preview that provides a connection between massing models and objects created during conceptual design and structural elements such as beams, column, walls, and plates. With Project Structure Generator, structural engineers and architects, from the earliest stages, can very quickly create and visualize a physical and analytical model of a structure based on the massing model. The technology preview will operate until April 1, 2012.

What does Project Structure Generator do?

It provides a connection between massing models and objects created during conceptual design, enabling structural engineers and architects to:

• Automatically create and visualize a physical model of the structure with mass objects.
• Generate variants of the physical and analytical model with structural systems based on the massing model.
• Predict volume and weight of materials used.
• Extend model to Revit Structure or Revit Architecture.
• Extend massing model to structural analysis with Project Storm, a cloud based static analysis technology preview, or Autodesk Robot Structural Analysis Professional.

String Search ADN Plugin of the Month

Best regards from Andalusia!

Here is just a short note to point out that my first ADN Plugin of the Month has been published on Autodesk Labs: the November ADN Plugin of the Month is the Revit String Search.

Look at the developer notes at the end for reasons why you should take a look at this :)

Description

Search Revit project elements and their parameter values for a given string value.

Standard string search options can be specified to define how the string is matched, which Revit elements and which of their parameters are searched.

Results are presented in a modeless navigator form listing the search hits. Selecting a search hit zooms to and highlights the Revit element containing it.

System Requirements

This plugin has been tested with Revit Architecture 2011 and 2012, and requires the .NET Framework 3.5.

A pre-built version of the plug-in has been provided which works on both Revit 2011 and 2012, and on both the 32- and 64-bit Windows systems.

The source code has been provided as a Visual Studio 2008 C# project. It is not required to run the plugin.

Usage

In Revit, click "Add-Ins" > "String Search" panel > "String Search" to launch the command.

In the dialogue that appears, you can type in the search string in the 'Find what' text box.

Click 'OK'. The command will search for the given string on all standard and user parameters of all elements in the current view.

All occurrences of the search string are listed in a data grid view in a modeless navigator dialogue. Double click on a row in the navigator to zoom to the element.

A log file of the search operation and its results is created in your temporary directory. To view the log file, right click on the search form and select 'Display Log File'.

The string matching options and the elements and parameters to search can be modified as follows.

Options

Category: Limit the search to elements belonging to a specific category. All other categories will be skipped. Specify an asterisk '*' to search all categories. This is the default setting.

Parameter name: You can specify the name of a specific parameter to search in. All other parameters will be skipped. Specify an asterisk '*' to search all parameters. This is the default setting.

Find options: Match case and match whole parameter limit the string pattern matching to more specific cases, i.e. the upper and lower case of each character must match, and the specified search string must match the entire parameter value.

Element selection: You can search the currently selected element set, all elements in the current view, or all elements in the entire project. The latter can be slow.

Instances versus Types and Symbols: You can specify whether to search in the BIM elements themselves, such as walls and family instances, or in the element types, such as wall types and family symbols. When searching element types, there is no way to limit the search to selected elements (because they cannot be selected) or to a view (because they are not displayed graphically). By default, all elements in the current view are searched. Searching types is not additional to instances, it is complementary. You can search either element types (derived from ElementType in the API) or instances, but not both at once.

Parameter selection: You can select whether only standard built-in Revit parameters are searched, or user-defined family and shared parameters, or both.

Advanced: You have the option of using a regular expression to specify the search string. This option is intended for users with advanced programming knowledge and is not suited for non-programmers. The .NET Regex library is used for this. For more detail about regular expression, please refer to the one of the available 'cheat sheets'.

You can also search in BuiltInParameters, which are only visible through the Revit API. Again, this option is intended for users with advanced programming knowledge and is not suited for others. With this option, the parameter selection option is ignored and the 'Parameter name' setting switches to a list of all built-in parameters. Again, you can search in all of them using the asterisk '*', or pick a specific one. Searching all built-in parameters across the entire project can be extremely slow.

Examples

To search for a string 'abc' in all parameter values of all elements in the current view, simply type in 'abc' as the search string and hit OK. If any occurrences are found, they are listed in the modeless navigator window. You can continue working in Revit as normal. If you double click an entry in the navigator, the Revit screen will zoom in to the selected element and highlight it.

To search for all structurally non-bearing walls, you might make use of the built-in parameter option as follows:

• Enter the search string 'Non-bearing'
• Under Category, select Walls
• Under Advanced, select 'Search BuiltInParameters'
• Under Built-in parameter, select WALL_STRUCTURAL_USAGE_TEXT_PARAM

Click OK and examine the results in the navigator.

Notes for Developers

• Hopefully optimal interaction with modeless search result navigator, as described for the modeless loose connector navigator.
• Neat external application implementation using built-in image resources.
• Handling of duplicate built-in parameter enumeration values.
• Identical source code for both Revit 2011 and 2012.

Associative Section View Fix and Greece

Here I am back from a very pleasant break.

Break in Greece

As mentioned, I gave a Revit API training in Athens last week. I was able to extend my stay to visit the Acropolis and spend a wonderful extended weekend on the beaches of Limni or Λιμνι, on the island of Euboea. Very impressive, how the ancient Greeks built things that last for thousands of years, even though some renovation is required...

Mastic Liqueur and Masticate

One interesting thing that I learned and was able to explore through first-hand experience during the training is the etymology of the English word masticate. I went out for a meal with my mainly Lebanese training participants, so we were speaking English and they spoke Arabic in this Greek environment. We had fish, salad, tzatsiki, water and ouzo (τζα&τζικι, ουζο) all very typical Greek, or rather Eastern Mediterranean. For dessert, as a present from the Egyptian chef, came a mastica liqueur, μαστιχα. This is produced from mastic, the resin of the Pistacia lentiscus shrub native to the Mediterranean. The really interesting point for me was that the same word 'mastic' is used in Arabic as well. I was surprised.

Dynamic Model Update Associative Section View SDK Sample

The training was unconventional, since these guys were all unusually experienced programmers, so I never needed to explain anything, just point out briefly how things works and they would immediately say 'ok, fine; next, please'. Mostly, in my trainings, I would like to go faster, and spend much too much time explaining .NET programming basics instead of the Revit API. This time, as soon as I got into any .NET related details, they got impatient and urged me to get on with the next topic. Great fun!

One thing we ended up looking at was the DynamicModelUpdate sample, which demonstrates an example of making use of the DMU or Dynamic Model Update framework. The version in the SDK does not work out of the box right now due to a mismatch between the namespace prefix of the class implementing the external application loaded by Revit. The add-in manifest file specifies the full class name 'Revit.SDK.Samples.DynamicModelUpdate.CS.AssociativeSectionUpdater'.

The two source files Application.cs and SectionUpdater.cs define the namespace 'DynamicModelUpdate' instead.

To fix the problem, simply replace the line

namespace DynamicModelUpdate

The correct specification in both files should be

namespace Revit.SDK.Samples.DynamicModelUpdate.CS

Once that is done, the sample works fine.

More Pictures of Beaches

To return to the unbelievably unpopulated beaches of Limni, obviously mainly due to the current economic crisis, here are some final pictures; here is Limni itself and its beach:

A pier and beach all to ourselves:

Totally clear water:

Another nice lonesome beach to sleep on:

Here are yet more pictures.

A wonderful place to be, I must say. I really am overwhelmed by the beauty and friendliness of Greece!

Text Size

I am back again from the Autodesk European Football Tournament 2011 in Verona, Italy, vividly described in more detail by Kean on his blog. We were both part of the combined Global Services (to which we of ADN belong) and Worldwide Marketing team:

Back to the Revit API, we already looked at some aspects of text formatting such as textnote alignment and rotation. Here is a still more immediate and simpler issue:

Question: I created some text using the NewTextNote method. Now I would like to change its size or font like a normal user might do using Edit type > Text size. How can that be achieved programmatically?

Answer: The Text Size parameter can be set as follows:

  Reference r = uidoc.Selection.PickObject( 
    ObjectType.Element );
 
  TextElement text = doc.GetElement( r ) 
    as TextElement;
 
  TextElementType textType = text.Symbol;
 
  Parameter textSize = textType.get_Parameter( 
    "Text Size" );
 
  Transaction transaction 
    = new Transaction( doc );
 
  transaction.Start( "change text size" );
 
  // units are in feet, so this is 1/8"
 
  double newSize = ( 1.0 / 8.0 ) * ( 1.0 / 12.0 ); 
 
  textSize.Set( newSize );
 
  transaction.Commit();

Obviously, it would be better still to use the built-in parameter enumeration value to identify the text size parameter, rather than the language dependent user display parameter name.

Improved MEP Element Shape and Mount Ararat

We recently talked about distinguishing Revit MEP duct element shapes, and Max aka Maciej Szlek presented a solution based on the analysis of the string value of the duct's Size parameter.

I suggested that the algorithm might be improved, both to make it more general and robust and also to remove the dependency on the different string formats used for imperial and metric units. It probably becomes more efficient as well, by the way.

Instead of looking at the duct size parameter, one can query it for its connectors and extract the shape from them directly, avoiding all string manipulations and language or unit dependencies.

Max went ahead and implemented this new algorithm. Simultaneously, he demonstrates that some useful helper methods can be reused from the Revit SDK samples, in this case ExtractMechanicalOrPipingSystem and ExtractSystemFromConnectors from the TraverseSystem sample. Here is the code of the new algorithm:

static public string GetElementShape(
  Element e,
  Element pe = null,
  Element ne = null )
{
  if( is_element_of_category( e, 
    BuiltInCategory.OST_DuctCurves ) )
  {
    // assuming that transition is using to change shape..
 
    ConnectorManager cm = ( e as MEPCurve )
      .ConnectorManager;
 
    foreach( Connector c in cm.Connectors )
      return c.Shape.ToString() 
        + " 2 " + c.Shape.ToString();
  }
  else if( is_element_of_category( e, 
    BuiltInCategory.OST_DuctFitting ) )
  {
    MEPSystem system 
      = ExtractMechanicalOrPipingSystem( e );
 
    FamilyInstance fi = e as FamilyInstance;
    MEPModel mm = fi.MEPModel;
 
    ConnectorSet connectors 
      = mm.ConnectorManager.Connectors;
 
    if( fi != null && mm is MechanicalFitting )
    {
      PartType partType 
        = ( mm as MechanicalFitting ).PartType;
 
      if( PartType.Elbow == partType )
      {
        // assuming that transition is using to change shape..
 
        foreach( Connector c in connectors )
        {
          return c.Shape.ToString() 
            + " 2 " + c.Shape.ToString();
        }
      }
      else if( PartType.Transition == partType )
      {
        string[] tmp = new string[2];
 
        if( system != null )
        {
          foreach( Connector c in connectors )
          {
            if( c.Direction == FlowDirectionType.In )
              tmp[0] = c.Shape.ToString();
 
            if( c.Direction == FlowDirectionType.Out )
              tmp[1] = c.Shape.ToString();
          }
          return string.Join( " 2 ", tmp );
        }
        else
        {
          int i = 0;
 
          foreach( Connector c in connectors )
          {
            if( pe != null )
            {
              if( is_connected_to( c, pe ) )
                tmp[0] = c.Shape.ToString();
              else
                tmp[1] = c.Shape.ToString();
            }
            else
            {
              tmp[i] = c.Shape.ToString();
            }
            ++i;
          }
 
          if( pe != null )
            return string.Join( " 2 ", tmp );
 
          return string.Join( "-", tmp );
        }
      }
      else if( PartType.Tee == partType
        || PartType.Cross == partType
        || PartType.Pants == partType
        || PartType.Wye == partType )
      {
        string from, to;
        from = to = null;
        List<string> unk = new List<string>();
 
        if( system != null )
        {
          foreach( Connector c in connectors )
          {
            if( c.Direction == FlowDirectionType.In )
              from = c.Shape.ToString();
            else
              unk.Add( c.Shape.ToString() );
 
            if( ne != null && is_connected_to( c, ne ) )
              to = c.Shape.ToString();
          }
 
          if( to != null )
            return from + " 2 " + to;
 
          return from + " 2 " + string.Join( "-", 
            unk.ToArray() );
        }
        else
        {
          foreach( Connector c in connectors )
          {
            if( ne != null && is_connected_to( 
              c, ne ) )
            {
              to = c.Shape.ToString();
              continue;
            }
 
            if( pe != null && is_connected_to( 
              c, pe ) )
            {
              from = c.Shape.ToString();
              continue;
            }
 
            unk.Add( c.Shape.ToString() );
          }
 
          if( to != null )
            return from + " 2 " + to;
 
          if( from != null )
            return from + " 2 " 
              + string.Join( "-", unk.ToArray() );
 
          return string.Join( "-", unk.ToArray() );
        }
      }
    }
  }
  return "unknown";
}
 

It is encapsulated as a static method in the class MepElementShape. I created a second wrapper class MepElementShapeV1 for the first implementation and call them both in The Building Coder sample CmdMepElementShape external command Execute method like this:

  Element e = <selected element>;
 
  Util.InfoMsg( string.Format(
    "{0} is {1} ({2})",
    Util.ElementDescription( e ),
    MepElementShape.GetElementShape( e ),
    MepElementShapeV1.GetElementShape( e ) ) );
 

This prints the following in the Visual Studio debug output window on selecting some of the elements generated by the AvoidObstruction SDK sample:

Mechanical Equipment Parallel Fan Powered VAV 
  <378728 Size 4 - 10 inch Inlet> is unknown (unknown)

Duct Fittings Rectangular Duct Radius Elbow <382720 1.5 W> 
  is RectProfile 2 RectProfile (rectangular2rectangular)

Ducts <382719 Radius Elbows / Tees> 
  is RectProfile 2 RectProfile (rectangular)

Duct Fittings Rectangular Duct Tee <382736 Standard> 
  is RectProfile 2 RectProfile-RectProfile (unknown)

Air Terminals Supply Diffuser 
  <378716 24 x 24 Face 12 x 12 Connection> is unknown (unknown)

As you see, the results are the same for the string-based first version as for the new connector-based one, except for the tee junction, which was not handled properly by the former.

Very many thanks to Max for implementing and sharing this!

Here is an updated version 2012.0.87.3 of The Building Coder sample code including this new classification method.

Climbing the Ararat

I am off for another break now, this time a bit more adventurous, to climb Mount Ararat in far Eastern Turkey. The flight from Istanbul to Van, the closest city with an airport, is almost as long as the one from Switzerland to Istanbul!

Since I am also busy preparing my Autodesk University proposals, which are due for submission today, as well as the upcoming Revit 2012 API webcast, I am pretty occupied and having difficulty finding time to even pack. With skis and winter clothing and mountain equipment, that is a non-trivial task... Still, I will make it, I am sure.

Iteration and Springtime – Change is the Only Constant

I am back again from a wonderful relaxing Easter holiday with beautiful weather and an almost obscene wealth of blossoming trees and flowers in the Swiss Emmental region:

Spring time really gives us an overwhelming impression of nature's capacity for rapid change! And change is the only constant... And, as we see below, change is a constant challenge in programming as well...

Meanwhile, here are quick pointers to two of the many noteworthy items that cropped up during the past week:

• Jose Guia'S bimKICKS Revit command prompt.
• Revit AppStore updated for Revit 2012.

For my own contribution on my first official day back at work and in the blogosphere, here is a summary of an issue I was dealing with just before Easter:

I heard of several different developers struggling with iterations over collections returned by properties of the Revit API classes. The last one we looked into was related to the iteration over an unordered set returned by the CurtainGrid Cells property.

Now the question was encountered again, in a seemingly different form, yet with a similar answer. In this case, both the question and the solution to it were found by Winston Yaw of RISA Technologies:

Question: I ran the following code on a simple Revit Structure model that only has one structural wall and I got an index of -1 for the first layer in the wall's compound structure. That makes no sense. I probably overlooked something simply, but what?

  FilteredElementIterator ^elementsIter;
 
  FilteredElementCollector ^filteredCollection 
    = gcnew FilteredElementCollector(
      pApplication->ActiveUIDocument->Document );
 
  filteredCollection->OfClass( Wall::typeid );
 
  elementsIter = filteredCollection
    ->GetElementIterator();
 
  Wall ^testWall = nullptr;
 
  // Get a wall
 
  while( elementsIter->MoveNext() )
  {
    testWall = dynamic_cast<Wall^>(
      elementsIter->Current );
 
    if( testWall )
    {
      // Look at compound structure
 
      CompoundStructure^ pCompound 
        = testWall->WallType->GetCompoundStructure();
 
      if( pCompound )
      {
        // Look at first layer
 
        System::Collections::IEnumerator ^layerIter 
          = pCompound->GetLayers()->GetEnumerator();
 
        while( layerIter->MoveNext() )
        {
          CompoundStructureLayer^ pLayer 
            = dynamic_cast<CompoundStructureLayer^>(
              layerIter->Current );
 
          // Get index of first layer
          Int32 index = pCompound->GetLayers()->IndexOf(
            pLayer );
 
          // Display in MessageBox
 
          MessageBox::Show( index.ToString() );
        }
      }
    }
  }
 

In this case, I was expecting a zero-valued index to be displayed. Can you tell me what's wrong, please? Thanks.

Answer: I found the problem myself. The code above is calling the GetLayers method twice: once to get the Enumerator, and again to use IndexOf.

In summary, the code is doing something like this:

• GetLayers()->GetEnumerator();
• GetLayers()->IndexOf(layer);

The problem doesn't occur when an intermediate variable to store the collection returned is introduced as follows:

• IList<> ^layers = GetLayers();
• layers->GetEnumerator();
• layers->IndexOf();

Jeremy responds: Yes, exactly. Congratulations on finding the root of the problem! As said, we have seen similar issues in the past, e.g. related to the iteration over an unordered set property.

Accessing the Compound Layer Structure in Revit 2012

For completeness sake, I tested accessing the compound layer structure and the IndexOf method using C# on both an architectural wall in Revit Architecture 2012 and a structural wall in Revit Structure 2012. Since I store the layer collection returned by the GetLayers method in an intermediate variable, just as suggested in your solution, I obviously don't see the problem you describe. Here is the code that I used, which includes comments to highlight the differences between the Revit 2011 and 2012 APIs, excerpted from the external command CmdWallLayers in The Building Coder samples migrated to Revit 2012 API and with a call added to exercise the IndexOf method instead of using an additional variable 'i' for the index:

[Transaction( TransactionMode.Automatic )]
class CmdWallLayers : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication app = commandData.Application;
    UIDocument uidoc = app.ActiveUIDocument;
    Document doc = app.ActiveUIDocument.Document;
 
    // retrieve selected walls, or all walls,
    // if nothing is selected:
 
    List<Element> walls = new List<Element>();
    if( !Util.GetSelectedElementsOrAll(
      walls, uidoc, typeof( Wall ) ) )
    {
      Selection sel = uidoc.Selection;
      message = ( 0 < sel.Elements.Size )
        ? "Please select some wall elements."
        : "No wall elements found.";
      return Result.Failed;
    }
 
    //int i; // 2011
    int n;
    double halfThickness, layerOffset;
    Creator creator = new Creator( doc );
    XYZ lcstart, lcend, v, w, p, q;
 
    foreach( Wall wall in walls )
    {
      string desc = Util.ElementDescription( wall );
 
      LocationCurve curve
        = wall.Location as LocationCurve;
 
      if( null == curve )
      {
        message = desc + ": No wall curve found.";
        return Result.Failed;
      }
 
      // wall centre line and thickness:
 
      lcstart = curve.Curve.get_EndPoint( 0 );
      lcend = curve.Curve.get_EndPoint( 1 );
      halfThickness = 0.5 * wall.WallType.Width;
      v = lcend - lcstart;
      v = v.Normalize(); // one foot long
      w = XYZ.BasisZ.CrossProduct( v ).Normalize();
      if( wall.Flipped ) { w = -w; }
 
      p = lcstart - 2 * v;
      q = lcend + 2 * v;
      creator.CreateModelLine( p, q );
 
      q = p + halfThickness * w;
      creator.CreateModelLine( p, q );
 
      // exterior edge
 
      p = lcstart - v + halfThickness * w;
      q = lcend + v + halfThickness * w;
      creator.CreateModelLine( p, q );
 
      //CompoundStructure structure = wall.WallType.CompoundStructure; // 2011
      CompoundStructure structure = wall.WallType.GetCompoundStructure(); // 2012
 
      //CompoundStructureLayerArray layers = structure.Layers; // 2011
      IList<CompoundStructureLayer> layers = structure.GetLayers(); // 2012
 
      //i = 0; // 2011
      //n = layers.Size; // 2011
      n = layers.Count; // 2012
 
      Debug.Print(
        "{0} with thickness {1}"
        + " has {2} layer{3}{4}",
        desc,
        Util.MmString( 2 * halfThickness ),
        n, Util.PluralSuffix( n ),
        Util.DotOrColon( n ) );
 
      if( 0 == n )
      {
        // interior edge
        p = lcstart - v - halfThickness * w;
        q = lcend + v - halfThickness * w;
        creator.CreateModelLine( p, q );
      }
      else
      {
        layerOffset = halfThickness;
        foreach( CompoundStructureLayer layer
          in layers )
        {
          Debug.Print(
            "  Layer {0}: function {1}, "
            + "thickness {2}",
            //++i, // 2011
            layers.IndexOf( layer ), // 2012
            layer.Function,
            Util.MmString( layer.Width ) );
 
          //layerOffset -= layer.Thickness; // 2011
          layerOffset -= layer.Width; // 2012
 
          p = lcstart - v + layerOffset * w;
          q = lcend + v + layerOffset * w;
          creator.CreateModelLine( p, q );
        }
      }
    }
    return Result.Succeeded;
  }
}

Here is the result of running this on a structural wall:

Walls <246407 Generic - 8"> with thickness 203.2 mm has 1 layer:
  Layer 0: function Structure, thickness 203.2 mm

As said, there is no problem with the IndexOf method itself. As you noted yourself, the issue you observed was due to the repeated call to GetLayers to retrieve the collection multiple times while iterating over it at the same time.