The Building Coder

Wall Elevation Profiles in The Building Coder Samples

Last week, I presented a stand-alone command by my colleague Katsuaki Takamizawa to retrieve wall elevation profiles.

His implementation provides a nice little example of using the ExporterIFCUtils.SortCurveLoops method and differentiates between outer and inner loops.

It can be used in almost exactly the same way as the first wall elevation profile implementation presented in 2008.

After publication, Katsu-san and I discussed what to do next and unearthed a couple of interesting aspects:

Response: Thank you very much for publishing the sample code.

I migrated the original wall profile sample. There were a number of places that needed to be changed for this migration.

I see many other Building Coder samples. It would be ideal to migrate them all, but this would require a good effort.

Maybe we can migrate frequently used samples and have developers migrate the rest by themselves as needed?

Answer: The Building Coder samples are already completely migrated, and the most up-to-date version is always available from The Building Coder samples GitHub repository.

I am not thinking of re-migrating the old code, since that is already done, but of replacing the current migrated version in The Building Coder samples by your new implementation, since you say it is simpler and better.

Response: I was not aware that all the old samples have already been migrated and put on GitHub. That is really great!

I migrated the old code from the original blog post. I am afraid that some developers might be doing the same.

Is this link visible and accessible from your blog?

Answer: Basically, I keep pointing out that the most up-to-date version is always available from The Building Coder samples GitHub repository, as above.

I followed your suggestion and integrated the new implementation in parallel with the original one.

The main entry point now looks like this:

  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    // Choose which implementation to use.
 
    bool use_execute_2 = true;
 
    return use_execute_2
      ? Execute2( commandData, ref message, elements )
      : Execute1( commandData, ref message, elements );
  }

You can switch between the two by toggling the value of the Boolean variable use_execute_2 in the debugger.

Here is the result of running the new implementation in the sample model you provided:

The result of the original implementation looks like this:

I published the version including the new command implementation as release 2015.0.116.7.

The integration of the two required changing the transaction mode of the external command from automatic to manual.

This really ought to be done in all of the external command samples.

Another overdue task is to completely remove all obsolete API usage. I last took a stab at it in November, eliminating more obsolete API usage.

I also want to update the copyright message to reflect the new year 2015.

In fact, I just completed the latter right away, and published the result as release 2015.0.116.8.

Many thanks to Katsu-san for this useful discussion and clarification!

Getting the Wall Elevation Profile

I am back from the vacation in Italy, which I enjoyed very much, especially another visit to the wonderful coast of Amalfi.

To quickly share an interesting new result using the Revit API, here is a solution by Katsuaki Takamizawa to retrieve the wall elevation profile.

It also provides a nice little example of using the ExporterIFCUtils.SortCurveLoops method that we just recently documented.

Says Katsu:

I created some sample code for finding the wall elevation profile and determining its outer and inner loops.

The wall elevation profile topic was already discussed way back in 2008, followed by determination of the related polygon areas.

This sample uses newer methods and the code is much simpler.

The sample draws model lines based on the existing wall elevation profile.

The outer edge loop is colored in red.

It uses the ExporterIFCUtils.SortCurveLoops method to sort the outer and inner loops.

The outer loop is always counter-clockwise oriented, so we can use the IsCounterclockwise method to detect it.

The result of running the command on a simple wall with a door and two windows looks like this:

Here is the entire implementation of the external command Execute method:

  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Application app = uiapp.Application;
  Document doc = uidoc.Document;
  View view = doc.ActiveView;
 
  Autodesk.Revit.Creation.Application creapp
    = app.Create;
 
  Autodesk.Revit.Creation.Document credoc
    = doc.Create;
 
  Reference r = uidoc.Selection.PickObject(
    ObjectType.Element, "Select a wall" );
 
  Element e = uidoc.Document.GetElement( r );
 
  Wall wall = e as Wall;
 
  using( Transaction tx = new Transaction( doc ) )
  {
    tx.Start( "Wall Profile" );
 
    // Get the external wall face for the profile
 
    IList<Reference> sideFaces
      = HostObjectUtils.GetSideFaces( wall,
        ShellLayerType.Exterior );
 
    Element e2 = doc.GetElement( sideFaces[0] );
 
    Face face = e2.GetGeometryObjectFromReference(
      sideFaces[0] ) as Face;
 
    // The normal of the wall external face.
 
    XYZ normal = face.ComputeNormal( new UV( 0, 0 ) );
 
    // Offset curve copies for visibility.
 
    Transform offset = Transform.CreateTranslation(
      5 * normal );
 
    // If the curve loop direction is counter-
    // clockwise, change its color to RED.
 
    Color colorRed = new Color( 255, 0, 0 );
 
    // Get edge loops as curve loops.
 
    IList<CurveLoop> curveLoops
      = face.GetEdgesAsCurveLoops();
 
    // ExporterIFCUtils class can also be used for 
    // non-IFC purposes. The SortCurveLoops method 
    // sorts curve loops (edge loops) so that the 
    // outer loops come first.
 
    IList<IList<CurveLoop>> curveLoopLoop
      = ExporterIFCUtils.SortCurveLoops(
        curveLoops );
 
    foreach( IList<CurveLoop> curveLoops2
      in curveLoopLoop )
    {
      foreach( CurveLoop curveLoop2 in curveLoops2 )
      {
        // Check if curve loop is counter-clockwise.
 
        bool isCCW = curveLoop2.IsCounterclockwise(
          normal );
 
        CurveArray curves = creapp.NewCurveArray();
 
        foreach( Curve curve in curveLoop2 )
        {
          curves.Append( curve.CreateTransformed( offset ) );
        }
 
        // Create model lines for an curve loop.
 
        Plane plane = creapp.NewPlane( curves );
 
        SketchPlane sketchPlane
          = SketchPlane.Create( doc, plane );
 
        ModelCurveArray curveElements
          = credoc.NewModelCurveArray( curves,
            sketchPlane );
 
        if( isCCW )
        {
          foreach( ModelCurve mcurve in curveElements )
          {
            OverrideGraphicSettings overrides
              = view.GetElementOverrides(
                mcurve.Id );
 
            overrides.SetProjectionLineColor(
              colorRed );
 
            view.SetElementOverrides(
              mcurve.Id, overrides );
          }
        }
      }
    }
    tx.Commit();
  }
  return Result.Succeeded;

I initially tried to move the model lines using the ElementTransformUtils.MoveElement method to offset them for better visibility.

That did not work.

It seems that these model lines are attached to the wall face, and the MoveElement method cannot move them away from the wall.

So I modified the underlying geometry curves first, before creating model lines from them.

Here is GetWallProfile.zip containing the entire Visual Studio solution, external command source code and add-in manifest.

Many thanks to Katsu-san for implementing and sharing this!

ExporterIfcUtils Curve Loop Sort and Validate

Joel Spahn raised a pertinent question on sorting face loop edges that was kindly picked up and answered by Scott Conover and Angel Velez from the Revit development team:

Question: It would be nice to know exactly what the following methods do:

• SortCurveLoops: sorts a set of curve loops such that outer and inner loops are separated.
• Remarks: Outer loops are separated and inner loops are grouped according to their outer loop. Loops are assumed to be non-intersecting, and there will be no nesting of inner loops, i.e., an inner loop of an inner loop is another outer loop.
• Returns: The sorted collection of loops.
• Input:
• loops, the curve loops.
• ValidateCurveLoops: performs validity checks on a list of curve loops to ensure that they are all co-planar, closed, and properly oriented.
• Returns the curve loops properly oriented, if possible. If not, the return contains no loops.
• Input:
• curveLoops, the loops to check
• extrDirVec, the normal vector.

In ValidateCurveLoops, the 'extrDirVec' normal vector defines what the 'proper orientation' means, by ensuring that the loops are counter-clockwise relative to this direction vector.

Both methods are perfectly usable outside of any IFC context.

In the long term, there is no reason why they should not move into the regular Revit API.

Thank you, Joel, for raising this very valid question, and to Scott and Angel for their answers.

As I mentioned in the recent discussion sorting face loop edges, the RoomEditorApp provides a sample code snippet exercising SortCurveLoops.

DevDays, GitHub, STL and OBJ Model Import

Long time no post.

Sorry, I am rather caught up in the DevDays conferences, accompanying meetups and travel back and forth across the continent.

After the first Western European DevDays conference and meetup in Paris on Monday, we continued and repeated in London, UK, and Gothenburg, Sweden.

We had a day's break there, and I took a quick bus and ferry ride out to Styrsö before leaving.

Now we have arrived in Munich, Germany, and the last goal for Tuesday and Wednesday is Milano, Italy.

On Sunday, Jim Quanci and I visited Thomas Fink of SOFiSTiK AG in Nürnberg, the birthplace of Albrecht Dürer:

Here we are admiring Jürgen Goertz's 1984 bronze sculpture Der Hase – Hommage á Dürer (The Hare – A Tribute to Dürer), a nod to Dürer's watercolour original Junger Feldhase (1502), hinting at the dire results of tampering with nature:

Although I did not post to The Building Coder in the last couple of days, I was still pretty busy on GitHub.

Check out these new GitHub projects of mine:

• StlImport
• DirectObjLoader
• StringSearch

StlImport

The StlImport Revit add-in has been around for some time, although it may not have caught your attention in the past.

It demonstrates some of the Revit 2015 API DirectShape element functionality by importing an interactively selected STL file into a DirectShape element in the Revit project, using the NuGet QuantumConcepts STL package to load and parse the STL file.

It was implemented by Scott Conover of the Revit development team, shown at last year's DevDays Online conferences, posted with the DevDays online recording and migrated to Revit 2015 UR1.

This is the first time I highlight it specifically and publish it on its own, in its very own cosy StlImport GitHub repository.

DirectObjLoader

The new DirectObjLoader project is the main reason I spent so much time on GitHub and so little time blogging.

It also reminded me of the StlImport sample project and prompted me to publish it, simplifying access to it both for you and me myself.

Inspired by Eric Boehlke of truevis.com at the DevHack after the DevDays conference in Las Vegas two weeks ago, I implemented this add-in, similar to StlImport, to load and parse a WaveFront OBJ model and generate a DirectShape element from that:

Here is a sample fire hydrant OBJ file:

DirectObjLoader generates this DirectShape element for it in the Revit model:

Eric requested functionality to specify an input scaling factor, so I added that.

Here is a gargoyle and a half produced by running the command twice, with scaling factors 1.0 and 0.5:

We continued experimenting with larger and more complex OBJ files.

As a final result of that work, OBJ files defining groups now generate a separate DirectShape element for each one:

I should certainly describe this project and various interesting aspects of it in more detail soon.

Here are some of the points worth mentioning and discussing in more depth:

• Simple user interaction to select a file
• Simple single button external app user interface
• Using a NuGet package in a Revit add-in
• Reading and parsing OBJ files using FileFormatWavefront
• Generating a DirectShape element
• Usage of various DirectShape generation options
• The workflow to capture as-built reality and use it to populate a Revit model, i.e. how to get from ReCap to a cleaned-up STL or OBJ model
• Storing user settings in a config file via .NET ConfigurationManager and OpenMappedExeConfiguration

For the moment, you can check it all out yourself in the DirectObjLoader GitHub repository.

StringSearch

A recent comment raised the issue of full-text string searches in Revit projects, and that reminded me of the old StringSearch plugin of the month add-in.

I presented it migrated to Revit 2013 as an example of retrieving an embedded resource image.

All the Plugin of the Month add-ins were also published on the Autodesk Exchange AppStore, and therefore I migrated it to Revit 2014 as well, but without publishing the updated code here on The Building Coder.

Now all the versions for Revit 2011, 2012, 2013, 2014 and 2015 are available from the StringSearch GitHub repository.

Now we are in the middle of the Munich DevDays conference, with the meetup coming up tonight, I Love 3D – Munchen – I hope to see you there!

SelFilter, a Powerful Generic Selection Filter Utility

I recently discussed the minimalist generic selection filter implementation JtElementsOfClassSelectionFilter that I added to The Building Coder samples.

Alexander Buschmann of IDAT GmbH responded to that and says:

I saw your generic SelectionFilter class and this reminded me of a little pet project I've done in my spare time that I thought your readers might be interested in.

Two things always bothered me about the ISelectionFilter:

• You have to create a class to use it.
• Though most often you just want to select Elements that match certain criteria, you can't use the already existing ElementFilters instead. It just feels wrong to create my own class to do something that a Revit class can do for me – and most probably it can do it even better than I could do it myself.

I therefore implemented a class GetFilter that provides fast and easy access to the (probably?) most common selection filtering scenarios:

It supports filtering for one or more classes, for one or more ElementIds, filtering using ElementFilters, some example ReferenceFilterings (for PlanarFaces and for normal vectors of Faces), some methods to filter with delegates or lambdas and some logical combinators, i.e. "and", "or" and "not".

For the logical combinators there are extension methods for ISelectionFilter defined, so every ISelectionFilter can be combined using these.

Using this should be quite easy – here is an example command and a Revit project to run it in.

Here are some usage examples:

• SelFilter.GetElementFilter<Wall>() – returns a filter for Walls.
• SelFilter.GetElementFilter(typeof(Wall), typeof(Floor), typeof(Pipe)) – returns a filter for Walls, Floors and Pipes.
• SelFilter.GetElementFilter (elementFilter) – return a filter using an Autodesk.Revit.DB.ElementFilter.
• SelFilter.GetElementFilter(idList) – returns a filter that will let only elements in the idList pass; this might be useful to select faces or edges on some preselected elements.
• filter1.And(filter2) – returns a filter that will check both filter1 and filter2.

Further information:

• The GetFilter class itself is a static class with static methods that return an interface of an instance of the actual (private) filter classes.
• The actual Filter classes are private to reduce namespace cluttering – it's mostly a matter of taste.
• GetElementFilter methods return an IElementSelectionFilter which does the filtering using the AllowElement method; those classes just return true for the AllowReference method.
• GetReferenceFilter, GetPlanarFaceFilter and GetFaceNormalFilter return an IReferenceSelectionFilter that performs the filtering using the AllowReference method; these classes just return true for the AllowElement method.
• As a consequence, the combination of IElementSelectionFilters with IReferenceSelectionFilters is only meaningful using "and". If "or" is used, everything will pass the combined filter.
• The "and" and "or" filter methods return an ILogicalCombinationFilter that combines two or more filters. This interface exposes a property "ExecuteAll" – if it is set to "true", all the filters are called, even when the result already is fixed. This might or might not be helpful for debugging purposes.
• The "not" filter is just an inversion of any other filter and directly returns an "ISelectionFilter".
• The GetFilter method creates a filter class for delegates, method groups or lambdas. This gives the option to create arbitrary and complex filters on the fly without creating classes for them.

I think the mightiest of the methods is the ElementFilter method – all different types of ElementFilter can be used, including CategoryFilters, IntersectionFilters, ExtensibleStorageFilters, ParameterFilters, etc.

If the power of ElementFilters is not needed, the Class and ElementId filters give easy access to simpler filtering, and if more power is needed, this can easily be done with lambdas or delegates.

There are lots of comments in the code, though it is really very easy and straightforward. The great thing about this class is not something complicated, just having everything needed in one single place.

The zip file SelFilters.zip contains the SelFilter class, the interface files, an example external command using some of the SelFilter functionality, an add-in manifest file for the example command and a small Revit project to test it in.

Hopefully, you and your readers find this class helpful.

Thank you very much, Alexander, for sharing this!

For the sake of completeness, and especially for the convenience of all those search engines out there, here is the source code for the sample external command mainline Execute method (to see the truncated lines in full, view source or copy and paste to a text editor):

//
// Copyright (c) 2014 Alexander Buschmann
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to 
// deal in the Software without restriction, including without limitation the 
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
// sell copies of the Software, and to permit persons to whom the Software is 
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in 
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
// DEALINGS IN THE SOFTWARE.
//
 
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Autodesk.Revit.Attributes;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using Autodesk.Revit.UI.Selection;
 
namespace RevitSelectionFilters
{
  [Transaction( TransactionMode.ReadOnly )]
  public class SelectionExamples : IExternalCommand
  {
    #region Implementation of IExternalCommand
 
    public Result Execute(
      ExternalCommandData commandData,
      ref string message,
      ElementSet elements )
    {
      UIDocument uiDoc = commandData.Application.ActiveUIDocument;
      Document doc = uiDoc.Document;
      Selection sel = uiDoc.Selection;
 
      try
      {
        //
        // Select Wall or Floor
        //
        Reference pickedReference = sel.PickObject(
          ObjectType.Element,
          SelFilter.GetElementFilter( typeof( Wall ), typeof( Floor ) ),
          "Select Wall or Floor" );
        if( pickedReference == null ) return Result.Failed;
        Element firstElement = doc.GetElement( pickedReference );
 
        TaskDialog.Show(
          "Result",
          "First Selection: " + firstElement.Category.Name + ": " + firstElement.Name + " (" +
          firstElement.Id + ")" );
 
        //
        // Select anything intersecting:
        //
        ElementFilter filter = new ElementIntersectsElementFilter( firstElement );
        ElementFilter notTheFirst = new ExclusionFilter( new Collection<ElementId> { firstElement.Id } );
        ISelectionFilter intersectionFilter =
          SelFilter.GetElementFilter( filter ).And( SelFilter.GetElementFilter( notTheFirst ) );
        pickedReference = sel.PickObject(
          ObjectType.Element, intersectionFilter,
          "Select anything intersecting the first picked Element" );
        if( pickedReference == null ) return Result.Failed;
        Element secondElement = doc.GetElement( pickedReference );
        TaskDialog.Show(
          "Result",
          "Second Selection: " + secondElement.Category.Name + ": " + secondElement.Name + " (" +
          secondElement.Id + ")" );
 
        //
        // Select colums or beams or foundations within 20 feet of the second element in any direction, 
        // but not if they do intersect with the first element
        //
        ICollection<BuiltInCategory> categories = new[] {
          BuiltInCategory.OST_StructuralColumns,
          BuiltInCategory.OST_Columns,
          BuiltInCategory.OST_StructuralFraming,
          BuiltInCategory.OST_StructuralFoundation,
        };
        ElementFilter catFilter = new ElementMulticategoryFilter( categories );
        BoundingBoxXYZ box = secondElement.get_BoundingBox( null );
        XYZ vector = new XYZ( 20, 20, 20 );
        Outline outline = new Outline( box.Min - vector, box.Max + vector );
        ElementFilter boxFilter = new BoundingBoxIntersectsFilter( outline );
        ISelectionFilter selectionFilter = intersectionFilter.Not().And(
          SelFilter.GetElementFilter( catFilter ),
          SelFilter.GetElementFilter( boxFilter ) );
        pickedReference = sel.PickObject(
          ObjectType.Element, selectionFilter,
          "Select Column, Beam, Foundation within 20 feet of second element, not intersecting first element" );
        if( pickedReference == null ) return Result.Failed;
        Element thirdElement = doc.GetElement( pickedReference );
        TaskDialog.Show(
          "Result",
          "Third Selection: " + thirdElement.Category.Name + ": " + thirdElement.Name + " (" +
          thirdElement.Id + ")" );
 
        //
        // Select Face of thirdElement with normal parallel to BasisZ
        //
        selectionFilter = SelFilter.GetReferenceFilter( ( reference, xyz ) =>
        {
          if( reference.ElementId != thirdElement.Id ) return false;
          Face face =
            thirdElement.GetGeometryObjectFromReference( reference ) as Face;
          if( face == null ) return false;
          XYZ normal = face.ComputeNormal( UV.Zero );
          XYZ crossProduct = normal.CrossProduct( XYZ.BasisZ );
          return ( crossProduct.IsAlmostEqualTo( XYZ.Zero ) );
        } );
        pickedReference = sel.PickObject(
          ObjectType.Face, selectionFilter,
          "Select Face of third element with normal parallel to z-Axis" );
        Face pickedFace = thirdElement.GetGeometryObjectFromReference( pickedReference ) as Face;
        XYZ pickedNormal = pickedFace.ComputeNormal( UV.Zero );
        TaskDialog.Show(
          "Result",
          "Fourth Selection: " + pickedFace.GetType().Name + " (" +
          pickedReference.ConvertToStableRepresentation( doc ) + ")\n" +
          "Normal: (" + pickedNormal.X.ToString( "0.###" ) + " / " + pickedNormal.Y.ToString( "0.###" ) + " / " +
          pickedNormal.Z.ToString( "0.###" ) + ")" );
 
        //
        // Now select any Face with an X oder Y-Normal from any previously selected Element
        //
        IElementSelectionFilter idFilter = SelFilter.GetElementFilter( firstElement.Id, secondElement.Id, thirdElement.Id );
        IReferenceSelectionFilter xFilter = SelFilter.GetFaceNormalFilter( doc, XYZ.BasisX, true );
        IReferenceSelectionFilter yFilter = SelFilter.GetFaceNormalFilter( doc, XYZ.BasisY, true );
        ILogicalCombinationFilter logicalFilter = idFilter.And( xFilter.Or( yFilter ) );
#if DEBUG
        logicalFilter.ExecuteAll = true;
#endif
        pickedReference = sel.PickObject(
          ObjectType.Face, logicalFilter,
          "Now select any Face with an x oder y-Normal from any previously selected Element" );
        Element element = doc.GetElement( pickedReference );
        pickedFace = element.GetGeometryObjectFromReference( pickedReference ) as Face;
        pickedNormal = pickedFace.ComputeNormal( UV.Zero );
        TaskDialog.Show(
          "Result",
          "Fifth Selection: " + pickedFace.GetType().Name + " (" +
          pickedReference.ConvertToStableRepresentation( doc ) + ")\n" +
          "Normal: (" + pickedNormal.X.ToString( "0.###" ) + " / " + pickedNormal.Y.ToString( "0.###" ) + " / " +
          pickedNormal.Z.ToString( "0.###" ) + ")" );
      }
      catch( Autodesk.Revit.Exceptions.OperationCanceledException )
      {
        TaskDialog.Show( "Cancelled", "User cancelled" );
        return Result.Cancelled;
      }
      return Result.Succeeded;
    }
    #endregion
  }
}

Here is the pretty fully documented SelFilter class source code:

public static class SelFilter
{
  //
  // Element-Filters: Will filter only for 
  // elements, not for references
  //
 
  /// <summary>
  /// Creates a selection filter that only 
  /// elements of type T will pass
  /// </summary>
  public static IElementSelectionFilter GetElementFilter<T>()
  {
    return new ElementTypeFilter( typeof( T ) );
  }
 
  /// <summary>
  /// Creates a selection filter that elements of 
  /// any type in the collection will pass
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    IEnumerable<Type> allowedTypes )
  {
    return new ElementTypeFilter( allowedTypes );
  }
 
  /// <summary>
  /// Creates a selection filter that elements 
  /// of any of the given types  will pass
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    Type type,
    params Type[] types )
  {
    return new ElementTypeFilter( type, types );
  }
 
  /// <summary>
  /// Creates a selection filter from an ElementFilter
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    ElementFilter filter )
  {
    return new ElementFilterFilter( filter );
  }
 
  /// <summary>
  /// Creates a selection filter that will use 
  /// the "filterMethod" to filter the elements
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    Func<Element, bool> filterMethod )
  {
    return new DelegatesFilter( filterMethod, DelegatesFilter.AllReferences );
  }
 
  /// <summary>
  /// Creates a selection filter that will use 
  /// the "filterMethod" to filter the elements
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    Predicate<Element> filterMethod )
  {
    return new DelegatesFilter(
      new Func<Element, bool>( filterMethod ),
      DelegatesFilter.AllReferences );
  }
 
  /// <summary>
  ///  Creates a selection filter that will 
  ///  let pass only the elements defined by the ids
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    ElementId id,
    params ElementId[] ids )
  {
    return new ElementIdFilter( id, ids );
  }
 
  /// <summary>
  ///  Creates a selection filter that will 
  ///  let pass only the elements defined by the ids
  /// </summary>
  public static IElementSelectionFilter GetElementFilter(
    IEnumerable<ElementId> ids )
  {
    return new ElementIdFilter( ids );
  }
 
  //
  // Reference-Filters: Will filter only for 
  // references, let all elements pass
  //
 
  /// <summary>
  /// Creates a selection filter that will use 
  /// the "filterMethod" to filter the references
  /// </summary>
  public static IReferenceSelectionFilter GetReferenceFilter(
    Func<Reference, XYZ, bool> filterMethod )
  {
    return new DelegatesFilter( DelegatesFilter.AllElements,
      filterMethod );
  }
 
  /// <summary>
  /// Creates a selection filter that will let only 
  /// PlanarFace-References pass
  /// </summary>
  public static IReferenceSelectionFilter GetPlanarFaceFilter( Document doc )
  {
    return GetReferenceFilter( ( reference, xyz ) =>
    {
      Element element = doc.GetElement( reference );
      PlanarFace planarFace = element.GetGeometryObjectFromReference(
        reference ) as PlanarFace;
      return planarFace != null;
    } );
  }
 
  /// <summary>
  /// Creates a selection filter that will let faces 
  /// pass if their normal vector at (0/0) is 
  /// codirectional or parallel to the given normal 
  /// vector
  /// </summary>
  public static IReferenceSelectionFilter GetFaceNormalFilter(
    Document doc,
    XYZ normal,
    bool acceptParallel = false )
  {
    XYZ _normal = normal.Normalize();
    XYZ minusNormal = -1 * _normal;
    return GetReferenceFilter( ( reference, xyz ) =>
    {
      Element element = doc.GetElement( reference );
      Face face = element.GetGeometryObjectFromReference( reference ) as Face;
      if( face == null ) return false;
      XYZ faceNormal = face.ComputeNormal( UV.Zero );
      bool erg = faceNormal.IsAlmostEqualTo( _normal );
      if( acceptParallel ) erg |= faceNormal.IsAlmostEqualTo( minusNormal );
      return erg;
    } );
  }
 
  //
  // Filter for Elements and References
  //
 
  public static ISelectionFilter GetFilter(
    Func<Element, bool> elementFilterMethod,
    Func<Reference, XYZ, bool> referencesFilterMethod )
  {
    return new DelegatesFilter( elementFilterMethod,
      referencesFilterMethod );
  }
 
  //
  // Logical-Filters: Will call other filters
  //
 
  /// <summary>
  /// Creates a logical "or" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalOrFilter(
    ISelectionFilter first,
    ISelectionFilter second,
    bool executeAll = false )
  {
    return new LogicalOrFilter( first, second, executeAll );
  }
 
  /// <summary>
  /// Creates a logical "or" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalOrFilter(
    ISelectionFilter first,
    params ISelectionFilter[] filters )
  {
    return new LogicalOrFilter( first, filters );
  }
 
  /// <summary>
  /// Creates a logical "or" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalOrFilter(
    IEnumerable<ISelectionFilter> filters )
  {
    return new LogicalOrFilter( filters );
  }
 
  /// <summary>
  /// Creates a logical "and" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalAndFilter(
    ISelectionFilter first,
    ISelectionFilter second,
    bool executeAll = false )
  {
    return new LogicalAndFilter( first, second, executeAll );
  }
 
  /// <summary>
  /// Creates a logical "and" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalAndFilter(
    ISelectionFilter first,
    params ISelectionFilter[] filters )
  {
    return new LogicalAndFilter( first, filters );
  }
 
  /// <summary>
  /// Creates a logical "and" filter
  /// </summary>
  public static ILogicalCombinationFilter GetLogicalAndFilter(
    IEnumerable<ISelectionFilter> filters )
  {
    return new LogicalAndFilter( filters );
  }
 
  /// <summary>
  /// Creates a logical "not" filter
  /// </summary>
  public static ISelectionFilter GetLogicalNotFilter(
    ISelectionFilter filter )
  {
    return new LogicalNotFilter( filter );
  }
 
  //
  // Extension Methods for SelectionFilters
  // 
 
  /// <summary>
  /// Creates a logical "or" filter
  /// </summary>
  /// <param name="_this"></param>
  /// <param name="filters"></param>
  /// <returns></returns>
  public static ILogicalCombinationFilter Or(
    this ISelectionFilter _this,
    params ISelectionFilter[] filters )
  {
    return new LogicalOrFilter( _this, filters );
  }
 
  /// <summary>
  /// Creates a logical "and" filter
  /// </summary>
  public static ILogicalCombinationFilter And(
    this ISelectionFilter _this,
    params ISelectionFilter[] filters )
  {
    return new LogicalAndFilter( _this, filters );
  }
 
  /// <summary>
  /// Creates a logical "not" filter
  /// </summary>
  public static ISelectionFilter Not(
    this ISelectionFilter _this )
  {
    return new LogicalNotFilter( _this );
  }
 
  //
  // Interfaces
  //
 
  //
  // Private classes will do the actual work - 
  // don't need to be visible.
  // ISelectionFilter is not strictly neccessary on 
  //each class, but I like to explicitly say what I 
  // am doing.
  //
 
  /// <summary>
  /// Private class that represents a selection 
  /// filter that will filter only for elements
  /// and lets all references pass
  /// </summary>
  private abstract class ElementSelectionFilter
    : IElementSelectionFilter,
    IReferenceSelectionFilter,
    ISelectionFilter
  {
    #region Implementation of ISelectionFilter
 
    public abstract bool AllowElement( Element elem );
 
    /// <summary>
    /// This class does not filter for references
    /// </summary>
    public bool AllowReference(
      Reference reference,
      XYZ position )
    {
      return true;
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a 
  /// filter for one or more ElementTypes
  /// </summary>
  private class ElementTypeFilter
    : ElementSelectionFilter,
    IElementSelectionFilter,
    IReferenceSelectionFilter,
    ISelectionFilter
  {
    /// <summary>
    /// List of the allowed types 
    /// </summary>
    private readonly List<Type> m_types
      = new List<Type>();
 
    /// <summary>
    /// Constructs a Filter for a single Type
    /// </summary>
    public ElementTypeFilter( Type type )
    {
      m_types.Add( type );
    }
 
    /// <summary>
    /// Constructs a Filter for a list of Types
    /// </summary>
    public ElementTypeFilter( IEnumerable<Type> types )
    {
      m_types.AddRange( types );
    }
 
    /// <summary>
    /// Constructs a Filter for a number of Types
    /// </summary>
    public ElementTypeFilter(
      Type type,
      params Type[] types )
      : this( type )
    {
      m_types.AddRange( types );
    }
 
    #region Implementation of ISelectionFilter
 
    public override bool AllowElement( Element elem )
    {
      return m_types.Any( type
        => type.IsInstanceOfType( elem ) );
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a 
  /// filter using an ElementFilter
  /// </summary>
  private class ElementFilterFilter
    : ElementSelectionFilter,
    IElementSelectionFilter,
    IReferenceSelectionFilter,
    ISelectionFilter
  {
    /// <summary>
    /// The ElementFilter that is used
    /// </summary>
    private readonly ElementFilter m_filter;
 
    /// <summary>
    /// Constructs a SelectionFilter for an ElementFilter
    /// </summary>
    public ElementFilterFilter( ElementFilter filter )
    {
      m_filter = filter;
    }
 
    #region Overrides of ElementSelectionFilter
 
    /// <summary>
    /// An element passes if it passes the ElementFilter
    /// </summary>
    public override bool AllowElement( Element elem )
    {
      return m_filter.PassesFilter( elem );
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a filter 
  /// for one or more specific elements.
  /// Especially usefull when and-combined 
  /// with a ReferenceFilter
  /// </summary>
  private class ElementIdFilter
    : ElementSelectionFilter,
    IElementSelectionFilter,
    IReferenceSelectionFilter,
    ISelectionFilter
  {
 
    /// <summary>
    /// The list of valid ElementIds
    /// </summary>
    private readonly List<ElementId> m_ids
      = new List<ElementId>();
 
    /// <summary>
    /// Constructs a ElementIdFilter for one or more ElementIds
    /// </summary>
    public ElementIdFilter(
      ElementId id,
      params ElementId[] ids )
    {
      m_ids.Add( id );
      m_ids.AddRange( ids );
    }
 
    /// <summary>
    /// Constructs a ElementIdFilter for a 
    /// collection of ElementIds
    /// </summary>
    public ElementIdFilter( IEnumerable<ElementId> ids )
    {
      m_ids.AddRange( ids );
    }
 
    #region Overrides of ElementSelectionFilter
 
    /// <summary>
    /// An Element passes if its Id is 
    /// in the list of valid Ids
    /// </summary>
    public override bool AllowElement( Element elem )
    {
      return m_ids.Contains( elem.Id );
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents 
  /// a filter using delegate methods
  /// </summary>
  private class DelegatesFilter
    : IElementSelectionFilter,
    IReferenceSelectionFilter,
    ISelectionFilter
  {
    /// <summary>
    /// The delegate used to filter elements
    /// </summary>
    private readonly Func<Element, bool> m_elementFilter;
 
    /// <summary>
    /// The delegate used to filter References
    /// </summary>
    private readonly Func<Reference, XYZ, bool> m_referenceFilter;
 
    /// <summary>
    /// Constructs a filter that uses the element 
    /// and reference filter delegates
    /// </summary>
    public DelegatesFilter(
      Func<Element, bool> elementFilter,
      Func<Reference, XYZ, bool> referenceFilter )
    {
      m_elementFilter = elementFilter;
      m_referenceFilter = referenceFilter;
    }
 
    /// <summary>
    /// Use this if all Elements should pass the Filter
    /// </summary>
    public static Func<Element, bool> AllElements
    {
      get { return element => true; }
    }
 
    /// <summary>
    /// Use this, if all References should pass the Filter
    /// </summary>
    public static Func<Reference, XYZ, bool> AllReferences
    {
      get { return ( reference, xyz ) => true; }
    }
 
    #region Implementation of ISelectionFilter
 
    /// <summary>
    /// Elements that pass the element filter 
    /// predicate will pass
    /// </summary>
    public bool AllowElement( Element elem )
    {
      return m_elementFilter( elem );
    }
 
    /// <summary>
    /// Elements that pass the reference filter 
    /// predicate will pass
    /// </summary>
    public bool AllowReference(
      Reference reference,
      XYZ position )
    {
      return m_referenceFilter( reference, position );
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a logical or filter for selection filters.
  /// </summary>
  private abstract class LogicalCombinationFilter : ISelectionFilter, ILogicalCombinationFilter
  {
    /// <summary>
    /// List of the filters to check
    /// </summary>
    protected readonly List<ISelectionFilter> m_filterList
      = new List<ISelectionFilter>();
 
    /// <summary>
    /// If true, all filters are executed, 
    /// even if the result is already obvious
    /// </summary>
    public bool ExecuteAll { get; set; }
 
    /// <summary>
    /// Constructs a logical filter for two selectionFilters
    /// </summary>
    protected LogicalCombinationFilter(
      ISelectionFilter first,
      ISelectionFilter second,
      bool executeAll = false )
    {
      this.ExecuteAll = executeAll;
      m_filterList.Add( first );
      m_filterList.Add( second );
    }
 
    /// <summary>
    /// Constructs a logical filter for 
    /// a number of selectionsFilters
    /// executeAll is set to false
    /// </summary>
    protected LogicalCombinationFilter(
      ISelectionFilter first,
      params ISelectionFilter[] filters )
    {
      this.ExecuteAll = false;
      m_filterList.Add( first );
      m_filterList.AddRange( filters );
    }
 
    /// <summary>
    /// Constructs a logical filter for 
    /// a number of selectionsFilters
    /// executeAll is set to false
    /// </summary>
    /// <param name="filters"></param>
    protected LogicalCombinationFilter(
      IEnumerable<ISelectionFilter> filters )
    {
      ExecuteAll = false;
      m_filterList.AddRange( filters );
    }
 
    #region Implementation of ISelectionFilter
 
    public abstract bool AllowElement(
      Element elem );
 
    public abstract bool AllowReference(
      Reference reference,
      XYZ position );
 
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a logical or filter
  /// </summary>
  private class LogicalOrFilter
    : LogicalCombinationFilter, ISelectionFilter
  {
 
    /// <summary>
    /// Constructs a logical or filter for two Filters
    /// </summary>
    public LogicalOrFilter(
      ISelectionFilter first,
      ISelectionFilter second,
      bool executeAll )
      : base( first, second, executeAll )
    {
    }
 
    /// <summary>
    /// Constructs a logical or filter for 
    /// a number of filters
    /// </summary>
    public LogicalOrFilter(
      ISelectionFilter first,
      params ISelectionFilter[] filters )
      : base( first, filters )
    {
    }
 
    /// <summary>
    /// Constructs a logical or filter for 
    /// a number of filters
    /// </summary>
    public LogicalOrFilter(
      IEnumerable<ISelectionFilter> filters )
      : base( filters )
    {
    }
 
    #region Implementation of ISelectionFilter
 
    /// <summary>
    /// Elements that pass at least on 
    /// of the filters will pass
    /// </summary>
    public override bool AllowElement( Element elem )
    {
      bool erg = false;
      if( ExecuteAll )
      {
        m_filterList.ForEach( filter
          => erg |= filter.AllowElement( elem ) );
      }
      else
      {
        erg = m_filterList.Any( filter
          => filter.AllowElement( elem ) );
      }
      return erg;
    }
 
    /// <summary>
    /// References that pass at least one 
    /// of the filters will pass
    /// </summary>
    public override bool AllowReference(
      Reference reference,
      XYZ position )
    {
      bool erg = false;
      if( ExecuteAll )
      {
        m_filterList.ForEach( filter
          => erg |= filter.AllowReference(
            reference, position ) );
      }
      else
      {
        erg = m_filterList.Any( filter
          => filter.AllowReference(
            reference, position ) );
      }
      return erg;
    }
 
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a logical and filter
  /// </summary>
  private class LogicalAndFilter
    : LogicalCombinationFilter, ISelectionFilter
  {
 
    /// <summary>
    /// Constructs a logical and filter for two Filters
    /// </summary>
    public LogicalAndFilter(
      ISelectionFilter first,
      ISelectionFilter second,
      bool executeAll )
      : base( first, second, executeAll )
    {
    }
 
    /// <summary>
    /// Constructs a logical and filter 
    /// for a number of filters
    /// </summary>
    public LogicalAndFilter(
      ISelectionFilter first,
      params ISelectionFilter[] filters )
      : base( first, filters )
    {
    }
 
    /// <summary>
    /// Constructs a logical and 
    /// filter for a number of filters
    /// </summary>
    public LogicalAndFilter(
      IEnumerable<ISelectionFilter> filters )
      : base( filters )
    {
    }
 
    #region Implementation of ISelectionFilter
 
    /// <summary>
    /// Elements that pass all of the filters will pass
    /// </summary>
    public override bool AllowElement( Element elem )
    {
      bool erg = true;
      if( ExecuteAll )
      {
        m_filterList.ForEach( filter
          => erg = erg & filter.AllowElement( elem ) );
      }
      else
      {
        erg = m_filterList.All( filter
          => filter.AllowElement( elem ) );
      }
      return erg;
    }
 
    /// <summary>
    /// References that pass all of the filters will pass
    /// </summary>
    public override bool AllowReference(
      Reference reference,
      XYZ position )
    {
      bool erg = true;
      if( ExecuteAll )
      {
        m_filterList.ForEach( filter
          => erg = erg & filter.AllowReference(
            reference, position ) );
      }
      else
      {
        erg = m_filterList.All( filter
          => filter.AllowReference(
            reference, position ) );
      }
      return erg;
    }
    #endregion
  }
 
  /// <summary>
  /// Private class that represents a logical Not filter
  /// </summary>
  private class LogicalNotFilter : ISelectionFilter
  {
    /// <summary>
    /// The filter, that will get negated
    /// </summary>
    private readonly ISelectionFilter m_filter;
 
    /// <summary>
    /// constructs a not-Filter
    /// </summary>
    /// <param name="filter"> </param>
    public LogicalNotFilter( ISelectionFilter filter )
    {
      m_filter = filter;
    }
 
    #region Implementation of ISelectionFilter
 
    /// <summary>
    /// Elements will pass, if they don't 
    /// pass the original filter
    /// </summary>
    public bool AllowElement( Element elem )
    {
      return !m_filter.AllowElement( elem );
    }
 
    /// <summary>
    /// References will pass, if they 
    /// don't pass the original filter
    /// </summary>
    public bool AllowReference(
      Reference reference,
      XYZ position )
    {
      return !m_filter.AllowReference(
        reference, position );
    }
    #endregion
  }
}

Culinary Notes from Paris

By the way, I am sitting in the meetup in London now.

Before ending for today, I have two little culinary notes from Paris to share:

I was lucky enough not to stay in horrible huge hotel there, but in a really nice little bed and breakfast instead, right next to Montmartre and Sacré-Cœur.

Better still, it was right next to the prize-winning baker and patissier Boulangerie Raphaëlle, so I had great croissants and chocolate for breakfast.

Then, to my surprise, arriving a bit early at the airport, I discovered the Ladurée restaurant at the Charles de Gaulle airport and enjoyed my first ever truffle omelette before hopping on to the plane.

Concrete Setout Points for Revit Structure 2015

I was prompted by a Revit API forum discussion thread on Jeremy's setoutpoint to take another look at my SetoutPoints structural concrete setout point add-in, publish it on GitHub and migrate it from Revit Structure 2013 to 2015.

SetoutPoints is a Revit add-in for automatic placement and management of structural concrete setout points.

Setout point markers are automatically generated at all vertices of structural members. They can be manually designated as minor or major:

The major points are automatically numbered, scheduled and converted to global northing and easting coordinates.

The numbering can be edited and regenerated to ensure schedule consistency and readability.

Here is a collection on background and further reading on this project:

• Detailed description
• Original implementation
• Commercial use
• Discussion thread

Sanjaymann took a look at this project, encountering and solving a transformation issue with some structural foundations:

Question: I was working with the setoutpoint example on structural foundations. The code places the points on one foundation but not on the other. Both of them are same family.

While debugging, the only difference that I saw was that in the case of the first foundation, the code directly retrieves a solid in the GetSolid function; in the case of the second one, it retrieves a geometry instance instead:

  /// <summary>
  /// Retrieve the first non-empty solid found for 
  /// the given element. In case the element is a 
  /// family instance, it may have its own non-empty
  /// solid, in which case we use that. Otherwise we 
  /// search the symbol geometry. If we use the 
  /// symbol geometry, we have to keep track of the 
  /// instance transform to map it to the actual
  /// instance project location.
  /// </summary>
  Solid GetSolid(
    Element e,
    Options opt,
    out Transform t )
  {
    GeometryElement geo = e.get_Geometry( opt );
 
    Solid solid = null;
    GeometryInstance inst = null;
    t = Transform.Identity;
 
    // Some columns have no solids, and we have to 
    // retrieve the geometry from the symbol; 
    // others do have solids on the instance itself 
    // and no contents in the instance geometry 
    // (e.g. in rst_basic_sample_project.rvt).
 
    foreach( GeometryObject obj in geo )
    {
      solid = obj as Solid;
 
      if( null != solid
        && 0 < solid.Faces.Size )
      {
        break;
      }
 
      inst = obj as GeometryInstance;
    }
 
    if( null == solid && null != inst )
    {
      geo = inst.GetSymbolGeometry();
      t = inst.Transform;
 
      foreach( GeometryObject obj in geo )
      {
        solid = obj as Solid;
 
        if( null != solid
          && 0 < solid.Faces.Size )
        {
          break;
        }
      }
    }
    return solid;
  }

As said, both foundations belong to the same family. Why do they behave so differently?

Answer: The difference may be caused by the fact that one foundation can use the unmodified family symbol geometry, whereas the other one needs some kind of instance specific modification, and therefore cannot use the unmodified symbol geometry. Does that make sense?

Response: Sometimes the sword fails and the needle does the job.

While looping over the corners:

  foreach( XYZ p in corners.Keys )

The point p has to be transformed:

  XYZ p1 = t.OfPoint( p );
 
  FamilyInstance fi
    = doc.Create.NewFamilyInstance( p1,
      symbols[1], StructuralType.NonStructural );

One line did the trick.

Answer: Congratulations on finding the right needle for the job!

Thank you very much for your research!

Motivated by your work, I created a GitHub repository for the SetoutPoints application and migrated it to Revit Structure 2015.

I applied the change that you suggest by adding the transformation as an 'out' parameter to the GetSolid method instead of moving the code out, cf. the GitHub diffs.

The updated solution for Revit 2015 with your transformation added is published in the SetoutPoints GitHub repository and your transformation enhancement is the content of release 2015.0.0.1.

Many thanks to Sanjaymann for his interest and research!

I hope this is of interest to others as well.

Point Cloud Indexing Update

The Point Cloud API has changed a bit in the past couple of years, and it is time for an update of the previous point cloud overview from 2011.

My re-exploration of this topic was triggered by Henrik's Revit API discussion forum thread on the point cloud indexer API:

Question: Is there an API or another way to programmatically access the Indexer of PointClouds?

I am referring to the dialog that pops up when you try to import a different format point cloud, e.g., e57.

Do you have an example of the Indexer API? Or is it possible to access the functions through python? Or command line, maybe?

Besides this we have another question that maybe you can answer as well: We have had some questions if Revit / Recap, when it converts from e.g. .fls to .rcs, moves points into a grid structure? It is questions from land surveyors, who believe this is the case, and mention that it is not suitable for their work if they can't count on that the points are in the same position as when they scan. Do you know if this is the case?

Answer: Wow, that was a pretty chase...

For your convenience, I put together a dedicated point cloud topic group on The Building Coder listing the discussions published so far.

However, the Point Cloud Indexer API provided by the Revit 2012 API is now deprecated.

Before discovering that, Adam Nagy republished his Revit 2012 point cloud indexer sample for Revit 2012 on GitHub.

It would in theory be interesting to hear whether it works as is or can be modified to work with Revit 2015.

You could fork Adam's repository, keep track of the changes, and send him a pull request when done to ask him to merge them back in.

As said, though, this API is now deprecated and may not be usable at all.

I found another discussion on batch PCG creation using Autodesk point cloud indexer that confirms this.

Once that was clear, I asked the development team about the current status.

Their initial response was, "We moved away from writing indexers, right? ReCap SDK should be where customers go now?"

Indeed, that just about summarises it.

Arkady Gilman and his colleagues provided some more detail and background information as follows:

The Revit team no longer writes indexers, just uses the ones provided by the Recap team. We still do indexing of raw data into Recap format in Revit, though.

The Revit 2013 API for alternative point cloud engine is deprecated. Please do not implement another engine. Use ReCap instead.

Similarly, PCG is deprecated and should not be used.

Revit has an indexer, i.e. a separate executable that is launched when you want to insert a file other than RCP or RCS (e.g. PTX, PTS of FLS). This indexer is in fact a 'headless' version of ReCap. So adding a 'codec' (I think they use this term) for ReCap will automatically make new format available for Revit indexer as well. In general, the Revit indexer is intended for a novice, sporadic user. We assume that people using point clouds 'for real' will use ReCap to index and register scans before importing the data to Revit.

ReCap may be making and supporting the standalone indexer at some point. Revit probably only uses our thin UI for converting old (PCG) point cloud files into the ReCap format (RCP, RCS).

Can you clarify what you are trying to do? Do you want to index some new 'raw' data format that ReCap does not currently recognize?

From the thread it is not clear exactly what you want to achieve.

You ask: We have had some questions if Revit / Recap, when it converts from e.g. .fls to .rcs, moves points into a grid structure? It is questions from land surveyors, who believe this is the case, and mention that it is not suitable for their work if they can't count on that the points are in the same position as when they scan. Do you know if this is the case?

The answer is that ReCap indexing does not alter point coordinates; they are completely sacred.

What do you mean by 'moving points into a grid structure'? ReCap stores points in a spatial tree, but this is just the method used to quickly find points within a given part of space.

There is whole separate issue w/regard to what happens with different scans when they are registered with respect to one another.

Response: First of all thank you very much for your answers this is really great.   :-)

To explain what we are doing: I am part of a research group called CITA (Center for IT and Architecture) at the school of architecture in Copenhagen, Denmark.

We are part of an EU funded research project called duraark, which deals with the life circle of architectural knowledge, in this case ifc and e57 formats.

The project deals with how a long-term archive of architectural knowledge can be set up and integrated into the workflows of the stakeholders involved in the architectural disciplines.

For this we are developing methods of e.g. extracting metadata and verifying quality from point clouds and from comparison of point clouds and BIM models.

Because the majority of the stakeholders are working in Autodesk products, we want to be able to integrate these extraction, comparison and quality checking tools into Revit.

At the moment we are considering using Dynamo for prototyping the integrated workflow of our stakeholders.

At the end of the project, we will hopefully have a plugin for Revit   :-)

To answer your questions:

1. "Can you clarify what you are trying to do? Do you want to index some new 'raw' data format that ReCap does not currently recognize? From the thread it is not clear exactly what you want to achieve."

The first thing we want to be able to do is to visualize .e57 point clouds in Revit without having to go through and open them in Recap to transform them into the rcs format.

One idea I just had now for this was maybe to be able to access "the separate executable that is launched when you want to insert a file other than RCP or RCS" ('the headless' version of ReCap) through command line. And in this way be able to visualize and link e57 point clouds in Revit with full control over the files generated and linked to Revit from within Dynamo and python.

Would a command line solution be possible?

Or can you see another way?

Is there an API for Recap?

2. "... if they can't count on that the points are in the same position as when they scan. Do you know if this is the case?"

I do not know for sure if this is the case. It was a comment I got from one of our stakeholders. As you say that "ReCap indexing does not alter point coordinates; they are completely sacred", then I will assume this really is the case.

Again thanks for your replies and I hope this clarifies what we are trying to achieve. And I hope it sounds interesting from your point of view.

Answer: Thank you for your answers.

Here is some more feedback from the development team:

Long term preservation of architectural knowledge sounds interesting and I’m glad Autodesk tools are used for this!

As far as I understood, the input format is E57, which ReCap can index and so can Revit (using its standalone indexer).

I am puzzled by the client’s desire not to use ReCap for indexing. I would ask if his scans are already 'registered', i.e. unified in one E57 file per building.

If so, then I understand his desire to write a script to automate E57 to RCS conversion of the large number of files. Our standalone indexer can be used for that; we had this use case in mind from the beginning, although I don’t know if anybody is actually using such a workflow.

I found the following description:

The indexer program is called AdPointcloudIndexer.exe and is located in the Program folder in Revit installation.

The command line for the indexer is:

AdPointcloudindexer [/batch] [/pluginspath=PathToPluginsFolder] InputFile [OutputFile]

Where:

• InputFile: must be specified; all other parameters are optional;
• OutputFile: If specified is the resulting RCP file from the conversion. If no file is specified, then the resulting file is same base filename as the input file, and placed in the same folder as the input file. If the output file already exists, a prompt will be provided asking the user if they wish to overwrite it or not.

/batch causes the following to be true:

• No progress will be reported as the indexer operates.
• No end of process reporting will be done.
• If the output file already exists, an error is generated to stderr and the indexing terminated.

The /pluginspath argument specifies the folder to look for plugins, and defaults to a folder named 'plugins\Point Clouds Codecs' under the folder where the indexer exe resides.

The thread discussing batch PCG creation using Autodesk point cloud indexer also refers to this usage.

ADN Labs Xtra on GitHub and RvtVa3c in Three.js

I had several cases recently discussing advanced Revit API exploration issues with experienced application developers new to the Revit API.

Therefore, once again, the topic of available tools and their various uses came up.

One important tool for me is the simple element lister, which is currently still part of the ADN Xtra labs, the precursor to the official ADN Revit API training labs.

I had not yet migrated those to Revit 2015, so I now finally did so and posted them to GitHub.

Another interesting GitHub learning step today was integrating the Revit JSON model exporter RvtVa3c for the vA3C AEC viewer into the official list of three.js exporters.

So this is what I discuss today:

• Getting Started with the Revit API
• Revit database exploration tools
• ADN Revit API Xtra training labs for Revit 2015
• Integrating RvtVa3c into three.js
• Updated integration of RvtVa3c into three.js

Getting Started with the Revit API

One important step before starting to think about working on a Revit add-in is to understand the basic Revit concepts and workflows from a user point of view.

Revit is significantly different from most traditional CAD systems, and this is thoroughly reflected in the Revit API as well.

Once that is understood, the next and obvious step is to work through the Revit API getting started material.

It provides both a 'My First Revit Plug-in' and DevTV tutorials discussing all the basics of add-in development and leading you through the entire process step by step, including setting up the development environment, SDK, basic tools, understanding the add-in architecture, installation, coding, compilation and main API principles.

Often some research is required to determine how to programmatically address a specific task.

The main important documentation components that you absolutely must be aware of are:

• The Revit SDK, including:
• The Revit API help file RevitAPI.chm
• The extensive SDK sample collection and solution SDKSamples2015.sln
• The SDK external application add-in RvtSamples that loads all the external command samples
• The online Revit developer guide
• The database exploration tool RevitLookup

The help file documents all classes, their properties and methods. It does not say much about how they work together, though.

The developer guide explains concepts, workflows, more complex and higher-level relationships, and how the classes, properties and methods work together.

The SDK samples demonstrate real code executing most of the workflows in a simple manner. The sample solution file enables compilation and debugging of all samples in one fell swoop, and RvtSamples provides a method to load all external command samples in one go, instead of manually installing a hundred or so separate add-ins.

In addition to this brief overview, please do not miss this more detailed explanation and the recommendations on preparing for a hands-on Revit API training.

Even with all the documentation in place and at your disposal, there are a number of undocumented areas and workflows.

You will often need to research properties, relationships and methods used to create and modify the model for your specific needs yourself.

One of the most powerful ways to approach this research is to create a simple sample model manually, store that starting point, perform the required changes by hand in the user interface, store the ending point, and compare the differences.

A detailed comparison of the models before and after requires database exploration tools.

Revit Database Exploration Tools

The first and foremost Revit database exploration tool is RevitLookup.

You absolutely must install and understand the usage of this tool. It is actually also pretty useful for end users.

Here are a number of discussions of various uses of RevitLookup.

It is a simple interactive dialogue based tool that enables you to navigate the Revit database, its elements, their properties and relationships with each other.

It is a statically compiled add-in and provided in source code in the RevitLookup GitHub repository.

Once you have found the objects and properties you are interested in via the RevitLookup user interface, you can use the Visual Studio environment and debugger to explore how that property or relationship can be reached programmatically.

Once you have acquainted yourself with that static interactive exploration method and understand the database structure, you can move on to more powerful interactive, dynamic, interpreted API interaction, e.g. using the Revit Python or Ruby shells.

Both RevitLookup and the interactive shells will enable you to explore elements and list their parameters. The shells will also allow you to manually set up transactions and modify the database from the command line in real time.

Another statically compiled tool specifically developed for exploring the parameters attached to elements is BipChecker, the built-in parameter checker:

• Duplicate Built-in parameter values and BipChecker update
• Retrieving ElementType parameters and BipChecker
• BipChecker for Revit 2015 on GitHub

Yet another very simple and often surprisingly useful tool for me is the element lister.

I recently described its use and pointed to other discussions of it while determining the relationship between an image element and the associated ImageType.

ADN Revit API Xtra Training Labs for Revit 2015

The element lister is part of my ADN Xtra labs:

• Xtra ADN Revit 2013 API Training Labs
• Exporting Parameter Data to Excel, and Re-importing
• ADN Xtra Labs and BipChecker for Revit 2014
• ADN Revit API Training Material on GitHub

Answering one of these cases, I noted that I had not yet migrated them to Revit 2015, and finally got around to doing so.

The migration was pretty straightforward, and the ADN Revit API training material including the unofficial Xtra labs now resides in its own AdnRevitApiLabsXtra GitHub repository.

To avoid confusion and be absolutely clear, I will repeat the contents of the repository readme here:

This repository contains the source code and Visual Studio solution of the ADN Revit API Training Labs including the old historical Xtra samples.

The official collection excluding the Xtra labs is available from the Autodesk Developer Network ADN Revit Developer page. Look there under Samples and Documentation. It lives in its own ADN DevTech RevitTrainingMaterial GitHub repository.

If you have no need for the Xtra labs or do not know what they are, please stick with the official version provided there.

Integrating RvtVa3c into Three.js

I recently mentioned the significant progress on the vA3C project (home, git), the generic three.js based AEC viewer.

One important aspect is the discovery that the vA3C JSON models are fully compatible and can be merged and mingled with standard three.js ones, providing the models are stored as objects, not as scenes, as discussed in the issue #5 on exporters and JSON output.

I modified RvtVa3c, the Revit vA3C JSON model exporter to produce such a JSON file and tried to add it to the official three.js exporter list:

The way to do this is to fork the repository, apply the required changes, and submit a pull request.

Here is what I ended up doing to hopefully achieve that:

• Fork the three.js dev branch into my personal collection of repositories.
• Clone my forked version to my local system:

$ git clone https://github.com/jeremytammik/three.js

• Add RvtVa3c as a new submodule in the utils/exporters folder:

$ git submodule add https://github.com/va3c/RvtVa3c utils/exporters/revit

• Commit
• Push
• In the forked repository, click 'Pull request', describe the submission, and submit it.

The result in my local repository looks promising enough:

I hope it works :-)

Updated Integration of RvtVa3c into Three.js

The linking of the RvtVa3c repository into the list of three.js exporters described above worked, but...

... as discussed in the three.js issue #5297, mrdoob thinks "the folder approach was better. This repo currently has no submodule. And submodules don't get included when downloading the zip of the repo... the idea of just having a README.md file in a revit/ folder with a url to the other repo should do the trick."

I therefore deleted eveything I did above, reforked the three.js repository to start again from scratch and performed the following steps on it:

• Fork the three.js dev branch into my personal collection of repositories.
• Clone my forked version to my local system:

$ git clone https://github.com/jeremytammik/three.js

• Add a new subfolder 'revit' to the utils/exporters folder:

$ cd three.js/utils/exporters/
$ mkdir revit

• Edit and add the readme file

$ touch README.md
$ edit README.md
$ git add .

• Commit

$ git commit -m "added Revit three.js JSON exporter RvtVa3c"

• Push

$ git push

• In the forked repository, click 'Pull request', describe the submission, and submit it.

The result is a new pull request #5305 "added the revit exporter RvtVa3c: simply a subfolder utils/exporter/revit with a readme file pointing to the RvtVa3c repository".

I agree that this is simpler, of course, and more suitable, considering the facts stated above.

As an added advantage, I am getting the hang of this now...

Unique Names and the NamingUtils Class

The Revit API is still full of surprises.

Here is another one that leads us to look at a utility class that you may not have noticed:

Question: I am encountering a strange problem with the name checking functionality when creating ParameterFilterElements.

The following code snippet creates two ParameterFilterElements with all identical settings except for a slight naming difference:

  public void ParameterFilterElementError(
    Document doc )
  {
    ICollection<ElementId> ceilingCategory
      = new List<ElementId>();
 
    ceilingCategory.Add(
      doc.Settings.Categories.get_Item(
        BuiltInCategory.OST_Ceilings ).Id );
 
    using( Transaction tr = new Transaction( doc ) )
    {
      tr.Start( "Test" );
 
      ParameterFilterElement.Create( doc,
        "HygienKlass 2", ceilingCategory );
 
      ParameterFilterElement.Create( doc,
        "Hygienklass 2", ceilingCategory );
 
      tr.Commit();
    }
  }

One is called "Hygienklass 2" and the other "HygienKlass 2". This throws an exception saying that the names are equal.

This happens both in Revit 2014 and Revit 2015.

Is there any fix for this?

Answer: The API is consistent with the Revit UI in this case.

The user interface displays the following message when you use two names that differ only by case:

This restriction around Revit unique naming is currently not highlighted anywhere in the Revit API help file, even though it applies to more than just filters.

We may enhance the error message to clarify this in future.

The Revit rules around what constitutes a unique name and how names are sorted in lists and trees can definitely cause surprises for some folk.

For this reason, the Revit API actually exposes the NamingUtils.CompareNames method, and also because some non-standard comparisons are used, especially around breaking up sections of numeric and non-numeric sequences.

Please take a look at the NamingUtils class, which provides a collection of utilities related to element naming.

Currently, it implements the following two static member methods:

• CompareNames – compares two object name strings using Revit's comparison rules.
• IsValidName – identifies if the input string is valid for use as an object name in Revit.

Architecture Mismatch Warning Disabler Update

The default Visual Studio settings will generate a processor architecture mismatch warning when compiling a Revit 2014 or 2015 add-in.

Last year, I implemented a utility named DisableMismatchWarning.exe to recursively disable this warning in all projects in all subfolders of the current directory.

Now I just happened to receive a new sample add-in project from a developer for testing that was not recognised by this utility, so I implemented an update for it.

Before getting to that, let me share some pictures from our full moon fire last night by my friend Anja:

The Moon

The Fire

The Moon Cloud Bed

DisableMismatchWarning Update

To process the new Visual Studio project file I received, I simply added support for additional Import tags in the first few lines.

This should work fine for both C# and VB projects.

The updated version is available from the DisableMismatchWarning GitHub repository.

Upgrading Family Files Silently, Part 2

Last week, I provided some suggestions for upgrading family files silently, i.e. suppressing the warning messages displayed for every family file that requires updating when being loaded into a project, requiring a user confirmation for each one:

1. Use a Revit file updater, e.g. the file upgrader on Autodesk labs provided by the ADN team.
2. Handle the pop-up messages yourself using one of the techniques for handling dialogues and failures.
3. Determine the Revit version used to save the family files before trying to load them.

The developer tried out these three suggestions and we will take a look at the results, followed by a reiteration of a different observation, a warm welcome to my new colleague Jaime, and congratulations on his first blog post:

• Revit file updater
• Handling the dialogue
• Determining the Revit file version
• Each ribbon button requires a separate external command
• Welcome, Jaime, and congratulations on your first post!

1. Revit File Updater

a. I tried looking for the add-in at the Autodesk lab link, but the page is no longer available.

b. I searched a bit and saw that the file updater add-in was moved to Autodesk Exchange. I looked, but couldn't find it there either.

c. I did find add-ins made by others, but haven't looked at any of them.

d. It would be nice if the sample code were still around somewhere, so that we can see how to do it correctly if we plan to upgrade the family files before importing.

2. Handling the Dialogue

The dialogue we're trying to close/hide is this:

It appears when we use doc.LoadSymbol and the family file needs upgrading. It goes away after upgrading without user input, but it does pop up again if we're loading symbols from many files.

I tried using the DialogBoxShowing event, but I think this is one of those dialogues that do not broadcast that event.

I tried using the Failure API by creating a class implementing IFailuresPreprocesser and using the method call

  transaction.SetFailureHandlingOptions( options );

Unfortunately, this didn't work as expected. The call to IFailuresPreprocessor.PreprocessFailures did happen (the breakpoint was captured), but it only gets called when the transaction is committed:

  // The dialogue appears in this line:
 
  doc.LoadFamilySymbol( familyfilePath,
    typeName, out symbol );
 
  // The failure preprocesser is called here:
 
  transaction.commit();

I haven't tried the Windows API method to close the window, but I think I'll only use that as a last resort only.

3. Determining the Revit File Version

The BasicFileInfo method worked wonderfully. I was able to get the Revit version the family files were saved in.

In conclusion, it would be nice if the LoadFamilySymbol would provide an overload something like

  doc.LoadFamilySymbol( familyFilePath,
    typeName, ignorePrompts, out symbol );

For now I'll use BasicFileInfo to gather information about the saved version of the family files we're going to load into the document and inform the user that some warning messages will popup because some files needs to be upgraded. If the ADN Revit file updater is still around, perhaps we can even ask the user if they would like the family files to be upgraded automatically too.

Answer: Here is the complete file upgrader source code, Visual Studio solution and add-in manifest.

Sorry to hear that the other methods did not help, and thank you for trying them out.

I agree that dismissing the dialogue via the Windows API is best left as a last resort.

Would you like to share a code snippet showing how you use the BasicFileInfo as you describe?

I do not think there is any sample code of using that on the net yet.

Probably, the file upgrader approach could be combined with that to fully automate the upgrade process.

It might be possible to use the BasicFileInfo to determine which files need upgrading, display the list in a message box to the user, ask for confirmation to upgrade, and then run the upgrader automatically before loading the resulting updated models.

Response: I used this to get the BasicFileInfo:

  var familyFilePath = "FamilyFile.rfa";
 
  var fileInfo = BasicFileInfo.Extract(
    familyFilePath );

The file info provides two properties of interest.

• fileInfo.IsSavedInCurrentVersion returns true if the version of the family file is the same as the Revit version.
• fileInfo.SavedInVersion returns a string with the full Revit name and version. For example, for a family file saved in Revit 2015, it returns "Autodesk Revit Architecture 2015".

Thanks for including the file updater code. It's good reference. From looking at the code, each family file is opened and saved in the current version. I'll try to implement it that way. And yes, we'll need to ask the user if they would like to upgrade the files. It's possible they might not want to.

Many thanks for this interesting and fruitful discussion!

Each Ribbon Button Requires a Separate External Command

Question: I would like to implement only one single external command and let it handle all ribbon button clicks for my external application. The motivation for this is to increase or decrease the number of ribbon buttons at Revit startup depending on the state of other, external resources. How can my external command determine which ribbon button triggered its Execute method? For instance, can I determine the label of the clicked button?

Answer: Neither does the Revit API support this, nor can I think of any other method to achieve it.

The best way to go is to define a separate external command for each button.

If you wish, you can then call a common handler for all commands, calling one single method from each of the different Execute methods, with an additional parameter specifying which button was clicked.

For more detailed background information and suggestions, please refer to this discussion on implementing a single command for multiple buttons.

Addendum by Guy Robinson: Couldn't you just set the buttons to be enabled or visible to achieve the desired effect? This setting can be updated from an external command whenever a service becomes available or unavailable.

Welcome, Jaime, and Congratulations on Your First Post!

We have a new member in the ADN DevTech team: Jaime Rosales Duque joined us from a different department in Autodesk. He was part of the BIM 360 Glue team and worked on add-ins for various Autodesk products, including Revit, Navisworks, AutoCAD and its verticals.

Jaime is also a certified NYC bartender and passionate photographer. He relates these hobbies to his coding passion, saying that a well done, tasty cocktail and an expressive and unique picture can be related to a well written, maintainable and scalable piece of code   :-)

Jaime now published his first blog post on FamilyType values and aerial pictures.

Congratulations, Jaime, and thank you very much!

RvtVa3c – Revit Va3c Generic AEC Viewer JSON Export

When you read this, I will already be sitting on the plane back from New York to Switzerland.

Before leaving, though, I wanted to add some more explanations on the extremely fruitful work we accomplished this weekend.

I am very happy and grateful that we spontaneously formed such a wonderful team and worked together so enthusiastically, pleasantly and effectively.

Most of all, I enjoyed the companionship, competence and professionality of my closest teammate Matt Mason of Imaginit Technologies.

In the short AEC Hackathon project description that I published yesterday, I mentioned our new three.js based open source AEC visualisation project va3c to view 3D building models in any web browser.

The entire va3c team ended up proudly winning the second place in the Hackathon competition, and each project participant was awarded an Arduino as a prize.

Here are more details on the RvtVa3c Revit va3c exporter project that I completed together with Matt in a total effort of 2 * 26 hours = 52 man hours.

The entire source code, Visual Studio solution and add-in manifest is provided in the RvtVa3c GitHub repository.

The other projects, especially the central viewer component fed by the Revit add-in component, can be copied or cloned from their respective own repositories listed below.

Short RvtVa3c Project Description

Implement a Revit add-in external application, external command and custom exporter extracting information straight from the Revit graphics output pipeline and streaming it to a three.js scene version 4 JSON model file for consumption and display in the va3c AEC viewer, including support for meta-data and Internet hyperlinks.

Task List and Features

• Done:
• Properly handle instance transformation, e.g. doors and windows
• Properly handle colour and material
• Support transparency, e.g. window panes
• Get completely fed up with the buggy Microsoft System.Runtime.Serialization.Json.DataContractJsonSerializer class and switch to the more reliable Json.NET component
• Add scaling to common viewer size, e.g. [(0,0),(20000,20000)]
• Implement the external application ribbon panel and button
• Implement element properties, i.e. metadata support
• Eliminate multiple non-element materials
• Prompt user for output file name and location
• Eliminate null element properties, i.e. useless JSON userData entries
• Fix the GitHub repository corrupted by adding an excessively large file exceeding the 100 MB GitHub size limit
• Todo:
• More optimisations to reduce file size
• More intelligent family instance and type reuse

I could spend hours discussing each one of the steps listed above, more hours than Matt and I spent implementing them.

I can also save some time and breath and let you explore them for yourself.

Suffice to say that the Revit add-in is up and running, reliably producing version 4 three.js rendering of both small and large Revit models, and that the va3c viewer and all the other different va3c exporters work reliably as well.

Main Challenge

The target JSON format was initially a moving target, oscillating between version 3 and 4, both of which are nowhere completely reliably defined, requiring hard-core reverse engineering of the viewer by extensive JavaScript debugging.

We settled for version 4 in the end, since 3 is announced soon to be deprecated.

Links to Related Va3c Projects

• va3c project landing page
• viewer – HTML viewer
• GHva3c – Grasshopper va3c exporter
• maxscriptVa3c – 3DS Max va3e JSON Exporter
• json – JSON sample files
• va3c – web viewer for AEC models organisation
• va3c viewer demo

Project Solon and BipChecker for Revit 2015 on GitHub

One of the handful of Revit database exploration tools that I use on a regular basis is BipChecker, the Revit built-in parameter checker, so that is a pretty obvious candidate for migration to Revit 2015... see below.

Before I get to that, let me mention some new Revit energy analysis functionality that you might want to check out:

Simple Interactive Energy Analysis in Revit with Project Solon

Project Solon beta arrives in Revit, providing more interactive energy analysis results, the ability to create your own and publish them to Revit.

Autodesk Green Building Studio (GBS) has released the Beta version of Analysis Application Dashboard in Project Solon: You can now author your Revit model once and deliver energy analysis results to your software application, web, and mobile device. Project Solon delivers responsive results designs for your energy analysis, with customized dynamic charts of energy results.

Read all about it on the Building Perfomance Analysis blog.

BipChecker GitHub Repository and Migration to Revit 2015

Back to the BipChecker migration: while I was at it, I also created the BipChecker GitHub repository to host it, and the initial release 2014.0.0.3 based on the existing Revit 2014 code.

Once again, the migration was very straightforward: change the .NET framework and update the Revit API assembly reference paths.

The initial flat migration is available as release 2015.0.0.3 and generates just two compilation warnings concerning the use of the UIDocument.Selection.Elements property:

• Warning CS0618: 'Autodesk.Revit.UI.Selection.Selection.Elements' is obsolete: 'This property is deprecated in Revit 2015. Use GetElementIds() and SetElementIds instead.'

Here is one example of the Revit 2014 code causing the warning, from the GetSingleSelectedElementOrPrompt method:

  public static Element
    GetSingleSelectedElementOrPrompt(
      UIDocument uidoc )
  {
    Element e = null;
    ElementSet ss = uidoc.Selection.Elements;
 
    if( 1 == ss.Size )
    {
      ElementSetIterator iter = ss.ForwardIterator();
      iter.MoveNext();
      e = iter.Current as Element;
    }
 
    // . . .

Moving this to Revit 2015 to eliminate the warning is straightforward – and the result looks better   :-)

    ICollection<ElementId> ids
      = uidoc.Selection.GetElementIds();
 
    if( 1 == ids.Count )
    {
      foreach( ElementId id in ids )
      {
        e = uidoc.Document.GetElement( id );
      }
    }

I fixed that and published the result as BipChecker release 2015.0.0.4, which now compiles with zero warnings.

Of course, you should normally always go for the most up-to-date master branch, though, to pick up possible later enhancements as well.

Add-In Wizards for Revit 2015

I updated my Visual Studio Revit add-in wizards for Revit 2015.

The 2015 version generates the same boilerplate code as the reliable old Revit 2014 one and its update did, which can be simply deleted if not needed.

I selflessly also implemented and tested the Visual Basic version right away.

Revit Add-in Wizard Customisation

As I keep pointing out, it is important to understand how easy it is to modify the wizards for your own needs, and make copies with variations to support different requirements.

Here is an overview of previous explanations of various aspects that also show how to create your own flavours:

• Original introduction, benefits, and usage example for C# and VB.
• Personalised minimal C# version for Revit 2011.
• A short additional usage note.
• 64-bit versions for C# and VB.
• Support for the Revit 2012 API for C# and VB.
• Updated C# and VB versions placing assembly DLL alongside add-in manifest.
• Revit 2013 C# version including more skeleton code.
• Revit 2013 VB version.
• C# and VB add-in wizards for Revit 2014.
• Wizard update suppressing the processor architecture mismatch warning and referring to Revit Onebox instead of the architectural flavour.
• Wizard generating a multi-version add-in supporting both Revit 2013 and 2014.

Just like for Revit 2014, the Revit 2015 add-in wizard uses the $(ProgramW6432) Visual Studio project template variable to determine where to locate the Revit API assembly files for referencing and the Revit.exe executable for debugging.

Revit Add-in Wizard Usage

Simply install the wizard zip files you need in the appropriate locations, start up Visual Studio, create a new C# or VB Revit add-in project using the wizard default settings, and immediately hit F5 to start up Revit.exe in the debugger.

The wizards perform the following functions for C# and VB, respectively:

• Generate the skeleton source code, Visual Studio solution and add-in manifest.
• On successful build, copy the add-in assembly DLL and add-in manifest to the Revit add-in folder, thus automatically installing it for Revit to pick up and load.
• Define the add-in debugging settings to start up the Revit.exe program.

Therefore, immediately after the initial add-in creation, you can immediately launch the debugger. The add-in is compiled, Revit is started up, the add-in is loaded, you can select the new external command in the External Tools menu, launch and test it immediately without entering one single further keystroke yourself.

The new command even executes in zero document state, although the default external command skeleton implementation throws an exception trying to access a property on the current UI document, which is null. It shows you that everything is working correctly right away, though.

Wizard Download and Installation

The appropriate locations to install the wizards for Visual Studio to pick them up are language dependent.

Copy the zip file of your choice to the matching Visual Studio project template folder in your local file system:

• C# – copy Revit2015AddinWizardCs1.zip to
  [My Documents]\Visual Studio 2012\Templates\ProjectTemplates\Visual C#
• Visual Basic – copy Revit2015AddinWizardVb1.zip to
  [My Documents]\Visual Studio 2012\Templates\ProjectTemplates\Visual Basic

I hope you find this useful and look forward to hearing any suggestions for improvement you come up with.

Better still, implement them yourself and let us know where to pick them up :-)

IFC Exporter Open Source Wiki

As you certainly know, the Revit IFC exporter is open source and available from the sourceforge IFC Exporter for Revit project repository.

It has now been updated to Revit 2015, obviously, covers import as well as export, and enhanced with a FAQ wiki to address the most frequently asked questions.

Below, I would like to present both the main IFC exporter project description and its new FAQ.

Autodesk Revit Wikipedia Entry

Before getting to that, let me briefly add that I just discovered the Wikipedia entry for Autodesk Revit itself, which I was previously unaware of, and took the liberty of immediately adding a new short section on Revit programming to it.

Back to the IFC exporter news.

IFC Exporter Includes Import

Starting with 2015, the 'IFC Exporter for Revit' project is actually misnamed: it should be renamed 'IFC for Revit', because it includes import as well as export. The old name still remains for the moment, since it is not trivial to change the SourceForge project name.

In the interest of file disclosure and easier understanding of the architecture and implementation: although the 'Open IFC' command goes through the open source code, it is almost entirely processed in native Revit code. The 'Link IFC' command, on the other hand, is almost entirely processed in the open source code. The long-term plan is to synchronise the two more.

IFC Exporter Project Description

This is the .NET code used by the Revit 2015 family of products to support IFC, and the Revit 2012-2014 families of products to support IFC export. The open source version can override the version that comes standard with shipped Revit. Revit 2013-2015 contain both IFC export and IFC export UI overrides, which contains options not available in the regular UI, such as ifcXML and ifcZIP support. The Revit 2014 and 2015 versions also work for Revit LT 2014 and 2015, respectively.

IFC Exporter Project FAQ

This page addresses some common problems when installing the exporter and alternate UI. Note that starting with 2015, some of these problems are no longer relevant, as the importer, exporter, and alternate UI are bundled together.

Q: I installed the exporter and UI, but I don't see any buttons in the add-in tab. How do I use it?

A: The exporter seamlessly replaces the existing "out of the box" exporter. Simply use Revit Button > Export > IFC as usual. Similarly for import, use Link IFC in the insert tab, or via the Manage Links button.

Q: I downloaded the exporter, but I still have the old UI. What happened?

A: For 2013 and 2014, there are two separate products to install: the exporter and the alternate UI. Although they work independently, they are intended to work together, and you may get only partial improvements with just one.

Q: I upgraded to the Revit 2014 exporter from Revit 2013, but now my exports are worse! What happened?

A1: The newest versions of the Revit 2014 exporter need at least Revit 2014 UR1 to run. If you are using Revit 2014 without any Update Release patches, it will silently fail and revert to the standard functionality.

A2: You may not have the right permissions to use the add-in. If the add-in was installed by an administrator, and you do not have administrative privileges, it may not run.

Q: How can I know what version of the exporter and UI I am using?

A: For the UI, you can find the version number on the dialog box when you export. To know if you have the right version of the exporter running, you can either look at the Control Panel in the Add/Remove Programs list, or you can do a trivial export and open up the file in Notepad. Search for FILE_NAME and you will see the version of the Exporter and the Alternate UI. If you see an odd version number there, look through the other items on this troubleshooting page for more information.

Hackergarten Meetup

In order to become more immersed and fluent in web and mobile technologies, I participated in the Hackergarten meetup in Basel last week.

We were a dozen people, mostly experienced in large-scale modern web and database technologies.

The suggested topics were legion, including WebRTC, Spike/Chatapp, Node Webkit, JS tools, CouchDB, Ionic Framework, High scalability, Guice, Gradle plugin, Android slide show, Polymar JS (similar to Angular).

I sat down with three other guys with the goal of exploring PouchDB.

It is an open-source JavaScript database inspired by Apache CouchDB that runs well within the browser and enables applications that work as well offline as they do online, storing data locally while offline, then synchronising it with CouchDB and compatible servers when the application is back online, keeping the user's data in sync no matter where they next login.

We installed the bower package manager to simplify the development work and package management:

We installed the grunt JavaScript task runner in order to run a local web server for testing:

The web server is provided by the grunt-contrib-connect plugin.

Those packages were installed and running within minutes, we had a framework set up for developing, and a local web server running for testing.

We started exploring PouchDB step by step in the DjDoodle project that I set up on GitHub for testing purposes.

As a summary, I can say I saw a lot of powerful and impressive technology.

One little immediate consequence I took was to install and start using Chrome instead of Firefox :-)

WPF Fill Pattern Viewer Control Benchmark

I recently presented Victor Chekalin's WPF control for viewing Revit fill patterns.

In his comment, Victor already mentioned some worries about performance of this control and his intention to create a simple benchmark to monitor it.

Well, here it is.

At the same time, I also took the opportunity to migrate the fill pattern control to Revit 2015.

Migrate the Fill Pattern Viewer Control to Revit 2015

The migration to the Revit 2015 API was extremely straightforward, just like the previous add-ins I performed it for, e.g.:

• RevitLookup for Revit 2015
• Compiling the Revit 2015 SDK and Migrating The Building Coder Samples
• Migrating RoomEditorApp to Revit 2015
• RevitLookup for Revit 2015 UR1

The source code, Visual Studio solution and add-in manifest of the complete AddMaterials add-in including the fill pattern viewer WPF control is provided in the AddMaterials GitHub repository, and the initial migration to the Revit 2015 API is captured in release 2015.0.0.2.

Fill Pattern Viewer Control Benchmark

In Victor's own words:

I was interested about benchmark and created it:)

I created the new command 'AddMaterials - Fill Pattern benchmark' and added it to the AddMaterials Add-In.

As it turned out, the most complex pattern is 'Concrete'. To create the graphics for it took more that one second.

Displaying any other fill pattern in this control requires only about 10 milliseconds.

The benchmark implementation is accomplished in a new external command, FillPatternBenchmarkCommand, which retrieves all fill patterns from the model and displays them in a form:

  [Transaction( TransactionMode.ReadOnly )]
  public class FillPatternBenchmarkCommand
    : IExternalCommand
  {
    public Result Execute(
      ExternalCommandData commandData,
      ref string message,
      ElementSet elements )
    {
      var doc = commandData.Application
        .ActiveUIDocument.Document;
 
      var fillPatternElements
        = new FilteredElementCollector( doc )
          .OfClass( typeof( FillPatternElement ) )
          .OfType<FillPatternElement>()
          .OrderBy( fp => fp.Name )
          .ToList();
 
      var fillPatterns
        = fillPatternElements.Select(
          fpe => fpe.GetFillPattern() );
 
      FillPatternsViewModel fillPatternsViewModel
        = new FillPatternsViewModel( fillPatterns
          .Select( x => new FillPatternViewModel(
            x ) ) );
 
      FillPatternsView fillPatternsView
        = new FillPatternsView()
      {
        DataContext = fillPatternsViewModel
      };
 
      fillPatternsView.ShowDialog();
 
      return Result.Succeeded;
    }
  }

The form requires two new ViewModel modules to view a simple fill pattern, a list of all fill patterns, and present that list in a WPF form.

The actual benchmarking is performed by adding a couple of lines to the existing FillPatternViewerControlWpf.xaml.cs module.

The new code instantiates a stopwatch.

In debug mode only, the stopwatch elapsed time in milliseconds is displayed in red on top of the fill pattern:

  private void DrawFillPattern( Graphics g )
  {
    Stopwatch sw = Stopwatch.StartNew();
 
    float matrixScale;
 
    var fillPattern = FillPattern;
 
    if( fillPattern == null )
      return;
 
    if( fillPattern.Target == FillPatternTarget.Model )
      matrixScale = Scale;
    else
      matrixScale = Scale * 10;
 
    try
    {
      var width =
      ( ActualWidth == 0 ? Width : ActualWidth ) == 0
        ? 100
        : ( ActualWidth == 0 ? Width : ActualWidth );
 
      if( double.IsNaN( width ) )
        width = 100;
 
      var height =
          ( ActualHeight == 0 ? Height : ActualHeight ) == 0
            ? 30
            : ( ActualHeight == 0 ? Height : ActualHeight );
 
      if( double.IsNaN( height ) )
        height = 30;
 
      var rect = new Rectangle( 0, 0,
        (int) width, (int) height );
 
      var centerX = ( rect.Left + rect.Left
        + rect.Width ) / 2;
 
      var centerY = ( rect.Top + rect.Top
        + rect.Height ) / 2;
 
      g.TranslateTransform( centerX, centerY );
 
      var rectF = new Rectangle( -1, -1, 2, 2 );
 
      g.FillRectangle( Brushes.Blue, rectF );
 
      g.ResetTransform();
 
      var fillGrids = fillPattern.GetFillGrids();
 
      Debug.Print( "FilPattern name: {0}",
        fillPattern.Name );
 
      Debug.Print( "Grids count: {0}",
        fillGrids.Count );
 
      foreach( var fillGrid in fillGrids )
      {
        var degreeAngle = (float) RadianToGradus(
          fillGrid.Angle );
 
        Debug.Print( new string( '-', 100 ) );
 
        Debug.Print( "\tOrigin: U: {0} V:{1}",
          fillGrid.Origin.U, fillGrid.Origin.V );
 
        Debug.Print( "\tOffset: {0}", fillGrid.Offset );
        Debug.Print( "\tAngle: {0}", degreeAngle );
        Debug.Print( "\tShift: {0}", fillGrid.Shift );
 
        var pen = new Pen( System.Drawing.Color.Black )
        {
          Width = 1f / matrixScale
        };
 
        float dashLength = 1;
 
        var segments = fillGrid.GetSegments();
 
        if( segments.Count > 0 )
        {
          pen.DashPattern = segments
              .Select( Convert.ToSingle )
              .ToArray();
 
          Debug.Print( "\tSegments:" );
 
          foreach( var segment in segments )
          {
            Debug.Print( "\t\t{0}", segment );
          }
 
          dashLength = pen.DashPattern.Sum();
        }
 
        g.ResetTransform();
 
        var rotateMatrix = new Matrix();
        rotateMatrix.Rotate( degreeAngle );
 
        var matrix = new Matrix( 1, 0, 0, -1,
          centerX, centerY );
 
        matrix.Scale( matrixScale, matrixScale );
 
        matrix.Translate( (float) fillGrid.Origin.U,
          (float) fillGrid.Origin.V );
 
        var backMatrix = matrix.Clone();
        backMatrix.Multiply( rotateMatrix );
        matrix.Multiply( rotateMatrix );
 
        bool first = true;
        for( int i = 20; i > 0; i-- )
        {
          if( !first )
          {
            matrix.Translate( (float) fillGrid.Shift,
              (float) fillGrid.Offset );
 
            backMatrix.Translate( (float) fillGrid.Shift,
              -(float) fillGrid.Offset );
          }
          else
          {
            first = false;
          }
 
          var offset = ( -10 ) * dashLength;
          matrix.Translate( offset, 0 );
          backMatrix.Translate( offset, 0 );
 
          g.Transform = matrix;
 
          g.DrawLine( pen, new PointF( 0, 0 ),
            new PointF( 200, 0 ) );
 
          g.Transform = backMatrix;
 
          g.DrawLine( pen, new PointF( 0, 0 ),
            new PointF( 200, 0 ) );
        }
      }
 
      sw.Stop();
      g.ResetTransform();
 
#if DEBUG
      g.DrawString( string.Format( "{0} ms",
        sw.ElapsedMilliseconds),
        System.Drawing.SystemFonts.DefaultFont,
        Brushes.Red, 0, 0);
#endif
 
    }
    catch( Exception ex )
    {
      Debug.Print( ex.Message );
    }
  }

The result of running the benchmark command in Revit 2015 looks like this:

The benchmarking code is added to the AddMaterials GitHub repository and captured in release 2015.0.0.3.

Many thanks to Victor for the initial implementation and again for this benchmark implementation!

Getting Serious Adding New Materials from List

Here is a post on some serious usability enhancements for the AddMaterials add-in, which reads a list of material properties from an Excel spreadsheet and generates Revit material elements accordingly.

It was originally presented for Revit 2011, reimplemented for Revit 2014, and enhanced with improved error messages and reporting soon after.

Until now, it was more of a programming example than an actual usable tool, but that is starting to change, thanks to a number of enhancements by Alexander Ignatovich, last but least the WPF FillPattern viewer control presented last week. Says Alex:

I want to further enhance the tool for adding new materials from a list.

First of all, I split off the XLS data reading from the materials creation. I also noticed that we cannot create a new material if the copy source base material does not exist in project, i.e. there if is no material with the name provided in 11 column. Another problem I noticed occurs if I try to run the add-in command several times: in this case, it tries to repeatedly generate materials with the same name, and the LINQ ToDictionary method fails. So, we must avoid such situations.

Summarizing: let's read data, mark the materials with no base class provided, or base class not found, and existing materials as "non-loadable", show the materials list to the user, where he (or she) can deselect some items and create the resulting materials list.

And one other, I think, the most valuable thing: in the materials import dialogue I added surface and cut pattern preview controls (see View\Controls\FillPatternViewerControlWpf.xaml). This code is based on work performed by Victor Chekalin when he was working in our company.

I hope this code sample will be helpful. Sorry, maybe some things are not accurate. For example, Visual Studio does not show the design view of the MaterialsView form, because my MaterialViewModel.SurfacePattern and MaterialViewModel.CutPattern classes are really Autodesk.Revit.DB.FillPattern, but it is just an example :-)

Thank you very much, and thanks to Victor as well for the nice fill pattern viewer.

That is a powerful tool and sample in its own right.

Here are screen snapshots of the AddMaterials add-in in action running. In the first run, none of the CSI copy source base materials have been defined in the current project, so no new materials can be added:

In the second run, I manually added one CSI material to copy from, and now one material can be added:

If this project is of further interest, another enhancement might be to remove the COM references to Microsoft office, to allow the command to work on computers without Microsoft Office installed.

Once again, many thanks to Victor and Alex for these valuable enhancements!

The complete source code, Visual Studio solution and add-in manifest is provided in the AddMaterials GitHub repository.

The version discussed above is release 2014.0.0.2.

Please feel free to fork that and add your own enhancements as well.

Good luck!

WPF Fill Pattern Viewer Control

Today, I present a useful stand-alone WPF control for viewing Revit fill patterns, originally implemented by Victor Checkalin, Виктор Чекалин, shared with us by Alexander Ignatovich, Александр Игнатович, of Investicionnaya Venchurnaya Companiya, as part of further enhancements for the AddMaterial add-in. The rest of his new enhancements will be discussed as soon as possible in a future post.

The AddMaterials add-in reads a list of material properties from an Excel spreadsheet and generates Revit material elements accordingly.

The input data includes columns defining the material surface and cut patterns.

These patterns are displayed graphically like this in the third and fourth columns of Alex' WPF control:

Making use of the WPF fill pattern control in your own add-in is achieved in two simple steps:

• Add a copy of the XAML module FillPatternViewerControlWpf.xaml to your Visual Studio add-in project.
• Add references to the FillPatternViewerControlWpf control in your own XAML form source.

The fill pattern viewer XAML module appears like this in the solution explorer:

Here is the XAML code to define the surface and cut pattern columns in the form shown above:

  <GridViewColumn Header="Surface"
                  Width="80">
   
    <GridViewColumn.CellTemplate>
      <DataTemplate DataType
          ="{x:Type ViewModel:MaterialViewModel}">
   
        <Border CornerRadius="2"
                BorderThickness="1"
                BorderBrush="Gray">
   
          <Controls:FillPatternViewerControlWpf
            HorizontalAlignment="Stretch"
            Height="30"
            Margin="1,3"
            FillPattern="{Binding SurfacePattern}"/>
   
        </Border>
      </DataTemplate>
    </GridViewColumn.CellTemplate>
  </GridViewColumn>
   
  <GridViewColumn Header="Cut"
                  Width="80">
   
    <GridViewColumn.CellTemplate>
      <DataTemplate DataType
          ="{x:Type ViewModel:MaterialViewModel}">
   
        <Border CornerRadius="2"
                BorderThickness="1"
                BorderBrush="Gray">
   
          <Controls:FillPatternViewerControlWpf
            HorizontalAlignment="Stretch"
            Height="30"
            Margin="1,3"
            FillPattern="{Binding CutPattern}"/>
   
        </Border>
      </DataTemplate>
    </GridViewColumn.CellTemplate>
  </GridViewColumn>

The fill pattern viewer control is defined by its XAML description plus the C# code defining its associated behaviour.

The XAML description looks like this:

<UserControl 
  x:Class="AddMaterials.View.Controls.FillPatternViewerControlWpf"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  xmlns:Converters="clr-namespace:AddMaterials.View.Converters" 
  mc:Ignorable="d"
  d:DesignHeight="300"
  d:DesignWidth="300">
 
  <Grid Name="_grid" 
        ToolTip="{Binding Path=FillPattern.Name, 
          RelativeSource={RelativeSource 
            AncestorType={x:Type UserControl}}}">

    <Grid.Resources>
      <Converters:BitmapToImageSourceConverter 
        x:Key="BitmapToImageSourceConverter"/>
    </Grid.Resources>

    <Image Source="{Binding Path=FillPatternImage, 
             RelativeSource={RelativeSource 
             AncestorType={x:Type UserControl}},                 
             Converter={StaticResource BitmapToImageSourceConverter}}"
           Stretch="None"/>
 
  </Grid>
</UserControl>

The C# code defining its behaviour is where the real action takes place, in the DrawFillPattern method, which retrieves and displays the graphical data defined by the Revit FillGrid instances managed by the FillPattern object:

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Windows;
using Autodesk.Revit.DB;
using Image = System.Drawing.Image;
using Matrix = System.Drawing.Drawing2D.Matrix;
using Rectangle = System.Drawing.Rectangle;
 
namespace AddMaterials.View.Controls
{
  /// <summary>
  /// Interaction logic for FillPatternViewerControlWpf.xaml
  /// </summary>
  public partial class FillPatternViewerControlWpf
    : INotifyPropertyChanged
  {
    private const float Scale = 50;
    private Bitmap fillPatternImg;
 
    public static readonly DependencyProperty
      FillPatternProperty = DependencyProperty
        .RegisterAttached( "FillPattern",
          typeof( FillPattern ),
          typeof( FillPatternViewerControlWpf ),
          new UIPropertyMetadata( null,
            OnFillPatternChanged ) );
 
    private static void OnFillPatternChanged(
      DependencyObject d,
      DependencyPropertyChangedEventArgs e )
    {
      var fillPatternViewerControl
        = d as FillPatternViewerControlWpf;
 
      if( fillPatternViewerControl == null ) return;
 
      fillPatternViewerControl.OnPropertyChanged(
        "FillPattern" );
 
      fillPatternViewerControl.CreateFillPatternImage();
    }
 
    public FillPattern FillPattern
    {
      get
      {
        return (FillPattern) GetValue(
          FillPatternProperty );
      }
      set
      {
        SetValue( FillPatternProperty, value );
      }
    }
 
    public FillPattern GetFillPattern(
      DependencyObject obj )
    {
      return (FillPattern) obj.GetValue(
        FillPatternProperty );
    }
 
    public void SetFillPattern(
      DependencyObject obj,
      FillPattern value )
    {
      obj.SetValue( FillPatternProperty, value );
    }
 
    public FillPatternViewerControlWpf()
    {
      InitializeComponent();
    }
 
    public event PropertyChangedEventHandler
      PropertyChanged;
 
    //[NotifyPropertyChangedInvocator]
    protected virtual void OnPropertyChanged(
      string propertyName )
    {
      var handler = PropertyChanged;
      if( handler != null ) handler( this,
        new PropertyChangedEventArgs( propertyName ) );
    }
 
    public Image FillPatternImage
    {
      get
      {
        if( fillPatternImg == null )
          CreateFillPatternImage();
        return fillPatternImg;
      }
    }
 
    private void CreateFillPatternImage()
    {
      if( FillPattern == null )
        return;
 
      var width =
        ( ActualWidth == 0 ? Width : ActualWidth ) == 0
          ? 100
          : ( ActualWidth == 0 ? Width : ActualWidth );
 
      if( double.IsNaN( width ) )
        width = 100;
 
      var height =
          ( ActualHeight == 0 ? Height : ActualHeight ) == 0
            ? 30
            : ( ActualHeight == 0 ? Height : ActualHeight );
 
      if( double.IsNaN( height ) )
        height = 30;
 
      fillPatternImg = new Bitmap(
        (int) width, (int) height );
 
      using( var g = Graphics.FromImage(
        fillPatternImg ) )
      {
        DrawFillPattern( g );
      }
 
      OnPropertyChanged( "FillPatternImage" );
    }
 
    private void DrawFillPattern( Graphics g )
    {
      float matrixScale;
 
      var fillPattern = FillPattern;
 
      if( fillPattern == null )
        return;
 
      if( fillPattern.Target == FillPatternTarget.Model )
        matrixScale = Scale;
      else
        matrixScale = Scale * 10;
 
      try
      {
        var width =
        ( ActualWidth == 0 ? Width : ActualWidth ) == 0
          ? 100
          : ( ActualWidth == 0 ? Width : ActualWidth );
 
        if( double.IsNaN( width ) )
          width = 100;
 
        var height =
            ( ActualHeight == 0 ? Height : ActualHeight ) == 0
              ? 30
              : ( ActualHeight == 0 ? Height : ActualHeight );
 
        if( double.IsNaN( height ) )
          height = 30;
 
        var rect = new Rectangle( 0, 0,
          (int) width, (int) height );
 
        var centerX = ( rect.Left + rect.Left
          + rect.Width ) / 2;
 
        var centerY = ( rect.Top + rect.Top
          + rect.Height ) / 2;
 
        g.TranslateTransform( centerX, centerY );
 
        var rectF = new Rectangle( -1, -1, 2, 2 );
 
        g.FillRectangle( Brushes.Blue, rectF );
 
        g.ResetTransform();
 
        var fillGrids = fillPattern.GetFillGrids();
 
        Debug.Print( "FilPattern name: {0}",
          fillPattern.Name );
 
        Debug.Print( "Grids count: {0}",
          fillGrids.Count );
 
        foreach( var fillGrid in fillGrids )
        {
          var degreeAngle = (float) RadianToGradus(
            fillGrid.Angle );
 
          Debug.Print( new string( '-', 100 ) );
 
          Debug.Print( "\tOrigin: U: {0} V:{1}",
            fillGrid.Origin.U, fillGrid.Origin.V );
 
          Debug.Print( "\tOffset: {0}", fillGrid.Offset );
          Debug.Print( "\tAngle: {0}", degreeAngle );
          Debug.Print( "\tShift: {0}", fillGrid.Shift );
 
          var pen = new Pen( System.Drawing.Color.Black )
          {
            Width = 1f / matrixScale
          };
 
          float dashLength = 1;
 
          var segments = fillGrid.GetSegments();
 
          if( segments.Count > 0 )
          {
            pen.DashPattern = segments
                .Select( Convert.ToSingle )
                .ToArray();
 
            Debug.Print( "\tSegments:" );
 
            foreach( var segment in segments )
            {
              Debug.Print( "\t\t{0}", segment );
            }
 
            dashLength = pen.DashPattern.Sum();
          }
 
          g.ResetTransform();
 
          var rotateMatrix = new Matrix();
          rotateMatrix.Rotate( degreeAngle );
 
          var matrix = new Matrix( 1, 0, 0, -1,
            centerX, centerY );
 
          matrix.Scale( matrixScale, matrixScale );
 
          matrix.Translate( (float) fillGrid.Origin.U,
            (float) fillGrid.Origin.V );
 
          var backMatrix = matrix.Clone();
          backMatrix.Multiply( rotateMatrix );
          matrix.Multiply( rotateMatrix );
 
          bool first = true;
          for( int i = 20; i > 0; i-- )
          {
            if( !first )
            {
              matrix.Translate( (float) fillGrid.Shift,
                (float) fillGrid.Offset );
 
              backMatrix.Translate( (float) fillGrid.Shift,
                -(float) fillGrid.Offset );
            }
            else
            {
              first = false;
            }
 
            var offset = ( -10 ) * dashLength;
            matrix.Translate( offset, 0 );
            backMatrix.Translate( offset, 0 );
 
            g.Transform = matrix;
 
            g.DrawLine( pen, new PointF( 0, 0 ),
              new PointF( 200, 0 ) );
 
            g.Transform = backMatrix;
 
            g.DrawLine( pen, new PointF( 0, 0 ),
              new PointF( 200, 0 ) );
          }
        }
      }
      catch( Exception ex )
      {
        Debug.Print( ex.Message );
      }
    }
 
    private double RadianToGradus( double radian )
    {
      return radian * 180 / Math.PI;
    }
  }
}

The source code, Visual Studio solution and add-in manifest of the complete AddMaterials add-in including the fill pattern viewer WPF control is provided in the AddMaterials GitHub repository.

The version discussed above is release 2014.0.0.2.

Many thanks to Victor for the implementation and to Alex for sharing this valuable tool!

RevitLookup for Revit 2015

My first post dealing with Revit 2015 is dedicated to RevitLookup, the most important Revit database exploration tool, both for developers and interested non-developers.

This is particularly urgent, since RevitLookup no longer is included in the standard Revit SDK (software development kit).

It is now available from the RevitLookup GitHub repository instead.

I created a preliminary version of RevitLookup for the Revit 2015 Meridian pre-release, just to ensure that everybody who needs access to this tool has it available right away.

It compiles and runs perfectly fine, although some compilation warnings on use of deprecated API functionality are displayed.

It currently refers to the Revit API assemblies located in the Revit Meridian root installation folder. That path needs to be updated to compile for an official release of Revit 2015.

Migration

Here are the steps I performed for the migration, which was extremely straightforward:

1. Replaced the RevitAPI.dll and RevitAPIUI.dll references.
2. Changed the .NET framework from 4.0 to 4.5.
3. Rebuilt all. It compiles successfully, generating 0 errors and 24 warnings.
4. Fixed a few of the deprecated API usage occurrences:
• Rewrote FamilyUtil.GetFamilySymbol using GetFamilySymbolIds instead of Symbols.
• Ditto in TypeSelectorForm.GetAvailableSymbols.
• Ditto in Importer.UpdateFamilySymbol.
• Rewrote TestElements.ViewToNewSheetHardwired to use ViewSheet.GetAllPlacedViews instead of ViewSheet.Views.
5. Updated the version number to 2015.0.0.0.

The fixes are currently marked with a comment:

  // jeremy migrated from Revit 2014 to 2015:

That will probably be removed again soon, since the same information can be easily gleaned from the version control system.

Download

For the complete source code, Visual Studio solution and add-in manifest, please refer to the RevitLookup GitHub repository.

The version discussed above is stored there as release 2015.0.0.0.

It compiles successfully, currently still generating 0 errors and 19 warnings.