The Building Coder

Setting up your ViewOrientation3D

Here is a contribution from Mario Guttman of CASE, who already made various contributions here in the past. He says:

I have been purging my 2013 code of deprecated functions in preparation for my 2014 upgrade. One group of statements I have needed to replace are the view creations. They were previously using the Document.Create.NewView3D method and needed converting to the View3D.CreateIsometric with a separate ViewOrientation3D object defining the view direction.

Typically, in these kind of cases, I just search your blog for the answer. In this case I found a few references, for example your March 04, 2013 item on What's New in the Revit 2013 API – View API – View Creation. This, together with the wikihelp entry on the View3D class, describe the new syntax, but they don't really explain how you would create the values.

After searching the inner reaches of my brain for some ancient math skills I figured out the following:

Assuming that your user interface has produced two angular values (in degrees):

  /// <summary>
  /// The angle in the XY plane (azimuth),
  /// typically 0 to 360.
  /// </summary>
  double angleHorizD;
 
  /// <summary>
  /// The vertical tilt (altitude),
  /// typically -90 to 90.
  /// </summary>
  double angleVertD;

Then this utility function returns a unit vector in the specified direction:

  /// <summary>
  /// Return a unit vector in the specified direction.
  /// </summary>
  /// <param name="angleHorizD">Angle in XY plane 
  /// in degrees</param>
  /// <param name="angleVertD">Vertical tilt between 
  /// -90 and +90 degrees</param>
  /// <returns>Unit vector in the specified 
  /// direction.</returns>
  private XYZ VectorFromHorizVertAngles(
    double angleHorizD,
    double angleVertD )
  {
    // Convert degreess to radians.
 
    double degToRadian = Math.PI * 2 / 360;
    double angleHorizR = angleHorizD * degToRadian;
    double angleVertR = angleVertD * degToRadian;
 
    // Return unit vector in 3D
 
    double a = Math.Cos( angleVertR );
    double b = Math.Cos( angleHorizR );
    double c = Math.Sin( angleHorizR );
    double d = Math.Sin( angleVertR );
 
    return new XYZ( a * b, a * c, d );
  }

From this it is easy to create the ViewOrientation3D object as follows:

  XYZ eye = new XYZ.Zero;
 
  XYZ forward = VectorFromHorizVertAngles(
    angleHorizD, angleVertD );
 
  XYZ up = VectorFromHorizVertAngles(
    angleHorizD, angleVertD + 90 );
 
  ViewOrientation3D viewOrientation3D
    = new ViewOrientation3D( eye, up, forward );

Although it is already explained in one of your other posts, just for completeness, here is the final step is to apply the orientation to the view:

  ViewFamilyType viewFamilyType3D
    = new FilteredElementCollector( doc )
      .OfClass( typeof( ViewFamilyType ) )
      .Cast<ViewFamilyType>()
      .FirstOrDefault<ViewFamilyType>(
        x => ViewFamily.ThreeDimensional
          == x.ViewFamily );
 
  View3D view3d = View3D.CreateIsometric(
    doc, viewFamilyType3D.Id );
 
  view3d.SetOrientation( viewOrientation3D );

I hope you find this useful.

Personally, I do indeed.

Many thanks to Mario for sharing!

What's New in the Revit 2013 API

This is the fourth and last instalment of a series publishing the information provided in the 'What's New' sections of the past few Revit API releases help file RevitAPI.chm.

The first instalment covering What's New in the Revit 2010 API explains my motivation for this and provides an overview of the other releases.

We now move on to the Revit 2013 API, looking at:

• Major changes and renovations
• Major enhancements
• Small enhancements & API interface changes

First, however, another update on my vacation.

Turning North Again

I am still on holiday in Italy, so please do not expect any immediate responses to comments for a while.

After withstanding a snowstorm in the north, I did indeed find some warmth further south.

Almond trees are in bloom, and the grass is as green as it will ever get.

I explored the sweet Apulian local train system.

We had some cold and rainy days in the south also.

Turning back northwards towards Napoli under splendid blue skies, I passed this house beside a cafe I visited changing trains in Taranto.

I walked the wonderful Sentiero degli Dei that I remember so well from my visit in 2009.

This time around, I started at the bottom, in Praiano, walked up to the Convento San Domenico, spent the night there, and walked on through Nocelle back down to Positano next morning.

We had a terrible struggle to get there and back out again due to a bus strike. We finally reached Napoli, though, and first of all had a pizza.

The clouds returned and covered the Vesuvio.

Spring is eagerly awaited here also, even inspiring the pasticceria.

Now for the last instalment of the previous Revit API releases' news, bringing us up to date with the current day.

Major Changes and Renovations

to the Revit 2013 API

.NET 4.0 for compilation

All Revit components including RevitAPI.dll and RevitAPIUI.dll are now built with the .NET 4.0 compiler. Thus, add-in projects which reference Revit DLLs must be set as .NET 4.0 Framework projects as well.

New macro environment

VSTA has been replaced by SharpDevelop. This provides identical capabilities for macro creation, editing, and debugging as well as for deployment (application-level and document-level macros) and a simple upgrade procedure for existing macros.

SharpDevelop also provides expanded IDE capabilities, .NET 4.0, extended refactoring tools, code analysis tools, a regular expression toolkit, and macro IDE add-in support.

Revit.ini registration disabled

Add-ins will no longer be read from Revit.ini. Revit will look only to .addin files in the machine-wide and user-specific locations when deciding what add-ins to load.

Document.Element properties replaced

The indexed properties:

• Document.Element[ElementId]
• Document.Element[String]

have been replaced by methods:

• Document.GetElement(ElementId)
• Document.GetElement(String)

The old indexed properties have been marked obsolete.

The behavior for the new methods is identical to what they replaced.

Replacements for use of old-style collections

ElementArray and ElementSet are now obsolete

With a few exceptions, API methods using ElementArray and ElementSet have been replaced with equivalents using .NET generic collections of ElementIds (ICollection<ElementId>).

Some APIs have been obsoleted with no replacement; these methods are batch element creation methods which dated to the time when regeneration was automatic after every database change. Now that regeneration is manual, having separate batch creation methods provides no extra benefit as multiple element creation calls can be chained together with no delay caused by regeneration. Thus these methods are obsolete:

• ItemFactoryBase.NewTextNotes()
• Creation.Document.NewRooms(List<RoomCreationData>)
• Creation.Document.NewWalls() (all overloads)

When replacing calls to these methods, you should use the corresponding creation method which creates a single element in a loop, while delaying calls to Regenerate() until the loop has concluded. Because Regenerate() is delayed, you should not make inquiries to the newly created elements' geometry as a part of the loop.

Definitions and DefinitionGroups

These classes used to inherit from base classes consisting of old-style Revit API collections. The new versions of the classes offer the same functionality, but implement System.Collections.Generic.IEnumerable<T>.

Code which referred to the older base class or its associated iterator will need to be changed to access members through iteration or the now-available LINQ methods.

In addition, code which called ForwardIterator() or ReverseIterator() on these classes will need to be changed as the new version of the class does not offer these two legacy methods.

GeometryElement.Objects

The property

• GeometryElement.Objects

has been obsoleted. GeometryElement now inherits directly from IEnumerable<GeometryObject>, and it possible to directly iterate the contents of the GeometryElement using .NET and LINQ, if needed.

Replacements for wall creation methods

New wall creation APIs have been provided as a part of the Wall class:

• static Wall Create(Document document, Curve curve, ElementId levelId, bool structural) – Creates a new rectangular profile wall within the project using the default wall style.
• static Wall Create(Document document, Curve curve, ElementId wallTypeId, ElementId levelId, double height, double offset, bool flip, bool structural) – Creates a new rectangular profile wall within the project using the specified wall type, height, and offset.
• static Wall Create(Document document, IList<Curve> profile, bool structural) – Creates a non rectangular profile wall within the project using the default wall type:
• static Wall Create(Document document, IList<Curve > profile, ElementId wallTypeId, ElementId levelId, bool structural) – Creates a non rectangular profile wall within the project using the specified wall type.
• static Wall Create(Document document, IList<Curve> profile, ElementId wallTypeId, ElementId levelId, bool structural, XYZ normal) – Creates a non rectangular profile wall within the project using the specified wall type and normal vector.

These methods replace the obsolete methods on Autodesk.Revit.Creation.Document (NewWall() (all overloads)). The NewWalls() overloads are obsoleted without dedicated replacements, as described in the section ElementArray and ElementSet are now obsolete.

Idling event and External Events

Idling event frequency

The Idling event has been changed to offer two different modes of behavior. The default behavior has changed; pre-existing code that needs the original behavior will need to opt-in to the non-default behavior.

In the default mode, a single raise of the event will be made each time Revit begins an idle session. Note that when the user is active in the Revit user interface, idle sessions begin whenever the mouse stops moving for a moment or when a command completes. However, if the user is not active in the user interface at all, Revit may not invoke additional idling sessions for quite some time; this means that your application may not be able to take advantage of time when the user leaves the machine completely idle for a period of time.

In the non-default mode, your application forces Revit to keep the idling session open and to make repeated calls to your event subscriber. In this mode even if the user is totally inactive the Revit session will continue to make Idling calls to your application. However, this can result in performance degradation for the system on which Revit is running because the CPU remains fully engaged in serving Idling events during the Revit application's downtime.

You can indicate the preference for the non-default Idling frequency by calling

• IdlingEventArgs.SetRaiseWithoutDelay()

each time the Idling event callback is made. Revit will revert to the default Idling frequency if this method is not called every time in your callback.

Idling event with no active document

The Idling event now is invoked when there is no document active in Revit.

External Events framework

The External Events framework is a new API framework tailored for asynchronous processing such as that which is needed to support modeless dialogs. It operates similarly to the Idling event with default frequency.

With this framework, instead of implementing an event handler and implementing the handler to do nothing when there is no activity in your dialog, instead you do the following:

1. Implement an external event by deriving from the interface:
   • IExternalEvent
2. Create an ExternalEvent with
   • ExternalEvent.Create()
3. When an event happens in your modeless UI where a Revit action needs to be taken, call
   • ExternalEvent.Raise()
4. Revit will wait for an available Idling timecycle and call the implementation of your event:
   • IExternalEvent.Execute()

This framework is more useful for modeless dialog developers because you can skip the default no-op implementation when nothing has happened, and tell Revit when there is some work you need to do in Revit. It also saves on the time required for Revit to make repeated calls to the Idling event when there is no actual work to be done.

Calling OpenAndActivateDocument during events

The UIApplication.OpenAndActivateDocument can now be invoked during events under the following conditions:

1. When invoked from an External Event, not restrictions apply except for the original active document to be free of transactions and transaction groups.
2. When invoked from regular event handlers, the following restrictions apply:
   • There must be no active document open yet in Revit
   • The event must not be nested in other events or in execution external command

Document & worksharing changes

Worksharing properties

The information required to identify a workshared file on the central or local locations have changed due to changes to RevitServer. As a result, the members

• Application.GetRevitServerNetworkHosts()
• Application.CurrentRevitServerAccelerator
• Document.WorksharingCentralFilename

replace the properties

• Application.CentralServerName
• Application.LocalServerName
• Document.GetWorksharingCentralModelPath()

The new members:

• Application.GetWorksharingCentralGUID(ServerPath serverModelPath)
• Document.WorksharingCentralGUID

provides read access to the worksharing central GUID of the given server-based model. This is applicable only to workshared models saved in Revit 2013 or later.

New overloads for Application.OpenDocumentFile() and UIApplication.OpenAndActivateDocument()

The new overloads support parameters OpenOptions and OpenOptionsForUI, respectively, to specify how a Revit document should be opened. Both options classes currently offer the ability to detach the opened document from central if applicable.

The property:

• OpenOptions.DetachFromCentralOption

can be set to DoNotDetach (the default) or DetachAndPreserve.

The property:

• OpenOptionsForUI.DetachFromCentralOption

can be set to DoNotDetach (the default), DetachAndPreserveWorksets or DetachAndPrompt.

BasicFileInfo

The new class

• BasicFileInfo

offers basic information about a Revit file, including worksharing status, Revit version, username and central path. The information can be extracted without fully opening the file.

Point cloud engine API changes

Because these are new methods in a pre-existing interface, existing code will have to be modified to implement the methods.

Free()

Unlike other Point Cloud interfaces in the Revit 2012 release, this interface did not offer a method to be called when Revit is finished with it.

When Revit calls this function it indicates that the IPointCloudAccess interface is no longer going to be used and the provider of the interface can dispose of all allocated resources.

GetOffset()

Implement this method to return the offset stored in the point cloud. All points are assumed to be offset by the same offset vector. The offset should be expressed in the same units as used by the point coordinates (the scale conversion factor is not applied). The offset will be used by Revit if the user choose to place an instance relative to another point cloud (the "Auto – Origin To Last Placed" placement option).

CreatePointSetIterator()

A second overload with an additional argument – density – the desired number of points per unit area. Area is computed in native units of the point cloud.

IFC export APIs

The IFC export implementation in Revit has switched to a more generic toolkit. As a result, many of the APIs introduced in Revit 2012 to support customized IFC export have been removed and replaced, and new interfaces introduced that allow more flexibility in the data that is written to the IFC file. Autodesk recommends that any customization of IFC export begin with the implementation of the default Revit IFC exporter client, and that customizations written for 2012 be ported incrementally to support Revit 2013.

Construction Modeling changes

The following members are now obsolete:

• Part.GetDividedParents() – replaced with Part.GetSourceElementIds
• PartMaker.GetDividedElementIds() – replaced with PartMaker.GetSourceElementIds
• PartMaker.IsElementDivided() – replaced with PartMaker.IsSourceElement
• PartMaker.SetDividedElementIds() – replaced with PartMaker.SetSourceElementIds
• PartUtils.ArePartsValidForDivide -> replaced with PartUtils.AreElementsValidForDivide()

The following members are now obsolete – they are not being replaced with new members because the information they returned can be obtained by applying GetSourceElementIds recursively to source elements that are Parts.

• Part.OriginalDividedElementId
• Part.ParentDividedElementId
• PartUtils.GetDividedParent()

The following members are obsolete. Their replacements live on the PartMakerMethodToDivideVolumes class, which you can obtain for a given PartMaker using PartUtils.GetPartMakerMethodToDivideVolume():

• PartUtils.AreElementsValidIntersectingReferences()
• PartUtils.IsValidSketchPlane()
• PartUtils.SetOffsetForIntersectingReference()
• PartUtils.GetOffsetForIntersectingReference()
• PartUtils.PartMakerUsesReference()

The methods:

• AssemblyViewUtils.CreatePartList()
• AssemblyViewUtils.CreateMaterialTakeoff()

now return ViewSchedule instead of View.

Structure changes

Rebar.GetCenterlineCurves()

The overload taking one argument is now obsolete.

The new three-argument Rebar.GetCenterlineCurves(Boolean, Boolean, Boolean) has arguments to control whether or not to:

• Adjust for self-intersection
• Include hooks
• Include bend radius curves (fillets)

Rebar member changes

These members are now obsolete:

• Rebar.DistributionPath is replaced by Rebar.GetDistributionPath()
• Rebar.Host is replaced by Rebar.GetHostId() and SetHostId()
• Rebar.RebarShape is replaced by Rebar.RebarShapeId property
• Rebar.BarType is obsoleted. Use the inherited GetTypeId() and ChangeTypeId()

AreaReinforcement and PathReinforcement

BarDescription class

The new RebarInSystem element replaces the BarDescription class. This class and related methods:

• AreaReinforcement.NumBarDescriptions()
• AreaReinforcement.GetBarDescription()
• PathReinforcement.NumBarDescriptions()
• PathReinforcement.GetBarDescription()

are obsolete in 2013.

When ReinforcementSettings.HostStructuralRebar is true, Area and Path Reinforcement elements create individual rebar elements that participate in views and schedules. The individual RebarInSystem elements have the same graphical representation and parameters as Rebar elements, and have the same API methods for inquiry. But the RebarInSystem elements are almost entirely controlled by their system element (Area or Path). Therefore they are missing most of the modification methods of the Rebar class.

New methods:

• AreaReinforcement.GetRebarInSystemIds()
• AreaReinforcement.RemoveAreaReinforcementSystem()
• PathReinforcement.GetRebarInSystemIds()
• PathReinforcement.RemovePathReinforcementSystem()

MEP changes

ConnectorProfileType, PartType

ConnectorProfileType enums are renamed to:

• Invalid, Round, Rectangular, Oval

PartType::UndefinedPartType is renamed to PartType::Undefined.

ConnectorElement

Subclasses of ConnectorElement: PipeConnector, DuctConnector, and ElectricalConnector, are obsolete.

• IsPrimary – moved to ConnectorElement
• AssignAsPrimary – moved to ConnectorElement
• LinkedConnector – moved to ConnectorElement as GetLinkedConnectorElement and SetLinkedConnectorElement
• Please query the parameters RBS_PIPE_CONNECTOR_SYSTEM_CLASSIFICATION_PARAM, RBS_DUCT_CONNECTOR_SYSTEM_CLASSIFICATION_PARAM, or RBS_ELEC_CIRCUIT_TYPE on ConnectorElement to obtain the PipeSystemType, DuctSystemType, and ElectricalSystemType values on the now obsolete PipeConnector, DuctConnector, and ElectricalConnector elements.

Connector element types can now be created using new methods:

• ConnectorElement.CreatePipeConnector()
• ConnectorElement.CreateDuctConnector()
• ConnectorElement.CreateElectricalConnector()
• ConnectorElement.CreateConduitConnector()
• ConnectorElement.CreateCableTrayConnector()

These methods replace the methods on Autodesk.Revit.Creation.FamilyItemFactory (NewDuctConnector, NewPipeConnector, NewElectricalConnector). Those methods are now obsolete.

Obsolete API Cleanup

Many API classes and methods previously marked Obsolete in Revit 2012 and earlier have been removed from the API.

Classes removed

• MaterialConcrete, MaterialGeneric, MaterialOther, MaterialSteel, MaterialWood – all data is now accessed via the Material class
• Autodesk.Revit.DB.ConstructionType – replaced by Autodesk.DB.Analysis.ConstructionType
• SuspendUpdating – no longer needed because Automatic regeneration mode has been removed.Autodesk.Revit.UI.Macros.ApplicationEntryPoint
• Autodesk.Revit.VSTA.ApplicationEntryPoint – replaced by Autodesk.Revit.UI.Macros.ApplicationEntryPoint
• Autodesk.Revit.VSTA.DocumentEntryPoint – replaced by Autodesk.Revit.UI.Macros.DocumentEntryPoint
• Autodesk.Revit.VSTA.IEntryPoint – replaced by Autodesk.Revit.UI.Macros.IEntryPoint
• Autodesk.Revit.VSTA.AddInIdAttribute – replaced by Autodesk.Revit.UI.Macros.AddInIdAttribute
• Autodesk.Revit.VSTA.VendorIdAttribute – replaced by Autodesk.Revit.UI.Macros.VendorIdAttribute

Methods and properties removed

• AnalysisDisplayLegend.Width – replaced by legend settings of AnalysisDisplayStyle.
• AnalysisDisplayLegendSettings.SetTextTypeId(ElementId, Document)
• AnalysisDisplayMarkersAndTextSettings.SetTextTypeId(ElementId, Document)
• AnalyticalModel methods
  • IsValidAnalyticalProjectionType(AnalyticalDirection, AnalyticalProjectionType) replaced by IsValidProjectionType
  • GetAnalyticalProjectionDatumPlane(AnalyticalDirection ) replaced by GetAnalyticalProjectionDatumPlane(AnalyticalElementSelector, AnalyticalDirection)
  • IsValidDatumPlaneForProjection(AnalyticalDirection, ElementId ) replaced by IsValidProjectionDatumPlane
  • SetAnalyticalProjectionDatumPlane(AnalyticalDirection, ElementId ) replaced by setAnalyticalProjectionDatumPlane(AnalyticalElementSelector, AnalyticalDirection, ElementId)
  • SetAnalyticalOffset(XYZ) replaced by SetOffset
  • GetAnalyticalOffset() replaced by GetOffset
  • GetAnalyticalProjectionType(AnalyticalDirection) replaced by GetAnalyticalProjectionType(AnalyticalElementSelector, AnalyticalDirection)
  • SetAnalyticalProjectionType(AnalyticalDirection, AnalyticalProjectionType ) replaced by SetAnalyticalProjectionType(AnalyticalElementSelector, AnalyticalDirection, AnalyticalProjectionType)
• IFCExportOptions.CurrentViewOnly
• PointCloudFilter.GetFilterOutline() – replaced by PointCloudFilterUtils.GetFilteredOutline()
• RebarHostData.HasCoverTypeForReference(Reference ) – replaced by IsFaceExposed()
• SpatialFieldManager members
  • CurrentUnits replaced by AnalysisResultSchema.CurrentUnits and SpatialFieldManager.SetResultSchema()
  • UpdateSpatialFieldPrimitive(int, Autodesk.Revit.DB.Analysis.FieldDomainPoints, Autodesk.Revit.DB.Analysis.FieldValues)
  • SetUnits(System.Collections.Generic.IList<System.String>, System.Collections.Generic.IList<double>) replaced by AnalysisResultSchema.SetUnits() and SpatialFieldManager.SetResultSchema()
  • GetDescription() replaced by SpatialFieldManager.SetResultSchema() and AnalysisResultSchema.Description
  • SetDescription(System.String) replaced by AnalysisResultSchema.Description and SpatialFieldManager.SetResultSchema()
• AnnotationSymbol.AsFamilyInstance
• Area.Boundary – replaced by GetBoundarySegments(SpatialElementBoundaryOptions)
• Element members
  • ObjectType replaced by GetTypeId() and ChangeTypeId()
  • SimilarObjectTypes replaced by GetValidTypes()
• Materials members
  • AddOther(System.String) replaced by Material.Create
  • AddWood(System.String) replaced by Material.Create
  • AddConcrete(System.String) replaced by Material.Create
  • AddSteel(System.String) replaced by Material.Create
  • AddGeneric(System.String) replaced by Material.Create
• PropertySetElement.Create(Document, MaterialAspect) replaced by PropertySetElement.Create(Document, StructuralAsset) and PropertySetElement.Create(Document, ThermalAsset)
• Mullion.AsFamilyInstance
• Panel.AsFamilyInstance
• Rebar.IsShownInFrontOfGeometryInView[View] – replaced by IsUnobscuredInView() and SetUnobscuredInView()
• PointOnEdge members
  • PointOnEdge(Autodesk.Revit.DB.Reference, double) replaced by PointLocationOnCurve
  • CurveParameter replaced by LocationOnCurve
• Room.Boundary – replaced by GetBoundarySegments(SpatialElementBoundaryOptions)
• Face.MaterialElement – replaced by MaterialElementId
• Reference members
  • Element replaced by Document.GetElement(Reference)
  • GeometryObject replaced by Element.GetGeometryObjectFromReference(Reference)
  • Transform replaced by ReferenceByContext.GetInstanceTransform() after obtaining ReferenceWithContext from Document.FindReferencesWithContextByDirection()
  • ProximityParameter replaced by ReferenceByContext.ProximityParameter after obtaining ReferenceWithContext from Document.FindReferencesWithContextByDirection()
• PipingSystem members
  • FluidType, FluidType is now a property of the system type. Get the system type, and set the parameter RBS_PIPE_FLUID_TYPE_PARAM directly
  • FluidTemperature, FluidTemperature is now a property of the system type. Get the system type, and set the parameter RBS_PIPE_FLUID_TEMPERATURE_PARAM directly
  • FluidDensity, FluidDensity is now a property of the system type. Get the system type, and set the parameter RBS_PIPE_FLUID_DENSITY_PARAM directly
  • FluidViscosity, FluidViscosity is now a property of the system type. Get the system type, and set the parameter RBS_PIPE_FLUID_VISCOSITY_PARAM directly
• Space.Boundary – replaced by GetBoundarySegments(SpatialElementBoundaryOptions)
• Application.LibraryPaths – replaced by GetLibraryPaths() and SetLibraryPaths()
• ControlledApplication.LibraryPaths – replaced by GetLibraryPaths() and SetLibraryPaths()
• Application.NewPointOnEdge(Autodesk.Revit.DB.Reference, double edgeParam) – replaced by other constructor that uses PointLocationOnCurve
• Document members
  • Move() – all overloads – replaced by methods of ElementTransformUtils
  • Rotate() – all overloads – replaced by methods of ElementTransformUtils
  • Mirror() – all overloads – replaced by methods of ElementTransformUtils
  • Array() – all overloads – replaced by methods of LinearArray and RadialArray
  • ArrayWithoutAssociate() – all overloads – replaced by methods of LinearArray and RadialArray
  • SaveAs(System.String, bool) – replaced by SaveAs(String, SaveAsOptions)
  • FindReferencesByDirection() – replaced by FindReferencesWithContextByDirection() and ReferenceIntersector methods
  • ExternalFileReference & ImportFileData – all methods and enums related to material paths
  • AbbreviationItem – empty class removed completely
  • WorksharingCentralFilename – replaced by GetWorksharingCentralModelPath()
• ModelPathUtils.GetRevitServerPrefix() – RSN:// is the prefix string for Revit Server path.

Major Enhancements to the Revit API

Stairs and railings API

Stairs and stairs components

The new classes in the Autodesk.Revit.DB.Architecture namespace:

• Stairs
• StairsType

provide access to new stairs elements in the Revit database. Note that these API classes only provide access to the Stairs created "by component" introduced in this release. Stairs elements created by sketch cannot be accessed as a Stairs object in the API. It is possible to identify both type of stairs using the BuiltInCategory OST_Stairs and the static method Stairs.IsByComponent() can identify an element id represents a by component stairs.

The classes:

• StairsLanding
• StairsLandingType
• StairsRun
• StairsRunType

provide access to the subcomponents and subcomponent types of the new Stairs elements.

Railings and railing components

The new classes in the Autodesk.Revit.DB.Architecture namespace:

• Railing
• RailingType

provide access to the top level railing elements in the Revit database. Railings can be associated to a host, such as a stairs or a floor, or placed in space. Railings can be continuous or non-continuous. If non-continuous, only a limited level of access is provided.

Stairs annotations

The new class

• CutMarkType

provides access to the properties and capabilities of a CutMark annotation which can be associated to stairs.

The new classes

• StairsPath
• StairsPathType

provide access to the stairs path annotation.

View API

View Creation

Plan Views can now be created with the new ViewPlan.Create(document, viewFamilyTypeId, levelId) method.

For example, a ceiling plan can be created as follows:

  Element level = doc.GetElement(
    uidoc.Selection.PickObject(
      ObjectType.Element ) ) as Level;
 
  IEnumerable<ViewFamilyType> viewFamilyTypes
    = from elem in new FilteredElementCollector( doc )
      .OfClass( typeof( ViewFamilyType ) )
        let type = elem as ViewFamilyType
        where type.ViewFamily == ViewFamily.CeilingPlan
        select type;
 
  ViewPlan ceilingPlan = ViewPlan.Create(
    doc, viewFamilyTypes.First().Id, level.Id );
 
  ceilingPlan.Name = "New Ceiling Plan for "
    + level.Name;
 
  ceilingPlan.DetailLevel = ViewDetailLevel.Fine;
 
  // 3D views can be created with 
  // View3D.CreateIsometric and 
  // View3D.CreatePerspective. 
  // The new ViewOrientation3D object is used to 
  // get or set the orientation of 3D views.
 
  View3D view = View3D.CreateIsometric(
    doc, viewFamily3d );
 
  XYZ eyePosition = new XYZ( 10, 10, 10 );
  XYZ upDirection = new XYZ( -1, 0, 1 );
  XYZ forwardDirection = new XYZ( 1, 0, 1 );
  view.SetOrientation( new ViewOrientation3D(
    eyePosition, upDirection, forwardDirection ) );

• The ViewSection class now has methods that support the creation of Callout, Reference Callout, and Reference Section views.
• Rendering views containing images imported from disk can be created using the new ImageView class and the ImageView.Create method.

DisplayStyle

The enum DisplayStyle (with values including Wireframe, HLR, and Shading) has been added so the API can be used to get/set the new DisplayStyle property.

ViewDetailLevel

The enum ViewDetailLevel (with values Coarse, Medium, and Fine) has been added with get/set access to the new DetailLevel property.

ViewRange

The view range for plan views can now be retrieved via ViewPlan.GetViewRange().

3D View Locking

• 3D Views can now be locked and unlocked via the API with the methods SaveOrientationAndLock, RestoreOrientationAndLock, and Unlock.
• The property IsLocked indicates if a view is currently locked.
• NewTag can now be used in locked 3D Views.

View.Duplicate

Views can now be duplicated via the API with the View.Duplicate(ViewDuplicateOption) method.

UIView class and UIDocument.GetOpenUIViews()

The UIView class has been added to represent a view window in the Revit user interface. GetOpenUIViews provides a list of all open views. UIView.GetWindowRectangle() returns a rectangle that describes the size and placement of the UIView window.

Pan and Zoom

The method

• UIView.ZoomAndCenterRectangle()

offers the ability to zoom and pan the active view to center on the input region of the model.

The method

• UIView.GetZoomCorners()

returns the two points that define the corners of the view's rectangle in model coordinates.

PlanViewDirection

The enum PlanViewDirection has been added so API can be used to get/set the view direction to either Up or Down for StructuralPlan views.

ViewFamilyType class and ViewFamily enum

The ViewFamilyType class has been created to correspond to the Types seen in the UI's Properties dialog for each view. The ViewFamily enum (FloorPlan, Section, Legend, etc) specifies the family of the ViewFamilyType.

Temporary view modes

View.EnableRevealHiddenMode, View.EnableTemporaryAnalyticalDisplayMode, View.DisableTemporaryViewMode, and the TemporaryViewMode Enumeration have been added to allow control of temporary view modes.

Schedules

Schedule API

Several new classses have been added to allow schedule views to be created, modified, and added to drawing sheets. Major new classes include:

• The ViewSchedule class that represents the schedule view. Its create methods are used to create new schedules.
• The ScheduleField class for the inidivual fields in a schedule
• The ScheduleSheetInstance class represents schedules placed on sheets. The create method creates an instance of a schedule on a sheet.
• The ScheduleDefinition class defines the contents of a schedule view, including:
  1. Basic properties that determine the kind of schedule, such as the schedule's category.
  2. A set of fields that become the columns of the schedule.
  3. Filters that restrict the set of elements visible in the schedule.
  4. Sorting and grouping criteria.

Running API commands in Schedule Views

API commands may now be active when a Schedule is active in the current document.

Schedule export

The ViewSchedule class has been added to the API and the method ViewSchedule.Export method exports an existing schedule to a text file.

Discipline controls

The properties:

• Application.IsArchitectureEnabled
• Application.IsStructureEnabled
• Application.IsStructuralAnalysisEnabled
• Application.IsMassingEnabled
• Application.IsEnergyAnalysisEnabled
• Application.IsSystemsEnabled
• Application.IsMechanicalEnabled
• Application.IsMechanicalAnalysisEnabled
• Application.IsElectricalEnabled
• Application.IsElectricalAnalysisEnabled
• Application.IsPipingEnabled
• Application.IsPipingAnalysisEnabled

provide read and modify access to the available disciplines. Your application can read the properties to determine when to enable or disable aspects of the UI.

Enabling and disabling disciplines is available only in Autodesk Revit (and not in any other Revit product). When a discipline's status is toggled, Revit's UI will be adjusted, and certain operations and features will be enabled or disabled as appropriate.

Rendering Options

The settings shown in the Rendering Options Dialog are exposed, allowing an API user can get and set Rendering Options for a 3d view.

The new methods:

• View3D.GetRenderingSettings
• View3D.SetRenderingSettings

gets or changes the rendering settings for the 3d view.

The class

• RenderingSettings

offers properties and methods which correspond to the options in the UI dialog:

• RenderingSettings.UsesRegionRendering – Boolean value that indicates whether to use region rendering.
• RenderingSettings.BackgroundStyle – The enum value that controls the background style for rendering.
• RenderingSettings.ResolutionTarget – The resolution target.
• RenderingSettings.PrinterResolution – The resolution level when using printer.
• RenderingSettings.LightingSource – The lighting scheme type.
• RenderingSettings.ResolutionValue – The rendering resolution in dots per inch (DPI).
• RenderingSettings.GetBackgroundSettings() – Returns an object that represents the rendering background settings.
• RenderingSettings.SetBackgroundSettings() – Changes the rendering background settings details for the current background style.
• RenderingSettings.GetRenderingImageExposureSettings() – Returns an object that represents the rendering image exposure settings.
• RenderingSettings.SetRenderingImageExposureSettings() – Changes the rendering image exposure settings.
• RenderingSettings.GetRenderingQualitySettings() – Returns an object that represents the rendering quality settings.
• RenderingSettings.SetRenderingQualitySettings() – Changes rendering quality settings.
• RenderingSettings.GetRenderingRegionOutline() – Returns the outline of the rendering region.

The rendering properties are exposed with the following supplementary classes and enums:

• enum BackgroundImageFit – Represents the type of background image fit.
• enum ResolutionTarget – Represents the resolution target (Screen or Printer) used for rendering.
• enum PrinterResolution – Controls the resolution level for a printer target.
• enum LightingSource – Represents the lighting scheme type.
• enum RenderingQuality – Represents the rendering quality.
• enum BackgroundStyle- Represents the background style.
• class SkyBackgroundSettings – Represents the rendering sky background settings.
• class ColorBackgroundSettings – Represents the rendering color background settings.
• class ImageBackgroundSettings – Represents the rendering image background settings.
• class RenderingImageExposureSettings – Represents the exposure settings of rendering.

Example: checking rendering options for a 3D view:

  RenderingSettings renderingSettings
    = view3D.GetRenderingSettings();
 
  Transaction newTran = new Transaction(
    doc, "Change Rendering Settings" );
 
  newTran.Start();
 
  renderingSettings.BackgroundStyle
    = BackgroundStyle.Image;
 
  view3D.SetRenderingSettings( renderingSettings );
 
  newTran.Commit();

Construction Modeling

Linked element parents for parts

Parts can be created from linked elements. There are new overloads:

• PartUtils.CreateParts()
• PartUtils.IsValidForCreateParts()
• PartUtils.HasAssociatedParts()
• PartUtils.GetAssociatedParts()
• PartUtils.GetAssociatedPartMaker()

which accept LinkElementIds (representing the id of the element in the link). The existing Part utilities accepting ElementId have not been changed.

Merged parts

The methods:

• PartUtils.ArePartsValidForMerge()
• PartUtils.CreateMergedPart()
• PartUtils.FindMergeableClusters()
• PartUtils.GetChainLengthToOriginal()
• PartUtils.GetMergedParts()
• PartUtils.IsMergedPart()

provide support for merging of parts.

Excluded parts

The new property

• Part.Excluded

allows identification and assignment of parts to be excluded.

Part category

The new members:

• Part.OriginalCategoryId
• Part.GetSourceElementOriginalCategoryIds()

provide the ability to get and set the original category id for a given part.

Part division

Part divisions can now be assigned custom geometry divisions. The members:

• PartMakerMethodToDivideVolumes.ProfileMatch
• PartMakerMethodToDivideVolumes.DivisionGap
• PartMakerMethodToDivideVolumes.ProfileOffset
• PartMakerMethodToDivideVolumes.SplitterProfileType
• PartMakerMethodToDivideVolumes.ProfileFlipAcross
• PartMakerMethodToDivideVolumes.ProfileFlipAlong
• PartMakerMethodToDivideVolumes.GetSketchCurves()
• PartMakerMethodToDivideVolumes.GetPlaneOfSketch()
• PartMakerMethodToDivideVolumes.GetSplitRefsOffsets()
• PartMakerMethodToDivideVolumes.CanBeDivisionProfile()

offer the ability to examine and control properties of the divisions.

Assembly views

The method

• AssemblyViewUtils.AcquireAssemblyViews()

transfers the assembly views owned by a source assembly instance to a target sibling assembly instance of the same assembly type.

Assembly instance transform and location

The methods

• AssemblyInstance.GetTransform()
• AssemblyInstance.SetTransform()

provide read and write access to the transformation origin of the assembly. Changing this value causes the origin point to change relative to the assembly members (and does not move the assembly members). All assemblies of the same type should have changed their transforms by the same amount. For example, if you changed the transform of the assembly by a rotation of 90 degrees, then other assemblies should also have rotated their transform by 90 degrees.

The inherited property

• AssemblyInstance.Location

also has been modified to return a the location for an AssemblyInstance.

Structure improvements

New Rebar members

• RebarShapeMatchesCurvesAndHooks() checks if rebarShape matches curves and hooks.
• CreateFromCurvesAndShape() creates a new instance of a Rebar element with default shape parameters from the RebarShape
• GetBarPositionTransform()
• GetBarExistsAtPosition()
• GetHookTypeId() and SetHookTypeId()
• ScheduleMark property
• TotalLength property
• Volume property

ReinforcementSettings

The new class ReinforcementSettings controls project settings that are accessible from the Reinforcement Settings dialog in the Revit UI. For 2013 the only supported setting is the HostStructuralRebar property, which is new for 2013 and affects the AreaReinforcement and PathReinforcement elements.

AreaReinforcement/PathReinforcement

AreaReinforcement and PathReinforcement now have types.

The types – AreaReinforcementType and PathReinforcementType – contain only identity data.

There is no change to the interface for creating Area and Path Reinforcement elements. A default, or most-recently-used type, is automatically assigned on element creation.

New Area- and PathReinforcementTypes can be created using the following methods:

• (static) AreaReinforcementType AreaReinforcementType.Create(Document ADoc, AString Name)
• (static) PathReinforcementType PathReinforcementType.Create(Document ADoc, AString Name)

Analytical model

The new element type

• AnalyticalLink

can be created between two other Analytical Elements, e.g. an analytical beam and analytical column. There are two kinds of Links: user defined and automatically generated. Links have properties like "fixity state" that can be accessed via the API.

MEP improvements

Routing Preferences

Revit MEP now supports a system for selecting preferred pipe and duct sizes, materials, and fitting types for use in an MEP project. The routing preferences API can be used to set routing preference policies for end users as well as to query which fittings and segments will be used given size criteria.

• property MEPCurveType.RoutingPreferenceManager – accesses the main routing preferences object for a give MEPCurve Type. Currently, PipeType and DuctType are the only MEPCurve types that support Routing Preferences.
• class RoutingPreferenceManager – manages all routing preference rules for segments and fittings and allows the user to query which fitting or segment will be chosen by Revit, given a size condition.
• classes RoutingCriterionBase and PrimarySizeCriterion – These classes manage criteria for selecting fittings and segments based on minimum and maximum size constraints.
• class RoutingPreferenceRule – Manages one segment or fitting preference
• classes RoutingCondition and RoutingConditions – Inputs to RoutingPreferenceManager.GetMEPPartId() to select fittings and segments based on their selection criteria.
• class Segment – A class representing a length of MEPCurve that contains a material and set available sizes.
• class PipeSegment – a subclass of Segment representing a length of pipe
  • PipeSegment.Create(ElementId materialId, ElementId scheduleId) – Creates a new PipeSegment of given material, schedule, and size list.
• enum RoutingPreferenceRuleGroupType – Each routing preference rule is grouped according to what type of routing item it manages
  • Elbows
  • Junctions
  • Crosses
  • Transitions
  • Unions
  • MechanicalJoints
  • Segments
  • TransitionsRectangularToRound
  • TransitionsRectangularToOval
  • TransitionsOvalToRound

MEP Sections

The new class

• MEPSection

is the base class for duct and pipe section. It is a series of connected elements (segments – ducts or pipes, fittings, terminals and accessories). All section members should have same flow analysis properties: Flow, Size, Velocity, Friction and Roughness. One section member element which contains more than one connector can belongs to multiple section.

For example: One Tee fitting that has 3 connectors usually belongs to 3 sections. One segment that connects to a tap will be divided into 2 sections

FluidType and FluidTemperature

The new class

• FluidTemperature

represents the viscosity and density properties as defined at a certain temperature.

The class

• FluidType

has been extended to provide read and write access to a collection of FluidTemperature objects which represent the fluid's properties at various temperatures.

Panel schedule – spare values

The new functions

• PanelScheduleView.GetSpareLoadValue()
• PanelScheduleView.SetSpareLoadValue()
• PanelScheduleView.GetSpareCurrentValue()
• PanelScheduleViwe.SetSpareCurrentValue()

provide access to the parameter values of spare circuits.

LabelUtils

New overloads of

• LabelUtils.GetLabelFor()

have been added to supply the user-visible string matching members of the enums DuctLossMethodType, PipeLossMethodType, and PipeFlowState.

Physical Properties

Thermal properties

Thermal properties of various elements have been enhanced in Revit 2013.

• Class ThermalProperties
  • Absorptance
  • HeatTransferCoefficient
  • Roughness
  • ThermalMass
  • ThermalResistance

This class is a property on the following types:

• ThermalProperties WallType.ThermalProperties
• ThermalProperties FloorType.ThermalProperties
• ThermalProperties CeilingType.ThermalProperties
• ThermalProperties RoofType.ThermalProperties
• ThermalProperties BuildingPadType.ThermalProperties
• Class FamilyThermalProperties
  • AnalyticConstructionTypeId – This value corresponds to the 'id' property of a constructionType node in Constructions.xml, a supplied data library of thermal properties of common construction types.
  • HeatTransferCoefficient
  • SolarHeatGainCoefficient
  • ThermalResistance
  • VisualLightTransmittance
  • Find() – returns a FamilyThermalProperties object from an "id" string in Constructions.xml
• FamilySymbol.GetThermalProperties() – Gets the thermal properties of a family symbol of a door, window, or curtain panel.
• FamilySymbol.SetThermalProperties()-- Sets the thermal properties of a family symbol of a door, window, or curtain panel.

This class is a property on Door, Window, and Curtain Panel family symbols

• FamilyThermalProperties FamilySymbol.ThermalProperties

Structural properties

Beam, Column, and Foundation family instances now support an ElementId of an additional structural Material element

• ElementId FamilyInstance.StructuralMaterialId (Foundation, Beam, and Column instances)

All compound structurals can now elect one layer in the structural to be used as the "structural" layer.

• int CompoundStructure.StructuralMaterialIndex
• PropertySetElement now supports a StructuralAsset property via the GetStructuralAsset and SetStructuralAsset methods.

StructuralAsset contains named properties for various structural values, such as PoissonModulus and YoungModulus, that offer enhanced ease of use over the previous parameter-API based access to these same values.

Material assets

• StructuralAsset – contains structural properties that can be set on materials via PropertySetElement and SetMaterialAspectByPropertySet()
• ThermalAsset – contains thermal properties that can be set on materials via PropertySetElement and SetMaterialAspectByPropertySet()
• PropertySetElement.Create() – now takes a StructuralAsset or ThermalAsset as a parameter instead of a MaterialAspect.

GBXML Export

Thermal properties of building construction element types can now be set to use calculated values or pre-defined values from Constructions.xml with:

• MEPBuildingConstruction.GetBuildingConstructionOverride
• MEPBuildingConstruction.SetBuildingConstructionOverride

EnergyDataSettings.IncludeThermalProperties indicates if thermal information from model assemblies and components is included in GreenBuildingXML export of the detailed model.

User interface API improvements

Contextual help support

Items placed on the Ribbon can now be assigned an action for contextual help using

• RibbonItem.SetContextualHelp()

The options supported include linking to an external URL, launching a locally installed help file, or linking to a topic on the Autodesk help wiki.

You can also invoke the same set of contextual help options at any arbitrary time within your add-in by creating a ContextualHelp object with the appropriate target location, and invoking

• ContextualHelp.Launch()

Support for Keyboard Shortcuts and Quick Access Toolbar

API commands may now be assigned keyboard shortcuts, and those assignments will be preserved even if add-ins are added, removed or changed in subsequent sessions.

API commands may also be moved to the Quick Access Toolbar, and that assignment will also be preserved even if add-ins are added, removed or changed in subsequent sessions.

Replace implementation of commands

It provides ability to replace the existing Revit command (located in any tab, application menu and right-click menus) implementation with add-in routine.

• RevitCommandId

The new class RevitCommandId provides ability to look up and retrieve an object representing Revit Command id given an id string. The id string of the command is the string which appears in the journal when the command is clicked, e.g. "ID_APP_EXIT".

• AddInCommandBinding

The new class AddInCommandBinding provides ability to override the Revit command implementation with Executed and CanExecute events.

• UIApplication.CreateAddInCommandBinding()
• UIControlledApplication.CreateAddInCommandBinding()

These two new methods provide the ability to create a command binding with a given Revit command id.

Preview control

The new class

• PreviewControl

provides the ability to embed an interactive Revit view as a WPF control inside a dialog.

Options dialog customization

Subscribe to the new event

• UIApplication.DisplayingOptionsDialog

to be notified when Revit is preparing the Options dialog for display. During the event callback, your application can call

• DisplayingOptionsDialogEventArgs.AddTab()

to add a new tab to the dialog. The contents of the panel shown when this new tab is selected are determined by the members assigned to the input class:

• TabbedDialogExtension

Drag & Drop support

The new methods

• UIApplication.DoDragDrop(ICollection<String>)
• UIApplication.DoDragDrop(Object, IDropHandler)

initiate a drag and drop operation on the Revit user interface.

The first method accepts a list of file names, which can be Revit files, import CAD and images, or some combination of the two. The second method accepts arbitrary data, and provides an IDropHandler callback to handle the drop of the data when the user completes it.

Translation API enhancements

Several updates have been made to the APIs related to data exchange and translation of models.

DGN import

The new method

• Document.Import(string, DGNImportOptions, View)

supports import of DGN files into Revit views.

DXF import

The method

• Document.Import(string, DWGImportOptions)

now also supports DXF files for import.

DWG and DXF export settings changes

The options supported for DWG and DXF export have been expanded. A new base class

• BaseExportOptions

supports all properties shared by DWG/DXF & DGN export tasks. New properties include:

• BaseExportOptions.HideScopeBox
• BaseExportOptions.HideReferencePlane
• BaseExportOptions.HideUnreferenceViewTag

DGN export

The options supported for DGN export have changed to match the new implementation of DGN export based on DWG supporting DGN V8. The previously existing class

• DGNExportOptions

thus offers many new properties inherited from the same base classes as DWGExportOptions.

The property

• DGNExportOptions.TemplateFile

has been replaced with:

• DGNExportOptions.SeedName

FBX Export

Three new options have been added:

• FBXExportOptions.UseLevelsOfDetail – true to use levels of detail, false otherwise
• FBXExportOptions.LevelsOfDetailValue – the value of the levels of detail
• FBXExportOptions.WithoutBoundaryEdges – true to export without boundary edges, false otherwise

DividedPath

A DividedPath is an element supported in the massing environment that consists of a set of points distributed along a connected set of curves and edges. The points can be the result of a uniform distribution along the curves. The type of the distribution is determined by a selected 'layout'. The distance between the layout points depends on the curves, the layout, and layout specific settings. In addition, points can also be the result of intersecting the curves with other elements.

The class

• DividedPath

exposes the interface for this element type. It permits creation of a new DividedPath from input curves and edges, as well as optionally, intersecting elements. It allows control over the layout type and parameters, as well as other miscellaneous settings.

Analysis Visualization Framework

The following additions have been made to support deformed shapes in analysis visualization display:

• AnalysisDisplayStyleDeformedShapeTextLabelType class
• AnalysisDisplayDeformedShapeSettings class

A new override to CreateAnalysisDisplayStyle accepts an input argument of AnalysisDisplayDeformedShapeSettings

Revit Link creation

The API now contains two creation methods for Revit links.

• RevitLinkType.Create(Document, ModelPath, RevitLinkOptions) will create a new Revit link type and load the associated linked file into the document. This returns a RevitLinkLoadResult, which stores the ElementId of the newly-created RevitLinkType and contains any errors which occurred when trying to load the linked file (The RevitLinkLoadResultType enumeration contains the full list.)
• RevitLinkInstance.Create(Document, ElementId) will create a new instance of an already-loaded RevitLinkType.

FilledRegion

The class

• FilledRegion

has been extended to offer the ability to create Filled regions, to get the boundaries of the region, and to apply a linestyle to all boundary segments.

The class

• FilledRegionType

has been added providing access to the visible properties of a filled region type.

Light API

The classes

• LightType
• LightFamily

have been added to offer the ability to get and set photometric data and all other lighting parameters from both family instances in project documents and all family types in family documents. The LightType and LightFamily classes expose the same data except for light shape and distribution types which are only available from the LightFamily class.

Some examples of lighting parameters exposed are;

• Initial color
• Initial intensity
• Loss factor
• Color filter
• Dimming color

Light Group API

The classes

• LightGroupManager
• LightGroup

have been added to offer the ability to manage light groups to allow control over which lights are used when rendering the scene.

The LightGroupManager class gives the user the ability to

• Create a new light group
• Delete an existing light group
• Turn on or off all the lights in a light group
• Turn on or off individual lights
• Set the dimmer value for individual lights

The LightGroup class gives the user the ability to

• Get the name of a light group
• Rename light group
• Add a light to a light group
• Remove a light from a light group

Light groups are used in rendering options to turn lights on or off when rendering.

ReferenceIntersector

The new class ReferenceIntersector allows ray-cast selection of elements, given a point and direction, similar to FindReferencesWithContextByDirection(), but with support for filtering the output based on element or reference type.

The enum FindReferenceTarget is used with ReferenceIntersector to filter selection of elements, meshes, edges, curves, and faces.

Key members of ReferenceIntersector

• ReferenceIntersector(ElementId targetElementId, FindReferenceTarget targetType, View3d view3d) – constructor specifying a single element to search for in the intersection test.
• ReferenceIntersector(ElementIdSet targetElementIds, FindReferenceTarget targetType, View3d view3d) – constructor specifying a set of ElementIds to search for in the intersection test.
• ReferenceIntersector(ElementFilter filter, FindReferenceTarget targetType, View3d view3d) – constructor specifying an ElementFilter for the intersection test.
• Find(XYZ origin, XYZ direction) – Finds all references intersecting the origin-direction ray given the selection criteria set up in the ReferenceIntersector constructor
• FindNearest (XYZ origin, XYZ direction) – Finds the reference closest to the origin in the origin-direction ray given the selection criteria set up in the ReferenceIntersector constructor

Small Enhancements & API Interface Changes

Elements & filtering

Element.PhaseCreated and Element.PhaseDemolished

These readonly properties have been obsoleted and replaced with read/write properties:

• Element.CreatedPhaseId
• Element.DemolishedPhaseId

The new method Element.AllowsPhases() indicates whether these phase id properties can be modified for any given element.

Phase filter

The new class

• PhaseFilter

and related types support read/write and create access to phase filters.

SelectionFilterElement

The new class

• SelectionFilterElement

provides access to a filter type which contains a selected set of element ids, rather than criteria based on parameters.

Ceiling, Floor and CeilingAndFloor

The newly exposed Ceiling class represents a ceiling in Revit. It inherits from CeilingAndFloor. The Floor class has been modified to also inherit from CeilingAndFloor.

Geometry & sketching

Split volumes

The new method:

• SolidUtils.SplitVolumes()

takes a solid which includes multiple disjoint enclosed volumes, and returns newly allocated Solids representing each volume. If no splitting was necessary, a copy of the input Solid is returned.

Solid tessellation

The new method:

• SolidUtils.TessellateSolidOrShell()

generates a single triangulated structure for the given input Solid (which could one or more fully closed volumes, or a shell of faces which do not form a closed volume). The function returns:

• TriangulatedSolidOrShell

which allows access to the stored triangulated components and triangles.

Use the method:

• FacetingUtils.ConvertTrianglesToQuads()

with a TriangulationInterface object constructed from the TessellateSolidOrShell results to convert pairs of adjacent, coplanar triangles into quadrilaterals.

Face.Triangulate()

A new overload to Face.Triangulate() accepts a level of detail as an argument. Levels of detail close to 0 (the minimum) will result in coarser triangulations than levels of detail close to 1 (the maximum).

Ellipse – axes

The new properties:

• Ellipse.XDirection
• Ellipse.YDirection

provide the unit vectors of the ellipse for the X and Y directions.

GeometryElement.GetBoundingBox()

This new method provides read access to the bounding box of a given geometry element.

ItemFactoryBase.NewAlignment()

This method can now align a line and a reference plane as well as all other geometry types from previous versions.

CylindricalHelix curve type

A new subclass of Curve has been introduced: CylindricalHelix. The class offers methods useful for reading and creating such curves.

In this release, CylindricalHelix curves are used only in specific applications in stairs and railings, and should not be used or encountered when accessing curves of other Revit elements and geometry.

CurveLoop as IEnumerable<Curve>

The members of a CurveLoop can now be traversed, as CurveLoop implements IEnumerable<Curve>.

CurveElement – center point reference

The new property:

• CurveElement.CenterPointReference

returns a reference to the center of a curve if that curve is one that has a center (e.g. arcs, circles, elliptical arcs or ellipses). This reference can be used for dimensioning to the center point.

ModelCurve.ChangeToReferenceLine

ModelCurve.ChangeToReferenceLine is now supported in all family types, not just conceptual modeling.

NewSketchPlane(Document, Reference)

This new overload for NewSketchPlane in the ItemFactoryBase class supports creation of a sketch plane directly from a Reference representing a planar face.

Detailing & Annotations

MultiSegmentGrid class

This class has been added to the API to support multi-segment grids.

Grid geometry

Element.Geometry now supports Grids and MultiSegmentGrids, including the ability to see gaps and extents applied to the grid lines to form different segments.

Diameter dimensions

Revit now supports Diameter dimensions. The DimensionShape enumeration contains a new Diameter member. And there is a new creation method for diameter dimensions:

• FamilyItemFactory.NewDiameterDimension()

DimensionSegment overrides

There are several new properties on DimensionSegment to override text properties.

• DimensionSegment.Prefix
• DimensionSegment.Suffix
• DimensionSegment.Above
• DimensionSegment.Below
• DimensionSegment.ValueOverride

These properties are also available on Dimension, for use with dimensions with just one segment.

Detail element draw order

The class

• DetailElementOrderUtils

has been added providing the ability to affect the draw order of detail elements (including FilledRegions)

Families & content

SpatialElementCalculationPoint

This class provides access to the "Room or Space Calculation Point" seen in families. The Spatial Element Calculation Point is graphically showed as a location point marker with a "snake" line from the origin of the family. If the Spatial Element Calculation Point is turned on, this point will be used as a search point for room and space relations for all instances of this family. The API offer creation, read and modification options for this object type.

RPC content assets

The AssetType enum now contains a value "Content", which can be used to enumerate the loaded RPC content assets in the Revit session.

NewFamilyInstance validation

Some validation has been added to overloads of NewFamilyInstance(). This validation is intended to prevent use of the incorrect overload for a given family symbol input. For specific details on the exceptional conditions which will be validated, consult the documentation.

Family.PlacementType

This new property provides information about the placement type for instances of the given family. PlacementType roughly maps to the overloads of NewFamilyInstance.

DataStorage element

The new DataStorage class represents an element that API applications can create logically organize different sets of ExtensibleStorage entities into separate elements. This allows an application to update one set of data in a local workshared project without locking other elements.

ApplicationInitialized event

The ControlledApplication object now supports an ApplicationInitialized event, which is called once the Revit application is fully initialized, after all external applications have been started and when the application is ready to work with documents.

ProgressChanged application event and ProgressChangedEventArgs

The application object now supports a ProgressChanged event and ProgressChangedEventsArgs object that returns progress bar data from time-consuming transactions.

• ProgressChangedEventArgs
  • Caption – The name of the current transaction or subtransaction in progress
  • Stage – The type of progress event (Started, RangeChanged, PositionChanged, CaptionChanged, UserCancelled, Finished)
  • Position – The numerical index between zero and UpperRange showing the number of completed steps of the current transaction or subtransaction
  • UpperRange – The total number of steps in the current transaction or subtransaction
  • Cancel – Cancels the current transaction in progress, if possible.
  • Cancellable – indicates if the current transaction can be cancelled.

SiteLocation – PlaceName

The new property:

• SiteLocation.PlaceName

provides the place name of the site location.

Application.DefaultProjectTemplate

Provides the full path to the default template file for new project documents

UnitType, DisplayUnit and FamilyParameter updates

Many new units have been added to UnitType, DisplayUnitType and ParameterType.

One UnitType was renamed: UT_TemperalExp was renamed to UT_ThermalExpansion.

The corresponding ParameterType value (TemperalExp) was also renamed to ThermalExpansion.

BasePoint and BASEPOINT_ANGLETON_PARAM "True North" Parameter

The parameter to return the "True North" angle parameter "BASEPOINT_ANGLETON_PARAM" on the BasePoint object is now a double instead of a string.

Journaling of Add-in user interface

Revit now activates a tool to collect and journal certain actions which take place in the user interface provided by an add-in. The tool supports actions in both WPF and Windows Forms dialogs.

Some actions and some components may not be fully recorded.

This capability is useful to Autodesk in the event that a journal can be supplied from a Revit user indicating the presence of a software problem. Replay of add-in UI via journals is not supported.

---

End of document

---

That completes the list of news in the Revit 2013 API from last year, A.D. 2012, bringing us up to date with the current release.

As said, I look up information in these sections regularly, and still discover topics that I was previously not aware of, frequently leading me to research new Revit API classes and methods.

Since this documentation was not previously available to online Internet searches, it required the extra effort of opening the individual help files and searching it release by release on the off chance of finding something hitherto unknown and useful for the task at hand.

I hope making this information available online proves as helpful to you as it will to me!

ADN Revit API Training Material Update and Vacation

After cleaning up the usage of deprecated Revit API calls in The Building Coder samples, I decided to clean up the ADN training material as well.

My original plan was to remove all warnings about deprecated API usage, only I quickly discovered there were none to remove :-)

In the MEP sample application AdnRme, I just updated the year listed in the copyright message to 2013 and produced AdnRme version 2013.0.2.0.

I then did the same for the ADN Revit API Training labs and the Revit Structure API samples.

Here is the result of that, adn_src_2013-02-15.zip, containing the following solutions and projects:

• lab
  • 1_Revit_API_Intro
  • 2_Revit_UI_API
  • 3_Revit_Family_API
  • XtraCs
  • XtraVb
• rme
  • AdnRme
• rst
  • labs
  • link
  • NewRstLab
  • RstAvfDmu

Vacation Time

This is the last post before my vacation. Well, actually, this is already during my vacation.

I am hopping on a train in a minute and departing for Italy with unknown itinerary and goals. A possible candidate is Lecce, in the far south.

I'll be back in two and a half week's time, and keep you posted, maybe.

Bye!

Retrieving Schedules on a Sheet

Guy Robinson recently explained an easy way to access all elements in a schedule.

Victor Chekalin picked up and expanded on that.

Here is his solution to retrieve all schedules in a view and elements from a schedule. In his own words:

One wonderful day I had to retrieve schedules which are presented on a sheet:

At first I looked at the Revit API Help but unfortunately there is no method such as GetSchdulesOnView in the ViewSheet class. There is no explicit way to get it. After a couple of hours trying to achieve that I need I encountered Guy's simple solution to access all elements in a schedule. The solution is use FilteredElementCollector and pass in the element id of the view in which you want to collect elements.

I created the following simple extension method GetSchedules to get schedules on view:

  public static class ViewSheetExtensions
  {
    public static IEnumerable<ViewSchedule>
      GetSchedules( this ViewSheet viewSheet )   
    {
      var doc = viewSheet.Document;
 
      FilteredElementCollector collector =
        new FilteredElementCollector(
          doc, viewSheet.Id );
 
      var scheduleSheetInstances =
        collector
          .OfClass( typeof( ScheduleSheetInstance ) )
          .ToElements()
          .OfType<ScheduleSheetInstance>();
 
      foreach( var scheduleSheetInstance in
        scheduleSheetInstances )
      {
        var scheduleId =
          scheduleSheetInstance
            .ScheduleId;
 
        if( scheduleId == ElementId.InvalidElementId )
          continue;
 
        var viewSchedule =
          doc.GetElement( scheduleId )
          as ViewSchedule;
 
        if( viewSchedule != null )
          yield return viewSchedule;
      }
    }
  }

It can be used like this:

  var schedules = viewSheet
    .GetSchedules()
    .ToList();

  foreach( var viewSchedule in schedules )
  {
    // Do something
  }

Here is the demo result:

But I decided not to stop and go deeper. The next step is to get all elements which are involved in a schedule. The approach is the same as with schedules. Using FiltereredElementCollector but instead of the ViewSheet element id we pass in the ViewSchedule id.

The extension method is similar:

  public static class ViewScheduleExtensions
  {
    public static IEnumerable<ElementId>
      GetElementIdsInSchedule(
        this ViewSchedule viewSchedule )
    {
      var doc = viewSchedule.Document;
 
      FilteredElementCollector collector =
        new FilteredElementCollector(
          doc, viewSchedule.Id );
 
      var elementIds = collector
        .WhereElementIsNotElementType()
        .ToElementIds();
 
      return elementIds;
    }
  }

But there is an additional little nuance. If I retrieve elements from a material takeoff schedule, the method will return all materials in the project together with other elements. The solution is to just skip all elements which are materials:

  foreach( var id in elementIds )
  {
    var element = doc.GetElement( id );
 
    if( element is Material )
      continue;
 
    // Do something
  }

Here is the result of my demo project:

I attached the demo Visual Studio solution and Revit project.

I hope this information will useful for developers.

Have a nice day,
Victor.

Eliminating Compiler Warnings and Deprecated Calls

I am revisiting this topic again, which we last looked at a year ago, to clean up our usage of deprecated methods in the Revit 2012 API.

In that discussion, I also pointed back to previous versions and other related issues.

Here are the warnings about obsolete usage currently produced when compiling The Building Coder samples version 2013.0.100.1 against the Revit 2013 API – copy to a text editor or view source to see the truncated lines in full:

C:\bc\BuildingCoder\BuildingCoder\CmdTransformedCoords.cs(67,41): warning CS0618: 'Autodesk.Revit.DB.GeometryElement.Objects' is obsolete: 'This property will be obsolete from 2013; Call GetEnumerator() instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdNestedInstanceGeo.cs(119,32): warning CS0618: 'Autodesk.Revit.DB.GeometryElement.Objects' is obsolete: 'This property will be obsolete from 2013; Call GetEnumerator() instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdLinkedFiles.cs(103,41): warning CS0618: 'Autodesk.Revit.DB.GeometryElement.Objects' is obsolete: 'This property will be obsolete from 2013; Call GetEnumerator() instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdSetTagType.cs(171,19): warning CS0618: 'Autodesk.Revit.Creation.Document.NewWall(Autodesk.Revit.DB.Curve, Autodesk.Revit.DB.Level, bool)' is obsolete: 'This method is obsolete in Revit 2013. Please call a static creation method of Wall class instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdCreateGableWall.cs(89,19): warning CS0618: 'Autodesk.Revit.Creation.Document.NewWall(Autodesk.Revit.DB.CurveArray, Autodesk.Revit.DB.WallType, Autodesk.Revit.DB.Level, bool, Autodesk.Revit.DB.XYZ)' is obsolete: 'This method is obsolete in Revit 2013. Please call a static creation method of Wall class instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdPlanTopology.cs(103,26): warning CS0618: 'Autodesk.Revit.DB.PlanTopology.Rooms' is obsolete: 'This property is obsolete in Revit 2013.  Call GetRoomIds() instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdPressKeys.cs(222,19): warning CS0618: 'Autodesk.Revit.Creation.Document.NewWall(Autodesk.Revit.DB.Curve, Autodesk.Revit.DB.WallType, Autodesk.Revit.DB.Level, double, double, bool, bool)' is obsolete: 'This method is obsolete in Revit 2013. Please call a static creation method of Wall class instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdSlopedWall.cs(65,19): warning CS0618: 'Autodesk.Revit.Creation.Document.NewWall(Autodesk.Revit.DB.CurveArray, bool)' is obsolete: 'This method is obsolete in Revit 2013. Please call a static creation method of Wall class instead.'
C:\bc\BuildingCoder\BuildingCoder\CmdSlopedWall.cs(140,19): warning CS0618: 'Autodesk.Revit.Creation.Document.NewWall(Autodesk.Revit.DB.CurveArray, Autodesk.Revit.DB.WallType, Autodesk.Revit.DB.Level, bool, Autodesk.Revit.DB.XYZ)' is obsolete: 'This method is obsolete in Revit 2013. Please call a static creation method of Wall class instead.'

Compile complete -- 0 errors, 9 warnings

Basically, there are just three different warnings:

• The GeometryElement.Objects property is obsolete; GeometryElement itself is now enumerable, so you can iterate directly over the instance instead of querying its obsolete property.
• The creation document NewWall method is obsolete, and replaced by static creation methods on the Wall class.
• The PlanTopology.Rooms property is obsolete, and can be replaced using the GetRoomIds method.

Let's tackle those right here and now to future-proof this guy.

Enumerable GeometryElement

The first one is caused by accessing the GeometryElement.Objects property like this:

  GeometryObjectArray objects = geoElem.Objects;
 
  n = objects.Size;
 
  // . . .
 
  foreach( GeometryObject obj in objects )

The GeometryElement is now itself iterable, so the foreach loop can be implemented on geoElem itself directly, eliminating the need for the intermediate objects variable.

The number of geometry objects is only used in an informational message and can be determine through the generic templated LINQ Count method:

  n = geoElem.Count<GeometryObject>();
 
  // . . .
 
  foreach( GeometryObject obj in geoElem )

The next two warnings are eliminated in the same way.

Static Creation Methods on Wall Class

We then get to the call using the creation document NewWall method:

  Wall wall = createDoc.NewWall(
    line, levelBottom, false );

This is simply replaced by a call to the new Wall class static Create method taking the same arguments plus the document:

  Wall wall = Wall.Create(
    doc, line, levelBottom.Id, false );

The second occurence of this method in CmdCreateGableWall defines a profile for the wall. It was passed in using a CurveArray instance in 2012:

  // Create wall profile
 
  CurveArray profile = new CurveArray();
 
  XYZ q = pts[pts.Length - 1];
 
  foreach( XYZ p in pts )
  {
    profile.Append( appCreation.NewLineBound(
      q, p ) );
 
    q = p;
  }
 
  // . . .
 
  Wall wall = doc.Create.NewWall(
    profile, wallType, level, true, normal );

The Revit 2013 API eliminates the need for the custom collection class and uses a standard .NET List instead:

  List<Curve> profile = new List<Curve>(
    pts.Length );
 
  XYZ q = pts[pts.Length - 1];
 
  foreach( XYZ p in pts )
  {
    profile.Add( appCreation.NewLineBound(
      q, p ) );
    q = p;
  }
 
  // . . .
 
  Wall wall = Wall.Create(
    doc, profile, wallType.Id, level.Id, true, normal );

PlanTopology GetRoomIds Method

The PlanTopology Rooms property is obsolete and should be replaced by GetRoomIds, e.g. in the following old code in CmdPlanTopology:

  foreach( Room r in pt.Rooms )
  {
    output += "\n  " + r.Name + " : "
      + Util.RealString( r.Area ) + " sqf";
  }

Here is a possible reimplementation of that:

  foreach( ElementId id in pt.GetRoomIds() )
  {
    Room r = doc.GetElement( id ) as Room;
 
    output += "\n  " + r.Name + " : "
      + Util.RealString( r.Area ) + " sqf";
  }

The rest of the warnings are pointing out more calls to the obsolete NewWall method, that I converted similarly to above.

Here is version 2013.0.100.2 of The Building Coder samples all deprecated API calls eliminated.

It also includes Victor's little update to the room retrieval sample.

All obsolete lines are marked with comments saying '// 2012', and their replacements are marked '// 2013'. If you wish to analyse the exact differences, you can simply compare the code of this version with the version 2013.0.100.1 implementing the updated CmdDemoCheck command and serial number detection.

Basic File Info and RVT File Version

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

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

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

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

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

Building Setout Points Used in a Commercial Application

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

Here is an excerpt from the current Australian ARSoftwareSolutions newsletter:

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

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

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

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

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

Tagged points

Scheduled Keypoints

Schedule - All points

The interface

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

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

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

Screen Recording on the Mac

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

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

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

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

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

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

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

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

Sustainable Autodesk Offices

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

• Farnborough
• Milano

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

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

Determining the RVT File Version Without Revit

Back to the main topic that I started discussing above.

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

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

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

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

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

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

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

Here is the regular expression:

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

Here is the code:

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

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

Answer from Victor Chekalin:

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

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

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

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

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

  string fileContents = streamReader.ReadToEnd();

Also, Regular expression on the huge file works slow.

I think you should use

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

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

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

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

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

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

Many thanks to Victor for his clear explanation and solution!

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

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

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

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

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

This is a summary of the resulting readable text fields:

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

Revit 2013 Unit Conversion Utility

Here is a Revit 2013 update of the Revit 2011 unit conversion utility, originally posted and described for Revit 2010, by Harry Mattison.

In his own words:

I was looking at the great unit conversion utility and created a new version upgraded to Revit 2013 that I thought you readers might enjoy.

I ran into one issue that required a code enhancement to catch an exception thrown by many parameters, such as HVAC_Temperature, HVAC_Slope, etc.

The rest of the code handles error conditions nicely, so I was surprised to see these uncaught exceptions.

I solved it by adding a try/catch statement around the existing call to AddParameter in frmUnitConversions.cs:

  if( null == _Parameter )
  {
    // Create a new parameter
 
    try
    {
      _Parameter
        = _DbDocument.FamilyManager.AddParameter(
          parameterTypeToCreate.ToString(),
          BuiltInParameterGroup.INVALID,
          parameterTypeToCreate,
          false );
    }
    catch( Exception ex )
    {
      TaskDialog.Show( "Error",
        "Cannot create parameter '"
        + parameterTypeToCreate.ToString()
        + "' with parameter type '"
        + parameterTypeToCreate
        + "' because of exception\n"
        + ex.Message.ToString() );
 
      return;
    }
  }

I think I figured out what is causing this and thought it would be interesting to share with your blog readers:

I am creating family parameters from a shared parameter file. Some parameters have types that are not supported in the version of Revit that I am currently using, which is Revit Architecture.

I created this function to detect the situation:

  public static bool canGetFormatOptions(
    Document doc,
    FamilyParameter familyParameter )
  {
    try
    {
      UnitType parameterUnitType
        = ConvertParameterTypeToUnitType(
          familyParameter.Definition.ParameterType );
 
      doc.ProjectUnit.get_FormatOptions(
        parameterUnitType );
 
      return true;
    }
    catch
    {
      return false;
    }
  }

I use it like this:

  if( !canGetFormatOptions(
    famDoc, familyParameter ) )
  {
    TaskDialog.Show( "Error",
      "Cannot set parameter value.\nUnit Type "
      + ConvertParameterTypeToUnitType(
        familyParameter.Definition.ParameterType )
      + " is not supported in Revit "
      + famDoc.Application.Product.ToString() );
  }

Take care.

The updated code is provided above.

Many thanks to Harry for this update with his enhancement and analysis!

Family Symbols versus Types and SelectionFilterElement

Here is a question that has been asked a couple of times recently and thus seems worthwhile clarifying:

Question: If I access the OwnerFamily.Symbols in a family document, i.e. an RFA file, it returns an empty collection. If I load that same family into a project and access the Family.Symbols property, it returns the correct expected family types. Why does this property not work in the family editor?

Put differently, the following code snippet will show zero in the message box:

  Document fdoc = app.OpenDocumentFile(
    "C:/Family.rfa" );

  Family fam = fdoc.OwnerFamily;

  MessageBox.Show(fam.Symbols.Size.ToString());

Loading the same family into a project and then querying the symbol count returns the correct number:

  Document doc = app.OpenDocumentFile(
    "C:/Project.rvt" );

  Family fam = null;

  doc.LoadFamily( "C:/Family.rfa",
    new FamilyOption(), out fam );

  MessageBox.Show(fam.Symbols.Size.ToString());

Again, why does the Family.Symbols property not work in the family context?

Answer: Why things are the way they are is often quite difficult to answer. For that situation, I quite like the adage "Mine is not to wonder why, mine is but to do or die."

However, if I am allowed to rephrase you question constructively and ask "How can I access the symbols defined by a family in the family editor context?", the answer is clear and easy:

Use the FamilyManager class. The family manager object is used to manage the family types and parameters within a family document. You can access it through the Document.FamilyManager property on the family document object.

Getting back to the why and wherefore, it is helpful to understand that the family does not contain any symbols. It only contains types. The types can be compared to records in a database. The family parameters define the database fields, i.e. columns, and the types represent the records, i.e. rows. You could go even further and compare the individual family parameters with the database fields.

The symbols do not exist in the RFA. They only spring into existence when the family is loaded into a project.

Here is a slightly more detailed explanation:

Family types and symbols are completely different objects with different purposes.

There can be FamilySymbols in a family document. If so, these are the symbols defined by other families that are loaded into the document.

Family types live in the family where they are defined, whereas family symbols in a family always come from some other family loaded into it.

• Types can add parameters, formulas, etc. Symbols are limited to the definition in the source family.
• Types can be added and deleted at run time. Symbols cannot, other than by special operations like Duplicate.
• Symbols can be instantiated in the document they live in. Types cannot.

The FamilyType class in a family is not inherited from the Revit Element class, so types are not elements. It offers the ability to access parameters either for read or write in conjunction with the FamilyManager.

For certain operations in a family, such as getting an image from a type, you can set the type to be active using the FamilyManager.CurrentType property, then generate an image from a view of the family using the Document.Export method and an appropriate ImageExportOptions argument.

SelectionFilterElement

Two posts of Harry Mattison's on the SelectionFilterElement introduced in the Revit 2013 API just caught my attention and also seem worthwhile pointing out here.

The SelectionFilterElement is a filter element that stores an explicit list of ElementIds. Only elements whose ElementIds are contained in this list will pass the filter.

I mentioned the existence of this class briefly and rather cryptically in the initial overview of the Revit 2013 API.

Harry now presents two running snippets of sample code using a SelectionFilterElement to save a set of elements and subsequently retrieve and highlight them.

Definitely worth keeping in mind if you have a specific set of elements that you wish to access quickly.

Dynamo and Vasari Holiday Hacking

If the above is not enough for you, here is an invitation to venture further afield, into the realm of the Dynamo visual programming add-in for Revit:

• Dynamo holiday project overview
• Dynamic Relaxation via Dynamo
• Youtube video of results

Solid Centroid and Volume Calculation

I have not posted anything since last Friday, being too caught up in the West European Developer days and travelling. Today and tomorrow we spend in Gothenburg on the last lap of our journey, after Paris, Milano, Farnborough and Munich. I had a nap in the taxis to and from the airport yesterday, both in Germany and Sweden, so I was able to burn some midnight oil to share the following exploration with you.

One of the many interesting conversations I had at Autodesk University that caught my special attention dealt with a simple geometrical Revit API question; geometrical questions are among my favourites, and this one is really basic: how to calculate the centre of mass or centroid of a solid.

Once again, that led to the exploration of a number of interesting little sub-topics:

• Revit API centroid and volume calculation methods
• Gap free triangulation for polyhedral approximation
• Polyhedron centroid calculation algorithm
• Revit implementation and CentroidVolume class
• Polyhedron centroid calculation implementation
• Support for multiple solids
• Mainline with picking twists
• Results
• Download

Before getting into that, here is a quick heads-up to point out a new free technology preview to simulate airflow around buildings or other objects in a virtual wind tunnel:

Project Falcon Computational Fluid Dynamics CFD Add-in

Autodesk released Falcon for Revit to Autodesk Labs. Project Falcon is an outdoor airflow simulation add-in for Revit:

Emile Kfouri describes the use and advantages of Falcon in some depth on his Building Performance Analysis blog that I was previously unaware of. He includes detailed explanations of the kind of problems this software addresses, getting started, and comparisons with other technologies such as the wind tunnel feature in Project Vasari and Simulation CFD 360. Fascinating stuff.

By the way, this is extremely interesting to look at for any Revit add-in developer, even if you do not care about this specific kind of analysis, because it shows an impressive example of using Revit as a front-end input tool to a powerful analysis component, reporting the results back graphically using the analysis visualisation framework AVF. If you hook up these components intelligently, a lot of functionality can be achieved with little effort.

Centroid and Volume of a Solid

Returning to the centroid and volume calculation, the Revit API provides both of these through the Solid ComputeCentroid method and Volume property. As said, a conversation prompted me to explore how to implement these calculations on my own as well.

Calculating exact results for an arbitrary solid is not trivial, of course, and could currently only be achieved making use of an external library.

If high precision is not paramount, however, we can simplify the solid to a planar faceted representation by triangulating all its faces to create a polyhedral approximation of it.

Determining the centroid of a polyhedron is something that can be achieved in a very few lines of code, as I will show below.

Gap Free Triangulation for Polyhedral Approximation

Happily, the Revit 2013 API provides a method for triangulating the entire surface of a solid in one single call, ensuring a closed volume, unlike doing it face by face, which does not.

The Face.Triangulate method returns a triangular mesh approximation to the face. Revit defines the approximation tolerance internally. Calling it separately for neighbouring faces, however, will return independent triangulations that do not line up where the faces meet, leaving gaps in the shell of the original solid.

This deficiency was eliminated by the SolidUtils class introduced in Revit 2013, which provides the TessellateSolidOrShell method to facet an entire solid or open shell in one single call. This enables each boundary component of the solid or shell to be represented by a single properly closed triangulated structure.

Polyhedron Centroid Calculation Algorithm

With these necessary and powerful basics in place, I searched the Internet for a bit of help on implementing an algorithm to calculate the centroid, and found a discussion on determining the centre of mass of a 3D model from the Game Maker Community. Here is my edited version summarising the results of that thread:

Question: I'm working on a model editor and I have a set centre function to reset the centre of a model. I can do this a few ways which I have implemented.

Method 1: Add vertices, average them and move the model; pseudocode:

  for each point
    dx += point.x
    dy += point.y
    dz += point.z
    count ++

  dx/=count
  dy/=count
  dz/=count

  for each point
    point.x-=dx
    point.y-=dy
    point.z-=dz

The problem: If the model has many points in one area, the deviation favours that area. Which is not always good because some models have many, many points like at the tip of a gun or the cone of a ship.

Method 2: Find min max of vertices, average the min max into a deviation and move the model:

  for each point
    mindx = min( point.x, mindx )
    maxdx = max( point.x, maxdx )
    same for y and z

  dx = (mindx + maxdx) / 2
  same for dy, dz;

  for each point
    point.x -= dx
    same for y and z

That works OK.

For my third method, I would really like to centre the model on its estimated centre mass.

I have a series of 3 points defining the planes/faces. I figure I could plug either the plane area or perimeter into the deviation calculation. That way many points defining a tiny area would not affect the calculation that much. But I can't figure out the right math for this.

Can you determine the surface areas of each face?

Answer: Well, one would assume that we'd want to count the inside of the model into the mass calculation as well, in which case you want to find the volume of the model. This actually isn't too difficult to compute assuming that the model is closed (no holes; otherwise it wouldn't really have a well-defined volume) and that it's simple (in the mathematical sense; that means it doesn't intersect with itself). Each triangular face contributes a tetrahedron's worth of volume to the whole model. To find this volume given the three vertices of the face v1, v2, and v3, you need only compute v1 · (v2 × v3 ) / 6.

The following is very important. The vertices of every face must be oriented the same way. This means that if you look at a face from the outside of a model, its vertices should be oriented in a clockwise fashion (counter-clockwise is valid too, as long as you're consistent).

So, now we essentially have a way to compute a weighting factor for every face in the model. The coordinates we have to weight this by are the centroids of each tetrahedron, given by (v1 + v2 + v3)/4. This is because one of the vertices of every tetrahedron is the origin so it's 0, so there's no reason to include it here. So, the centroid of the model is given by the following:

∑ (v1 + v2 + v3)/4 [v1 · (v2 × v3 )] / ∑ [v1 · (v2 × v3)]

The sum is performed over each face.

Also, the factor of 6 in the volume is left out because it cancels out because of the division. So, loop over each face, compute the volume contribution and add that onto a total volume counter and also multiply it by that average position (you can move the division by 4 outside of the sum to make the loop faster; that way only one division needs to be performed instead of one for each face) of the tetrahedron (i.e. multiply it by the sum of the vertices). Then, outside of the loop, divide by the total volume times 4 (assuming you moved that division by 4 outside of the loop). You now have the centroid assuming constant density.

The variables are all vectors. The product of the three vectors is a triple scalar product. It's the dot product with the cross product (and also the determinant of the matrix of these vectors). It's equal to this, which can be used as a formula for the volume:

  x1*(y2*z3 - y3*z2)
  + y1*(z2*x3 - z3*x2)
  + z1*(x2*y3 - x3*y2)

This is because one of the vertices of every tetrahedron is the origin.

Note that this does not require the model to be convex. All the tetrahedrons are not necessarily entirely contained inside the model.

I only assume that the model is closed and simple. Any tetrahedrons outside the model will have their area computed to be negative. They'll subtract off their contributions. The origin of the system can be anywhere as well. It doesn't have to be inside the model.

Here is the entire pseudo-code:

  var cx, cy, cz, volume, v, i, x1, y1, z1, x2, y2, z2, x3, y3, z3;
  volume = 0;
  cx = 0; cy = 0; cz = 0;
  // Assuming vertices are in vertX[i], vertY[i], and vertZ[i]
  // and faces are faces[i, j] where the first index indicates the
  // face and the second index indicates the vertex of that face
  // The value in the faces array is an index into the vertex array
  i = 0;
  repeat (numFaces) {
    x1 = vertX[faces[i, 0]]; y1 = vertY[faces[i, 0]]; z1 = vertZ[faces[i, 0]];
    x2 = vertX[faces[i, 1]]; y2 = vertY[faces[i, 1]]; z2 = vertZ[faces[i, 1]];
    x3 = vertX[faces[i, 2]]; y3 = vertY[faces[i, 2]]; z3 = vertZ[faces[i, 2]];
    v = x1*(y2*z3 - y3*z2) + y1*(z2*x3 - z3*x2) + z1*(x2*y3 - x3*y2);
    volume += v;
    cx += (x1 + x2 + x3)*v;
    cy += (y1 + y2 + y3)*v;
    cz += (z1 + z2 + z3)*v;
    i += 1;
  }
  // Set centroid coordinates to their final value
  cx /= 4 * volume;
  cy /= 4 * volume;
  cz /= 4 * volume;
  // And, just in case you want to know the total volume of the model:
  volume /= 6;

Remember that the vertices of each face must be oriented in the same way (one way to see if they are is to turn on back face culling; if the model appears normally then they're all oriented properly--the model could also appear inside-out which would also be a valid orientation).

Part of this is actually calculating the area of each triangle without having to figure out the angles, simply using the 3 side lengths.

One way to achieve this is using Heron's Formula:

  A = sqrt( s * (s - a) * (s - b) * (s - c) )

Here a, b, c are the lengths of each side and s is the semi-perimeter, s = (a + b + c) / 2.

You can also just take the magnitude of the cross product of two edge vectors of the face and divide it by 2. This means that you can find the area of a face as a side effect of determining its normal vector, just as I do in my GetSignedPolygonArea method.

Revit Implementation and CentroidVolume Class

I used the algorithm described above to implement a volume and centre of mass calculation for a Revit solid.

As said, curved solids are approximated by triangulating them. The result is pretty precise for solids that are planar faceted to start with.

The code includes an assertion to ensure that the volume calculated as a side effect is not too far removed from the value provided by the Solid.Volume property.

Since the algorithm above calculates both the centroid and volume, I implemented the following little helper class to package the two together:

  class CentroidVolume
  {
    public CentroidVolume()
    {
    }
 
    public XYZ Centroid { get; set; }
    public double Volume { get; set; }
 
    override public string ToString()
    {
      return RealString( Volume ) + "@"
        + PointString( Centroid );
    }
  }

Polyhedron Centroid Calculation Implementation

My translation of the algorithm described above to Revit API looks like this, including the validation assertions at the end and an exception handler around the call to TessellateSolidOrShell for reasons explained below:

CentroidVolume GetCentroid( Solid solid )
{
  CentroidVolume cv = new CentroidVolume();
  double v;
  XYZ v0, v1, v2;
 
  SolidOrShellTessellationControls controls
    = new SolidOrShellTessellationControls();
 
  controls.LevelOfDetail = 0;
 
  TriangulatedSolidOrShell triangulation = null;
 
  try
  {
    triangulation
      = SolidUtils.TessellateSolidOrShell(
        solid, controls );
  }
  catch( Autodesk.Revit.Exceptions
    .InvalidOperationException )
  {
    return null;
  }
 
  int n = triangulation.ShellComponentCount;
 
  for( int i = 0; i < n; ++i )
  {
    TriangulatedShellComponent component
      = triangulation.GetShellComponent( i );
 
    int m = component.TriangleCount;
 
    for( int j = 0; j < m; ++j )
    {
      TriangleInShellComponent t
        = component.GetTriangle( j );
 
      v0 = component.GetVertex( t.VertexIndex0 );
      v1 = component.GetVertex( t.VertexIndex1 );
      v2 = component.GetVertex( t.VertexIndex2 );
 
      v = v0.X*(v1.Y*v2.Z - v2.Y*v1.Z)
        + v0.Y*(v1.Z*v2.X - v2.Z*v1.X)
        + v0.Z*(v1.X*v2.Y - v2.X*v1.Y);
 
      cv.Centroid += v * (v0 + v1 + v2);
      cv.Volume += v;
    }
  }
 
  // Set centroid coordinates to their final value
 
  cv.Centroid /= 4 * cv.Volume;
 
  XYZ diffCentroid = cv.Centroid
    - solid.ComputeCentroid();
 
  Debug.Assert( 0.6 > diffCentroid.GetLength(),
    "expected centroid approximation to be "
    + "similar to solid ComputeCentroid result" );
 
  // And, just in case you want to know 
  // the total volume of the model:
 
  cv.Volume /= 6;
 
  double diffVolume = cv.Volume - solid.Volume;
 
  Debug.Assert( 0.3 > Math.Abs(
    diffVolume / cv.Volume ),
    "expected volume approximation to be "
    + "similar to solid Volume property value" );
 
  return cv;
}

As you may have noticed, the assertion limits are pretty arbitrarily chosen.

Support for Multiple Solids

Since the centroid of any given element will be determined by all of its solids, which may be multiple, I implemented the following GetCentroid method to determine all solids belonging to a given element and calculate its total centroid and volume across all its component solids:

/// <summary>
/// Calculate centroid for all non-empty solids 
/// found for the given element. Family instances 
/// may have their own non-empty solids, in which 
/// case those are used, otherwise the symbol geometry.
/// The symbol geometry could keep track of the 
/// instance transform to map it to the actual 
/// project location. Instead, we ask for 
/// transformed geometry to be returned, so the 
/// resulting solids are already in place.
/// </summary>
CentroidVolume GetCentroid(
  Element e,
  Options opt )
{
  CentroidVolume cv = null;
 
  GeometryElement geo = e.get_Geometry( opt );
 
  Solid s;
 
  if( null != geo )
  {
    // List of pairs of centroid, volume for each solid
 
    List<CentroidVolume> a
      = new List<CentroidVolume>();
 
    Document doc = e.Document;
 
    if( e is FamilyInstance )
    {
      geo = geo.GetTransformed(
        Transform.Identity );
    }
 
    GeometryInstance inst = null;
 
    CentroidVolume cv1;
 
    foreach( GeometryObject obj in geo )
    {
      s = obj as Solid;
 
      if( null != s
        && 0 < s.Faces.Size
        && SolidUtils.IsValidForTessellation( s )
        && (null != ( cv1 = GetCentroid( s ) ) ) )
      {
        a.Add( cv1 );
      }
      inst = obj as GeometryInstance;
    }
 
    if( 0 == a.Count && null != inst )
    {
      geo = inst.GetSymbolGeometry();
 
      foreach( GeometryObject obj in geo )
      {
        s = obj as Solid;
 
        if( null != s
          && 0 < s.Faces.Size
          && SolidUtils.IsValidForTessellation( s )
          && (null != ( cv1 = GetCentroid( s ) ) ) )
        {
          a.Add( cv1 );
        }
      }
    }
 
    // Get the total centroid from the partial
    // contributions. Each contribution is weighted
    // with its associated volume, which needs to 
    // be factored out again at the end.
 
    if( 0 < a.Count )
    {
      cv = new CentroidVolume();
      foreach( CentroidVolume cv2 in a )
      {
        cv.Centroid += cv2.Volume * cv2.Centroid;
        cv.Volume += cv2.Volume;
      }
      cv.Centroid /= a.Count * cv.Volume;
    }
  }
  return cv;
}

The calculation of the total volume and centroid is similar to the base algorithm described above, with each centroid contribution weighted by the corresponding volume.

Mainline with Picking Twists

Finally, here is the external command Execute method implementation driving this and including some additional useful picking interaction handling twists, such as:

• Support for pre-selection or interactive picking.
• Checking for a valid active view type before prompting the user to pick an element.
• Exception handling to gracefully terminate picking and the entire command on cancels.

The resulting code looks like this:

public Result Execute(
  ExternalCommandData commandData,
  ref string message,
  ElementSet elements )
{
  UIApplication uiapp = commandData.Application;
  UIDocument uidoc = uiapp.ActiveUIDocument;
  Application app = uiapp.Application;
  Document doc = uidoc.Document;
  List<ElementId> ids = new List<ElementId>();
  Selection sel = uidoc.Selection;
  SelElementSet set = sel.Elements;
 
  if( 0 < set.Size )
  {
    foreach( Element e in set )
    {
      ids.Add( e.Id );
    }
  }
  else
  {
    if( ViewType.Internal == doc.ActiveView.ViewType )
    {
      TaskDialog.Show( _caption,
        "Cannot pick elements in this view: "
        + doc.ActiveView.Name );
 
      return Result.Failed;
    }
 
    try
    {
      IList<Reference> refs = sel.PickObjects(
        ObjectType.Element,
        "Please select some elements" );
 
      foreach( Reference r in refs )
      {
        ids.Add( r.ElementId );
      }
    }
    catch( Autodesk.Revit.Exceptions.OperationCanceledException )
    {
      return Result.Cancelled;
    }
  }
 
  Options opt = app.Create.NewGeometryOptions();
 
  foreach( ElementId id in ids )
  {
    Element e = doc.GetElement( id );
 
    CentroidVolume cv = GetCentroid( e, opt );
 
    Debug.Print( "{0} {1}",
      (null == cv ? "<nil>" : cv.ToString()),
      ElementDescription( e ) );
  }
  return Result.Succeeded;
}

Results

I ran this on the basic sample model delivered with Revit, rac_basic_sample_project.rvt, simply selecting all elements on level 1. Not surprisingly, this causes a couple of hiccups, notably a few assertions stating that my volume approximation does not match Revit's and an exception thrown by the TessellateSolidOrShell method, in spite of calling IsValidForTessellation beforehand to ensure tht I only feed in acceptable solids to it. This exception is caused by the teapot in the model, which is in fact a rather abnormal building element, but still...

These hiccups can be ironed out. Here is the report logged to the debug output window with the hiccups and exception messages manually edited away, informing us that a large number of elements in the model are correctly processed and that for all of them my calculated approximate values correspond more or less to the ones reported by the built-in Revit API methods; copy and paste to an editor to see the truncated lines in full:

115.87@(-52.42,8.9,11.04) Wall Walls <117653 Foundation - 305 Concrete>
455.96@(-20.92,6.23,11.54) Wall Walls <117654 Generic - 200>
461.1@(-24.09,27.23,11.75) Wall Walls <117698 CORR>
<nil> Wall Walls <117714 Storefront>
52.65@(-19.42,13.54,4.88) Wall Walls <117945 Interior - Partition>
36.09@(-12.55,15.23,5.22) Wall Walls <117963 Interior - Partition>
<nil> Element Stairs <118049 open treads>
<nil> Railing Railings <118116 Handrail - Pipe>
64.4@(-7.56,11.37,4.92) Wall Walls <118356 Interior - Partition>
168.87@(11.08,17.15,13.97) Wall Walls <123926 CORR>
<nil> Wall Walls <123967 Storefront>
0.32@(5.54,12.96,0.69) FamilyInstance Doors Window_Insert <123981 Window_Insert>
0.24@(11.08,25.92,0.13) Mullion Curtain Wall Mullions Rectangular Mullion <123986 64 x 128 rectangular>
0.29@(11.08,22.37,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <123987 64 x 128 rectangular>
0.34@(5.54,12.96,1.97) FamilyInstance Doors Window_Insert <123990 Window_Insert>
0.29@(10.95,27.23,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <123995 64 x 128 rectangular>
0.29@(11.08,22.37,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <124013 64 x 128 rectangular>
0.29@(11.08,27.1,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <124015 64 x 128 rectangular>
0.29@(11.08,27.1,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <124016 64 x 128 rectangular>
0.24@(11.08,25.92,2.62) Mullion Curtain Wall Mullions Rectangular Mullion <124017 64 x 128 rectangular>
0.29@(10.95,27.23,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <124019 64 x 128 rectangular>
0.6@(-10.02,6.82,1.5) FamilyInstance Windows Fixed <125448 406 x 610>
3.16@(2.85,4.18,0.91) FamilyInstance Doors Double-Glass 1 <126295 1800 x 2100>
252.05@(-24.2,34.28,6.92) Wall Walls <127132 Foundation - 305 Concrete>
236.66@(-1.03,9.27,2.21) FamilyInstance Walls FIREPLACE <127491 FIREPLACE>
51.52@(-31.92,13.3,4.86) Wall Walls <127659 Interior - Partition>
79.29@(-31.83,20.23,5.11) Wall Walls <127660 Interior - Partition>
3.84@(-11.31,6.72,1.2) FamilyInstance Doors Single-Flush <127661 800 x 2100>
3.84@(-9.97,6.72,1.2) FamilyInstance Doors Single-Flush <127662 800 x 2100>
17.84@(-35.67,24.22,5.51) Wall Walls <127663 Interior - Partition>
0.26@(-5.33,3.72,0.31) FamilyInstance Plumbing Fixtures Sink Vanity-Square <127666 508 x 445>
3.84@(-11.92,7.41,1.2) FamilyInstance Doors Single-Flush <127667 800 x 2100>
1.47@(-8.6,1.54,1.38) FamilyInstance Windows Fixed <127718 1219 X 915>
1.47@(-5.51,1.54,1.38) FamilyInstance Windows Fixed <127719 1219 X 915>
28.59@(-27.64,23.9,6.44) Wall Walls <127941 Interior - Partition>
11.78@(-19.42,25.25,4.95) Wall Walls <128006 Interior - Partition>
<nil> CurtainGridLine Curtain Wall Grids <128399 Grid Line>
0.29@(0.69,13.62,0.69) FamilyInstance Doors Window_Insert <128400 Window_Insert>
0.3@(0.69,13.62,1.97) FamilyInstance Doors Window_Insert <128401 Window_Insert>
<nil> CurtainGridLine Curtain Wall Grids <128408 Grid Line>
0.57@(2.29,13.62,0.69) FamilyInstance Doors Window_Insert <128409 Window_Insert>
0.59@(2.29,13.62,1.97) FamilyInstance Doors Window_Insert <128410 Window_Insert>
0.46@(4.58,27.23,0.13) Mullion Curtain Wall Mullions Rectangular Mullion <128432 64 x 128 rectangular>
0.2@(1.37,27.23,2.62) Mullion Curtain Wall Mullions Rectangular Mullion <128433 64 x 128 rectangular>
0.46@(4.58,27.23,2.62) Mullion Curtain Wall Mullions Rectangular Mullion <128434 64 x 128 rectangular>
0.29@(2.41,27.23,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <128450 64 x 128 rectangular>
0.29@(2.41,27.23,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <128452 64 x 128 rectangular>
4.73@(19.5,10.48,9.25) FamilyInstance Columns Rectangular Column <128571 140 X 140>
2.38@(19.5,6.82,3.67) FamilyInstance Columns Rectangular Column <128683 140 X 140>
<nil> CurtainGridLine Curtain Wall Grids <130207 Grid Line>
0.55@(4.42,13.62,0.69) FamilyInstance Doors Window_Insert <130208 Window_Insert>
0.58@(4.42,13.62,1.97) FamilyInstance Doors Window_Insert <130209 Window_Insert>
0.44@(8.85,27.23,0.13) Mullion Curtain Wall Mullions Rectangular Mullion <130248 64 x 128 rectangular>
0.44@(8.85,27.23,2.62) Mullion Curtain Wall Mullions Rectangular Mullion <130249 64 x 128 rectangular>
0.29@(6.75,27.23,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <130256 64 x 128 rectangular>
0.29@(6.75,27.23,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <130257 64 x 128 rectangular>
2.38@(-8.38,34.98,3.67) FamilyInstance Columns Rectangular Column <130550 140 X 140>
4.23@(-5.81,5.05,1.21) FamilyInstance Doors Single-Flush <135477 915 x 2134>
13.47@(-15.67,13.3,4.92) Wall Walls <135527 Interior - Partition>
8.72@(-1.14,2.81,0.13) FamilyInstance Furniture Chair-Corbu <137191 Chair-Corbu>
8.72@(0.4,2.99,0.13) FamilyInstance Furniture Chair-Corbu <137272 Chair-Corbu>
4.73@(-26.85,34.98,9.25) FamilyInstance Columns Rectangular Column <137480 140 X 140>
0.29@(0.37,27.23,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <139162 64 x 128 rectangular>
0.29@(0.37,27.23,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <139163 64 x 128 rectangular>
0.2@(1.37,27.23,0.13) Mullion Curtain Wall Mullions Rectangular Mullion <139229 64 x 128 rectangular>
9.04@(-35.67,18.87,4.92) Wall Walls <140108 Interior - Partition>
15.8@(-39.9,17.9,6.41) Wall Walls <140130 Interior - Partition>
4.39@(-5.72,2.54,0.51) FamilyInstance Doors Bifold-4 Panel <140140 1800 x 2100>
9.04@(-28.17,18.87,4.92) Wall Walls <140190 Interior - Partition>
15.93@(-23.79,17.9,6.27) Wall Walls <140191 Interior - Partition>
4.39@(-3.4,2.54,0.51) FamilyInstance Doors Bifold-4 Panel <140192 1800 x 2100>
33.57@(1.08,8.95,4.79) Wall Walls <140204 Generic - 200>
13.99@(-8.49,6.36,0.37) FamilyInstance Specialty Equipment Dryer <144101 686 x 635 x 889>
13.63@(-10.27,8.48,0.49) FamilyInstance Specialty Equipment Washer <144494 686 x 635 x 889>
4.39@(-4.57,3.4,0.51) FamilyInstance Doors Bifold-4 Panel <144534 1800 x 2100>
4.39@(-3.27,3.4,0.51) FamilyInstance Doors Bifold-4 Panel <144657 1800 x 2100>
10.42@(-27.54,25.45,5.03) Wall Walls <144706 Interior - Partition>
64.17@(5.93,7.23,4.92) Wall Walls <144998 CORR>
22.4@(10.08,9.17,4.92) Wall Walls <145015 CORR>
12.23@(10.58,11.11,4.92) Wall Walls <145032 CORR>
36@(6.75,10.69,2) FamilyInstance Casework Bar <145182 Bar>
6.5@(-7.92,13.3,2.38) Wall Walls <145199 Interior - Partition>
0.29@(0.34,27.23,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <150839 64 x 128 rectangular>
0.29@(0.34,27.23,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <150840 64 x 128 rectangular>
308.55@(-22,6.39,-0.49) Wall Walls <150987 Generic - 305>
134.41@(-44.42,17.07,1.02) Wall Walls <151006 Generic - 200>
256.5@(-25.18,27.08,-0.49) Wall Walls <151081 Generic - 305>
1284.19@(-38.12,13.27,4) Room Rooms <152552 BEDROOM 1 5>
<nil> RoomTag Room Tags <152553 Room Tag>
1298.34@(-25.66,13.27,4) Room Rooms <152555 BEDROOM 2 6>
<nil> RoomTag Room Tags <152556 Room Tag>
420.33@(-27.44,22.07,4) Room Rooms <152557 HALL 7>
<nil> RoomTag Room Tags <152558 Room Tag>
423.9@(-39.98,23.65,4) Room Rooms <152559 BATH 8>
<nil> RoomTag Room Tags <152560 Room Tag>
839.97@(-10.26,9.39,4) Room Rooms <152561 STORAGE 9>
<nil> RoomTag Room Tags <152562 Room Tag>
<nil> ModelLine <Room Separation> <152596 Model Lines>
352.08@(-27.54,25.49,4) Room Rooms <152642 MECH 11>
<nil> RoomTag Room Tags <152643 Room Tag>
19.63@(-6.85,1.82,0.17) FamilyInstance Furniture Bed-Box <153466 Double 1346 x 1880>
19.63@(-3.76,1.79,0.17) FamilyInstance Furniture Bed-Box <153556 Double 1346 x 1880>
<nil> ReferencePlane Reference Planes <165634 Reference Plane>
<nil> Opening Rectangular Straight Wall Opening <166134 Rectangular Straight Wall Opening>
0.47@(-2.86,22.65,0.01) FamilyInstance Furniture Rug_zk <167847 1220 x 2134>
2.44@(-0.57,4.53,0.23) FamilyInstance Furniture Table-Coffee <168561 915 x 1830 x 457>
0.02@(-1.7,11.35,0.98) FamilyInstance Generic Models teapot <169568 teapot>
0.1@(-2.09,6.25,0.48) FamilyInstance Lighting Fixtures Floor Lamp 1 <171113 150 watt Halogen>
3@(-14.28,8.03,0.18) FamilyInstance Plumbing Fixtures Tub-Rectangular-3D <178179 Tub-Rectangular-3D>
<nil> CurtainGridLine Curtain Wall Grids <178753 Grid Line>
0.39@(11.19,23.55,1.38) Panel Curtain Panels System Panel <178754 Glazed>
0.41@(11.19,23.55,3.94) Panel Curtain Panels System Panel <178755 Glazed>
0.24@(11.08,23.55,0.13) Mullion Curtain Wall Mullions Rectangular Mullion <178774 64 x 128 rectangular>
0.24@(11.08,23.55,2.62) Mullion Curtain Wall Mullions Rectangular Mullion <178775 64 x 128 rectangular>
0.29@(11.08,24.73,1.31) Mullion Curtain Wall Mullions Rectangular Mullion <178782 64 x 128 rectangular>
0.29@(11.08,24.73,3.94) Mullion Curtain Wall Mullions Rectangular Mullion <178783 64 x 128 rectangular>
<nil> Room Rooms <180268 LIVING ROOM 12>
<nil> RoomTag Room Tags <180269 Room Tag>
11.72@(-0.33,2.33,0.13) FamilyInstance Furniture Chair-Corbu <181500 Couch Corbu>

This is more than enough for me and my rather quick and dirty exploration of this. Improved filtering and error handling is left as an exercise to the inclined reader.

Download

Here is GetCentroid.zip containing the complete source code, Visual Studio solution and add-in manifest for this command.

Accessing all Elements in a Schedule

Here is a quick little post, with a surprisingly short and simple answer to a short and seemingly difficult Revit API question.

Before getting to that, I will just mention that I arrived safe and sound in Paris for a developer conference here. I had a walk in the sunset on the north bank of the Seine from the Gare de Lyon along the industrial areas on Quai de Bercy and crossed the river over the new-built Pont National to reach the rue de Tolbiac by a rather roundabout route.

So, back to Revit; how can we easily retrieve all the elements listed in a schedule view?

Question: The Revit 2013 API finally enabled the creation of schedule views, which is great.

I would also need to query that schedule and retrieve all the element ids of the elements contained in it.

Currently, I am using the workaround of exporting the schedule and then comparing with elements within the project, which takes a considerable amount of time.

Is there any simpler way to achieve this?

Answer: Yes, there is.

The schedule is a view, and its view id can be passed in to the filtered element collector just like any other.

That will return the relevant elements.

Sorry you had to go to all that unnecessary trouble :-)

Many thanks to Guy Robinson for pointing this out!

AU Classes on Python, UI, Server and Framework APIs

Thursday was another very full and fruitful day at AU. I gave my third and last class, the most exciting one in my eyes, on some UI and integration aspects. I was unable to attend Iffat May's class introducing Python and using it in Revit and Vasari via RevitPythonShell, but I love her material so much I am including it anyway. Adam Nagy presented a class addressing cloud and mobile development and the Revit Server API. Finally, Arnošt Löbel provided a peek behind the scenes and into the depths of the fundamental frameworks underlying the Revit API.

Here they are in chronological order:

1. CP3837-L Scripting with RevitPythonShell in Vasari by Iffat May.
2. CP4107 Let's Face It: New Revit 2013 User Interface API Functionality by Jeremy Tammik.
3. CP3093 My First Cloud/Mobile App with Revit Server by Adam Nagy.
4. CP3426 Core Frameworks in the Revit API by Arnošt Löbel.

I am including the class materials below, for your and my own convenience, and also to ensure that all this juicy stuff really is picked up and returned by Internet search engines.

1. CP3837-L RevitPythonShell in Vasari

Iffat provides an entire introductory tutorial to the Python programming language, and then shows how to apply it to solve a number of useful tasks in Revit and Vasari. She makes use of Daren Thomas' Revit Python shell, originally implemented for Revit 2010, then for Vasari, Revit 2012 and Vasari 2.1, and now available for Revit 2013.

RevitPythonShell introduces interactive scripting ability to Revit and Project Vasari. Designers now have the ability to interactively design and manipulate Revit elements using algorithms and computational logic. The class explores the Python structures, variables, data types, and flow control, and shows how to use them to create scripts to control Revit elements dynamically.

• Handout
• Presentation
• Sample code and models

2. CP4107 Revit 2013 User Interface API

This class takes a deeper look at the new user interface and add-in integration functionality provided by the Autodesk Revit 2013 API. It covers 2013 features including Options dialogue custom extensions using WPF components, subscription to Revit progress bar notifications, embedding and controlling a Revit view inside an add-in dialogue for preview purposes, the new drag and drop API, and the UIView. This class is complementary to and expands on CP3272, a Snapshot of the Revit UI API:

• Document management and View API
• Revit progress bar notifications
• Options dialogue WPF custom extensions
• Embedding and controlling a Revit view
• UIView and Windows coordinates
• Drag and drop

From my point of view, one of the most exciting new features provided by the Revit 2013 UI API is the possibility to correlate between Windows screen device coordinates and Revit model coordinates provided by the UIView class, which I used to examine and implement my own Revit tooltip, which also makes use of the new ReferenceIntersector class and Idling event. This has never previously been possible. Now you can do anything you like using the Windows API and connect that intelligently with the underlying Revit model.

• Handout
• Presentation
• Sample code

3. CP3093 Cloud/Mobile App with Revit Server

This class has two objectives: to introduce you to the Revit Server REST API and to introduce you to cloud and mobile programming.

Autodesk Revit Server is a server-based file storage system that we can use to store Revit files. It has a public API that uses simple HTTP known as REST (or Representational State Transfer). REST is a "style" for designing network applications, and it is used to communicate between the server and a client machine. REST is simple, yet powerful enough. You can use it from anywhere where HTTP programming is available: from a desktop, a mobile device or a server-side application. In this class, we discuss what REST is, using the context of Revit Server.

We then go one step further and show you how to create your own REST service in .NET. We implement it as a notification system in the cloud and demonstrate with an Apple iPad/iPhone application in Apple iOS. At the end of this class, you will be able to:

• Use HTTP requests to interact with a REST API
• Programmatically access and modify data available on Revit Server
• Create basic iOS applications in Xcode
• Create a basic REST service in .NET
• Use Apple Push Notification

Here is the detailed handout document:

• Handout

4. CP3426 Core Frameworks in the Revit API

A good understanding of core frameworks in the Revit API is a prerequisite for developing well behaved Revit add-ins. Among the most important ones, the following frameworks play key roles in most applications:

• External applications, commands, and events
• Transactions phases
• Regeneration and transaction modes
• Updaters and other call-backs
• Scoped objects and element validity

These concepts have been around for many releases, yet there are still facts about them that may not be completely understood. This class summarizes the necessary basics, and also sheds some light on the behaviour that is normally hidden 'under the hood'. Knowledge acquired during this class will help Revit developers to build more efficient, safer, and robust applications.

• Paper
• Presentation

By the time you read this, I will be sitting in the plane heading back to Europe.

Take care, and walk in beauty.

AU Classes on the View, MEP and Link APIs

Wednesday was my first normal and full AU day, after completing the developer conference and DevLab activities. I was able to attend two interesting classes held by Revit API developers Steven Mycynek and Arnošt Löbel, and present my own Revit MEP API one. Here they are in chronological order:

• CP3133 Using the Revit Schedule and View APIs by Steven Mycynek
• CP4108 Revit MEP Programming: All Systems Go by Jeremy Tammik
• CP3455 Managing Revit Links with the Revit API by Arnošt Löbel

I am including the class materials below, both for your and my own convenience, and also to ensure that all this juicy stuff really is picked up and returned by Internet search engines.

Schedule and View APIs

Revit 2013 includes a major expansion of the Schedule and View APIs. This class introduces the API for Schedule and Elevation views as well as many methods and properties that apply to all views. Learn how to create and modify these views to help document and display your Revit model.

• Handout
• Presentation
• Sample code
• Sample models

This class should really resolve all those recurring questions associated with the creation of different views once and for all! Take a special deep look at Steve's multitude of useful utility classes in the sample code.

Revit MEP Programming

This class shows how to work programmatically with Revit MEP models. It provides an overview of the entire Revit MEP API with specific focus on the major enhancements in Revit 2013. The most important 2013 feature is the routing preference functionality. An overview of the available samples is provided. All MEP domains including HVAC, electrical, and plumbing are addressed. It shows how to analyse existing systems and create new MEP models from scratch; covers mechanical and electrical system traversal; display of system hierarchies in a tree view; components such as circuits, ducts, pipes, fittings, connectors, cable trays, and conduits; and automatic calculation and sizing based on room and space requirements.

• Handout
• Presentation
• Sample code

Managing Revit Links

This class explains common pitfalls working with links and how to avoid them. It details the creation of Revit link types and instances, and recommends how to easily check or modify the parameters of links. Material describing ways to inquire for data about the various types of external files, including Revit links, is included. It concludes with an overview of a larger Revit link API application – the eTransmit add-in, which enables users to move an entire package of Revit files while maintaining relationships with all linked files.

• Presentation
• Sample code and models

Implementing a BIM Business Transformation

Unrelated to any direct programming topic, here is a white paper on implementing a BIM business transformation that is of interest to visionaries and decision makers and neatly complements the recently released BIM for Infrastructure one.

Building Performance Analysis and Face Tessellation

I am busy with Autodesk University and developer conference preparations. The Mac is happily chugging along.

Welcome to Building Performance Analysis

In spite of these busy times, Emile Kfouri and John Kennedy just launched a new blog on the topic of Building Performance Analysis that will probably be of great interest to many of us Revit API aficionados.

Meanwhile, here is an API issue that raises a couple of new points:

Triangulation Level of Detail

Question: I am triangulating Revit geometry face objects to get the triangular meshes. When I first tried this for each face of a standard UB-Universal beam I didn't get the root face (the curved face joining the flange and the web). I found that setting the Options detail level to Fine sorted that issue.

Now I wonder:

1. What is the 'LevelOfDetail' argument for on the Triangulate method? Does it relate to the Options detail level?
2. Does calling the Triangulate method without an argument correspond to calling the same method with 0.5 as the argument?
3. Is it possible to triangulate a solid element as a whole so that the triangle vertices match along an edge line, rather than tessellate each face individually, which gives non-matching vertices along the edge?

Answer: The level of detail argument to the triangulation has to do with the level of precision of the triangulation. Lower levels of detail will result in a coarser tessellation with less triangles but maybe less accuracy. Higher levels of detail will result in a more accurate but also more populous tessellation (with more triangles as a result). Of course this applies only to faces with curvature – planes should be well represented at any level.

But this does not answer the question asked – the face comes from Element.Geometry, and there are different sets of faces typically for DetailLevels Coarse, Medium and Fine. The Fine geometry will likely have more details such as the curved face mentioned, where the Medium geometry won't. So it has nothing to do with Triangulate(LOD), the inputs are different from the different geometry so you get different output.

To address your other questions:

2. As usual, a simple question with a not-so-simple answer. When the level of detail is not used, it uses the Revit defaults for when Revit triangulates faces for graphics (there may actually be a cache of these facets in some cases). There is probably no universal lod set in these situations.
3. Yes! The Revit 2013 API introduced the SolidUtils.TessellateSolidOrShell method. This routine processes the entire solid at once so that there are matched vertices at the edges. It takes a SolidOrShellTessellationControls argument including an option about LevelOfDetail with the same range of values and meaning as in the Face.Triangulate case. Revit doesn't use this method itself, so this data will never be cached.

Response: Thank you for finding out. I should have searched the 2013 Developer's Guide to find the SolidUtils class myself. I generally use the 2012 PDF guide since it is easier to read/use than the 2013 WikiHelp.

Answer: I understand about the PDF.

However, the Wikihelp has the advantage that Google will return hits in it for you.

I generally use the Revit API help file RevitAPI.chm, and especially I often consult the What's New section. It would actually be quite useful to have a collection of each release's What's New section. Maybe I should write a blog post on that.

From then on, all my further search is online. Obviously, I start with the blog first. That is what it is there for: my own personal knowledge base :-)

Drive Revit through a WCF Service

Today, a special titbit for you:

How can I access Revit functionality from an external process?

As we have underlined many times in the past, the Revit API does not support any kind of asynchronous access.

The Idling event, however, provides a possibility to work around this limitation.

Daren Thomas, the author or RevitPythonShell, even presented a neat and clean pattern for semi asynchronous Idling API access.

Now Victor Chekalin, aka Виктор Чекалин, presents another very neat sample providing such an access. He says:

I have an idea how to access Revit from an external application.

The only official way to achieve this is through the Idling event and external events, of course.

The main idea:

• Inside Revit I create a service which receives queries from a stand-alone external process.
• The service receives a command from the external process and pushes it to the command pool.
• The Idling event handler looks at the command pool; if a command is waiting in the pool, it will be executed in the Idling event handler.

There is no risk. All commands are executed in the one and only Revit thread.

Here is the scheme of work:

In this implementation, I am using a WCF service. It would be equally possible to use any other technology or framework to handle the inter-application communication.

Everything you need to know about creating and using a WCF service is described in the WCF Getting Started Tutorial.

I created a simple demonstration project to test this idea. It implements the following minimal service demonstrating that we can access the Revit API, both to query it for information and execute and action that modifies the current BIM:

namespace RevitExternalAccessDemo
{
  [ServiceContract]
  public interface IRevitExternalService
  {
    [OperationContract]
    string GetCurrentDocumentPath();
 
    [OperationContract]
    bool CreateWall( XYZ startPoint, XYZ endPoint );
  }
}

It further requires:

• An external application to manage the Idling event subscription.
• An implementation of the service defined above.
• Two helper classes:
  • One to contain the queued up tasks and handle locking issues.
  • The other to redefine an own representation of the Revit API XYZ point class.

Here is a short video showing how it works:

I am happy to make the project available for everyone in its current state.

The source code is available on Github, both directly and as a Github zip archive file.

It is just a demo and provided as is.

To launch it on your computer, you must run Revit as administrator, because this is required by the WCF service.

Remember, Revit must be idling to launch a command from the external application.

In this kind of situation, calling the SetRaiseWithoutDelay method is of utmost importance. Without the call, the demo pauses. Even with it, some delay exists, and the CPU load grows to over 25% even if no operations are active in Revit.

A better solution exists – follow Arnošt Löbel suggestion: subscribe to the Idling event only when you really need it, and unsubscribe immediately afterwards, as soon as possible.

Obviously, we need to handle Idling only when we have a request queued up from the WCF service. The idea would be to subscribe to the Idling event when we receive a request from the WCF Service and unsubscribe when it has been processed.

Unfortunately, I have not yet implemented this idea in the code presented here.

Here are some sample code snippets from the current implementation.

First, here is the main external application implementation including:

• OnStartup, which creates the WCF service and subscribes to the Idling event.
• OnIdling, the Idling event handler, which dequeues and executes the next task.
• OnShutdown, unsubscribing and cleaning up.

class App : IExternalApplication
{
  private const string serviceUrl =
    "http://localhost:56789/RevitExternalService";
 
  private ServiceHost serviceHost;
 
  public Result OnStartup( 
    UIControlledApplication a )
  {
    a.Idling += OnIdling;
 
    Uri uri = new Uri( serviceUrl );
 
    serviceHost = new ServiceHost( 
      typeof( RevitExternalService ), uri );
 
    try
    {
      serviceHost.AddServiceEndpoint( 
        typeof( IRevitExternalService ), 
        new WSHttpBinding(), 
        "RevitExternalService" );
 
      ServiceMetadataBehavior smb 
        = new ServiceMetadataBehavior();
 
      smb.HttpGetEnabled = true;
 
      serviceHost.Description.Behaviors.Add( smb );
 
      serviceHost.Open();
    }
    catch( Exception ex )
    {
      a.ControlledApplication.WriteJournalComment( 
        "Could not start WCF service.\r\n" 
        + ex.ToString(),
        true );
    }
    return Result.Succeeded;
  }
 
  private void OnIdling( 
    object sender, 
    IdlingEventArgs e )
  {
    var uiApp = sender as UIApplication;
 
    Debug.Print( "OnIdling: {0}", 
      DateTime.Now.ToString( "HH:mm:ss.fff" ) );
 
    // Be careful! This loads the CPU:
 
    e.SetRaiseWithoutDelay();
 
    if( !TaskContainer.Instance.HasTaskToPerform )
      return;
 
    try
    {
      Debug.Print( "Start execute task: {0}", 
        DateTime.Now.ToString( "HH:mm:ss.fff" ) );
 
      var task = TaskContainer.Instance.DequeueTask();
 
      task( uiApp );
 
      Debug.Print( "Ending execute task: {0}", 
        DateTime.Now.ToString( "HH:mm:ss.fff" ) );
    }
    catch( Exception ex )
    {
      uiApp.Application.WriteJournalComment(
        "RevitExternalService. An error occured "
        + "while executing the OnIdling event:\r\n"
        + ex.ToString(), true );
 
      Debug.WriteLine( ex );
    }
  }
 
  public Result OnShutdown( UIControlledApplication a )
  {
    a.Idling -= OnIdling;
 
    if( serviceHost != null )
    {
      serviceHost.Close();
    }
    return Result.Succeeded;
  }
}

Secondly, here is part of the RevitExternalService definition including one of its method implementations:

class RevitExternalService : IRevitExternalService
{
  private string currentDocumentPath;
 
  private static readonly object _locker 
    = new object();
 
  private const int WAIT_TIMEOUT = 10000; // 10 seconds timeout
 
  public string GetCurrentDocumentPath()
  {
    Debug.Print( "Push task to the container: {0}", 
      DateTime.Now.ToString( "HH:mm:ss.fff" ) );
 
    lock( _locker )
    {
      TaskContainer.Instance.EnqueueTask( GetDocumentPath );
 
      // Wait when the task is completed
 
      Monitor.Wait( _locker, WAIT_TIMEOUT );
    }
 
    Debug.Print( "Finish task: {0}", 
      DateTime.Now.ToString( "HH:mm:ss.fff" ) );
 
    return currentDocumentPath;
  }
 
  private void GetDocumentPath( 
    UIApplication uiapp )
  {
    try
    {
      currentDocumentPath 
        = uiapp.ActiveUIDocument.Document.PathName;
    }
    finally
    {
      // Always release locker in finally block
      // to ensure to unlock locker object.
 
      lock( _locker )
      {
        Monitor.Pulse( _locker );
      }
    }
  }
 
  public bool CreateWall( 
    XYZ startPoint, 
    XYZ endPoint )
  {
    // . . .
  }
}

For completeness' sake, here is also VCRevitExternalAccessDemo.zip containing my personal version of the code, mainly for my own convenience :-)

Many thanks to Victor for very clear and efficient sample implementation!

By the way, don't miss the additional neat little feature demonstrated by the sample code above, the use of the Application WriteJournalComment method to add a comment to the Revit journal file.

Programmatic Creation of a Structural Engineering Plan

Saikat Bhattacharya discusses the details and provides sample code to create a new Revit EngineeringPlan view using the static ViewPlan.Create method and a ViewFamily.StructuralPlan ViewFamilyType.

Stair Geometry and Roombook

A long time back we touched on the difficulties and challenges in retrieving column and stair geometry.

From Revit 2013 onwards, you have full API access to create and read data from stairs and railings, as well as their separate subcomponents, as you can see from this excerpt of the What's New section in the Revit API help file RevitAPI.chm:

Stairs and Railings API – Stairs and Stair Components

The new Stairs and StairsType classes in the Autodesk.Revit.DB.Architecture namespace provide access to new stairs elements in the Revit database. Note that these API classes only provide access to the Stairs created 'by component' introduced in this release. Stair elements created by sketch cannot be accessed as a Stairs object in the API. It is possible to identify both types of stairs using the BuiltInCategory OST_Stairs. The static predicate method Stairs.IsByComponent indicates whether a stair alement is created by components (runs, landings and supports) or not.

The classes StairsLanding, StairsLandingType, StairsRun and StairsRunType provide access to the subcomponents and subcomponent types of the new Stairs elements.

The pre-2013 stairs are still supported by Revit in old models, and their geometry is still not accessible.

Several useful hints about pre-2013 stair geometry access can be gleaned from the Autodesk Revit API forum discussion on accessing stair geometry, so I edited and summarised it a bit for reproduction here:

Question: I have a multiple floor building with stairs and need to access the stair geometry using the Revit API.

However, it returns empty values for stairs.

What can we do?

Answer: Stairs are not exposed in the Revit API prior to 2013. Please look at the Revit 2013 API overview and SDK update.

Unfortunately, only post-2013 stairs provide access to full location and geometry information.

For pre-2013 stairs, you will have to use other means.

Question: My stair models were created in Revit 2011 and 2012. I am trying to retrieve their information using the Revit 2013 API.

I can access information like Name, TypeName, FamilyName, TopLevel, BaseLevel, ActualNumRiser, ActualRiserHeight, TreadWidth, TreadDepth, TravelDistance, etc.

What I actually is geometry information like location points.

Is there any method to get the location information and the rooms associated with stairs?

Answer: You could calculate location points for pre-2013 stairs in a variety of different ways.

First, you could get the BoundingBoxXYZ of your stair. Using this, you could calculate its lower-most centre point as your desired location point.

Second, you could browse the stair geometry, also searching for the bottom-most point. For this, you need to iterate over all its solids and faces.

Third, there is a Sketch assigned to non-FamilyInstance based stairs. You can access it using unsupported element id relationships.

Having calculated a proper point, you can use the Document GetRoomAtPoint method to find the proper room.

You could compare the elevations of your levels to find the one fitting your location point, but actually both sketch and family based stairs already maintain a built-in parameter STAIRS_BASE_LEVEL_PARAM which provides the level directly, avoiding the need to iterate and search through all level elevations.

Question: By using BoundingBoxXYZ I can only get the Max and Min points of the stair bounding box. I still do not know location point of the landing or floor at the top and bottom of each stairway. How can I get these points from the bounding box?

Also, GetRoomAtPoint returns null when I try to use it to retrieve the room name. What should be causing that?

Answer: GetRoomAtPoint needs a point that is inside the room volume. It may be useful to ensure that the point you test is not located directly on the volume border. Because of tolerance issues, it could easily end up being falsely calculated as very slightly outside.

LocationPoint from BoundingBoxXYZ: What I meant was that you could calculate the point that is in the lower centre of the bounding box, meaning on the bottom. Add one meter to its Z value, e.g., to ensure it to be inside the 3D room volume. Use that to calculate a point to be passed to GetRoomAtPoint.

To calculate the landing and floor location points, you could analyze the stair geometry, meaning that you need to interpret it.

Question: Is it possible to analyze the stair's geometry for the Revit file created prior to 2013?

And is it possible to access the geometry information of stairs created by sketch and not by component?

Answer As I wrote in the comments on unsupported element id relationships:

"But even if we cannot *modify* a stair this way, we can get *more* information than we would get if we just read the stair's parameters or properties.

For example, the longest CurveArray in the Sketch.Profile of a stair can be combined with the number of steps to calculate the 3D data of each step's front side. The curves in the profile won't give us the correct Z data because the sketch is just a projection, but using the stair height and number of steps, we can calculate the Z distance for each step."

Of course you only can obtain 'stupid' geometry such as lines, faces and solids.

By combining that with the parameter values you mention above, you could *calculate* the information you want.

I must admit that there is no common approach for each type of stairs, but the point is how to obtain any information *at all*.

Many thanks to Rudolf the Revitalizer for this deep and inspiring explanation!

Revit 2013 Roombook Extension

The Revit Roombook extension helps calculate the surface area of walls, floors and ceiling elements, room circumferences and the total number of furnishing elements. It enables automated detection of room areas and surfaces and supports users in configuring this data to local requirements, achieving more accurate model take-offs, and exporting quantified results to Excel and QTO, Autodesk Quantity Takeoff.

I happened to notice this sweet 15 minute video explaining it in full detail:

A special highlight that I particularly enjoyed in this case is the effective and pleasant narration in a soft, very nicely and slightly accented female voice :-)

Revit 2013 Update Release 2

Revit 2013 Update Release 2 is now available.

I found a path to the Revit Architecture update via Autodesk Revit Products > Services & Support > Service Packs & Downloads > Autodesk Revit Architecture > Updates > Revit Architecture 2013 Update Release 2.

Phew. That was rather hard.

A much easier way to reach the exact download I am after is to enter the appropriate string in Google. That takes me directly to the download page with no need to manually traverse any convoluted search paths.

Here is a list of the Google search strings I entered and the resulting URLs:

• autodesk revit 2013 ultimate design suite update 2.
• autodesk revit 2013 architecture update 2
• autodesk revit 2013 mep update 2
• autodesk revit 2013 structure update 2

Here are the enhancements listed for this update. API enhancements are not included this time, unfortunately, but there are some of those in there as well:

Revit Architecture

• Improves stability when upgrading 2012 project which contains analytical walls.
• Improves stability when adjusting multiple sketch lines of a floor at the same moment.
• Improves stability when editing the gutters on a roof object with the Add/Remove Segment tool.
• Improves stability when renaming a Stair run type or landing to ‘none’.
• Improves stability when using the ribbon Cancel Edit Mode button to exit Stair Edit Mode.
• Improves stability when using an open profile for a wall sweep.
• Improves stability when splitting a wall.

Revit Structure

• Enables the Area, Area Boundary and Tag Area ribbon commands.
• Improves stability when using Beam Systems.
• Improves the respect of the Top In-Plane parameter for Analytical Models Walls after wall is modified.
• Improves the joining of Rebar to the host surfaces.
• Improves retention of Rebar Shapes upgraded within Revit 2012 projects.
• Improves stability when editing Rebar Shapes in the Family Editor.
• Improves display of underlay items in non-wireframe Structural Views.

Revit MEP

• Improves stability when sizing Duct.
• Corrects the use of tees when specified in duct routing preferences within projects upgraded from Revit 2012.
• Improves stability when upgrading a pipe fitting connected to multiple systems.
• Improves stability when editing duct fitting size in the active view and then editing the duct fitting type in the Property Palette.

Revit Platform

• Improves stability when Save to Central or Sync with Central.
• Improves stability when utilizing Create Assembly Views from the project browser.
• Improves stability when editing a label within the family editor.
• Improves stability when saving file to a location with low disc space.
• Improves stability when launching Export gbXML Settings dialog.
• Improves stability and memory usage within graphics display.
• Improves stability during IFC data import which contains openings with no usable geometry.
• Improves stability when importing IFC data which imported into Revit 2012 with warnings.
• Improves import of clipped solids during IFC import.
• Improves IFC Export to support buildingSMART International IFC certification.
• Improves stability when linking or attached DWG files.
• Improves stability of printing after Export to DWG or DXF format.
• Improves stability when creating, duplicating or deleting a material in the Material Editor.
• Improves the retention of part parameters within a part upgraded from Revit 2012.
• Corrects ribbon tab population after installing .NET 4.5
• Improves stability while editing calculated values within a schedule after deleting a parameter used in a formula.
• Improves stability with schedules which contains a filter based upon a user defined parameter and elements in linked files do not contain the user defined parameter.
• Improves stability when opening Sun Settings dialog.
• Improves stability when editing Text Notes.
• Improves stability when upgrading Revit 2012 project to Revit 2013.
• Improves stability when moving a Crop Region which utilizes the disjoin option.

The build identifier is 20121003_2115 Update Release 2.

UIView, Windows Coordinates, ReferenceIntersector and My Own Tooltip

Here is my well-meant contribution to making this the most exciting Wednesday of your entire week.

For the first time in history, the Revit 2013 UIView class provides a possibility to convert back and forth between Revit model coordinates and Windows device screen points.

I imagined making use of that right away when I read about the UIView class, and mentioned it when discussing UIView and Windows device coordinates.

I am still a bit surprised that I have not yet received any questions about these exciting possibilities. Well, anyway, that gives me a chance to finally dive into this exploration free of preconceptions.

Another Revit 2013 topic that I wanted to talk about for a long time is the new ReferenceIntersector class. My previous attempts at publishing anything on it were thwarted by running into some unintended features which have meanwhile been attended to.

Now I can combine both of these topics into a single nice example, presenting my very own tooltips displaying any information I like based on the cursor location in the Revit BIM.

Does that sound cool, or what?

To give you an idea of what I am talking about, here is a two-minute video depicting a sample run demonstrating the final result, with the normal Revit tooltips and my own specialised ones displayed side by side.

To run the demo, I open up the basic architectural sample project, switch away from the perspective view, since add-ins are disabled there, select Level 2, turn on my own tooltips, hover around different elements to compare the Revit tooltip with my own one, and turn off my tooltips again:

Table of Contents

To display a useful tooltip, the user needs to be free to play around in the model.

Simultaneously, my add-in needs to be able to access the Windows cursor location, determine the corresponding Revit model coordinates from it, and query the Revit BIM to determine the information I would like to display.

This calls for an Idling event handler, adding a third topic to the two already mentioned above.

We thus end up with the following list, including hints on the respective approaches, solutions, and helper methods:

• Top-level form and Idling event management: ModelessForm_IdlingEvent.
• Helper methods: GetActiveUiView, GetView3d, ElementDescription.
• Idling event handler:
  • Access Windows cursor location: System.Windows.Forms.Cursor.Position.
  • Determine Revit model coordinates: UIView.
  • Query Revit BIM for information: ReferenceIntersector.
  • Display tooltip: JtTooltipForm.
  • Entire implementation.
• Toggle tooltip on and off commands.
• Conclusion and download.

Before closing, I also mention Saikat's new posts on multi-image naming conventions and text file TaskDialog command links, DesignScript availability on Autodesk Labs, and a nice video of my friend Falk on the Schafberg.

Top-level Form and Idling Event Management

As you hopefully know by now, the implementation to handle the Idling event needs to be really clean and clear and is a little bit tricky.

I strongly suggest basing anything you do on the ModelessForm_IdlingEvent SDK sample.

If you implemented your Idling event handler in any other way in the past, it might be a good idea revisiting it now and comparing notes with that sample.

I based my WinTooltip external application on it, anyway.

It handles all the modeless form interaction in the external application implementation.

In my case, the modeless form is either a Visual Studio designer generated JtTooltipForm or a hand-built JtTooltipForm2.

The external application is instantiated as a singleton instance, and provides public access to that instance so that external commands can access it and use its functionality to show and hide the modeless form.

It implements an internal CloseForm method, public methods ShowForm and HideForm, called by the external commands, and the standard interface methods OnStartup and OnShutdown, like this:

  /// <summary>
  /// Singleton external application class instance.
  /// </summary>
  internal static App _app = null;
 
  /// <summary>
  /// Provide access to singleton class instance.
  /// </summary>
  public static App Instance
  {
    get { return _app; }
  }
 
  /// <summary>
  /// The tooltip form to display.
  /// </summary>
  internal static JtTooltipForm2 _form = null;
 
  /// <summary>
  /// Dispose and null out form.
  /// Return true if it was previously not disposed.
  /// </summary>
  static bool CloseForm()
  {
    bool rc = _form != null;
 
    if( rc )
    {
      if( !_form.IsDisposed )
      {
        _form.Dispose();
      }
      _form = null;
    }
    return rc;
  }
 
  /// <summary>
  /// Create and show the form, 
  /// unless it already exists.
  /// </summary>
  /// <remarks>
  /// The external command invokes 
  /// this on end-user request.
  /// </remarks>
  public void ShowForm( UIApplication uiapp )
  {
    // If we do not have a form yet, create and show it
 
    if( _form == null || _form.IsDisposed )
    {
      // Instantiate JtTooltipForm to use 
      // the designer generated form.
 
      _form = new JtTooltipForm2();
 
      _form.Show();
 
      // If we have a form, we need Idling too
 
      uiapp.Idling += IdlingHandler;
    }
  }
 
  /// <summary>
  /// Hide the form.
  /// </summary>
  /// <remarks>
  /// The external command invokes 
  /// this on end-user request.
  /// </remarks>
  public void HideForm( UIApplication uiapp )
  {
    if( CloseForm() )
    {
      // If the form was showing, we had subscribed
 
      uiapp.Idling -= IdlingHandler;
    }
  }
 
  public Result OnStartup( UIControlledApplication a )
  {
    _app = this;
    _form = null;
 
    return Result.Succeeded;
  }
 
  public Result OnShutdown( UIControlledApplication a )
  {
    if( CloseForm() )
    {
      a.Idling -= IdlingHandler;
    }
    return Result.Succeeded;
  }

Helper Methods

Apart from the top-level management, the Idling event handler does all the rest of the work.

Before we get to the event handler itself, I'll present the three helper methods it uses:

• GetActiveUiView: retrieve the active UIView.
• GetView3d: retrieve the 3D view named "{3D}".
• ElementDescription: return a descriptive text for a given Revit element.

We can get the active document view directly, but need some additional coding to determine the associated UIView, for example like this:

/// <summary>
/// Return currently active UIView or null.
/// </summary>
static UIView GetActiveUiView( 
  UIDocument uidoc )
{
  Document doc = uidoc.Document;
  View view = doc.ActiveView;
  IList<UIView> uiviews = uidoc.GetOpenUIViews();
  UIView uiview = null;
 
  foreach( UIView uv in uiviews )
  {
    if( uv.ViewId.Equals( view.Id ) )
    {
      uiview = uv;
      break;
    }
  }
  return uiview;
}

The ReferenceIntersector constructor requires a 3D view argument in which the ray tracing takes place. In this sample, I assume that a suitable 3D view named "{3D}" is available and retrieve that using one single line of filtered element and LINQ driven code:

/// <summary>
/// Return the 3D view named "{3D}".
/// </summary>
View3D GetView3d( Document doc )
{
  return new FilteredElementCollector( doc )
    .OfClass( typeof( View3D ) )
    .Cast<View3D>()
    .FirstOrDefault<View3D>( 
      v => v.Name.Equals( "{3D}" ) );
}

You can obviously modify this in any way you like and set up a suitable 3D view to suit your specific view setting, sectioning and filtering needs.

The location dependent BIM information displayed in the tooltip can be determined completely freely. In my case, I simply detect what element the cursor is hovering over and use the ElementDescription method to put together a descriptive text for it:

/// <summary>
/// Return a string describing the given element:
/// .NET type name,
/// category name,
/// family and symbol name for a family instance,
/// element id and element name.
/// </summary>
static string ElementDescription(
  Element e )
{
  if( null == e )
  {
    return "<null>";
  }
 
  // For a wall, the element name equals the
  // wall type name, which is equivalent to the
  // family name ...
 
  FamilyInstance fi = e as FamilyInstance;
 
  string typeName = e.GetType().Name;
 
  string categoryName = ( null == e.Category )
    ? string.Empty
    : e.Category.Name + " ";
 
  string familyName = ( null == fi )
    ? string.Empty
    : fi.Symbol.Family.Name + " ";
 
  string symbolName = ( null == fi
    || e.Name.Equals( fi.Symbol.Name ) )
      ? string.Empty
      : fi.Symbol.Name + " ";
 
  return string.Format( "{0} {1}{2}{3}<{4} {5}>",
    typeName, categoryName, familyName,
    symbolName, e.Id.IntegerValue, e.Name );
}

This is somewhat similar to and yet does not exactly match the information displayed by the standard Revit tooltip and other parts of the user interface, as you might have noticed in the video recording.

Idling Event Handler

The Idling event handler implements the following steps, which we first discuss one by one before presenting the entire code in context:

• Access Windows cursor location: System.Windows.Forms.Cursor.Position.
• Determine Revit model coordinates: UIView.
• Query Revit BIM for information: ReferenceIntersector.
• Display tooltip: JtTooltipForm.
• Entire implementation.

Access Windows Cursor Location

Converting from the cursor position retrieved in Windows device coordinates to Revit model coordinates is possible by calculating the relative position in the UIView.

Here is an illustration assuming a screen resolution of 1600 x 1200 with a Revit view located at the rectangle 800,150 to 1500,650, displaying a plan view of part of the Revit model, with model coordinates ranging from 10,40,0 to 220,120,0. The current cursor location is represented by the green spot:

The Windows device coordinate origin 0,0 is at the upper left, and Y values increase downwards, whereas the Revit model coordinate Y values increase upwards.

You can easily query the cursor position in device coordinates on the Windows screen from .NET framework at any time using the System.Windows.Forms.Cursor.Position property:

  Point p = System.Windows.Forms.Cursor.Position;

Determine Revit Model Coordinates

The cursor location is obviously returned in Windows device coordinates, stored in the point (or vector) variable 'p'.

The aim is to determine the location indicated by this point in Revit model coordinates, for example by determining the vector v from the lower left corner of the Revit view to that location.

We can easily determine the relative position of p between the two corners of the UIView in Windows device coordinates by subtracting the lower left hand corner and dividing by the total width and height to obtain the relative width and height location values dx and dy like this:

  UIView uiview = GetActiveUiView( uidoc );
 
  Rectangle rect = uiview.GetWindowRectangle();
 
  Point p = System.Windows.Forms.Cursor.Position;
 
  double dx = (double) ( p.X - rect.Left )
    / ( rect.Right - rect.Left );
 
  double dy = (double) ( p.Y - rect.Bottom )
    / ( rect.Top - rect.Bottom );

From the UIView, we can also determine model coordinates of the view corners. They are stored in a and b, respectively.

Now it is easy to calculate the cursor point 'q' in model coordinates from the two relative values like this:

  IList<XYZ> corners = uiview.GetZoomCorners();
  XYZ a = corners[0];
  XYZ b = corners[1];
  XYZ v = b - a;
 
  XYZ q = a
    + dx * v.X * XYZ.BasisX
    + dy * v.Y * XYZ.BasisY;

Query Revit BIM for Information using ReferenceIntersector Ray Casting

Once we have the model space cursor location 'q', we can calculate a point beyond the model extents (hopefully) from which one can picture the user looking into the model.

The first element intersected by a ray cast from that point in the view direction should be the one we are interested in displaying information about.

Initially, the sample run was a bit boring, because the only element encountered when looking from straight above was always the roof.

I tweaked that to make the example more interesting, not by modifying the model itself – I use the standard architectural basic sample project rac_basic_sample_project.rvt – but by adding a filter to remove all roof category elements from the reference intersector results instead. The exact elements of interest and information to display are entirely up to you and your needs to determine, of course.

The ray casting requires a 3D view to operate in. In this case, I simply pick the one named "{3D}" returned by the GetView3d helper method. You can set up your own view with specific graphics properties, section cuts, and only certain elements visible, if that better suits your requirements.

Here is the code determining the view, view direction and ray origin, setting up the intersector, determining the target element, and defining the tooltip text to display in the variable 's':

  View3D view3d = GetView3d( doc );
 
  XYZ viewdir = view.ViewDirection;
 
  XYZ origin = q + 1000 * viewdir;
 
  // Find all elements:
 
  //ReferenceIntersector ri
  //  = new ReferenceIntersector( view3d );
 
  // Find all elements except roofs:
 
  ElementFilter f = new ElementCategoryFilter( 
    BuiltInCategory.OST_Roofs, true );
 
  ReferenceIntersector ri 
    = new ReferenceIntersector( f, 
      FindReferenceTarget.Element, view3d );
 
  ReferenceWithContext rc
    = ri.FindNearest( origin, -viewdir );
 
  string s = "Element not found";
 
  if( null != rc )
  {
    Reference r = rc.GetReference();
 
    Element e = doc.GetElement( r );
 
    s = ElementDescription( e );
  }

Display Tooltip and the JtTooltipForm class

I originally used the Visual Studio designer to create a simple tooltip form named JtTooltipForm for me, then tweaked that auto-generated code to create one named JtTooltipForm2 myself programmatically from scratch.

Besides the constructor setting up the form and the Label object to display the tooltip text, it also manages an offset from the cursor position at which to display itself, provides a method to set the tooltip text, and overrides the OnShown and OnVisibleChanged methods to react appropriately to position changes:

/// <summary>
/// A tooltip window designed to move 
/// around with the cursor position.
/// </summary>
class JtTooltipForm2 : Form
{
  /// <summary>
  /// The offset from the mouse pointer 
  /// at which to show the form.
  /// </summary>
  public Point Offset { get; set; }
 
  /// <summary>
  /// Tooltip text.
  /// </summary>
  Label _label;
 
  /// <summary>
  /// Set the tooltip text.
  /// </summary>
  public void SetText( string s )
  {
    _label.Text = s;
  }
 
  /// <summary>
  /// Move the window to an offset of mouse pointer.
  /// </summary>
  protected override void OnShown( EventArgs e )
  {
    base.OnShown( e );
 
    Location = new Point(
      MousePosition.X + Offset.X,
      MousePosition.Y + Offset.Y );
  }
 
  /// <summary>
  /// Move the window to an offset of mouse pointer.
  /// </summary>
  protected override void OnVisibleChanged(
    EventArgs e )
  {
    base.OnVisibleChanged( e );
 
    if( Visible )
    {
      Location = new Point(
        MousePosition.X + Offset.X,
        MousePosition.Y + Offset.Y );
    }
  }
 
  public JtTooltipForm2()
  {
    Size = new Size( 200, 20 );
 
    _label = new Label();
 
    SuspendLayout();
 
    _label.AutoSize = false; // the label will not change its height automatically, only width, so switch off AutoSize to wrap text
    _label.CausesValidation = false;
    _label.Dock = DockStyle.Fill;
    _label.Location = new Point( 0, 0 );
    _label.Size = new Size( 35, 13 );
    _label.Parent = this;
 
    AutoScaleDimensions = new SizeF( 6F, 13F );
    AutoScaleMode = AutoScaleMode.Font;
    BackColor = SystemColors.Info;
    ClientSize = new Size( 200, 12 );
    Controls.Add( _label );
    FormBorderStyle = FormBorderStyle.None;
    Name = "JtTooltipForm";
    Opacity = 0.8D;
    ShowInTaskbar = false;
    TopMost = true;
    TransparencyKey = Color.White;
 
    ResumeLayout( false );
    PerformLayout();
 
    Offset = new Point( 10, 0 );
  }
}

You may note that I switched off the AutoSize property. Setting it to true enables the label to automatically expand, and that just means getting wider to fit the text length. The label will not change its height automatically, only width.

A neat trick to wrap text before putting it into the label that I spotted and did not make use of employs a regular expression to do the job:

  WrappedMessage := RegExReplace( 
    LongMessage, "(.{50}\s)", "$1`n" );

Controlling the text and position from the Idling event handler is a trivial two-liner:

  // Move tooltip to current cursor 
  // location and set tooltip text.
 
  _form.Location = p + new Size( _form.Offset );
  _form.SetText( s );

Entire Idling Event Handler Implementation

For better readability, here is the entire Idling event handler implementation in all its glory.

It even includes one slight improvement that is not demonstrated by the ModelessForm_IdlingEvent SDK sample implementation:

If the Revit project is closed while the Idling event is still subscribed to, the UI document may be null. One needs to add a check for that situation as well in the Idling handler, in case the hander relies on an open document.

/// <summary>
/// Idling event handler.
/// </summary>
/// <remarks>
/// We keep the handler very simple. First check
/// if we still have the form. If not, unsubscribe 
/// from Idling, for we no longer need it and it 
/// makes Revit speedier. If the form is around, 
/// check if it has a request ready and process 
/// it accordingly.
/// </remarks>
public void IdlingHandler( 
  object sender, 
  IdlingEventArgs args )
{
  UIApplication uiapp = sender as UIApplication;
  UIDocument uidoc = uiapp.ActiveUIDocument;
 
  if( null == uidoc || _form.IsDisposed )
  {
    uiapp.Idling -= IdlingHandler;
  }
  else // form still exists
  {
    Document doc = uidoc.Document;
    View view = doc.ActiveView;
 
    UIView uiview = GetActiveUiView( uidoc );
 
    Rectangle rect = uiview.GetWindowRectangle();
 
    Point p = System.Windows.Forms.Cursor.Position;
 
    double dx = (double) ( p.X - rect.Left )
      / ( rect.Right - rect.Left );
 
    double dy = (double) ( p.Y - rect.Bottom )
      / ( rect.Top - rect.Bottom );
 
    IList<XYZ> corners = uiview.GetZoomCorners();
    XYZ a = corners[0];
    XYZ b = corners[1];
    XYZ v = b - a;
 
    XYZ q = a
      + dx * v.X * XYZ.BasisX
      + dy * v.Y * XYZ.BasisY;
 
    // If the current view happens to be a 3D view, 
    // we could simply use it right away. In 
    // general we have to find a different one to 
    // run the ReferenceIntersector in.
 
    View3D view3d = GetView3d( doc );
 
    XYZ viewdir = view.ViewDirection;
 
    XYZ origin = q + 1000 * viewdir;
 
    // Find all elements:
 
    //ReferenceIntersector ri
    //  = new ReferenceIntersector( view3d );
 
    // Find all elements except roofs:
 
    ElementFilter f = new ElementCategoryFilter( 
      BuiltInCategory.OST_Roofs, true );
 
    ReferenceIntersector ri 
      = new ReferenceIntersector( f, 
        FindReferenceTarget.Element, view3d );
 
    ReferenceWithContext rc
      = ri.FindNearest( origin, -viewdir );
 
    string s = "Element not found";
 
    if( null != rc )
    {
      Reference r = rc.GetReference();
 
      Element e = doc.GetElement( r );
 
      s = ElementDescription( e );
    }
 
    // Move tooltip to current cursor 
    // location and set tooltip text.
 
    _form.Location = p + new Size( _form.Offset );
    _form.SetText( s );
  }
}

Toggle Tooltip On and Off Commands

To simplify the usage and cooperation with other add-ins, I implemented two trivial read-only external commands calling the external application ShowForm and HideForm methods to toggle my personal tooltips on and off:

[Transaction( TransactionMode.ReadOnly )]
public class CmdTooltipOn : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    App.Instance.ShowForm( 
      commandData.Application );
 
    return Result.Succeeded;
  }
}
 
[Transaction( TransactionMode.ReadOnly )]
public class CmdTooltipOff : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    App.Instance.HideForm(
      commandData.Application );
 
    return Result.Succeeded;
  }
}

Conclusion and Download

I hope you find this as useful as I imagine it might become, and look forward to your feedback.

By the way, I will be talking about this sample and the possibilities it demonstrates along with many other topics in my Autodesk University presentation CP4107 on the new Revit 2013 UI API functionality, probably making this the most exciting one of my three AU sessions.

Here is a current snapshot of the entire source code, Visual Studio solution and add-in manifest of the WinTooltip sample application, together the rest of my CP4107 sample material. The latter is based on my DevCamp Revit 2013 UI API samples.

Here are a couple of other items of interest before I wrap up, related to the Revit API, technology and purely human interst.

DWG and Image Export Naming Convention

Saikat Bhattacharya points out that the naming convention for exporting multiple images follows the one used for DWG export: [FileName]-[ViewType]-[ViewName].[image format].

Displaying a Text File from a TaskDialog Command Link

I recently mentioned the order of TaskDialog command links.

Now Saikat Bhattacharya picked up a related issue, on how to define a TaskDialog command link to open up a text file in the local system.

URLs and local system HTML links work fine out of the box. A text file, however, needs special processing. One way to launch it is by using the Process.Start method in the .NET System.Diagnostics namespace. Saikat provides the source.

DesignScript

A very exciting new technology is now publicly available on Autodesk Labs: DesignScript:

• A powerful scripting language for exploratory programming.
• Managing and distinguishing between a generative description of a design (as a script) and the resulting generated model.
• A language to help designers build and analyze complex geometric models that would be difficult to model with interactive techniques.
• Integrated into a host geometry application (currently AutoCAD).

The designer no longer directly models the resulting design: instead she develops a script whose execution generates the model. This enables a completely different kind of design model to be created. The design process is also different. An apparently minor edit to the script can have a profound effect on the generated model, enabling the exploration of a vast array of alternatives, with much less effort than manual interactive modeling. Here is a five-minute video explanation of Design Computation by Robert Aish for Autodesk University last year:

Kean Walmsley provides a very nice explanation and description of the DesignScript sample he implemented for it together with Robert in 2008 for the Design Computation Symposium and AU mainstage presentation.

Now you can try it for yourself. Unfortunately, DesignScript is not yet available for Revit...

Falk on Schafberg

For something completely unrelated to any technology at all, here is a nice little video of my friend Falk recently when we hiked over the Wildhauser Schafberg (sheep mountain) together, clearly illustrating some basic and sympathetic human and ovine commonalities :-)

Wall Footing Relationship Revisited

In the far distant past, I looked at various ways to programmatically determine relationships between associated objects (also in VB), including references between a host object and its hosted dependent elements, e.g. determining the relationship between a wall and its footing.

That was back in the year 2009, using Revit 2010.

A few things have changed and been added since then, but the more things change, the more they stay the same, don't they?

Anyway, this very question was raised again:

Question: Is there a way to obtain a reference to a wall footing from the wall attached to it?

Answer: Yes, sure, there are several different possibilities to achieve this.

You could start off by determining the bottom face of the wall.

Using that, you could set up an ElementIntersectsSolidFilter for a filtered element collector to retrieve all foundation elements touching or intersecting that face, as described for retrieving all touching beams. You would obviously want to apply as many quick filters as possible before taking recourse to the slow geometric filtering, e.g. check for level, category, type, etc. first.

Another way to determine adjacency of Revit BIM elements is to make use of the ray casting functionality provided by the FindReferencesByDirection method, FindReferencesWithContextByDirection method and the ReferenceIntersector class, e.g. cast a ray downwards from the wall and detect the first foundation hit by it.

Last but not least, another way to determine relationships between associated objects such as a wall and its footing is to temporarily delete the host object, causing the dependent objects to be deleted as well. The deleted element ids can be determined, and the whole operation undone to leave the model unchanged.

I described this principle several times, e.g. looking at object relationships (in VB), and specifically determining the wall footing of a given wall.

I cannot tell off-hand which of these methods is most useful and efficient in your specific case, although I would be very interested in seeing the results of some comparisons and benchmarks evaluating this.

Anyway, I note that The Building Coder sample command CmdWallFooting implementing the latter approach is pretty much out of date, having been simply flat ported across several Revit API releases in the past few years.

I therefore updated it for and tested it with Revit 2013, and can now confirm that it still works.

Here is the updated implementation:

[Transaction( TransactionMode.Manual )]
class CmdWallFooting : IExternalCommand
{
  public Result Execute(
    ExternalCommandData commandData,
    ref string message,
    ElementSet elements )
  {
    UIApplication app = commandData.Application;
    UIDocument uidoc = app.ActiveUIDocument;
    Document doc = uidoc.Document;
 
    Wall wall = Util.SelectSingleElementOfType(
      uidoc, typeof( Wall ), "a wall", false ) 
        as Wall;
 
    if ( null == wall )
    {
      message 
        = "Please select a single wall element.";
 
      return Result.Failed;
    }
 
    ICollection<ElementId> delIds = null;
 
    using( Transaction t = new Transaction( doc ) )
    {
      try
      {
        t.Start( "Temporary Wall Deletion" );
 
        delIds = doc.Delete( wall );
 
        t.RollBack();
      }
      catch ( Exception ex )
      {
        message = "Deletion failed: " + ex.Message;
        t.RollBack();
      }
    }
 
    ContFooting footing = null;
 
    foreach ( ElementId id in delIds )
    {
      footing = doc.GetElement( id ) as ContFooting;
 
      if( null != footing )
      {
        break;
      }
    }
 
    string s = Util.ElementDescription( wall );
 
    Util.InfoMsg( ( null == footing )
      ? string.Format( "No footing found for {0}.", s )
      : string.Format( "{0} has {1}.", s,
        Util.ElementDescription( footing ) ) );
 
    return Result.Succeeded;
  }
}

I ran this command on a minimal sample model containing just one structural wall with its footing:

The command reports the expected relationship:

It says:

Wall Walls <164432 Generic - 200mm> has 
ContFooting Structural Foundations <164470 
Retaining Footing - 300 x 600 x 300>.

Here is version 2013.0.99.3 of The Building Coder samples including the updated CmdWallFooting external command.

Detach Workset and TaskDialog Command Link Order

Here is a neat and simple solution using the DialogBoxShowing event to detach and discard worksets by Erik Eriksson of White Arkitketer AB, who already provided a useful workaround to synchronize with central using SendKeys in combination with the Idling and DocumentSynchronizedWithCentral events.

Here is the issue:

Question: We have a need to detach project files without worksets.

For instance, it would be great to just have an option to detach and discard worksets.

Why do we need this?

This would be useful for our in-house tools to diagnose project files. For this to work, we need to have the project files without worksets, because we delete different types of elements and check the file size before and afterwards. To determine a correct file size, we need to compact the files after every operation. This cannot be done programmatically, but, for non-workshared files, it is performed automatically each time the project file is saved.

Currently, we execute the detach and discard operation manually. However, with big projects containing many files, it would be nice to do less of these things manually.

Answer: The API currently does not provide this functionality directly.

However, the Revit 2013 API added some new document handling and worksharing changes which may help. Here is the description from the What's New section in the Revit API help file RevitAPI.chm:

Worksharing properties

The information required to identify a workshared file on the central or local locations has changed due to changes to RevitServer. As a result, the members

• Application.GetRevitServerNetworkHosts
• Application.CurrentRevitServerAccelerator
• Document.WorksharingCentralFilename

replace the properties

• Application.CentralServerName
• Application.LocalServerName
• Document.GetWorksharingCentralModelPath

The new members:

• Application.GetWorksharingCentralGUID(ServerPath serverModelPath)
• Document.WorksharingCentralGUID

provide read access to the worksharing central GUID of the given server-based model. This is applicable only to workshared models saved in Revit 2013 or later.

New overloads for Application.OpenDocumentFile and UIApplication.OpenAndActivateDocument

The new overloads support parameters OpenOptions and OpenOptionsForUI, respectively, to specify how a Revit document should be opened. Both options classes currently offer the ability to detach the opened document from central if applicable.

• The OpenOptions.DetachFromCentralOption property can be set to the default DoNotDetach or to DetachAndPreserve.
• The OpenOptionsForUI.DetachFromCentralOption property can be set to the default DoNotDetach, DetachAndPreserveWorksets or DetachAndPrompt.

In other words, the OpenOptions argument that you pass in to the OpenDocumentFile and OpenAndActivateDocument methods can now use the DetachFromCentral option to specify whether or not a workset-enabled document is detached from its central document.

Response: The new API functionality still does not provide the option of discarding the worksets.

I want the file to be a normal project file again.

OpenOptions holds the same options as OpenOptionsForUI (besides DetachAndPrompt). However, maybe I can catch that dialogue programmatically using the DialogBoxShowing event and override the result...

Success!

This is the code I used to fix it:

  public void OnDialogBoxShowing(
    object sender,
    DialogBoxShowingEventArgs e )
  {
    TaskDialogShowingEventArgs e2 
      = e as TaskDialogShowingEventArgs;
 
    if( null != e2 && e2.DialogId.Equals( 
      "TaskDialog_Detach_Model_From_Central" ) )
    {
      e.OverrideResult( 
        (int) TaskDialogResult.CommandLink2 );
    }
  }

The full implementation of this method actually includes a few more statements taking care of other dialogue boxes, which I omitted here.

I checked the IsWorkshared property after opening the file, and it was set to false. This indicates that it is no longer workshared, which means that the operation to discard the worksets succeeded. When you discard worksets, the workshared central file goes back to being a normal non-workshared project file, just like what you obtain when starting from a normal project template.

One thing I do wonder about is whether CommandLink2 is always below CommandLink1 and above CommandLink3?

Answer: It would appear so, since the description of the TaskDialog.AddCommandLink method clearly states that "CommandLinks will always be shown in the dialog in the order of their ids".

Also, as always, keep in mind that there is no guarantee that this will continue working in future releases. The order of these options can change at any time, and the required functionality might even be added to the official API one of these days.

Congratulations on solving this, Erik, and thank you for sharing it and providing this helpful explanation!

Setting IndependentTag Label to Pick Up a Parameter Value

I'll wrap up with a quick pointer to another AEC DevBlog article by Saikat Bhattacharya on defining the label displayed by an IndependentTag. Unfortunately this does not seem to be possible programmatically. It can however easily be achieved using an appropriate template or tag family configuration.

Updating Properties and Announcing Revit LT

Today, exceptionally, a second post, partly to highlight an interesting comment submitted by Jinshou on how to programmatically trigger a refresh of the Revit element properties window, and partly to announce a non-API issue, totally non-API, the imminent arrival of Autodesk Revit LT.

Refreshing Revit Element Properties

If I first invoke the UIApplication OpenAndActivateDocument method, then highlight elements as described in a previous post, the 'properties' window is updated.

The trick is that in order to call OpenAndActivateDocument on the document containing the elements to highlight, you have to first ensure that it is not the active document. To achieve this, I:

• Create an empty RVT file.
• Invoke OpenAndActivateDocument to activate that.
• Invoke OpenAndActivateDocument again on the document of interest.
• Highlight the elements.
• Don't forget to close the empty RVT file when finished.

Many thanks to Jinshou for this interesting hint.

Announcing Autodesk Revit LT

For the nonce, here is an announcement completely unrelated to the Revit API. In fact, the product announced is specifically designed to not be customisable.

Autodesk today announced Autodesk Revit LT software, a new addition to its award winning family of Revit software products. Designed for architects, designers and building industry professionals using 2D workflows who are looking to transition to the Building Information Modeling (BIM) process, Autodesk Revit LT software delivers a focused 3D application to help users create higher-quality and more accurate designs and documentation.

"Autodesk Revit LT reflects our commitment to provide architects, designers and building professionals, particularly those in small firms, the tools they need to ease the transition to get started with – and take advantage of – a BIM workflow," said Amar Hanspal, Autodesk senior vice president, information modeling products. "With Revit LT, customers can deliver higher-quality, more accurate designs and documentation – allowing them to bring projects to market faster and save time and money."

Autodesk Revit LT is built on the Revit platform for BIM and allows users to create designs efficiently with 3D, real-world building objects to produce reliable, coordinated documentation faster. Revit-based applications help deliver better coordination and quality, and can contribute to higher profitability for architects, design professionals and the rest of the building team. Some of the benefits of Revit LT include:

• Work more efficiently with a single, coordinated model that allows users to concurrently design and document building projects. Autodesk Revit LT automatically manages iterative changes to building models throughout the documentation process. As a result, a consistent representation of the building is maintained, helping to improve drawing coordination and reducing errors.
• Design and visualize in 3D. Revit LT allows users to see their designs virtually, improving their understanding of the building and its spaces, and helping them communicate design ideas to clients more clearly and effectively.
• Create photorealistic renderings in the cloud. Users who purchase Autodesk Subscription with Revit LT can render in the cloud directly from the Revit LT interface, enabling them to produce compelling, photorealistic visualizations without tying up their desktop
• Exchange designs in the DWG or RVT file formats. Produce designs in the DWG file format, and experience fluid file exchange with project team members using other Autodesk Revit software applications.

Availability

Autodesk Revit LT 2013 is scheduled to be available within the month in North America and in select countries worldwide. The product is available as a standalone version and as part of the new AutoCAD Revit LT Suite 2013, which includes both Autodesk Revit LT 2013 and AutoCAD LT 2013. Product availability varies by country. Details and purchasing options are available at www.autodesk.com/revitlt