/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Material MaterialFromRevit(this Autodesk.Revit.DB.Material revitMaterial, string grade = null, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
if (revitMaterial == null)
{
return new Material {
Name = "Unknown Material"
}
}
;
settings = settings.DefaultIfNull();
string refId = revitMaterial.Id.ReferenceIdentifier(grade);
Material material = refObjects.GetValue <Material>(refId);
if (material != null)
{
return(material);
}
material = new Material {
Properties = revitMaterial.MaterialProperties(grade, settings, refObjects), Name = revitMaterial.Name
};
//Set identifiers, parameters & custom data
material.SetIdentifiers(revitMaterial);
material.CopyParameters(revitMaterial, settings.ParameterSettings);
material.SetProperties(revitMaterial, settings.ParameterSettings);
refObjects.AddOrReplace(refId, material);
return(material);
}
/***************************************************/
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Family ToRevitFamily(this oM.Adapters.Revit.Elements.Family family, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
Family revitFamily = refObjects.GetValue <Family>(document, family.BHoM_Guid);
if (revitFamily != null)
{
return(revitFamily);
}
settings = settings.DefaultIfNull();
if (family.PropertiesList != null && family.PropertiesList.Count != 0)
{
foreach (InstanceProperties instanceProperties in family.PropertiesList)
{
instanceProperties.ToRevitElementType(document, settings, refObjects);
}
}
HashSet <BuiltInCategory> categories = family.BuiltInCategories(document);
revitFamily = family.Family(document, categories, settings.FamilyLoadSettings);
revitFamily.CheckIfNullPush(family);
if (revitFamily == null)
{
return(null);
}
// Copy parameters from BHoM object to Revit element
revitFamily.CopyParameters(family, settings);
refObjects.AddOrReplace(family, revitFamily);
return(revitFamily);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static FamilyInstance AdaptiveComponent(Document document, FamilySymbol familySymbol, List <XYZ> points, RevitSettings settings = null)
{
if (document == null || familySymbol == null || points == null)
{
return(null);
}
settings = settings.DefaultIfNull();
FamilyInstance adaptiveComponent = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(document, familySymbol);
IList <ElementId> pointIds = AdaptiveComponentInstanceUtils.GetInstancePointElementRefIds(adaptiveComponent);
if (pointIds.Count != points.Count)
{
pointIds = AdaptiveComponentInstanceUtils.GetInstancePlacementPointElementRefIds(adaptiveComponent);
}
if (pointIds.Count != points.Count)
{
BH.Engine.Reflection.Compute.RecordError($"An adaptive component could not be created based on the given ModelInstance because its definition requires different number of points than provided.");
document.Delete(adaptiveComponent.Id);
return(null);
}
for (int i = 0; i < pointIds.Count; i++)
{
ReferencePoint rp = (ReferencePoint)document.GetElement(pointIds[i]);
Transform t = Transform.CreateTranslation(points[i]);
rp.SetCoordinateSystem(t);
}
return(adaptiveComponent);
}
/***************************************************/
public static HostObjAttributes ToRevitElementType(this oM.Physical.Constructions.IConstruction construction, Document document, IEnumerable <BuiltInCategory> categories = null, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (construction == null || document == null)
{
return(null);
}
HostObjAttributes elementType = refObjects.GetValue <HostObjAttributes>(document, construction.BHoM_Guid);
if (elementType != null)
{
return(elementType);
}
settings = settings.DefaultIfNull();
elementType = construction.ElementType(document, categories, settings) as HostObjAttributes;
if (elementType == null)
{
return(null);
}
// Copy parameters from BHoM object to Revit element
elementType.CopyParameters(construction, settings);
refObjects.AddOrReplace(construction, elementType);
return(elementType);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static FamilySymbol ToRevitElementType(this oM.Physical.FramingProperties.IFramingElementProperty framingElementProperty, Document document, IEnumerable <BuiltInCategory> categories = null, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (framingElementProperty == null || document == null)
{
return(null);
}
FamilySymbol familySymbol = refObjects.GetValue <FamilySymbol>(document, framingElementProperty.BHoM_Guid);
if (familySymbol != null)
{
return(familySymbol);
}
settings = settings.DefaultIfNull();
familySymbol = framingElementProperty.ElementType(document, categories, settings) as FamilySymbol;
if (familySymbol == null)
{
return(null);
}
// Copy parameters from BHoM object to Revit element
familySymbol.CopyParameters(framingElementProperty, settings);
refObjects.AddOrReplace(framingElementProperty, familySymbol);
return(familySymbol);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static List <ICurve> AnalyticalOutlines(this HostObject hostObject, RevitSettings settings = null)
{
AnalyticalModel analyticalModel = hostObject.GetAnalyticalModel();
if (analyticalModel == null)
{
//TODO: appropriate warning or not - physical preferred?
return(null);
}
settings = settings.DefaultIfNull();
List <ICurve> wallCurves = analyticalModel.GetCurves(AnalyticalCurveType.ActiveCurves).ToList().FromRevit();
if (wallCurves.Any(x => x == null))
{
hostObject.UnsupportedOutlineCurveWarning();
return(null);
}
List <ICurve> result = BH.Engine.Geometry.Compute.IJoin(wallCurves).ConvertAll(c => c as ICurve);
if (result.Any(x => !x.IIsClosed()))
{
hostObject.NonClosedOutlineWarning();
return(null);
}
return(result);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ViewSheet ToRevitSheet(this Sheet sheet, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (sheet == null)
{
return(null);
}
ViewSheet viewSheet = refObjects.GetValue <ViewSheet>(document, sheet.BHoM_Guid);
if (viewSheet != null)
{
return(viewSheet);
}
settings = settings.DefaultIfNull();
viewSheet = ViewSheet.Create(document, ElementId.InvalidElementId);
viewSheet.Name = sheet.SheetName;
viewSheet.SheetNumber = sheet.SheetNumber;
// Copy parameters from BHoM object to Revit element
viewSheet.CopyParameters(sheet, settings);
refObjects.AddOrReplace(sheet, viewSheet);
return(viewSheet);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static SolidMaterial SolidMaterialFromRevit(this Material material, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
if (material == null)
{
return(null);
}
settings = settings.DefaultIfNull();
SolidMaterial result = refObjects.GetValue <SolidMaterial>(material.Id.IntegerValue);
if (result != null)
{
return(result);
}
else
{
result = new SolidMaterial();
}
result.Name = material.Name;
Parameter parameter = material.get_Parameter(BuiltInParameter.ALL_MODEL_DESCRIPTION);
if (parameter != null)
{
result.Description = parameter.AsString();
}
result.CopyCharacteristics(material);
result.SetProperties(material, settings.ParameterSettings);
refObjects.AddOrReplace(material.Id, result);
return(result);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ModelInstance ModelInstanceFromRevit(this FamilyInstance adaptiveComponent, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
ModelInstance modelInstance = refObjects.GetValue <ModelInstance>(adaptiveComponent.Id);
if (modelInstance != null)
{
return(modelInstance);
}
ElementType elementType = adaptiveComponent.Document.GetElement(adaptiveComponent.GetTypeId()) as ElementType;
InstanceProperties instanceProperties = elementType.InstancePropertiesFromRevit(settings, refObjects) as InstanceProperties;
IEnumerable <BH.oM.Geometry.Point> pts = AdaptiveComponentInstanceUtils.GetInstancePointElementRefIds(adaptiveComponent).Select(x => ((ReferencePoint)adaptiveComponent.Document.GetElement(x)).Position.PointFromRevit());
modelInstance = new ModelInstance {
Properties = instanceProperties, Location = new CompositeGeometry {
Elements = new List <IGeometry>(pts)
}
};
modelInstance.Name = adaptiveComponent.Name;
//Set identifiers, parameters & custom data
modelInstance.SetIdentifiers(adaptiveComponent);
modelInstance.CopyParameters(adaptiveComponent, settings.ParameterSettings);
modelInstance.SetProperties(adaptiveComponent, settings.ParameterSettings);
refObjects.AddOrReplace(adaptiveComponent.Id, modelInstance);
return(modelInstance);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ElementType ToRevitElementType(this InstanceProperties instanceProperties, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
ElementType elementType = refObjects.GetValue <ElementType>(document, instanceProperties.BHoM_Guid);
if (elementType != null)
{
return(elementType);
}
settings = settings.DefaultIfNull();
elementType = instanceProperties.ElementType(document, new List <BuiltInCategory> {
instanceProperties.BuiltInCategory(document)
}, settings);
if (elementType == null)
{
return(null);
}
// Copy parameters from BHoM object to Revit element
elementType.CopyParameters(instanceProperties, settings);
refObjects.AddOrReplace(instanceProperties, elementType);
return(elementType);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static FamilyInstance FamilyInstance(Document document, FamilySymbol familySymbol, XYZ origin, Transform orientation = null, Element host = null, RevitSettings settings = null)
{
if (document == null || familySymbol == null || origin == null)
{
return(null);
}
settings = settings.DefaultIfNull();
switch (familySymbol.Family.FamilyPlacementType)
{
case FamilyPlacementType.OneLevelBased:
return(Create.FamilyInstance_OneLevelBased(document, familySymbol, origin, orientation, host, settings));
case FamilyPlacementType.OneLevelBasedHosted:
return(Create.FamilyInstance_OneLevelBasedHosted(document, familySymbol, origin, orientation, host, settings));
case FamilyPlacementType.TwoLevelsBased:
return(Create.FamilyInstance_TwoLevelBased(document, familySymbol, origin, orientation, host, settings));
case FamilyPlacementType.WorkPlaneBased:
return(Create.FamilyInstance_WorkPlaneBased(document, familySymbol, origin, orientation, host, settings));
case FamilyPlacementType.ViewBased:
case FamilyPlacementType.CurveBasedDetail:
familySymbol.FamilyPlacementTypeDraftingError();
return(null);
default:
BH.Engine.Reflection.Compute.RecordError($"Revit family placement type named {familySymbol.Family.FamilyPlacementType} does not support point locations. Revit ElementId: {familySymbol.Id.IntegerValue}");
return(null);
}
}
/***************************************************/
public static FamilyInstance FamilyInstance(Document document, FamilySymbol familySymbol, Curve curve, Element host = null, RevitSettings settings = null)
{
if (document == null || familySymbol == null || curve == null)
{
return(null);
}
settings = settings.DefaultIfNull();
switch (familySymbol.Family.FamilyPlacementType)
{
case FamilyPlacementType.TwoLevelsBased:
return(Create.FamilyInstance_TwoLevelsBased(document, familySymbol, curve, host, settings));
case FamilyPlacementType.WorkPlaneBased:
return(Create.FamilyInstance_WorkPlaneBased(document, familySymbol, curve, host, settings));
case FamilyPlacementType.CurveBased:
return(Create.FamilyInstance_CurveBased(document, familySymbol, curve, host, settings));
case FamilyPlacementType.CurveDrivenStructural:
return(Create.FamilyInstance_CurveDrivenStructural(document, familySymbol, curve, host, settings));
case FamilyPlacementType.ViewBased:
case FamilyPlacementType.CurveBasedDetail:
familySymbol.FamilyPlacementTypeDraftingError();
return(null);
default:
BH.Engine.Reflection.Compute.RecordError($"Revit family placement type named {familySymbol.Family.FamilyPlacementType} does not support curve locations. Revit ElementId: {familySymbol.Id.IntegerValue}");
return(null);
}
}
public static BH.oM.MEP.System.SectionProperties.PipeSectionProperty PipeSectionProperty(this Autodesk.Revit.DB.Plumbing.Pipe pipe, RevitSettings settings = null)
{
settings = settings.DefaultIfNull();
IProfile profile = pipe.Profile(settings);
double liningThickness = pipe.LookupParameterDouble(BuiltInParameter.RBS_REFERENCE_LINING_THICKNESS); // Extract the lining thk from Duct element
if (liningThickness == double.NaN)
{
liningThickness = 0;
}
double insulationThickness = pipe.LookupParameterDouble(BuiltInParameter.RBS_REFERENCE_INSULATION_THICKNESS); // Extract the lining thk from Duct element
if (insulationThickness == double.NaN)
{
insulationThickness = 0;
}
SectionProfile sectionProfile = BH.Engine.MEP.Create.SectionProfile((TubeProfile)profile, liningThickness, insulationThickness);
PipeSectionProperty result = BH.Engine.MEP.Create.PipeSectionProperty(sectionProfile);
return(result);
}
/***************************************************/
/**** Protected Methods ****/
/***************************************************/
protected override IEnumerable <IBHoMObject> Read(IRequest request, ActionConfig actionConfig = null)
{
ICollection <ElementId> selected = this.UIDocument.Selection.GetElementIds();
if (request == null)
{
BH.Engine.Reflection.Compute.RecordError("BHoM objects could not be read because provided IRequest is null.");
return(new List <IBHoMObject>());
}
RevitPullConfig pullConfig = actionConfig as RevitPullConfig;
if (pullConfig == null)
{
BH.Engine.Reflection.Compute.RecordError("BHoM objects could not be read because provided actionConfig is not a valid RevitPullConfig.");
return(new List <IBHoMObject>());
}
Discipline?requestDiscipline = request.Discipline(pullConfig.Discipline);
if (requestDiscipline == null)
{
BH.Engine.Reflection.Compute.RecordError("Conflicting disciplines have been detected.");
return(new List <IBHoMObject>());
}
Discipline discipline = requestDiscipline.Value;
if (discipline == Discipline.Undefined)
{
discipline = Discipline.Physical;
}
Dictionary <Document, IRequest> requestsByLinks = request.SplitRequestTreeByLinks(this.Document);
if (requestsByLinks == null)
{
BH.Engine.Reflection.Compute.RecordError($"Pull failed due to issues with the request containing {nameof(FilterByLink)}. Please try to restructure the used Request and try again.");
return(new List <IBHoMObject>());
}
RevitSettings settings = RevitSettings.DefaultIfNull();
List <IBHoMObject> result = new List <IBHoMObject>();
foreach (KeyValuePair <Document, IRequest> requestByLink in requestsByLinks)
{
result.AddRange(Read(requestByLink.Key, requestByLink.Value, pullConfig, discipline, settings));
}
bool?[] activePulls = new bool?[] { pullConfig.GeometryConfig?.PullEdges, pullConfig.GeometryConfig?.PullSurfaces, pullConfig.GeometryConfig?.PullMeshes, pullConfig.RepresentationConfig?.PullRenderMesh };
if (activePulls.Count(x => x == true) > 1)
{
BH.Engine.Reflection.Compute.RecordWarning("Pull of more than one geometry/representation type has been specified in RevitPullConfig. Please consider this can be time consuming due to the amount of conversions.");
}
this.UIDocument.Selection.SetElementIds(selected);
return(result);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static oM.Architecture.Elements.Room RoomFromRevit(this SpatialElement spatialElement, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Architecture.Elements.Room room = refObjects.GetValue <oM.Architecture.Elements.Room>(spatialElement.Id);
if (room != null)
{
return(room);
}
room = new oM.Architecture.Elements.Room()
{
Perimeter = spatialElement.Perimeter(settings).First()
};
room.Name = spatialElement.Name;
//Set location
if (spatialElement.Location != null && spatialElement.Location is LocationPoint)
{
room.Location = ((LocationPoint)spatialElement.Location).FromRevit();
}
//Set identifiers, parameters & custom data
room.SetIdentifiers(spatialElement);
room.CopyParameters(spatialElement, settings.ParameterSettings);
room.SetProperties(spatialElement, settings.ParameterSettings);
refObjects.AddOrReplace(spatialElement.Id, room);
return(room);
}
public static BH.oM.MEP.System.SectionProperties.SectionProfile DuctSectionProfile(this Autodesk.Revit.DB.Mechanical.Duct revitDuct, RevitSettings settings = null)
{
settings = settings.DefaultIfNull();
IProfile profile = revitDuct.Profile(settings);
// Lining thickness
double liningThickness = revitDuct.LookupParameterDouble(BuiltInParameter.RBS_REFERENCE_LINING_THICKNESS);
if (liningThickness == double.NaN)
{
liningThickness = 0;
}
// Insulation thickness
double insulationThickness = revitDuct.LookupParameterDouble(BuiltInParameter.RBS_REFERENCE_INSULATION_THICKNESS);
if (insulationThickness == double.NaN)
{
insulationThickness = 0;
}
// Create a section profile
if (profile != null)
{
return(BH.Engine.MEP.Create.SectionProfile(profile as dynamic, liningThickness, insulationThickness));
}
else
{
return(null);
}
}
public static BH.oM.MEP.System.WireSegment WireFromRevit(this Autodesk.Revit.DB.Electrical.Wire revitWire, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
// Reuse a BHoM duct from refObjects it it has been converted before
BH.oM.MEP.System.WireSegment bhomWire = refObjects.GetValue <BH.oM.MEP.System.WireSegment>(revitWire.Id);
if (bhomWire != null)
{
return(bhomWire);
}
LocationCurve locationCurve = revitWire.Location as LocationCurve;
Curve curve = locationCurve.Curve;
BH.oM.Geometry.Point startPoint = curve.GetEndPoint(0).PointFromRevit();
BH.oM.Geometry.Point endPoint = curve.GetEndPoint(1).PointFromRevit();
BH.oM.Geometry.Line line = BH.Engine.Geometry.Create.Line(startPoint, endPoint); // BHoM line
// Wire
bhomWire = BH.Engine.MEP.Create.WireSegment(line);
//Set identifiers, parameters & custom data
bhomWire.SetIdentifiers(revitWire);
bhomWire.CopyParameters(revitWire, settings.ParameterSettings);
bhomWire.SetProperties(revitWire, settings.ParameterSettings);
refObjects.AddOrReplace(revitWire.Id, bhomWire);
return(bhomWire);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Sheet SheetFromRevit(this ViewSheet viewSheet, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
Sheet sheet = refObjects.GetValue <Sheet>(viewSheet.Id);
if (sheet != null)
{
return(sheet);
}
sheet = BH.Engine.Adapters.Revit.Create.Sheet(viewSheet.Name, viewSheet.SheetNumber);
ElementType elementType = viewSheet.Document.GetElement(viewSheet.GetTypeId()) as ElementType;
if (elementType != null)
{
sheet.InstanceProperties = elementType.InstancePropertiesFromRevit(settings, refObjects);
}
sheet.Name = viewSheet.Name;
//Set identifiers, parameters & custom data
sheet.SetIdentifiers(viewSheet);
sheet.CopyParameters(viewSheet, settings.ParameterSettings);
sheet.SetProperties(viewSheet, settings.ParameterSettings);
refObjects.AddOrReplace(viewSheet.Id, sheet);
return(sheet);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static oM.Adapters.Revit.Elements.ViewPlan ViewPlanFromRevit(this ViewPlan revitViewPlan, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Adapters.Revit.Elements.ViewPlan viewPlan = refObjects.GetValue <oM.Adapters.Revit.Elements.ViewPlan>(revitViewPlan.Id.IntegerValue);
if (viewPlan != null)
{
return(viewPlan);
}
viewPlan = BH.Engine.Adapters.Revit.Create.ViewPlan(revitViewPlan.Name, revitViewPlan.GenLevel?.Name);
View template = revitViewPlan.Document.GetElement(revitViewPlan.ViewTemplateId) as View;
if (template != null)
{
viewPlan.TemplateName = template.Name;
}
ElementType elementType = revitViewPlan.Document.GetElement(revitViewPlan.GetTypeId()) as ElementType;
if (elementType != null)
{
viewPlan.InstanceProperties = elementType.InstancePropertiesFromRevit(settings, refObjects);
}
viewPlan.Name = revitViewPlan.Name;
//Set identifiers, parameters & custom data
viewPlan.SetIdentifiers(revitViewPlan);
viewPlan.CopyParameters(revitViewPlan, settings.ParameterSettings);
viewPlan.SetProperties(revitViewPlan, settings.ParameterSettings);
refObjects.AddOrReplace(revitViewPlan.Id, viewPlan);
return(viewPlan);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static oM.Adapters.Revit.Elements.Viewport ViewportFromRevit(this Viewport revitViewPort, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Adapters.Revit.Elements.Viewport viewPort = refObjects.GetValue <oM.Adapters.Revit.Elements.Viewport>(revitViewPort.Id.IntegerValue);
if (viewPort != null)
{
return(viewPort);
}
oM.Geometry.Point location = revitViewPort.GetBoxCenter().PointFromRevit();
string viewName = revitViewPort.get_Parameter(BuiltInParameter.VIEW_NAME).AsString();
string sheetNumber = revitViewPort.get_Parameter(BuiltInParameter.VIEWPORT_SHEET_NUMBER).AsString();
viewPort = BH.Engine.Adapters.Revit.Create.Viewport(sheetNumber, viewName, location);
ElementType elementType = revitViewPort.Document.GetElement(revitViewPort.GetTypeId()) as ElementType;
if (elementType != null)
{
viewPort.InstanceProperties = elementType.InstancePropertiesFromRevit(settings, refObjects);
}
viewPort.Name = revitViewPort.Name;
//Set identifiers, parameters & custom data
viewPort.SetIdentifiers(revitViewPort);
viewPort.CopyParameters(revitViewPort, settings.ParameterSettings);
viewPort.SetProperties(revitViewPort, settings.ParameterSettings);
refObjects.AddOrReplace(revitViewPort.Id, viewPort);
return(viewPort);
}
/***************************************************/
public static ElementType ToRevitElementType(this ClonedType clonedType, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
ElementType elementType = refObjects.GetValue <ElementType>(document, clonedType.BHoM_Guid);
if (elementType != null)
{
return(elementType);
}
settings = settings.DefaultIfNull();
Element source = document.GetElement(new ElementId(clonedType.SourceTypeId));
if (source == null)
{
BH.Engine.Reflection.Compute.RecordError($"The element with ElementId {clonedType.SourceTypeId} does not exist in the active Revit document.");
return(null);
}
ElementType sourceType = source as ElementType;
if (sourceType == null)
{
BH.Engine.Reflection.Compute.RecordError($"The element with ElementId {clonedType.SourceTypeId} exists in the active Revit document, but it is not an element type.");
return(null);
}
elementType = sourceType.Duplicate(clonedType.Name);
// Copy parameters from BHoM object to Revit element
elementType.CopyParameters(clonedType, settings);
refObjects.AddOrReplace(clonedType, elementType);
return(elementType);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ParameterElement ToRevitParameterElement(this ParameterDefinition parameterDefinition, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (parameterDefinition == null)
{
return(null);
}
ParameterElement parameterElement = refObjects.GetValue <ParameterElement>(document, parameterDefinition.BHoM_Guid);
if (parameterElement != null)
{
return(parameterElement);
}
settings = settings.DefaultIfNull();
Definition definition = Create.Parameter(document, parameterDefinition.Name, parameterDefinition.ParameterType, parameterDefinition.ParameterGroup, parameterDefinition.Instance, parameterDefinition.Categories, parameterDefinition.Shared, parameterDefinition.Discipline);
if (definition is ExternalDefinition)
{
parameterElement = SharedParameterElement.Lookup(document, ((ExternalDefinition)definition).GUID);
}
else if (definition is InternalDefinition)
{
parameterElement = document.GetElement(((InternalDefinition)definition).Id) as ParameterElement;
}
refObjects.AddOrReplace(parameterDefinition, parameterElement);
return(parameterElement);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static ViewPlan ToRevitViewPlan(this oM.Adapters.Revit.Elements.ViewPlan viewPlan, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (viewPlan == null || string.IsNullOrEmpty(viewPlan.LevelName) || string.IsNullOrEmpty(viewPlan.ViewName))
{
return(null);
}
ViewPlan revitViewPlan = refObjects.GetValue <ViewPlan>(document, viewPlan.BHoM_Guid);
if (revitViewPlan != null)
{
return(revitViewPlan);
}
settings = settings.DefaultIfNull();
ElementId levelElementID = null;
List <Level> levels = new FilteredElementCollector(document).OfClass(typeof(Level)).Cast <Level>().ToList();
if (levels == null || levels.Count < 1)
{
return(null);
}
Level level = levels.Find(x => x.Name == viewPlan.LevelName);
if (level == null)
{
return(null);
}
levelElementID = level.Id;
ElementId viewTemplateId = ElementId.InvalidElementId;
if (!string.IsNullOrWhiteSpace(viewPlan.TemplateName))
{
IEnumerable <ViewPlan> viewPlans = new FilteredElementCollector(document).OfClass(typeof(ViewPlan)).Cast <ViewPlan>();
ViewPlan viewPlanTemplate = viewPlans.FirstOrDefault(x => x.IsTemplate && viewPlan.TemplateName == x.Name);
if (viewPlanTemplate == null)
{
Compute.ViewTemplateNotExistsWarning(viewPlan);
}
else
{
viewTemplateId = viewPlanTemplate.Id;
}
}
revitViewPlan = Create.ViewPlan(document, level, viewPlan.ViewName, null, viewTemplateId) as ViewPlan;
// Copy parameters from BHoM object to Revit element
revitViewPlan.CopyParameters(viewPlan, settings);
refObjects.AddOrReplace(viewPlan, revitViewPlan);
return(revitViewPlan);
}
/***************************************************/
public static CurveElement ToCurveElement(this DraftingInstance draftingInstance, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
CurveElement curveElement = refObjects.GetValue <CurveElement>(document, draftingInstance.BHoM_Guid);
if (curveElement != null)
{
return(curveElement);
}
settings = settings.DefaultIfNull();
if (!(draftingInstance.Location is ICurve))
{
return(null);
}
ICurve curve = (ICurve)draftingInstance.Location;
Curve revitCurve = curve.IToRevit();
if (revitCurve == null)
{
return(null);
}
if (!BH.Engine.Geometry.Query.IsPlanar(curve as dynamic))
{
return(null);
}
View view = Query.View(draftingInstance, document);
if (view == null)
{
return(null);
}
curveElement = document.Create.NewDetailCurve(view, revitCurve);
if (curveElement == null)
{
return(null);
}
if (draftingInstance.Properties != null)
{
string name = draftingInstance.Properties.Name;
if (!string.IsNullOrEmpty(name))
{
Element element = new FilteredElementCollector(document).OfClass(typeof(GraphicsStyle)).ToList().Find(x => x.Name == name);
if (element != null)
{
curveElement.LineStyle = element;
}
}
}
refObjects.AddOrReplace(draftingInstance, curveElement);
return(curveElement);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Element ToRevitElement(this ModelInstance modelInstance, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (modelInstance == null || document == null)
{
return(null);
}
Element element = refObjects.GetValue <Element>(document, modelInstance.BHoM_Guid);
if (element != null)
{
return(element);
}
if (modelInstance.Properties == null)
{
Compute.NullObjectPropertiesWarning(modelInstance);
return(null);
}
settings = settings.DefaultIfNull();
BuiltInCategory builtInCategory = modelInstance.BuiltInCategory(document);
if (modelInstance.Location is ISurface || modelInstance.Location is ISolid)
{
Solid brep = ToRevit(modelInstance.Location as dynamic);
if (brep == null)
{
Compute.GeometryConvertFailed(modelInstance);
return(null);
}
DirectShape directShape = DirectShape.CreateElement(document, new ElementId((int)builtInCategory));
directShape.AppendShape(new List <GeometryObject> {
brep
});
element = directShape;
}
else
{
ElementType elementType = modelInstance.Properties.ElementType(document, new List <BuiltInCategory> {
builtInCategory
}, settings);
element = modelInstance.IToRevitElement(elementType, settings);
}
if (element == null)
{
return(null);
}
// Copy parameters from BHoM object to Revit element
element.CopyParameters(modelInstance, settings);
refObjects.AddOrReplace(modelInstance, element);
return(element);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static DraftingInstance DraftingInstanceFromRevit(this FilledRegion filledRegion, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
DraftingInstance draftingInstance = refObjects.GetValue <DraftingInstance>(filledRegion.Id);
if (draftingInstance != null)
{
return(draftingInstance);
}
View view = filledRegion.Document.GetElement(filledRegion.OwnerViewId) as View;
if (view == null)
{
return(null);
}
InstanceProperties instanceProperties = (filledRegion.Document.GetElement(filledRegion.GetTypeId()) as ElementType).InstancePropertiesFromRevit(settings, refObjects) as InstanceProperties;
List <ICurve> curves = new List <oM.Geometry.ICurve>();
foreach (CurveLoop loop in filledRegion.GetBoundaries())
{
curves.Add(loop.FromRevit());
}
List <PlanarSurface> surfaces = BH.Engine.Geometry.Create.PlanarSurface(curves);
if (surfaces.Count == 1)
{
draftingInstance = new DraftingInstance {
Properties = instanceProperties, ViewName = view.Name, Location = surfaces[0]
}
}
;
else
{
draftingInstance = new DraftingInstance {
Properties = instanceProperties, ViewName = view.Name, Location = new PolySurface {
Surfaces = surfaces.Cast <ISurface>().ToList()
}
}
};
draftingInstance.Name = filledRegion.Name;
//Set identifiers, parameters & custom data
draftingInstance.SetIdentifiers(filledRegion);
draftingInstance.CopyParameters(filledRegion, settings.ParameterSettings);
draftingInstance.SetProperties(filledRegion, settings.ParameterSettings);
refObjects.AddOrReplace(filledRegion.Id, draftingInstance);
return(draftingInstance);
}
/***************************************************/
}
public static BH.oM.MEP.System.SectionProperties.CableTraySectionProperty CableTraySectionProperty(this Autodesk.Revit.DB.Electrical.CableTray revitCableTray, RevitSettings settings = null)
{
settings = settings.DefaultIfNull();
// Cable Tray section profile
SectionProfile sectionProfile = revitCableTray.CableTraySectionProfile(settings);
// Cable Tray section property
return(BH.Engine.MEP.Create.CableTraySectionProperty(new oM.Physical.Materials.Material(), sectionProfile));
}
public static BH.oM.MEP.System.SectionProperties.DuctSectionProperty DuctSectionProperty(this Autodesk.Revit.DB.Mechanical.Duct revitDuct, RevitSettings settings = null)
{
settings = settings.DefaultIfNull();
// Duct section profile
SectionProfile sectionProfile = revitDuct.DuctSectionProfile(settings);
// Duct section property
return(BH.Engine.MEP.Create.DuctSectionProperty(sectionProfile));
}
/***************************************************/
public static BH.oM.Geometry.Line LocationCurveColumn(this FamilyInstance familyInstance, RevitSettings settings = null)
{
settings = settings.DefaultIfNull();
BH.oM.Geometry.Line curve = null;
if (familyInstance.IsSlantedColumn)
{
curve = (familyInstance.Location as LocationCurve).Curve.IFromRevit() as BH.oM.Geometry.Line;
}
else
{
Parameter baseLevelParam = familyInstance.get_Parameter(BuiltInParameter.FAMILY_BASE_LEVEL_PARAM);
if (baseLevelParam != null)
{
Parameter topLevelParam = familyInstance.get_Parameter(BuiltInParameter.FAMILY_TOP_LEVEL_PARAM);
Parameter baseOffsetParam = familyInstance.get_Parameter(BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM);
Parameter topOffsetParam = familyInstance.get_Parameter(BuiltInParameter.FAMILY_TOP_LEVEL_OFFSET_PARAM);
double baseLevel = (familyInstance.Document.GetElement(baseLevelParam.AsElementId()) as Level).ProjectElevation;
double topLevel = (familyInstance.Document.GetElement(topLevelParam.AsElementId()) as Level).ProjectElevation;
double baseOffset = baseOffsetParam.AsDouble();
double topOffset = topOffsetParam.AsDouble();
XYZ loc = (familyInstance.Location as LocationPoint).Point;
XYZ baseNode = new XYZ(loc.X, loc.Y, baseLevel + baseOffset);
XYZ topNode = new XYZ(loc.X, loc.Y, topLevel + topOffset);
curve = new oM.Geometry.Line {
Start = baseNode.PointFromRevit(), End = topNode.PointFromRevit()
};
}
}
if (curve != null)
{
Output <double, double> extensions = familyInstance.ColumnExtensions(settings);
double startExtension = extensions.Item1;
double endExtension = extensions.Item2;
if (Math.Abs(startExtension) > settings.DistanceTolerance || Math.Abs(endExtension) > settings.DistanceTolerance)
{
Vector direction = curve.Direction();
curve = new oM.Geometry.Line {
Start = curve.Start - direction * startExtension, End = curve.End + direction * endExtension
};
}
}
if (curve == null)
{
familyInstance.FramingCurveNotFoundWarning();
}
return(curve);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Space SpaceFromRevit(this SpatialElement spatialElement, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
SpatialElementBoundaryOptions spatialElementBoundaryOptions = new SpatialElementBoundaryOptions();
spatialElementBoundaryOptions.SpatialElementBoundaryLocation = SpatialElementBoundaryLocation.Center;
spatialElementBoundaryOptions.StoreFreeBoundaryFaces = false;
return(spatialElement.SpaceFromRevit(spatialElementBoundaryOptions, settings, refObjects));
}