public static Element FromElement(DB.Element element)
{
if (element is null)
{
return(null);
}
if (element.GetType() == typeof(DB.Element))
{
try
{
if (DB.Category.GetCategory(element.Document, element.Id) is DB.Category category)
{
return(new Category(category));
}
}
catch (Autodesk.Revit.Exceptions.InternalException) { }
}
else if (ActivatorDictionary.TryGetValue(element.GetType(), out var activator))
{
return(activator(element));
}
if (GeometricElement.IsValidElement(element))
{
return(new GeometricElement(element));
}
return(new Element(element));
}
public static Element FromElement(DB.Element element)
{
if (element is null)
{
return(null);
}
if (element.GetType() == typeof(DB.Element))
{
try
{
if (DB.Category.GetCategory(element.Document, element.Id) is DB.Category category)
{
return(new Category(category));
}
}
catch (Autodesk.Revit.Exceptions.InternalException) { }
}
else
{
for (var type = element.GetType(); type != typeof(DB.Element); type = type.BaseType)
{
if (ActivatorDictionary.TryGetValue(type, out var activator))
{
return(activator(element));
}
}
}
if (GraphicalElement.IsValidElement(element))
{
if (InstanceElement.IsValidElement(element))
{
if (Panel.IsValidElement(element))
{
return(new Panel(element as DB.FamilyInstance));
}
return(new InstanceElement(element));
}
return(GeometricElement.IsValidElement(element) ?
new GeometricElement(element) :
new GraphicalElement(element));
}
return(new Element(element));
}
public static Element FromElement(DB.Element element)
{
if (element is null)
{
return(null);
}
for (var type = element.GetType(); type != typeof(DB.Element); type = type.BaseType)
{
if (ActivatorDictionary.TryGetValue(type, out var activator))
{
return(activator(element));
}
}
if (DocumentExtension.AsCategory(element) is DB.Category category)
{
return(new Category(category));
}
if (element is DB.PropertySetElement pset)
{
if (StructuralAssetElement.IsValidElement(element))
{
return(new StructuralAssetElement(pset));
}
else if (ThermalAssetElement.IsValidElement(element))
{
return(new ThermalAssetElement(pset));
}
}
else if (GraphicalElement.IsValidElement(element))
{
if (InstanceElement.IsValidElement(element))
{
if (Panel.IsValidElement(element))
{
return(new Panel(element as DB.FamilyInstance));
}
return(new InstanceElement(element));
}
if (GeometricElement.IsValidElement(element))
{
return(new GeometricElement(element));
}
return(new GraphicalElement(element));
}
else
{
if (DesignOptionSet.IsValidElement(element))
{
return(new DesignOptionSet(element));
}
}
return(new Element(element));
}
/// <summary>
/// find Column which will be used to placed to Wall
/// </summary>
/// <param name="rvtDoc">Revit document</param>
/// <param name="familyName">Family name of Column</param>
/// <param name="symbolName">Symbol of Column</param>
/// <returns></returns>
private FamilySymbol FindFamilySymbol(Document rvtDoc, string familyName, string symbolName)
{
FilteredElementCollector collector = new FilteredElementCollector(rvtDoc);
FilteredElementIterator itr = collector.OfClass(typeof(Family)).GetElementIterator();
itr.Reset();
while (itr.MoveNext())
{
Autodesk.Revit.DB.Element elem = (Autodesk.Revit.DB.Element)itr.Current;
if (elem.GetType() == typeof(Autodesk.Revit.DB.Family))
{
if (elem.Name == familyName)
{
Autodesk.Revit.DB.Family family = (Autodesk.Revit.DB.Family)elem;
foreach (Autodesk.Revit.DB.ElementId symbolId in family.GetFamilySymbolIds())
{
Autodesk.Revit.DB.FamilySymbol symbol = (Autodesk.Revit.DB.FamilySymbol)rvtDoc.GetElement(symbolId);
if (symbol.Name == symbolName)
{
return(symbol);
}
}
}
}
}
return(null);
}
/// <summary>
/// Implement this method as an external command for Revit.
/// </summary>
/// <param name="commandData">An object that is passed to the external application
/// which contains data related to the command,
/// such as the application object and active view.</param>
/// <param name="message">A message that can be set by the external application
/// which will be displayed if a failure or cancellation is returned by
/// the external command.</param>
/// <param name="elements">A set of elements to which the external application
/// can add elements that are to be highlighted in case of failure or cancellation.</param>
/// <returns>Return the status of the external command.
/// A result of Succeeded means that the API external method functioned as expected.
/// Cancelled can be used to signify that the user cancelled the external operation
/// at some point. Failure should be returned if the application is unable to proceed with
/// the operation.</returns>
public virtual Autodesk.Revit.UI.Result Execute(ExternalCommandData commandData
, ref string message, Autodesk.Revit.DB.ElementSet elements)
{
if (null == s_appCreation)
{
// share for class Intersection.
s_appCreation = commandData.Application.Application.Create;
}
UIDocument doc = commandData.Application.ActiveUIDocument;
CombinableElementArray solids
= new CombinableElementArray();
ElementSet es = new ElementSet();
foreach (ElementId elemId in es)
{
es.Insert(doc.Document.GetElement(elemId));
}
if (0 < es.Size)
{
foreach (Autodesk.Revit.DB.ElementId elementId in doc.Selection.GetElementIds())
{
Autodesk.Revit.DB.Element element = doc.Document.GetElement(elementId);
System.Diagnostics.Trace.WriteLine(element.GetType().ToString());
GenericForm gf = element as GenericForm;
if (null != gf && !gf.IsSolid)
{
continue;
}
CombinableElement ce = element as CombinableElement;
if (null != ce)
{
solids.Append(ce);
}
}
if (solids.Size < 2)
{
message = "At least 2 combinable elements should be selected.";
return(Autodesk.Revit.UI.Result.Failed);
}
doc.Document.CombineElements(solids);
//The selected generic forms are joined, whether or not they overlap.
return(Autodesk.Revit.UI.Result.Succeeded);
}
AutoJoin autojoin = new AutoJoin();
autojoin.Join(doc.Document);
//All overlapping generic forms are joined.
return(Autodesk.Revit.UI.Result.Succeeded);
}
public ElementIdJSON(revitElemId Id,
[DefaultArgument("Synthetic.Revit.Document.Current()")] revitDoc Document)
{
this.Id = Id.IntegerValue;
revitElem elem = Document.GetElement(Id);
this.ElementName = elem.Name;
this.ElementClass = elem.GetType().Name;
}
/// <summary>
/// Create reference plane with the selected element.
/// the selected element must be wall or slab at this sample code.
/// </summary>
public void Create()
{
foreach (ElementId eId in m_document.Selection.GetElementIds())
{
Element e = m_document.Document.GetElement(eId);
try
{
CreateDelegate createDelegate = m_createHandler[e.GetType()];
createDelegate(e);
}
catch (Exception)
{
continue;
}
}
}
public ElementJSON(revitElem element)
{
this.Class = element.GetType().Name;
this.Name = element.Name;
this.Id = element.Id.IntegerValue;
this.UniqueId = element.UniqueId.ToString();
this.Category = element.Category.Name;
this.Parameters = new List <ParameterJSON>();
//Iterate through parameters
foreach (Parameter param in element.Parameters)
{
//If the parameter has a value, the add it to the parameter list for export
if (!param.IsReadOnly)
{
this.Parameters.Add(new ParameterJSON(param, element.Document));
}
}
}
public static Element FromElement(DB.Element element)
{
if (element is null)
{
return(null);
}
for (var type = element.GetType(); type != typeof(DB.Element); type = type.BaseType)
{
if (ActivatorDictionary.TryGetValue(type, out var activator))
{
return(activator(element));
}
}
if (DocumentExtension.AsCategory(element) is DB.Category category)
{
return(new Category(category));
}
if (GraphicalElement.IsValidElement(element))
{
if (InstanceElement.IsValidElement(element))
{
if (Panel.IsValidElement(element))
{
return(new Panel(element as DB.FamilyInstance));
}
return(new InstanceElement(element));
}
if (GeometricElement.IsValidElement(element))
{
return(new GeometricElement(element));
}
return(new GraphicalElement(element));
}
return(new Element(element));
}
//public static SerialElement DeserializeByJson (string Json)
//{
// SerialElement serialElem = JsonConvert.DeserializeObject<SerialElement>(Json);
// switch (serialElem.Class)
// {
// case "Autodesk.Revit.DB.Material":
// serialElem = JsonConvert.DeserializeObject<SerialMaterial>(Json);
// break;
// case "Autodesk.Revit.DB.ElementType":
// case "Autodesk.Revit.DB.TextNoteType":
// case "Autodesk.Revit.DB DimensionType":
// serialElem = JsonConvert.DeserializeObject<SerialElementType>(Json);
// break;
// default:
// break;
// }
// return serialElem;
//}
//public static string SerializeToJson (SerialElement serialElement)
//{
// SerializeJSON serializeJSON = new SerializeJSON();
// serializeJSON._sortSerialElement(serialElement);
// return Newtonsoft.Json.JsonConvert.SerializeObject(serializeJSON, Formatting.Indented);
//}
#endregion
#region Serialization Helper Functions
private static SerialElement _serialByType(RevitElem revitElement)
{
SerialElement serializeElement = null;
string revitType = revitElement.GetType().FullName;
switch (revitType)
{
case "Autodesk.Revit.DB.Material":
serializeElement = new SerialMaterial((RevitMaterial)revitElement);
break;
case "Autodesk.Revit.DB.ElementType":
case "Autodesk.Revit.DB.TextNoteType":
case "Autodesk.Revit.DB DimensionType":
serializeElement = new SerialElementType((RevitElemType)revitElement);
break;
case "Autodesk.Revit.DB.WallType":
case "Autodesk.Revit.DB.FloorType":
case "Autodesk.Revit.DB.CeilingType":
case "Autodesk.Revit.DB.RoofType":
case "Autodesk.Revit.DB.BuildingPadType":
serializeElement = new SerialHostObjType((RevitHostObjType)revitElement);
break;
case "Autodesk.Revit.DB.View":
case "Autodesk.Revit.DB.TableView":
case "Autodesk.Revit.DB.View3D":
case "Autodesk.Revit.DB.ViewDrafting":
case "Autodesk.Revit.DB.ViewPlan":
case "Autodesk.Revit.DB.ViewSection":
case "Autodesk.Revit.DB.ViewSheet":
serializeElement = new SerialView((RevitView)revitElement);
break;
default:
serializeElement = new SerialElement(revitElement);
break;
}
return(serializeElement);
}
public SerialElementId(RevitElemId Id,
[DefaultArgument("Synthetic.Revit.Document.Current()")] RevitDoc Document)
{
this.Id = Id.IntegerValue;
RevitElem elem = Document.GetElement(Id);
if (elem != null)
{
this.Name = elem.Name;
this.Class = elem.GetType().FullName;
this.UniqueId = elem.UniqueId;
RevitDB.Category cat = elem.Category;
if (cat != null)
{
this.Category = elem.Category.Name;
}
}
}
protected override void TrySolveInstance(IGH_DataAccess DA)
{
DB.Element element = null;
if (!DA.GetData("Element", ref element) || element is null)
{
return;
}
// Special cases
if (element is DB.FamilyInstance familyInstace)
{
DA.SetData("Host", Types.HostObject.FromElement(familyInstace.Host));
return;
}
else if (element is DB.Opening opening)
{
DA.SetData("Host", Types.HostObject.FromElement(opening.Host));
return;
}
else if (element.get_Parameter(DB.BuiltInParameter.HOST_ID_PARAM) is DB.Parameter hostId)
{
DA.SetData("Host", Types.HostObject.FromElementId(element.Document, hostId.AsElementId()));
return;
}
// Search geometrically
if (element.get_BoundingBox(null) is DB.BoundingBoxXYZ bbox)
{
using (var collector = new DB.FilteredElementCollector(element.Document))
{
var elementCollector = collector.OfClass(typeof(DB.HostObject));
if (element.Category.Parent is DB.Category hostCategory)
{
elementCollector = elementCollector.OfCategoryId(hostCategory.Id);
}
var bboxFilter = new DB.BoundingBoxIntersectsFilter(new DB.Outline(bbox.Min, bbox.Max));
elementCollector = elementCollector.WherePasses(bboxFilter);
var classFilter = default(DB.ElementFilter);
if (element is DB.FamilyInstance instance)
{
classFilter = new DB.FamilyInstanceFilter(element.Document, instance.GetTypeId());
}
else if (element is DB.Area)
{
classFilter = new DB.AreaFilter();
}
else if (element is DB.AreaTag)
{
classFilter = new DB.AreaTagFilter();
}
else if (element is DB.Architecture.Room)
{
classFilter = new DB.Architecture.RoomFilter();
}
else if (element is DB.Architecture.RoomTag)
{
classFilter = new DB.Architecture.RoomTagFilter();
}
else if (element is DB.Mechanical.Space)
{
classFilter = new DB.Mechanical.SpaceFilter();
}
else if (element is DB.Mechanical.SpaceTag)
{
classFilter = new DB.Mechanical.SpaceTagFilter();
}
else
{
if (element is DB.CurveElement)
{
classFilter = new DB.ElementClassFilter(typeof(DB.CurveElement));
}
else
{
classFilter = new DB.ElementClassFilter(element.GetType());
}
}
foreach (var host in elementCollector.Cast <DB.HostObject>())
{
if (host.Id == element.Id)
{
continue;
}
if (host.FindInserts(false, true, true, false).Contains(element.Id))
{
DA.SetData("Host", Types.HostObject.FromElement(host));
break;
}
// Necessary to found Panel walls in a Curtain Wall
else if (host.GetDependentElements(classFilter).Contains(element.Id))
{
DA.SetData("Host", Types.HostObject.FromElement(host));
break;
}
}
}
}
}
public static Element FromElement(DB.Element element)
{
if (element is null)
{
return(null);
}
if (element.GetType() == typeof(DB.Element))
{
try
{
if (DB.Category.GetCategory(element.Document, element.Id) is DB.Category category)
{
return(new Category(category));
}
}
catch (Autodesk.Revit.Exceptions.InternalException) { }
}
else
{
if (element is DB.ParameterElement parameter)
{
return(new ParameterKey(parameter));
}
if (element is DB.Material material)
{
return(new Material(material));
}
if (element is DB.GraphicsStyle graphicsStyle)
{
return(new GraphicsStyle(graphicsStyle));
}
if (element is DB.Family family)
{
return(new Family(family));
}
if (element is DB.ElementType elementType)
{
return(new ElementType(elementType));
}
if (element is DB.SketchPlane sketchPlane)
{
return(new SketchPlane(sketchPlane));
}
if (element is DB.HostObject host)
{
return(new HostObject(host));
}
if (element is DB.DatumPlane datumPlane)
{
if (element is DB.Level level)
{
return(new Level(level));
}
if (element is DB.Grid grid)
{
return(new Grid(grid));
}
return(new DatumPlane(datumPlane));
}
}
if (GeometricElement.IsValidElement(element))
{
return(new GeometricElement(element));
}
return(new Element(element));
}
/// <summary>
/// Retrive family instance hosted in boundary elements
/// This is the base function for Windows and Doors
/// </summary>
/// <param name="cat">The category of hosted elements</param>
/// <returns></returns>
private List <FamilyInstance> BoundaryFamilyInstance(DB.BuiltInCategory cat)
{
List <FamilyInstance> output = new List <FamilyInstance>();
//the document of the room
DB.Document doc = InternalElement.Document; // DocumentManager.Instance.CurrentDBDocument;
//Find boundary elements and their associated document
List <DB.ElementId> boundaryElements = new List <DB.ElementId>();
List <DB.Document> boundaryDocuments = new List <DB.Document>();
foreach (DB.BoundarySegment segment in InternalBoundarySegments)
{
DB.Element boundaryElement = doc.GetElement(segment.ElementId);
if (boundaryElement.GetType() == typeof(DB.RevitLinkInstance))
{
DB.RevitLinkInstance linkInstance = boundaryElement as DB.RevitLinkInstance;
boundaryDocuments.Add(linkInstance.GetLinkDocument());
boundaryElements.Add(segment.LinkElementId);
}
else
{
boundaryDocuments.Add(doc);
boundaryElements.Add(segment.ElementId);
}
}
// Create a category filter
DB.ElementCategoryFilter filter = new DB.ElementCategoryFilter(cat);
// Apply the filter to the elements in these documents,
// Use shortcut WhereElementIsNotElementType() to find family instances in all boundary documents
boundaryDocuments = boundaryDocuments.Distinct().ToList();
List <DB.FamilyInstance> familyInstances = new List <DB.FamilyInstance>();
foreach (DB.Document boundaryDocument in boundaryDocuments)
{
DB.FilteredElementCollector collector = new DB.FilteredElementCollector(boundaryDocument);
familyInstances.AddRange(collector.WherePasses(filter).WhereElementIsNotElementType().ToElements().Cast <DB.FamilyInstance>().ToList());
}
//Find all family instance hosted on a boundary element
IEnumerable <DB.FamilyInstance> boundaryFamilyInstances = familyInstances.Where(s => boundaryElements.Contains(s.Host.Id));
//loop on these boundary family instance to find to and from room
foreach (DB.FamilyInstance boundaryFamilyInstance in boundaryFamilyInstances)
{
DB.Phase familyInstancePhase = boundaryFamilyInstance.Document.GetElement(boundaryFamilyInstance.CreatedPhaseId) as DB.Phase;
if (boundaryFamilyInstance.get_FromRoom(familyInstancePhase) != null)
{
if (boundaryFamilyInstance.get_FromRoom(familyInstancePhase).Id == InternalRoom.Id)
{
output.Add(ElementWrapper.ToDSType(boundaryFamilyInstance, true) as FamilyInstance);
continue;
}
}
if (boundaryFamilyInstance.get_ToRoom(familyInstancePhase) != null)
{
if (boundaryFamilyInstance.get_ToRoom(familyInstancePhase).Id == InternalRoom.Id)
{
output.Add(ElementWrapper.ToDSType(boundaryFamilyInstance, true) as FamilyInstance);
}
}
}
output = output.Distinct().ToList();
return(output);
}
/// <summary>
/// Converts the Revit elements that have been added to the stream by the user, sends them to
/// the Server and the local DB, and creates a commit with the objects.
/// </summary>
/// <param name="state">StreamState passed by the UI</param>
public override async Task<StreamState> SendStream(StreamState state)
{
ConversionErrors.Clear();
OperationErrors.Clear();
var kit = KitManager.GetDefaultKit();
var converter = kit.LoadConverter(ConnectorRevitUtils.RevitAppName);
converter.SetContextDocument(CurrentDoc.Document);
var streamId = state.Stream.id;
var client = state.Client;
var convertedObjects = new List<Base>();
if (state.Filter != null)
{
state.Objects = GetSelectionFilterObjects(state.Filter);
}
if (state.Objects.Count == 0)
{
state.Errors.Add(new Exception("There are zero objects to send. Please create a filter, or set some via selection."));
return state;
}
var commitObject = new Base();
var conversionProgressDict = new ConcurrentDictionary<string, int>();
conversionProgressDict["Conversion"] = 0;
Execute.PostToUIThread(() => state.Progress.Maximum = state.Objects.Count());
var convertedCount = 0;
var placeholders = new List<Base>();
converter.SetContextObjects(state.Objects.Select(obj => new ApplicationPlaceholderObject { applicationId = obj.applicationId }).ToList());
foreach (var obj in state.Objects)
{
try
{
RevitElement revitElement = null;
if (obj.applicationId != null)
{
revitElement = CurrentDoc.Document.GetElement(obj.applicationId);
}
if (revitElement == null)
{
continue;
}
if (!converter.CanConvertToSpeckle(revitElement))
{
state.Errors.Add(new Exception($"Skipping {revitElement.GetType()}, not supported"));
continue;
}
var conversionResult = converter.ConvertToSpeckle(revitElement);
conversionProgressDict["Conversion"]++;
UpdateProgress(conversionProgressDict, state.Progress);
placeholders.Add(new ApplicationPlaceholderObject { applicationId = obj.applicationId, ApplicationGeneratedId = obj.applicationId });
convertedCount++;
//hosted elements will be returned as `null` by the ConvertToSpeckle method
//since they are handled when converting their parents
if (conversionResult != null)
{
var category = $"@{revitElement.Category.Name}";
if (commitObject[category] == null)
{
commitObject[category] = new List<Base>();
}
((List<Base>)commitObject[category]).Add(conversionResult);
}
}
catch (Exception e)
{
state.Errors.Add(e);
}
//var level = (Level) CurrentDoc.Document.GetElement(revitElement.LevelId);
//if(commitObject[$"@{level.Name}"] == null)
//{
// commitObject[$"@{level.Name}"] = new Base
// {
// ["@objects"] = new List<Base>(),
// ["elevation"] = level.Elevation, // TODO Cast!
// };
//}
}
if (converter.ConversionErrors.Count != 0)
{
// TODO: Get rid of the custom Error class. It's not needed.
ConversionErrors.AddRange(converter.ConversionErrors.Select(x => new Exception($"{x.Message}\n{x.details}")));
state.Errors.AddRange(converter.ConversionErrors.Select(x => new Exception($"{x.Message}\n{x.details}")));
}
if (convertedCount == 0)
{
Globals.Notify("Failed to convert any objects. Push aborted.");
return state;
}
Execute.PostToUIThread(() => state.Progress.Maximum = (int)commitObject.GetTotalChildrenCount());
if (state.CancellationTokenSource.Token.IsCancellationRequested)
{
return state;
}
var transports = new List<ITransport>() { new ServerTransport(client.Account, streamId) };
var objectId = await Operations.Send(
@object: commitObject,
cancellationToken: state.CancellationTokenSource.Token,
transports: transports,
onProgressAction: dict => UpdateProgress(dict, state.Progress),
onErrorAction: (s, e) =>
{
OperationErrors.Add(e); // TODO!
state.Errors.Add(e);
state.CancellationTokenSource.Cancel();
}
);
if (OperationErrors.Count != 0)
{
Globals.Notify("Failed to send.");
state.Errors.AddRange(OperationErrors);
return state;
}
if (state.CancellationTokenSource.Token.IsCancellationRequested)
{
return null;
}
var actualCommit = new CommitCreateInput()
{
streamId = streamId,
objectId = objectId,
branchName = state.Branch.name,
message = state.CommitMessage != null ? state.CommitMessage : $"Sent {convertedCount} objects from {ConnectorRevitUtils.RevitAppName}."
};
if (state.PreviousCommitId != null) { actualCommit.previousCommitIds = new List<string>() { state.PreviousCommitId }; }
try
{
var res = await client.CommitCreate(actualCommit);
var updatedStream = await client.StreamGet(streamId);
state.Branches = updatedStream.branches.items;
state.Stream.name = updatedStream.name;
state.Stream.description = updatedStream.description;
WriteStateToFile();
RaiseNotification($"{convertedCount} objects sent to Speckle 🚀");
}
catch (Exception e)
{
state.Errors.Add(e);
Globals.Notify($"Failed to create commit.\n{e.Message}");
}
return state;
}
