Clipper Library Project Integration

The Clipper GUI demo sample application solution contains two projects: one for the GUI demo itself, and the other to generate the Clipper library from its one and only C# source code module.

I therefore simply copied that entire project into my add-in solution, made my add-in dependent on the Clipper library and added a reference to its .NET assembly:

Clipper and Revit Point Class Translation

Part of the Clipper speed and reliability presumably stems from the fact that it is integer-based, eliminating all the rounding problems dealing with real numbers.

It uses an IntPoint class with two Int64 X and Y coordinates.

I have often approximated Revit XYZ vertices using integer-based point classes in the past, so this seems pretty appropriate for me.

Once again, I decided to simply convert the Revit XYZ imperial coordinates to millimetres. That choice is completely arbitrary. If you prefer higher precision, please be my guest.

Here is the code I use to convert back and forth between the two systems:

  /// <summary>
  /// Consider a Revit length zero 
  /// if is smaller than this.
  /// </summary>
  const double _eps = 1.0e-9;
 
  /// <summary>
  /// Conversion factor from feet to millimetres.
  /// </summary>
  const double _feet_to_mm = 25.4 * 12;
 
  /// <summary>
  /// Conversion a given length value 
  /// from feet to millimetres.
  /// </summary>
  static long ConvertFeetToMillimetres( double d )
  {
    if( 0 < d )
    {
      return _eps > d
        ? 0
        : (long) ( _feet_to_mm * d + 0.5 );
 
    }
    else
    {
      return _eps > -d
        ? 0
        : (long) ( _feet_to_mm * d - 0.5 );
 
    }
  }
 
  /// <summary>
  /// Conversion a given length value 
  /// from millimetres to feet.
  /// </summary>
  static double ConvertMillimetresToFeet( long d )
  {
    return d / _feet_to_mm;
  }
 
  /// <summary>
  /// Return a clipper integer point 
  /// from a Revit model space one.
  /// Do so by dropping the Z coordinate
  /// and converting from imperial feet 
  /// to millimetres.
  /// </summary>
  IntPoint GetIntPoint( XYZ p )
  {
    return new IntPoint(
      ConvertFeetToMillimetres( p.X ),
      ConvertFeetToMillimetres( p.Y ) );
  }
 
  /// <summary>
  /// Return a Revit model space point 
  /// from a clipper integer one.
  /// Do so by adding a zero Z coordinate
  /// and converting from millimetres to
  /// imperial feet.
  /// </summary>
  XYZ GetXyzPoint( IntPoint p )
  {
    return new XYZ(
      ConvertMillimetresToFeet( p.X ),
      ConvertMillimetresToFeet( p.Y ),
      0.0 );
  }

GetBoundaryLoops – Return Horizontal Slab Boundary Loops

Ok, so we now know how to convert a Revit point to a Clipper one.

How do we represent an entire boundary loop, and how can that data be retrieved from a BIM slab?

That is achieved in one fell swoop by the GetBoundaryLoops method, returning a collection of Clipper polygons.

A single slab may generate multiple loops, both due to holes in its interior and due to consisting of several separate pieces:

/// <summary>
/// Retrieve the boundary loops of the given slab 
/// top face, which is assumed to be horizontal.
/// </summary>
Polygons GetBoundaryLoops( CeilingAndFloor slab )
{
  int n;
  Polygons polys = null;
  Document doc = slab.Document;
  Application app = doc.Application;
 
  Options opt = app.Create.NewGeometryOptions();
 
  GeometryElement geo = slab.get_Geometry( opt );
 
  foreach( GeometryObject obj in geo )
  {
    Solid solid = obj as Solid;
    if( null != solid )
    {
      foreach( Face face in solid.Faces )
      {
        PlanarFace pf = face as PlanarFace;
        if( null != pf
          && pf.Normal.IsAlmostEqualTo( XYZ.BasisZ ) )
        {
          EdgeArrayArray loops = pf.EdgeLoops;
 
          n = loops.Size;
          polys = new Polygons( n );
 
          foreach( EdgeArray loop in loops )
          {
            n = loop.Size;
            Polygon poly = new Polygon( n );
 
            foreach( Edge edge in loop )
            {
              IList<XYZ> pts = edge.Tessellate();
 
              n = pts.Count;
 
              foreach( XYZ p in pts )
              {
                poly.Add( GetIntPoint( p ) );
              }
            }
            polys.Add( poly );
          }
        }
      }
    }
  }
  return polys;
}

With all of that in place, we have nothing more to do before proceeding with the external command mainline.

As mostly, it consists of two parts: the user interface to select the two slabs to intersect, and the worker code to do the job.

Select Two Slabs in the BIM

The selection supports both pre- and post-selection.

You can select a bunch of elements before launching the command. In that case, the first two slabs encountered in the selection will be picked.

If you pre-select nothing, all floor elements in the entire model will be retrieved and the first two encountered selected.

As you may have gathered, this is more geared towards effective simple testing than production use:

  // Two slabs to intersect.
 
  CeilingAndFloor[] slab
    = new CeilingAndFloor[2] { null, null };
 
  // Access current selection
 
  Selection sel = uidoc.Selection;
 
  int n = sel.Elements.Size;
 
  if( 0 < n )
  {
    foreach( Element e in sel.Elements )
    {
      if( null == slab[0] )
      {
        slab[0] = e as Floor;
      }
      else if( null == slab[1] )
      {
        slab[1] = e as Floor;
      }
      else
      {
        break;
      }
    }
    if( null == slab[0] || null == slab[1] )
    {
      message = "Please select two floor or ceiling slabs to intersect.";
      return Result.Failed;
    }
  }
  else
  {
    // Retrieve elements from database
 
    FilteredElementCollector floors
      = new FilteredElementCollector( doc )
        .WhereElementIsNotElementType()
        .OfCategory( BuiltInCategory.OST_Floors );
 
    foreach( Element e in floors )
    {
      if( null == slab[0] )
      {
        slab[0] = e as Floor;
      }
      else if( null == slab[1] )
      {
        slab[1] = e as Floor;
      }
      else
      {
        break;
      }
    }
    if( null == slab[0] || null == slab[1] )
    {
      message = "Unable to find two floors in project to intersect.";
      return Result.Failed;
    }
  }

Retrieve Boundaries, Intersect and Create a Floor

We have our two slabs.

Let's go ahead and do the job.

Download

One nice aspect of this version is that the C# version of the Clipper library is provided in its entirety by the clipper_library project included in my add-in Visual Studio solution, so you do not even need to download it separately yourself to make use of this.

You do need to ensure that the Clipper .NET assembly is located where the add-in assembly can find it, though. I'll leave that up to you, of course.