The Building Coder

Crop 3D View to Room

In case you have heard enough about both climbing and AU and AUv in the last few posts and would prefer to read about the Revit API and nothing but the Revit API, here is something for you. This is based on a recent case handled by Joe Ye and deals with the 3D view crop box and the transformations required to set it up properly, an issue we have never previously looked at.

Question: I would like to set the crop box of a 3D view to correspond to a single room.

Answer: As the 3D view rotates the room, the original bounding box of the plan view will not be suitable to use for the 3D view crop box. Here is an idea to calculate the crop box. Retrieve all the corner point vertex coordinates of the room, and project them onto the plane perpendicular to the 3D view's view direction. This produces projected point coordinates. From these result point coordinates, determine the maximum and minimum X and Y values. From the max and min points, create the 3D view's crop box.

Here are the detailed steps to implement this idea:

• Retrieve all vertex coordinates of the room.
• Project these coordinates to the plane perpendicular to the 3D view's view direction. To do so, create a face perpendicular to the view direction. The projected results can be obtained from the Face.Project method taking an XYZ point argument. For more information, see the Revit API help file RevitAPI.chm for the usage and return value of this method.
• Go through the resulting coordinates and determine the maximum and minimum X and Y coordinate values.
• Use the four values to determine a bounding box:

  BoundingBoxXYZ bb = new BoundingBoxXYZ(); 
  bb.Min = NewXYZ( xMin, yMin, 0 );
  bb.Max = NewXYZ( xMax, yMax, 0 );
  

• Use the bounding box to set the 3D view crop box:

  View3d.CropBox = bb;
  

Actually, after some further investigation, I found a better way to determine the room extents. It is hard to create a solid and make one face of it perpendicular to the view direction.

You can also use the Transform class to calculate the crop box of the 3D view instead.

First, determine the transformation for translating coordinates in the 3D view to the world coordinate system WCS from the View3d.CropBox.Transform property. Then invert it to obtain the transformation to translate model WCS coordinates back to the 3D view coordinates.

Determine the room vertices from its ClosedShell property, and translate them to 3D view coordinates. Find the minimum and maximum X and Y coordinate values as described above and set the 3D view's crop box Max and Min properties using these.

You do need to activate and make the crop box visible to see the effect. You can do so using the Crop View and Show Crop Region buttons in the user interface:

This can also be achieved programmatically using:

  view3d.CropBoxActive = true;
  view3d.CropBoxVisible = true;

So far for Joe's idea. Many thanks to Joe for all the research into this!

I implemented a new Building Coder sample command CmdCropToRoom to test and demonstrate this. In order to show how the crop box can be set to various different regions in the model, it iterates over all the rooms in the model and sets the crop box of the current 3D view to the next room in the sequence on each call. We retrieve a list of all rooms in the model using doc.get_Elements:

List<RvtElement> rooms = new List<RvtElement>();
int n = doc.get_Elements( typeof( Room ), rooms );

To loop through the rooms in the model and step to the next room in the list on each invocation of the command, we use their index in the list of elements returned by this call. The last index used is stored in a static variable _i, and the method BumpRoomIndex is used to increment it by one on each call:

static int _i = -1;

static int BumpRoomIndex( int room_count )
{
  ++_i;
 
  if( _i >= room_count )
  {
    _i = 0;
  }
  return _i;
}

The next room to crop the view to is selected using

Room room = (0 < n) 
  ? rooms[BumpRoomIndex( n )] as Room 
  : null;

Here is the entire code of the CmdCropToRoom external command Execute method which crops the current 3D view to the next room extents:

Application app = commandData.Application;
Document doc = app.ActiveDocument;
View3D view3d = doc.ActiveView as View3D;
 
if( null == view3d )
{
  message = "Please activate a 3D view"
    + " before running this command.";
 
  return CmdResult.Failed;
}
 
// get the 3d view crop box:
 
BoundingBoxXYZ bb = view3d.CropBox;
 
// get the transform from the current view 
// to the 3D model:
 
Transform transform = bb.Transform;
 
// get the transform from the 3D model 
// to the current view:
 
Transform transformInverse = transform.Inverse;
 
// get all rooms in the model:
 
List<RvtElement> rooms = new List<RvtElement>();
int n = doc.get_Elements( typeof( Room ), rooms );
 
Room room = (0 < n) 
  ? rooms[BumpRoomIndex( n )] as Room 
  : null;
 
if( null == room )
{
  message = "No room element found in project.";
  return CmdResult.Failed;
}
 
// collect all vertices of room closed shell 
// to determine its extents:
 
GeoElement e = room.ClosedShell;
XYZArray vertices = app.Create.NewXYZArray();
 
foreach( GeometryObject o in e.Objects )
{
  if( o is Solid )
  {
    // iterate over all the edges of all solids:
 
    Solid solid = o as Solid;
 
    foreach( Edge edge in solid.Edges )
    {
      foreach( XYZ p in edge.Tessellate() )
      {
        // collect all vertices, 
        // including duplicates:
 
        vertices.Append( p );
      }
    }
  }
}
 
XYZArray verticesIn3dView 
  = app.Create.NewXYZArray();
 
foreach( XYZ p in vertices )
{
  verticesIn3dView.Append( 
    transformInverse.OfPoint( p ) );
}
 
// ignore the Z coorindates and find the 
// min and max X and Y in the 3d view:
 
double xMin = 0, yMin = 0, xMax = 0, yMax = 0;
 
bool first = true;
foreach( XYZ p in verticesIn3dView )
{
  if( first )
  {
    xMin = p.X;
    yMin = p.Y;
    xMax = p.X;
    yMax = p.Y;
    first = false;
  }
  else
  {
    if( xMin > p.X )
      xMin = p.X;
    if( yMin > p.Y )
      yMin = p.Y;
    if( xMax < p.X )
      xMax = p.X;
    if( yMax < p.Y )
      yMax = p.Y;
  }
}
 
// grow the crop box by one twentieth of its 
// size to include the walls of the room:
 
double d = 0.05 * ( xMax - xMin );
xMin = xMin - d;
xMax = xMax + d;
 
d = 0.05 * ( yMax - yMin );
yMin = yMin - d;
yMax = yMax + d;
 
bb.Max = new XYZ( xMax, yMax, bb.Max.Z );
bb.Min = new XYZ( xMin, yMin, bb.Min.Z );
 
view3d.CropBox = bb;
 
// change the crop view setting manually or 
// programmatically to see the result:
 
view3d.CropBoxActive = true;
view3d.CropBoxVisible = true;
 
return CmdResult.Succeeded;

Here is a minimal model with two rooms to test this command:

Running the external command defined by CmdCropToRoom sets the 3D view crop box to the extents of the first room:

Running it another time increments the current room index and sets the 3D view crop box to its extents instead:

Here is version 1.1.0.56 of the complete Building Coder sample source code and Visual Studio solution including the new command.

There are a number of conceivable enhancements to this code. One of the most obvious would be to eliminate duplicate vertices before applying the inverse transformations and searching for the minimum and maximum coordinate values. We did implement some useful functionality for doing that with the XyzEqualityComparer class and GetVertices method in the nested instances geometry retrieval. It might also be possible to use generic collections such as List<XYZ> instead of XYZArray for the original and transformed vertices, and generic .NET functionality to apply the transformation and determine the max and min coordinate values. We left out such enhancements in this case for the sake of clarity, but if you have any suggestions to make, please feel free to do so.

Visible Elements

I am sitting here cramped up in an economy seat crossing the Atlantic Ocean as I write this. I should urgently be practicing and preparing for my sessions at AU, but somehow it feels as if writing a blog post requires slightly less space, so here goes. I would also like to answer some pending comments, but cannot right now due to lack of Internet access...

After revisiting the topic of selecting all model elements in the last post, there is one more important and interesting issue to take into account to determine all the visible model elements. In that post, we made use of element filtering instead of an iterator over all elements and eliminated a number of unwanted element types and categories. Once we have thus whittled away the non-model elements, there are still several possibilities to hide elements in a given view through the user interface. Here are two main methods that can be used to hide elements in a view:

• Hide an individual element.
• Hide an entire category of elements.

To determine whether an element is hidden, we need to check for both of these possibilities. In addition, an element may belong to a subcategory. If so, it may be hidden either because its subcategory or one of its parent categories is hidden.

The Revit SDK sample VisibilityControl demonstrates how to control visibility by category, and the topic of categories and how they are used is covered in detail in section 5.2.1 Category of the developer guide "Revit 2010 API Developer Guide.pdf".

The visibility of an element in a view can be queried using the Element.IsHidden( View ) method, the visibility of a category by the Category.Visible property.

Here is the code of a helper method IsHiddenElementOrCategory which takes all these factors into account and can be used to check whether an element 'e' is hidden in a given view 'v'. It returns true if the given element is hidden in this view, either as an individual element, or because its category or one of its parent categories is hidden:

static bool IsHiddenElementOrCategory(
  Element e,
  View v )
{
  bool hidden = e.IsHidden( v );
 
  if( !hidden )
  {
    Category cat = e.Category;
    while( null != cat && !hidden )
    {
      hidden = !cat.get_Visible( v );
      cat = cat.Parent;
    }
  }
  return hidden;
}

Red Rock Revisited

By the way, some time has passed between starting to write and actually posting this. I arrived safely in Las Vegas, grabbed a rental car, and went off to un-jetlag by spending the night in a sleeping bag in the desert. Rather cold, but not freezing, this time around. Two years ago, it was significantly below freezing and my gallon bottle of water froze solid, all the way down. Last year, it was warmer and moister and had actually rained just before my arrival. This year is the most pleasant to date. Frankly, I prefer the desert to the strip.

I spent my first day here climbing in the Red Rock climbing area with a bunch of crazy guys from Dallas, Texas, namely Karl, Fritz, Gary, Jess and Ellis. We did several easy routes on the Ultraman wall, including Scent of an Ultraman 5.7, Clutch Cargo 5.7 and Science Patrol 5.8.

We met up early next morning again to go the Black Corridor, which I visited in the previous two years as well. I led a number of climbs in the morning including The Cel 50' 5.9, Bon Ez 5.9+, and two of hardest and nicest I've ever done, Heavy Hitter and Friend 40', both 5.10d. The guys from Dallas left to return home at midday and I teamed up with Sonja & Jean-Francois from Quebec in the afternoon to climb two more routes led by Jean-Francois, Crude Street 5.9+ and Dance with a God 5.10a.

I am now sitting in the Barnes and Noble book store on West Charleston Boulevard and gratefully using the free Internet access they provide to finish off and post this. This is the road that I keep going up and down to get to Red Rock.

Select Model Elements 2

We already had several stabs at the topic of selecting all model elements, i.e. all elements in a Revit BIM which contribute to the building geometry. Their main characteristic is that they have a non-null geometry which is visible on the graphics screen and really contributes to the physical building model. Unfortunately, some elements which are not part of the building itself also have valid geometry and need to be eliminated.

The latest version of the code that we presented still made use of a full iteration over all document elements, i.e. something like this:

  Application app = commandData.Application;
  Document doc = app.ActiveDocument;
 
  ElementIterator it = doc.Elements;
 
  while( it.MoveNext() )
  {
    Element e = it.Current as Element;
    // . . .
  }

As we all know by now, this kind of full iteration over all document elements is unnecessarily time consuming and seldom useful, because an application is almost always only interested in a small subset of them. We will convert the model element selection to use element filtering, similarly to the conversion to use filters we described for the Revit SDK FrameBuilder sample.

We can add both a type filter to eliminate a list of classes that we are not interested in, and also a built-in category filter to eliminate unwanted categories. Here is the list of unwanted types, i.e. classes of elements which are not model elements:

static Type[] _types_to_skip = new Type[] {
  typeof( BasePoint ),
  typeof( DetailLine ),
  typeof( Dimension ),
  typeof( Family ),
  typeof( FamilyBase ),
  typeof( FillPattern ),
  typeof( gbXMLParamElem ),
  typeof( GraphicsStyle ),
  typeof( Level ),
  typeof( LinePattern ),
  typeof( MaterialOther ),
  typeof( ModelLine ),
  typeof( Phase ),
  typeof( PrintSetting ),
  typeof( ProjectInfo ),
  typeof( ProjectUnit ),
  typeof( ReferencePlane ),
  typeof( Room ),
  typeof( RoomTag ),
  typeof( Sketch ),
  typeof( SketchPlane ),
  typeof( Symbol ),
  typeof( TextNote ),
  typeof( ViewDrafting ),
  typeof( ViewPlan ),
  typeof( ViewSheet ),
  typeof( WallType ),
};

If you run into some additional unwanted element in your model that is not listed here, you can easily add it. You might want to let us know as well by submitting a comment on it.

We define the following helper method to more succinctly create a type filter which eliminates all of these classes. Given an existing type filter 'f', it adds another type 't' to it and returns the new expanded filter:

static Filter OrType(
  Filter f,
  Type t,
  Autodesk.Revit.Creation.Filter cf )
{
  Filter f2 = cf.NewTypeFilter( t );
  return cf.NewLogicOrFilter( f, f2 );
}

We can make use of it to implement the first step of our external command Execute method like this:

Application app = commandData.Application;
Document doc = app.ActiveDocument;
 
Autodesk.Revit.Creation.Filter cf
  = app.Create.Filter;
 
List<Element> els = new List<Element>();
Filter f = cf.NewTypeFilter( typeof( Symbol ) );
foreach( Type t in _types_to_skip )
{
  f = OrType( f, t, cf );
}
f = cf.NewLogicNotFilter( f );
int n = doc.get_Elements( f, els );

In addition to the unwanted types, we know some built-in categories whose elements also do not contribute to the building geometry and should be eliminated, for instance:

static int[] _bics_to_skip = new int[] {
  ( int ) BuiltInCategory.OST_PreviewLegendComponents,
  ( int ) BuiltInCategory.OST_IOSSketchGrid,
  ( int ) BuiltInCategory.OST_Cameras,
};

We have converted them to integer values to make use of the language independent category comparison. The following helper method encapsulates the code to determine whether a given built-in category integer value is included in this list and the associated element thus needs to be skipped. It makes use of the generic Array.Exists method:

static bool SkipThisBic( int bic )
{
  return Array.Exists<int>(
    _bics_to_skip,
    delegate( int i )
    {
      return i == bic;
    } );
}

With these preparations in place, we can iterate over and list the model elements like this in the rest of the implementation of the external command Execute method:

string s = string.Empty;
n = 0;
 
Geo.Options opt = app.Create.NewGeometryOptions();
 
foreach( Element e in els )
{
  if( (null != e.Category)
    && !SkipThisBic( e.Category.Id.Value )
    && (null != e.get_Geometry( opt )) )
  {
    ++n;
    s += string.Format( 
      "\r\n  Category={0}; Name={1}; Id={2}",
      e.Category.Name, e.Name, e.Id.Value );
  }
}
 
s = string.Format(
  "Project contains {0} model element{1}{2}",
  n,
  ( 1 == n ? "" : "s" ),
  ( 0 == n ? "." : ":" ) )
+ s;
 
LabUtils.InfoMsg( s );
 
return CmdResult.Failed;

Here is today's snapshot of the updated version of the Revit API introduction labs including the version of Lab 2-2 to select all model elements as described above.

Solid Material

Here is a simple question with a simple answer on materials and solids:

Question: Is there a way to retrieve the material of the solid geometry object of a Revit Element, like the door leaf of a door element?

Answer: No, I am not aware of any way that a material can be assigned to a solid. The only representation of the solid in the graphical user interface is through its faces, and they can have materials assigned to them. As far as I know, the solid itself has no such property. The only way that I am aware of to determine the material of a solid is through the path Solid > Faces > FaceArray > Item > Face > MaterialElement.

Another short little note on a completely unrelated topic:

Clean Uninstall of Revit 2010

In case you ever have problems with the installation of Revit, the Autodesk Revit Architecture Services & Support area includes a page describing a method to achieve a clean uninstall of Revit 2010 products.

Analytical Support Tolerance

Here is an interesting issue dealing with the analytical model in Revit Structure. As we see below, the issue is not really API related, but since one symptom is the missing data obtainable through the API, it is worth an explanation.

Question: We have created two columns over a three-pile cap foundation and are trying to retrieve the support data from their analytical models:

Unfortunately, the support data of the column is available only if its centre line is exactly over the analytical model location of the pile cap foundation. Else, it is not available and the property simply returns null. The main purpose of this requirement is actually to find the link between the column and the pile cap. How can we achieve this, please?

Answer: Happily, this situation is easily resolved by modifying the analytical support tolerance. First, note that the missing support data is not an API-specific problem. If you select the column through the user interface, the Show Related Warnings button is active and the warning says that the column may not be supported.

The pile cap foundation is actually four foundations – one cap foundation and three pile foundations. Geometry for the cap foundation starts at Level 1 and goes down 900. The geometries for the three pile foundations start at -900 and go down 6900. In Revit, the default position for the Isolated Foundation analytical model is at the top of the geometry. Since this is at -900, the analytical models for the pile foundations are at that elevation.

Analytical Support is governed by the Analytical Support tolerance, shown on the Analytical Model Settings tab of the Structural Settings dialog. In the attached file, this tolerance is set at 300. So even when the column's analytical model is directly over the pile foundation's analytical model, the thickness of the cap foundation (900) is keeping the column from seeing the pile foundation's analytical model.

To overcome this obstacle, increase the tolerance from 300 to 900. Then when you move the column over the top of the pile foundation, it will see the pile foundation, and the column will consider the pile foundation as a valid support.

Although that resolves the current problem, here are two additional general hints for approaches to find the link between two elements located close to each other:

• FindReferencesByDirection.
• Geometric analysis.

The FindReferencesByDirection method to find the link between the two elements determines that the pile cap foundation is located directly underneath the second column and hence is supporting it. This can be achieved by shooting a ray straight down from a point slightly raised up from the lower endpoint of the column and using FindReferencesByDirection to discover the foundation element directly underneath. FindReferencesByDirection returns an array of elements, faces, and references found when moving through the model from a specified point in a specified direction. Its use is demonstrated by the RayTraceBounce SDK sample.

You can also determine their relationship by pure geometric analysis, e.g. using a filter to collect all the structural elements on the relevant levels and then comparing the locations of their solids' faces with each other. The AreSolidsCut method defined by the RoomsRoofs SDK sample may be helpful in this context. Geometric analysis may or may not be simpler than using FindReferencesByDirection.

Unrotate North

I spent this weekend on the Rigi Mountain together with seventy other people from the alpine club. Saturday it rained quite hard most of the day, unfortunately, but a couple of us still went on a very nice hike from Rigi Scheidegg across to and over the top of Rigi Hochflueh with a beautiful view down on the Lucerne Lake and the Rütli Meadow. In the evening, we also tested how many people can be shoehorned into a wood-heated hot tub outside in snow and rain, among other interesting pastimes. Sunday I went climbing with Angela. Considering the rain from the day before and the night and it still being quite cloudy on Sunday, we were maybe the only two crazy enough to even try it. It involved the same walk from Scheidegg to Hochflueh, then searching for the climbing area, doing the climbs, and, last but not least, getting back again safely. The climbing area is called Thedys Gärtli and is on the Hochflue slabs close to the summit, so we could all the time enjoy the same beautiful view as the day before. We were extremely pleased to be able to do two very nice climbs, among the easier ones, Männertrü (4c) and Fürlinie (5c). Although we knew when we started the latter one that we would get back rather late, we actually ended up descending the mountain in total darkness and spending most of the night trying to get back to civilisation. Or, rather, all of the night, since I missed the last train out of there.

Anyway, meanwhile, our inexorable exploration of the Revit API continues, and here is another question to address which expands on our analysis of the calculation of the azimuth or Revit elements:

Question: I am using the Element.Location property to query the X and Y coordinate values of an element. I also make use of the project location and project angle. I have a problem if the Project North has been rotated. How can I determine the 'real' X and Y coordinates of an element if the Project North has been rotated?

Answer: Ok, I see what you mean.

To dive into this a little bit deeper, I implemented a new Building Coder sample command CmdUnrotateNorth to calculate the coordinates of the original unrotated element location for you. It transforms the element location back to the original coordinates to cancel effect of rotating the project north by simply determining the project north rotation angle 'a' and applying a similar transformation to the element coordinates like this:

  Transform t = Transform.get_Rotation(
    XYZ.Zero, XYZ.BasisZ, a );

To simplify testing, I implemented a helper method GetElementLocation which defines a location point for any given element having a non-null Location property:

bool GetElementLocation(
  out XYZ p,
  Element e )
{
  p = XYZ.Zero;
  bool rc = false;
  Location loc = e.Location;
  if( null != loc )
  {
    LocationPoint lp = loc as LocationPoint;
    if( null != lp )
    {
      p = lp.Point;
      rc = true;
    }
    else
    {
      LocationCurve lc = loc as LocationCurve;

      Debug.Assert( null != lc,
        "expected location to be either point or curve" );

      p = lc.Curve.get_EndPoint( 0 );
      rc = true;
    }
  }
  return rc;
}

In the main method, I check that one single element is selected and then list its location point as returned by the API, or rather by this method. I then iterate over all project locations, print each one's the project north angle and list the element location point rotated around the origin by that angle.

I tested this by selecting an element and running the command with it in its original unrotated position, which returns:

Selected element location: (-23.64,1.64,0)
Angle between project north and true north: 0 degrees
Unrotated element location: (-23.64,1.64,0)

After applying a rotation to the project north by calling Manage > Project Location > Position > Rotate Project North > Align selected line or plane, invoking the same command again returns the following:

Selected element location: (-21.66,9.62,0)
Angle between project north and true north: 20 degrees
Unrotated element location: (-23.64,1.64,0)

As you can see, the element location returned by the API is different, but the original value can easily be obtained by applying the rotation described.

Here is the code of the entire mainline of the sample command in its Execute method:

Application app = commandData.Application;
Document doc = app.ActiveDocument;

ElementSet els = doc.Selection.Elements;

if( 1 != els.Size )
{
  message = "Please select a single element.";
}
else
{
  ElementSetIterator it = els.ForwardIterator();
  it.MoveNext();

  Element e = it.Current as Element;

  XYZ p;
  if( !GetElementLocation( out p, e ) )
  {
    message
      = "Selected element has no location defined.";

    Debug.Print( message );
  }
  else
  {
    string msg
      = "Selected element location: "
      + Util.PointString( p );

    double pna = 0;

    foreach( ProjectLocation location
      in doc.ProjectLocations )
    {
      ProjectPosition projectPosition
        = location.get_ProjectPosition( XYZ.Zero );

      pna = projectPosition.Angle;

      msg +=
        "\nAngle between project north and true north: "
        + Util.AngleString( pna );

      Transform t = Transform.get_Rotation(
        XYZ.Zero, XYZ.BasisZ, pna );

      msg +=
        "\nUnrotated element location: "
        + Util.PointString( t.OfPoint( p ) );

      Util.InfoMsg( msg );
    }
  }
}
return IExternalCommand.Result.Failed;

Here is version 1.1.0.50 of the complete Building Coder sample source code and Visual Studio solution including the new command.

Room Boundary Location

We already had a look at enabling the room volume computation in C#. Here is a closely related question that also prompted me to implement something similar in VB for a change.

Question: Could you please provide some VB.NET code showing how to set the Autodesk.Revit.Rooms.BoundaryLocationType in the document, for instance to 'WallCenter'?

Answer: The boundary location type is applied when calculating the room volume. These settings are defined by the document settings volume calculation options. The post mentioned above discusses how to access and modify these settings.

I implemented a VB.NET sample application RoomBoundaryLocation for you to demonstrate this in VB as well. Here is the mainline code of its Execute method:

Public Function Execute( _
  ByVal commandData As ExternalCommandData, _
  ByRef message As String, _
  ByVal elements As ElementSet) _
  As CmdResult _
  Implements IExternalCommand.Execute

  Dim app As Application = commandData.Application
  Dim doc As Document = app.ActiveDocument

  Dim opt As VolumeCalculationOptions _
    = doc.Settings.VolumeCalculationSetting _
      .VolumeCalculationOptions

  opt.VolumeComputationEnable = True

  opt.RoomAreaBoundaryLocation _
    = Rooms.BoundaryLocationType.WallCenter

  doc.Settings.VolumeCalculationSetting _
    .VolumeCalculationOptions = opt

  Dim volumes As List(Of String) = New List(Of String)
  Dim els As ElementSet = doc.Selection.Elements

  Dim e As Autodesk.Revit.Element
  For Each e In els
    If TypeOf e Is Room Then
      Dim room As Room = CType(e, Room)
      volumes.Add(room.Volume.ToString("0.##"))
      'Else
      '  volumes.Add("Not a room")
    End If
  Next

  If 0 = volumes.Count Then
    message = "Please select some rooms."
  Else
    Dim s As String = _
      +"Selected room volumes in cubic feet: " _
      + String.Join(", ", volumes.ToArray()) _
      + "."
    MsgBox(s)
  End If

  Return CmdResult.Failed
End Function

Here are some sample rooms and spaces selected in the Revit user interface:

This is the resulting dialogue displayed by running the command:

Here is the complete Visual Studio solution RoomBoundaryLocation implementing the new command.

Duplicate Family Solids

Here is a question handled by Joe Ye on multiple occurrences of solids in a pipe family definition.

Question: We were surprised to discover that the solids inside a pipe family are duplicated. This is an issue for us, because we want to determine the relationship between the family symbol and the corresponding geometrical solid. We would like to add symbol properties such as a subcategory to the solid. During the export, we don't know which sub category is used for presentation on the screen. We retrieve all the solids, but their subcategory is not defined, so we cannot determine whether or not to export the data.

Answer: There are three solids in the family definition, and they represent three different parts of the pipe. One is for the pipe fitting insulation, another is for the pipe fitting lining, and the third for the pipe itself.

If the parameter values Lining Thickness and Insulation Thickness are zero, all three solids are identical. Otherwise, their sizes are different. Here is an example displaying non-zero Lining Thickness and Insulation Thickness parameter values:

According to which solid you need to export, you can compare the sizes and export only the one that you require.

For example, if you only want to export the insulation size, then you can search for the largest solid and export that. If you want to export the lining solid, export the smallest solid.

If the Lining Thickness and Insulation Thickness are both zero, then exporting any one of them will work.

By the way, for a pipe fitting, there are only two such solids.

Many thanks to Joe for this explanation!

Remove all Geometry from a Family

Here is a question from Joel Karr of Environmental Systems Design, Inc that nicely complements the issue of identifying model elements in a project file with the subsequent correction added.

Question: Is it possible to delete all geometry from a Revit RFA family file? I would like to keep all parameters but delete all geometry.

Answer: To achieve what you desire, we first need to identify all elements contributing geometry to the model, similarly to the model element selection issues mentioned above.

This is simpler in a family file than in a project file, since there are normally less elements and almost all elements having geometry are the ones we are interested in.

I implemented a sample application RemoveRfaGeom to test this, with the following mainline code for its Execute method:

public IExternalCommand.Result Execute( 
  ExternalCommandData commandData, 
  ref string message, 
  ElementSet elements )
{
  Application app = commandData.Application;
  Document doc = app.ActiveDocument;
 
  ElementIterator it = doc.Elements;
  Options opt = app.Create.NewGeometryOptions();
  List<Element> a = new List<Element>();
 
  while( it.MoveNext() )
  {
    Element e = it.Current as Element;
 
    if( null != e.get_Geometry( opt ) )
    {
      a.Add( e );
    }
  }
 
  int n = a.Count;
  Debug.Print( 
    "{0} element{1} have non-null geometry{2}", 
    n, 
    ( 1 == n ? "" : "s" ),
    ( 0 == n ? "." : ":" ) );
 
  ElementSet els = new ElementSet();
 
  foreach( Element e in a )
  {
    string cat = (null == e.Category)
      ? "<null>"
      : e.Category.Name;
 
    Debug.Print(
      "Category={0}; Name={1}; Id={2}; Type={3}",
      cat,
      e.Name,
      e.Id.Value.ToString(),
      e.GetType().Name );
 
    if( null == e.Category )
    {
      els.Insert( e );
    }
  }
 
  ElementIdSet ids = doc.Delete( els );
 
  n = (null == ids) ? 0 : ids.Size;
 
  Debug.Print( "{0} element{1} deleted.",
    n,
    ( 1 == n ? "" : "s" ) );
 
  return IExternalCommand.Result.Succeeded;
}

It performs the following steps, assuming that the active document is indeed a family document:

• Iterate over all family document elements.
• Identify and list all elements with non-null geometry.
• Create a set of all elements with geometry whose category is null.
• Delete the latter set and display the number of deleted elements.

Running this in the metric library rectangular column family file 'M_Rectangular Column.rfa' produces the following output:

2 elements have non-null geometry:
Category=; Name=Extrusion; Id=105; Type=Extrusion
Category=Cameras; Name=View 1; Id=427; Type=Element
13 elements deleted.

As you can see from this, there are some elements having geometry that you presumably do not want to eliminate, such as the camera, so you will need to remove those from the set before deletion. In this case, I simply noted that the camera has a non-null category, whereas the category of the extrusion I want to remove is null, so I just check the null category property to select the extrusion.

Secondly, deleting an element causes other dependent elements to be deleted also, so even though we just pass in one single extrusion element to the Delete method, a whole group of other elements are eliminated as well. We already discussed and made use of this effect to determine the association between a tag and the tagged element and between a host and its hosted elements.

Here is the complete Visual Studio solution RemoveRfaGeom implementing the new command.

Elevation and Section Views

Here are some questions handled by Joe Ye, on creation of and line work in elevation views and the cut plane definition of a section view.

Question: There are different specialised kinds of views derived from the Autodesk.Revit.Elements.View class, and I see several methods in the Revit API to create some of these, such as 3D, Plan, Section, Sheet and Drafting. However, I cannot find a method to create an Elevation View. How can I do that?

Answer: Unfortunately, the Revit API currently does not provide any method to create an elevation view. At the moment, you can use the NewViewSection method to create a vertical section view very similar to an elevation view. By using a large bounding box which does not intersect with the building model, it can display the same view as an elevation view:

Question: Once I have created an elevation view, how would I change the line work of certain elements in that view? In the user interface, Revit provides the Linework tool in the ribbon for this action. How can I achieve this through the API?

Answer: As regards modifying the line work displayed in an elevation view, you can use the CutLinePatternOverrideByElement method on the View object to set the line weight for specified elements. For more information about this method, please see the Revit API help file RevitAPI.chm file in SDK.

Question: How can I get the cut plane definition from a section view programmatically? I just need any point inside the cut plane and the normal vector of the plane to continue to do some other calculations.

Answer: The section view class provides the properties you need. The Origin property of a section view is a point in the world coordinate system or WCS located in the cut plane of the section view. The ViewDirection property of a section view returns a WCS vector indicating the direction towards the viewer. You can use the section view Origin as the cut plane origin, and the ViewDirection as its normal vector. Depending to your usage, you might need to reverse the direction of the ViewDirection.

Thank you very much Joe for these answers!