We are pleased to announce the release of BimorphNodes v4.0.0 which is available to download via Dynamo’s Package Manager.

BimorphNodes v4.0.0 targets Revit 2022 and Dynamo v2.10 and is backwards compatible with Revit 2018 – 2021 and Dynamo v2.x.

In the latest version we have added 24 new nodes and focused on stability, improved exception handling, and bug fixes. This release also includes major updates internally; we’ve refactored the entire codebase from the ground up following a strict OOP (Object Orientated Programming) approach. This approach brings with it new nodes as well as improvements to the organisation and purpose of the nodes, while ensuring that future updates of the package are quicker and easier to undertake so we can avoid lengthy delays between releases.

If you are already a BimorphNodes user and plan to upgrade, please read the ‘Important Considerations Before Upgrading’ section as this release includes breaking changes.

What’s New

BimorphNodes v4.0.0 introduces a range of new node classes which support the new software architecture. The new classes include:

• Four new types of ‘result’ nodes which store the results from the various intersection functions BimorphNodes provides (between curves, solids and elements etc) in a more meaningful way. Previously the output from the intersection nodes – for example, the Element.IntersectsElement node – required lacing techniques to map the intersecting elements with the element that was used to perform the intersection test. The new results nodes aim to eliminate the ambiguity and complication this can cause by ‘packaging’ the result of each intersection into an object which can then be queried more intuitively.
• The ImportInstanceReport node class, which is the new return type from the ImportInstance.ReportInstances node. The class is designed to improve the clarity of the ImportInstance.ReportInstances output, enabling users to access specific properties from the report via its query nodes.
• The LineStyleAttributes node class, which is the new return type of the LineStyle.AllAttributes node and LineStyle.Create node. This class includes query nodes which enable access to the properties of the line style.

In addition to the above nodes, we have also introduced two new node classes: CurveElement and ImportInstance, however these classes have been introduced to restructure the node library rather than to add new nodes. For more details of which nodes have migrated to these classes, see the ‘Breaking Changes – Reclassified Nodes’ section.

Other updates in BimorphNodes v4.0.0 include:

• Added support for Revit 2022 and Dynamo 2.10 with backwards compatibility down to Revit 2018 and Dynamo 2.0.
• Enhanced the performance of many of the nodes so they execute faster.
• Updated the ‘Create’, ‘Action’ or ‘Query’ organisation of nodes in the BimorphNodes Dynamo library so it’s easier to understand their purpose.
• Fixed a range of bugs including some of the most reported bugs affecting nodes such as CADTextData.ByLayers; see the ‘Bug Fixes’ section for full details.
• Improved the input validation and exception handling of all the nodes so they provide more useful information to users if an input is invalid or if something goes wrong which prevents a node from executing.

Below are the full details of the new nodes in this release:

CurveSolidIntersectionResult

CurveSolidIntersectionResult node class is the new output from the Curve.SolidIntersection node. It stores the result from a solid curve intersection test. The CurveSegments query node stores the list of any trimmed curve segments if the intersection was successful. The Curve and Solid query nodes return the input entities which were used to perform the intersection.

Located under the new ‘Results’ category in the BimorphNodes Dynamo node library.

Nodes:

• Solid – The Dynamo Solid which was intersected with the Curve.
• Curve – The Revit curve which was intersected with the Solid.
• CurveSegments – The resultant curve segments of the intersection or empty if it failed or didn’t intersect.
• FailedToConvert – Returns true if the Solid failed to convert to a Revit API solid (required to perform the intersection).

CurveDuplicatesResult

CurveDuplicatesResult node class is the new output from the CurveElement.RemoveDuplicates node. It stores the result of the comparison of a list of Revit element curves (Model, Detail or Symbolic) in the search for duplicates. If any duplicates are found they are grouped and stored in the result. The Duplicates query node can be used to view the duplicates with the first curve found in the set assigned to the UniqueCurve making it easy to delete the duplicates if required.

Located under the new ‘Results’ category in the BimorphNodes Dynamo node library.

Nodes:

• Duplicates – A list containing duplicates of the UniqueCurve or empty if there are none.
• UniqueCurve – The first curve from the duplicates which is assigned as ‘unique’ from the set.

ElementIntersectionResult

ElementIntersectionResult node class is the new output from the Element.IntersectsElement node. It stores the result of an intersection test between an element and another set of elements. If any intersections are found, they are stored in a list inside the result. The IntersectingElements query node provides access to this list, with the Element query node returning the element that clashed with them.

Located under the new ‘Results’ category in the BimorphNodes Dynamo node library.

Nodes:

• Element – The element (from element set A) which was intersected against a set of elements (element set B).
• IntersectingElements – A list of elements (from element set B) which intersected with the Element or empty if there were no intersections.
• IsSupported – Returns true if the Element is supported by the intersection algorithm.

SolidIntersectionResult

SolidIntersectionResult node class is the new output from the Element.IntersectsSolid. It stores the result of an intersection test between a Dynamo solid and a list of Revit elements. If any intersections are found, they are stored in a list inside the result. The IntersectingElements query node provides access to this list. Use the Solid query node to return the Dynamo solid which intersected with the elements.

Located under the new ‘Results’ category in the BimorphNodes Dynamo node library.

Nodes:

• Solid – The Dynamo Solid which was used to intersect against the set of Revit elements.
• IntersectingElements – A list of Revit elements which intersected the Solid.
• FailedToConvert – Returns true if the Solid failed to convert to a Revit API solid (required to perform the intersection).

LineStyleAttributes

LineStyleAttributes node class is the new output from the LineStyle.AllAttributes and LineStyle.Create nodes. The node provides a range of query nodes that enable access to the various properties of a Revit line style (a GraphicsStyle).

Located under the ‘Revit.LineStyleAttributes’ category in the BimorphNodes Dynamo node library.

Nodes:

• Name – The name of the Revit line style.
• Color – The colour of the Revit line style.
• Weight – The line weight of the Revit line style.
• GraphicStyle – The line style Revit element.
• LinePatternElement – The line pattern element of the Revit line style.

ImportInstanceReport

ImportInstanceReport node class is the new output from the ImportInstance.ReportInstances node. It includes a range of query nodes to view the report of a given ImportInstance, such as its link status and owner view.

Located under the ‘Revit.ImportInstanceReport’ category in the BimorphNodes Dynamo node library.

Nodes:

• ImportInstance – The Revit ImportInstance element.
• LevelHost – The level the instance is hosted on or null if it has no host level.
• OwnerView – The owner view element if the ImportInstance has an owner view.
• WorksetName – The name of the workset the ImportInstance is on.
• Path – The qualified path of the ImportInstance if it is linked or an empty string if it is imported.
• IsLinked – Returns true if the ImportInstance is linked.
• LinkStatus – The link status of the ImportInstance, e.g. Unloaded.

Important Considerations Before Upgrading

While rebuilding the codebase for BimorphNodes v4.0.0 we made the decision to improve the organisation of certain nodes and create more clarity to their inputs and outputs.

This decision ultimately led to the introduction of new types and changes to the behaviour of some nodes which subsequently cause breaking changes. Therefore, if you are an existing BimorphNodes user and plan to upgrade, please check if any of the nodes in the breaking changes overview table below are used in your graphs and follow the update instructions detailed under the ‘Breaking Changes – Reclassified Nodes’ and ‘Breaking Changes – Updates’ sections to ensure they continue to run as expected.

Overview of nodes with breaking changes in BimorphNodes v4.0.0 (click to enlarge / double click once open to zoom):

Breaking Changes – Reclassified Nodes

Reclassified nodes are pre-existing nodes which have been moved to a new node class and therefore appear under new categories in the BimorphNodes Dynamo node library.

If you are using any of the nodes listed below, they will no longer be recognised when you upgrade as Dynamo does not support migration of nodes to new classes, so you will need to open your graph, delete the old node, and replace it with the new node type, then reconnect the inputs and any outputs.

Steps to resolve any reclassified BimorphNodes present in your graphs:

CAD ImportInstance
The nodes listed below which used to be part of the CAD class have been moved to the new Revit.ImportInstance node class:

• ReportInstances
• LayerNames
• LayerNamesInUse
• SetObjectStyle
• SetLayerVisibility

Curve CurveElement
The following Curve node has been moved to the new Revit.CurveElement node class:

• RemoveDuplicates

Breaking Changes – Updates

The following nodes have breaking changes which are either behavioural changes (e.g. takes a single instance instead of a list) or changes to the input and/or output types. If you are upgrading and use any of these nodes in your graphs, they will need to be manually updated, so please plan your upgrade strategy carefully to avoid disruption:

CurveElement.RemoveDuplicates
CurveElement.RemoveDuplicates has the following updates and breaking changes:

• Moved from Curve.RemoveDuplicates.
• No longer supports Dynamo Curves, only Revit CurveElement types are supported: Revit Model, Detail and Symbolic Curves.
• The deleteRevitCurves input has been removed.
• Returns a list of new CurveDuplicatesResult objects.
• Heterogeneous lists are no longer supported (mixing Dynamo curves with Revit curves).
• The ‘report[]’ output has been removed.

The previous version of Curve.RemoveDuplicates output a dictionary of lists which lacked clarity. For example, it was not clear how to group the sets of duplicate curves:

In the latest version of the node, the output is significantly clearer as the duplicate curves are now packaged into an instance of the new CurveDuplicatesResult type. Use the Duplicates query node to return the list of duplicates from the result or the UniqueCurve query node to return the first curve which the Duplicates were matched against:

Curve.SolidIntersection

• Curve.SolidIntersection returns a list of the new CurveSolidIntersectionResult type.

The previous version of the node returned the resultant trimmed curve segments and an index of any exceptions which occurred during the intersection process:

The latest version of the node returns a list of the CurveSolidIntersectionResult which provides far more clarity to the output. To maintain the previous behaviour, each result can be queried to return the CurveSegments and the exceptions output has been simplified and replaced by the FailedToConvert node:

Element.IntersectsElement

• Element.IntersectsElement node returns a list of the new ElementIntersectionResult type.

The previous version of the node had output port labels which lacked clarity, and data matching (lacing) between the indexes of the ‘Element’ output and the ‘intersectsWith’ output was necessary to establish which element from set A clashed with elements from set B:

The new ElementIntersectionResult output clarifies the clash result significantly; use the Element query node to return the element which was used to create the result. To get the elements (from set B) which clashed with it, use the IntersectingElements query node:

Element.IntersectsSolid

• Element.IntersectsSolid node returns a list of the new SolidIntersectionResult type.

The previous version of Element.IntersectsSolid returned a dictionary of lists which lacked clarity, and required data matching (indexing) of the lists to establish which set of elements clashed with each solid. The exceptions output also lacked clarity:

In BimorphNodes v4.0.0 the node returns instances of the new SolidIntersectionResult which improves the clarity of the output; use the IntersectingElements query node to return the list of elements which clashed with an input solid. The Solid query node returns the solid which clashed with them. The ‘exceptions’ output has been replaced by the FailedToConvert query node which returns true if the conversion of the Dynamo Solid to a Revit API solid (required to perform the intersection test) failed:

LineStyle.AllAttributes

• LineStyle.AllAttributes returns a list of the new LineStyleAttributes type.

The previous node returned a dictionary of lists, where each index in the lists corresponded to the set of properties for a given line style:

In BimorphNodes v4.0.0 the new node returns a list of LineStyleAttributes which groups all the properties into one easy-to-understand entity. Use the query nodes to access the property of the attribute to match the same behaviour as the old node (as shown below), or index the list to select a specific attributes instance:

LineStyle.Create
LineStyle.Create has the following updates:

• The linePattern input is no longer optional.
• The return type has been changed to the new LineStyleAttributes node type.
• The report output has been removed.
• The node no longer returns the line style if it already exists (i.e. the input name matches an existing line style name). Instead, an exception is thrown warning that the name is in use.

The previous node returned a report and the wrapped GraphicsStyle:

The new version returns an instance of the LineStyleAttributes enabling easy querying of the properties of the new line style. To retain the same behaviour as before, add a LineStyleAttributes.GraphicsStyle node and pass in the output from the LineStyle.Create node:

Schedule

• The Schedule.GetData, Schedule.GetDataRows and Schedule.GetDataColumns nodes no longer accept a string name as an alternative input to a ViewSchedule. Only a ViewSchedule element is a valid input.

The previous nodes allowed the scheduleView input to accept either a string name of a schedule or a ViewSchedule as valid input:

In the latest version, only a ViewSchedule is a valid input:

Sheet.FromShedule
The Sheet.FromShedule has the following updates and breaking changes:

• The scheduleView input no longer accepts a schedule string name as an alternative input to a ViewSchedule. Only a ViewSchedule element is a valid input.
• The input type for the scheduleView has been changed to the Revit.Elements.Views.ScheduleView instead of the less derived Revit.Elements.Element super-class to improve the type checking.
• The return type is now the Revit.Elements.Views.Sheet subclass instead of Dynamo’s Element super-class.

With the previous node it was possible to provide a schedule view name as an alternative input to a ViewSchedule:

In BimorphNodes v4.0.0 this feature has been removed so only a ViewSchedule is a valid input. This update strengthens the type checking and reduces the potential for bugs:

Sheet.RenumberRename
The Sheet.RenumberRename node has the following updates and breaking changes:

• All the inputs now expect single instances instead of lists. If lists are input (or if you upgrade and do not change your inputs) Dynamo’s in-built replication behaviour will maintain the same behaviour from before.
• The node input names have been renamed to indicate single inputs: sheet, number and name.
• The sheet input type has been changed to the Revit.Elements.Views.Sheet type from Dynamo’s Element super-class.
• The return type is now the Revit.Elements.Views.Sheet subclass instead of Dynamo’s Element super-class and it returns the input sheet instance instead of a list.
• Resequencing sheet numbers (‘swapping’ numbers) is no longer possible now that only a single input is expected; Revit will throw an exception warning that the sheet number is already in use.

The previous node required lists as inputs and the number of items for each input list had to be equal otherwise the node would throw an exception:

In the new version it has been simplified to single inputs, but lists can still be provided to maintain the same behaviour. Note however that a list of empty strings is now required to ignore an input instead of an empty list, otherwise the node will fail to execute:

ImportInstance.ReportInstances
The ImportInstance.ReportInstances node has the following updates and breaking changes:

• Moved from CAD.ReportInstances.
• Output now returns the new ImportInstanceReport type.

The previous node returned a dictionary containing a jagged array of unrelated lists which comprised the report list and the linked and imported ImportInstances. The report also relied on strings to report values such as bools, which made it more cumbersome to perform useful queries on the output:

The latest version of the node resolves these issues, returning instances of the new ImportInstanceReport type. Its query nodes make it easy to return a specific report value from the instance, eliminating the problem caused by the old output which had to rely on strings to describe the report value. Lastly, the lists of linked or imported ImportInstances can be easily restored using a filtering node as shown below:

ImportInstance.SetObjectStyle
The ImportInstance.SetObjectStyle node has the following updates and breaking changes:

• Moved from CAD.SetObjectStyle.
• The linePattern input type has been changed to Dynamo’s Revit.Elements.LinePatternElement type instead of the less derived Revit.Elements.Element super-class to improve the type checking.
• The report output has been removed and the node now has one output which returns the same modified ImportInstance input.

The previous node:

The same graph using the latest node versions:

Other Updates

• The entire codebase has been rewritten from the ground up to improve stability and exception handling, minimise bugs and make maintenance easier.
• Updated ‘Create, ‘Action’ and ‘Query’ node library organisation across all node classes.
• Improved the type checking of inputs for all nodes and added more informative exception messages if the user inputs the wrong type.
• Improved Curve.SolidIntersection by adding enhanced scope for storing the conversion from the Dynamo ProtoGeometry Solid to Revit API Solid.
• The Sheet.Duplicate node will no longer rename views with illegal characters. This can only happen if you attempt to duplicate a default 3D view which includes the { } characters. These characters are not allowed to be input by the user, but Revit allows it if the user clicks the default 3D view button. Simply rename these views and remove the characters. The node will still run, but it won’t duplicate the view in this scenario and report the problem via the report output.
• All the CAD nodes, such as CAD.CurveFromCADLayers, which require ImportInstances as inputs have had the input type changed to the Revit.Elements.ImportInstance class instead of the less derived Revit.Elements.Element super-class to improve the type checking.
• The CAD.DetailCurvesFromCADLayers node view input type has been changed to the Revit.Elements.Views.View type instead of the less derived Revit.Elements.Element super-class to improve the type checking.
• The CADTextData.FromLayers node importInstance input has had its type changed to the Revit.Elements.ImportInstance class instead of the less derived Revit.Elements.Element super-class to improve the type checking.
• Improved the validation checking of the curve-from-CAD nodes when used in family documents. An exception will be thrown with a message indicating that a curve element (Symbolic, Detail or Model curves) is not supported by the family document.
• Improved the validation checking of the curve-from-CAD nodes when used to create curve elements (Symbolic, Detail or Model curves) in specific views. An exception will be thrown with a message indicating if that the view does not support the curve type.

Bug Fixes

BimorphNodes v4.0.0 includes many critical bug fixes – we recommend upgrading to ensure you are using the most stable version available:

• Fixed a bug in CAD.DetailCurvesFromCAD which prevented lines from being created in Legend views.
• Fixed a bug in Element.IsElementSupported which would always return false if a LinkElement was input.
• Fixed a bug in the Sheet.Duplicate node if placeholder sheets were input.
• Fixed a bug in the LinkElement.OfCategory node which would throw an invalid Document exception if an unloaded RevitLinkInstance was input. The node will continue to throw an exception, but the exception message will now explicitly state the link is unloaded to provide better feedback to the user.
• Fixed a bug in the Sheet.FromShedule node which caused the sheet on the first row to be ignored if the sheet schedule ‘Show Headers’ and ‘Blank row before data’ options are both unchecked.
• Fixed a bug in the Schedule.GetData and Schedule.GetDataColumns nodes which caused two rows to be removed from the table data if the removeHeading input was set to true (it was assumed the schedules ‘Blank row before data’ option was a constant/always on).
• Fixed the following bugs in the CadTextData.FromLayers node:
  • Fixed two causes of the “Categories cannot be hidden” exception:
    • If the view used to export the ImportInstance to DXF (required for text parsing) has its ‘Show imported categories in this view’ option unchecked the exception would be thrown. The node now temporarily enables this setting if its not checked.
    • If the ImportInstance has an owner view with a view template assigned, the exception would be thrown. The node now temporarily removes the view template.
  • Fixed a bug which caused layer names input into the layerNames input to ignore the layers if they included a period. This was caused by a limitation in the DXF export format (required for text parsing) which does not support periods in layer names. Once exported, any periods are converted to underscores which prevented the node from filtering these layers from the user input. The node now throws an exception with a warning message that periods in layer names are not supported as there is no workaround.
• Fixed a bug in the Sheet.Duplicate node which removed scope boxes from any duplicated dependent views. The scope box is now preserved.
• Fixed an Invalid Operation Exception with all the CAD, ImportInstance and CADTextData nodes requiring an ImportInstance if the input instance was unloaded. The nodes will continue to throw an exception, but the exception message will now explicitly state the import instance is unloaded to provide better feedback to the user.
• Fixed a bug in LinkElement.GetParameterValueByName which would return the incorrect value for any parameter which stored unit system type doubles which were not representing length (volume, area, etc).
• Fixed a bug in the Element and LinkElement nodes which accept lists of Element’s as inputs, where a zero-division exception would be thrown if the list was empty.