/// <summary>
/// Exports a Rebar Coupler,
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="coupler">The RebarCoupler element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void ExportCoupler(ExporterIFC exporterIFC, RebarCoupler coupler, ProductWrapper productWrapper)
{
if (coupler == null)
{
return;
}
FamilySymbol familySymbol = ExporterCacheManager.Document.GetElement(coupler.GetTypeId()) as FamilySymbol;
if (familySymbol == null)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcMechanicalFastener", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
ElementId categoryId = CategoryUtil.GetSafeCategoryId(coupler);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
Options options = GeometryUtil.GetIFCExportGeometryOptions();;
string ifcEnumType;
IFCExportInfoPair exportType = ExporterUtil.GetExportType(exporterIFC, coupler, out ifcEnumType);
using (IFCTransaction tr = new IFCTransaction(file))
{
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.FamilySymbolToTypeInfoCache.Find(coupler.GetTypeId(), false, exportType.ExportType);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, familySymbol);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
GeometryElement exportGeometry = familySymbol.get_Geometry(options);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyData = BodyExporter.ExportBody(exporterIFC, coupler, categoryId, ElementId.InvalidElementId, exportGeometry, bodyExporterOptions, null);
List <IFCAnyHandle> repMap = new List <IFCAnyHandle>();
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);;
repMap.Add(IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyData.RepresentationHnd));
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType, propertySetsOpt, repMap, coupler, familySymbol);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
string applicableOccurrence = NamingUtil.GetObjectTypeOverride(familySymbol, typeObjectType);
if (!string.IsNullOrEmpty(applicableOccurrence))
{
IFCAnyHandleUtil.SetAttribute(styleHandle, "ApplicableOccurrence", applicableOccurrence);
}
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.FamilySymbolToTypeInfoCache.Register(coupler.GetTypeId(), false, exportType.ExportType, currentTypeInfo);
}
}
int nCouplerQuantity = coupler.GetCouplerQuantity();
if (nCouplerQuantity <= 0)
{
return;
}
ISet <IFCAnyHandle> createdRebarCouplerHandles = new HashSet <IFCAnyHandle>();
string origInstanceName = NamingUtil.GetNameOverride(coupler, NamingUtil.GetIFCName(coupler));
for (int idx = 0; idx < nCouplerQuantity; idx++)
{
string instanceGUID = GUIDUtil.CreateSubElementGUID(coupler, idx);
IFCAnyHandle style = currentTypeInfo.Style;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(style))
{
return;
}
IList <IFCAnyHandle> repMapList = GeometryUtil.GetRepresentationMaps(style);
if (repMapList == null)
{
return;
}
if (repMapList.Count == 0)
{
return;
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
IFCAnyHandle contextOfItems3d = exporterIFC.Get3DContextHandle("Body");
ISet <IFCAnyHandle> representations = new HashSet <IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMapList[0], XYZ.Zero));
IFCAnyHandle shapeRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC, coupler, categoryId, contextOfItems3d, representations);
shapeReps.Add(shapeRep);
IFCAnyHandle productRepresentation = IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null, null, shapeReps);
Transform trf = coupler.GetCouplerPositionTransform(idx);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, coupler, trf, null))
{
IFCAnyHandle instanceHandle = null;
IFCExportInfoPair exportMechFastener = new IFCExportInfoPair();
exportMechFastener.SetValueWithPair(IFCEntityType.IfcMechanicalFastener);
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(exportMechFastener, exporterIFC, coupler, instanceGUID, ownerHistory,
setter.LocalPlacement, productRepresentation);
string instanceName = NamingUtil.GetNameOverride(instanceHandle, coupler, origInstanceName + ": " + idx);
IFCAnyHandleUtil.SetAttribute(instanceHandle, "Name", instanceName);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// In IFC4 NominalDiameter and NominalLength attributes have been deprecated. PredefinedType attribute was added.
IFCAnyHandleUtil.SetAttribute(instanceHandle, "PredefinedType", Revit.IFC.Export.Toolkit.IFC4.IFCMechanicalFastenerType.USERDEFINED);
}
else
{
IFCAnyHandleUtil.SetAttribute(instanceHandle, "NominalDiameter", familySymbol.get_Parameter(BuiltInParameter.COUPLER_WIDTH).AsDouble());
IFCAnyHandleUtil.SetAttribute(instanceHandle, "NominalLength", familySymbol.get_Parameter(BuiltInParameter.COUPLER_LENGTH).AsDouble());
}
createdRebarCouplerHandles.Add(instanceHandle);
productWrapper.AddElement(coupler, instanceHandle, setter, null, true);
}
}
string couplerGUID = GUIDUtil.CreateGUID(coupler);
if (nCouplerQuantity > 1)
{
// Create a group to hold all of the created IFC entities, if the coupler aren't already in an assembly.
// We want to avoid nested groups of groups of couplers.
if (coupler.AssemblyInstanceId == ElementId.InvalidElementId)
{
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(coupler, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(coupler, null);
string objectType = NamingUtil.GetObjectTypeOverride(coupler, revitObjectType);
IFCAnyHandle rebarGroup = IFCInstanceExporter.CreateGroup(file, couplerGUID,
ownerHistory, name, description, objectType);
productWrapper.AddElement(coupler, rebarGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebarCouplerHandles, null, rebarGroup);
}
}
else
{
// We will update the GUID of the one created element to be the element GUID.
// This will allow the IfcGUID parameter to be use/set if appropriate.
ExporterUtil.SetGlobalId(createdRebarCouplerHandles.ElementAt(0), couplerGUID);
}
tr.Commit();
}
}
/// <summary>
/// Exports a gutter element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcPipeSegmentType;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle bodyRep = BodyExporter.ExportBody(exporterIFC, element, categoryId, ElementId.InvalidElementId,
geometryElement, bodyExporterOptions, ecData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
string originalTag = NamingUtil.CreateIFCElementId(element);
// In Revit, we don't have a corresponding type, so we create one for every gutter.
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRep);
List <IFCAnyHandle> repMapList = new List <IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
string elementTypeName = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string typeGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCHostedSweepSubElements.PipeSegmentType);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, null, null, repMapList, IFCPipeSegmentType.Gutter);
IFCAnyHandleUtil.OverrideNameAttribute(style, elementTypeName);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcPipeSegmentType, IFCPipeSegmentType.Gutter.ToString());
IFCAnyHandleUtil.SetAttribute(style, "Tag", originalTag);
ExporterUtil.SetGlobalId(style, typeGuid);
IFCAnyHandleUtil.SetAttribute(style, "ElementType", elementTypeName);
List <IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
ISet <IFCAnyHandle> representations = new HashSet <IFCAnyHandle>();
representations.Add(mappedItem);
IFCAnyHandle bodyMappedItemRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyMappedItemRep))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyMappedItemRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
shapeReps.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
if (roomId == ElementId.InvalidElementId)
{
localPlacementToUse = ecData.GetLocalPlacement();
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(exporterIFC, element, guid,
ExporterCacheManager.OwnerHistoryHandle, localPlacementToUse, prodRep);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.LevelInfo, ecData, !containedInSpace, exportInfo);
if (containedInSpace)
{
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, elemHnd);
}
// Associate segment with type.
ExporterCacheManager.TypeRelationsCache.Add(style, elemHnd);
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a Rebar, AreaReinforcement or PathReinforcement to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
ISet <DelayedProductWrapper> createdRebars = new HashSet <DelayedProductWrapper>();
if (element is Rebar)
{
createdRebars = ExportRebar(exporterIFC, element, productWrapper);
}
else if (element is AreaReinforcement)
{
AreaReinforcement areaReinforcement = element as AreaReinforcement;
IList <ElementId> rebarIds = areaReinforcement.GetRebarInSystemIds();
Document doc = areaReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
if (newlyCreatedRebars != null)
{
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
else if (element is PathReinforcement)
{
PathReinforcement pathReinforcement = element as PathReinforcement;
IList <ElementId> rebarIds = pathReinforcement.GetRebarInSystemIds();
Document doc = pathReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
if (newlyCreatedRebars != null)
{
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
else if (element is RebarContainer)
{
int itemIndex = 1;
RebarContainer rebarContainer = element as RebarContainer;
foreach (RebarContainerItem rebarContainerItem in rebarContainer)
{
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarContainerItem, rebarContainer, itemIndex, productWrapper);
if (newlyCreatedRebars != null)
{
itemIndex += createdRebars.Count;
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
if (createdRebars != null && createdRebars.Count != 0)
{
string guid = GUIDUtil.CreateGUID(element);
// Create a group to hold all of the created IFC entities, if the rebars aren't already in an assembly or a group.
// We want to avoid nested groups of groups of rebars.
bool relateToLevel = true;
bool groupRebarHandles = (createdRebars.Count != 1);
foreach (DelayedProductWrapper delayedProductWrapper in createdRebars)
{
if (ElementIsContainedInAssembly(delayedProductWrapper.RebarElement))
{
groupRebarHandles = false;
relateToLevel = false;
break;
}
}
ISet <IFCAnyHandle> createdRebarHandles = new HashSet <IFCAnyHandle>();
foreach (DelayedProductWrapper delayedProductWrapper in createdRebars)
{
IFCAnyHandle currentRebarHandle = delayedProductWrapper.ElementHandle;
productWrapper.AddElement(delayedProductWrapper.RebarElement, currentRebarHandle, delayedProductWrapper.LevelInfo, null, relateToLevel);
createdRebarHandles.Add(currentRebarHandle);
}
if (createdRebars.Count > 1)
{
if (groupRebarHandles)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcGroup", out elementClassTypeEnum))
{
if (!ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle rebarGroup = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, rebarGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebarHandles, null, rebarGroup);
tr.Commit();
}
}
}
}
}
else
{
// We will update the GUID of the one created IfcReinforcingElement to be the element GUID.
// This will allow the IfcGUID parameter to be use/set if appropriate.
ExporterUtil.SetGlobalId(createdRebarHandles.ElementAt(0), guid);
}
}
}
/// <summary>
/// Exports a Rebar, AreaReinforcement or PathReinforcement to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
ISet <DelayedProductWrapper> createdRebars = new HashSet <DelayedProductWrapper>();
// First, we will create individual rebars based on the Revit element.
if (element is Rebar)
{
createdRebars = ExportRebar(exporterIFC, element, productWrapper);
}
else if (element is AreaReinforcement)
{
AreaReinforcement areaReinforcement = element as AreaReinforcement;
IList <ElementId> rebarIds = areaReinforcement.GetRebarInSystemIds();
Document doc = areaReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
if (newlyCreatedRebars != null)
{
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
else if (element is PathReinforcement)
{
PathReinforcement pathReinforcement = element as PathReinforcement;
IList <ElementId> rebarIds = pathReinforcement.GetRebarInSystemIds();
Document doc = pathReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
if (newlyCreatedRebars != null)
{
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
else if (element is RebarContainer)
{
int itemIndex = 1;
RebarContainer rebarContainer = element as RebarContainer;
foreach (RebarContainerItem rebarContainerItem in rebarContainer)
{
ISet <DelayedProductWrapper> newlyCreatedRebars = ExportRebar(exporterIFC, rebarContainerItem, rebarContainer, itemIndex, productWrapper);
if (newlyCreatedRebars != null)
{
itemIndex += createdRebars.Count;
createdRebars.UnionWith(newlyCreatedRebars);
}
}
}
// If we've created any rebar, we will group them below into three conceptual groups:
// 1. One rebar that shouldn't be grouped or be in an assembly,
// but be directly contained in a building story.
// 2. Rebar that are in assemblies, where the assembly is contained in a building story.
// 3. Multiple rebar that aren't in assembles, which should both be in a group and
// directly contained in a building story.
//
// The reason for the cases above:
// 1. Nested groups/assemblies aren't allow in IFC. So we can only have one level.
// 2. IfcGroups don't have level assignment. So the individual components inside have
// to be directly contained in a building story.
// 3. IfcAssemblies do have level assignment, so individual components can't be directly
// contained in a building story. This does mean that rebars in assemblies may
// be associated with the wrong level, but that is an IFC limitation.
if (createdRebars != null && createdRebars.Count != 0)
{
// Only one created element can have the consistent GUID of the main element.
// This will be either the first created assembly or the first rebar element.
string guid = GUIDUtil.CreateGUID(element);
// While it seems likely that all of the rebar would have the same assembly id,
// there's no need to assume this. Make a map of assembly id to created rebar.
IDictionary <ElementId, ISet <DelayedProductWrapper> > relatedRebar =
new Dictionary <ElementId, ISet <DelayedProductWrapper> >();
relatedRebar[ElementId.InvalidElementId] = new HashSet <DelayedProductWrapper>();
// Go through the created rebar and sort into buckets by assembly id.
foreach (DelayedProductWrapper delayedProductWrapper in createdRebars)
{
Element rebarElement = delayedProductWrapper.RebarElement;
if (rebarElement == null)
{
continue;
}
ElementId rebarAssemblyInstanceId = rebarElement.AssemblyInstanceId;
ISet <DelayedProductWrapper> currentRebarSet = null;
if (!relatedRebar.TryGetValue(rebarAssemblyInstanceId, out currentRebarSet))
{
currentRebarSet = new HashSet <DelayedProductWrapper>();
relatedRebar[rebarAssemblyInstanceId] = currentRebarSet;
}
currentRebarSet.Add(delayedProductWrapper);
}
foreach (KeyValuePair <ElementId, ISet <DelayedProductWrapper> > relatedToAssembly in relatedRebar)
{
// Ignore buckets with no items in them.
if (relatedToAssembly.Value.Count == 0)
{
continue;
}
// We will attach rebar to an assembly for rebar belonging to an assembly;
// otherwise we will create a group, assuming there are at least 2 rebar to group.
ElementId assemblyId = relatedToAssembly.Key;
bool hasAssemblyId = (assemblyId != ElementId.InvalidElementId);
bool attachToLevel = !hasAssemblyId;
ISet <IFCAnyHandle> createdRebarHandles = new HashSet <IFCAnyHandle>();
foreach (DelayedProductWrapper delayedProductWrapper in relatedToAssembly.Value)
{
IFCAnyHandle currentRebarHandle = delayedProductWrapper.ElementHandle;
productWrapper.AddElement(delayedProductWrapper.RebarElement, currentRebarHandle,
delayedProductWrapper.LevelInfo, null, attachToLevel, delayedProductWrapper.ExportInfo);
createdRebarHandles.Add(currentRebarHandle);
}
if (hasAssemblyId)
{
ExporterCacheManager.AssemblyInstanceCache.RegisterElements(assemblyId, productWrapper);
}
else if (createdRebarHandles.Count > 1)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
string rebarGUID = (guid != null) ? guid : GUIDUtil.CreateGUID();
CreateRebarGroup(exporterIFC, element, rebarGUID, productWrapper, createdRebarHandles);
guid = null;
}
}
// We will update the GUID of the one created IfcReinforcingElement to be the element GUID.
// This will allow the IfcGUID parameter to be use/set if appropriate.
if (createdRebars.Count == 1 && guid != null)
{
ExporterUtil.SetGlobalId(createdRebars.ElementAt(0).ElementHandle, guid);
}
}
}
