private static void CreateRebarGroup(ExporterIFC exporterIFC, Element element,
string guid, ProductWrapper productWrapper,
ISet <IFCAnyHandle> createdRebarHandles)
{
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcGroup;
if (!ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = NamingUtil.GetFamilyAndTypeName(element);
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);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(elementClassTypeEnum);
productWrapper.AddElement(element, rebarGroup, exportInfo);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebarHandles, null, rebarGroup);
tr.Commit();
}
}
}
/// <summary>
/// Exports an element as a zone.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportZone(ExporterIFC exporterIFC, Zone element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcZone;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
HashSet <IFCAnyHandle> spaceHnds = new HashSet <IFCAnyHandle>();
SpaceSet spaces = element.Spaces;
foreach (Space space in spaces)
{
if (space == null)
{
continue;
}
IFCAnyHandle spaceHnd = ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(space.Id);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(spaceHnd))
{
spaceHnds.Add(spaceHnd);
}
}
if (spaceHnds.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element));
string longName = NamingUtil.GetLongNameOverride(element, null);
IFCAnyHandle zoneHnd = IFCInstanceExporter.CreateZone(file, guid, ownerHistory, name, description, objectType, longName);
productWrapper.AddElement(element, zoneHnd);
string relAssignsGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCZoneSubElements.RelAssignsToGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, relAssignsGuid, ownerHistory, null, null, spaceHnds, null, zoneHnd);
tr.Commit();
return;
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoofAsParts(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
string elementName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementTag, ifcEnumType);
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(element, roofHandle, setter, null, true);
transaction.Commit();
}
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </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>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcCovering;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainer = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainer);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainer))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, "Wrapping");
ExporterCacheManager.ElementToHandleCache.Register(element.Id, ductLining);
productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as an IFC assembly with its members.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="assemblyElem">The element to be exported as IFC assembly.</param>
/// <param name="memberIds">The member element ids.</param>
/// <param name="assemblyType">The IFC assembly type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
static void ExportAssemblyInstanceWithMembers(ExporterIFC exporterIFC, Element assemblyElem,
ICollection <ElementId> memberIds, IFCElementAssemblyType assemblyType, ProductWrapper productWrapper)
{
HashSet <IFCAnyHandle> memberHnds = new HashSet <IFCAnyHandle>();
foreach (ElementId memberId in memberIds)
{
IFCAnyHandle memberHnd = ExporterCacheManager.ElementToHandleCache.Find(memberId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(memberHnd))
{
memberHnds.Add(memberHnd);
}
}
if (memberHnds.Count == 0)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcElementAssembly;
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, assemblyElem, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, assemblyElem, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
string guid = GUIDUtil.CreateGUID(assemblyElem);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(exporterIFC, assemblyElem, guid,
ownerHistory, localPlacement, null, IFCAssemblyPlace.NotDefined, assemblyType);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(elementClassTypeEnum, assemblyType.ToString());
productWrapper.AddElement(assemblyElem, assemblyInstanceHnd, placementSetter.LevelInfo, null, true, exportInfo);
string aggregateGuid = GUIDUtil.CreateSubElementGUID(assemblyElem, (int)IFCAssemblyInstanceSubElements.RelAggregates);
IFCInstanceExporter.CreateRelAggregates(file, aggregateGuid, ownerHistory, null, null, assemblyInstanceHnd, memberHnds);
ExporterCacheManager.ElementsInAssembliesCache.UnionWith(memberHnds);
// Update member local placements to be relative to the assembly.
SetLocalPlacementsRelativeToAssembly(exporterIFC, localPlacement, memberHnds);
}
tr.Commit();
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <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>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper, IFCExportInfoPair exportType = null)
{
if (element == null || geometryElement == null)
{
return(null);
}
if (exportType == null)
{
exportType = new IFCExportInfoPair(IFCEntityType.IfcBuildingElementProxy, IFCEntityType.IfcBuildingElementProxyType, "NOTDEFINED");
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcBuildingElementProxy;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(null);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, exportType.ValidatedPredefinedType);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <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 <IFCAnyHandle> createdRebars = null;
if (element is Rebar)
{
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);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
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);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
if (createdRebars != null && createdRebars.Count > 1)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
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, createdRebars, null, rebarGroup);
tr.Commit();
}
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </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>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, "Wrapping");
ExporterCacheManager.ElementToHandleCache.Register(element.Id, ductLining);
productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as a group.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportAreaScheme(ExporterIFC exporterIFC, AreaScheme element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
HashSet <IFCAnyHandle> areaHandles = null;
if (!ExporterCacheManager.AreaSchemeCache.TryGetValue(element.Id, out areaHandles))
{
return;
}
if (areaHandles == null || areaHandles.Count == 0)
{
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>("IfcGroup", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, element.Name);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle areaScheme = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, areaScheme);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, areaHandles, null, areaScheme);
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <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>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(null);
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(null);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, null);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <summary>
/// Exports an element as a zone.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportZone(ExporterIFC exporterIFC, Zone element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
HashSet <IFCAnyHandle> spaceHnds = new HashSet <IFCAnyHandle>();
SpaceSet spaces = element.Spaces;
foreach (Space space in spaces)
{
if (space == null)
{
continue;
}
IFCAnyHandle spaceHnd = ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(space.Id);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(spaceHnd))
{
spaceHnds.Add(spaceHnd);
}
}
if (spaceHnds.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
IFCAnyHandle zoneHnd = IFCInstanceExporter.CreateZone(file, guid, ownerHistory, name, description, objectType);
productWrapper.AddElement(element, zoneHnd);
string relAssignsGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCZoneSubElements.RelAssignsToGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, relAssignsGuid, ownerHistory, null, null, spaceHnds, null, zoneHnd);
tr.Commit();
return;
}
}
/// <summary>
/// Exports a FabricArea as an IfcGroup. There is no geometry to export.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricArea(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcGroup;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(false);
}
HashSet <IFCAnyHandle> fabricSheetHandles = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(element.Id, out fabricSheetHandles))
{
return(false);
}
if (fabricSheetHandles == null || fabricSheetHandles.Count == 0)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = NamingUtil.GetFamilyAndTypeName(element);
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle fabricArea = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcGroup);
productWrapper.AddElement(element, fabricArea, exportInfo);
string groupGuid = GUIDUtil.GenerateIFCGuidFrom(IFCEntityType.IfcRelAssignsToGroup,
fabricArea);
IFCInstanceExporter.CreateRelAssignsToGroup(file, groupGuid, ownerHistory,
null, null, fabricSheetHandles, null, fabricArea);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a Group as an IfcGroup.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportGroupElement(ExporterIFC exporterIFC, Group element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcGroup;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle groupHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element));
string longName = NamingUtil.GetLongNameOverride(element, null);
string ifcEnumType;
IFCExportInfoPair exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs.ExportInstance == IFCEntityType.IfcGroup)
{
groupHnd = IFCInstanceExporter.CreateGroup(file, guid, ownerHistory, name, description, objectType);
}
else if (!ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4 && exportAs.ExportInstance == IFCEntityType.IfcBuildingSystem)
{
groupHnd = IFCInstanceExporter.CreateBuildingSystem(file, exportAs, guid, ownerHistory, name, description, objectType, longName);
}
if (groupHnd == null)
{
return(false);
}
productWrapper.AddElement(element, groupHnd, exportAs);
ExporterCacheManager.GroupCache.RegisterGroup(element.Id, groupHnd);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as an IFC assembly with its members.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="assemblyElem">The element to be exported as IFC assembly.</param>
/// <param name="memberIds">The member element ids.</param>
/// <param name="assemblyType">The IFC assembly type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
static void ExportAssemblyInstanceWithMembers(ExporterIFC exporterIFC, Element assemblyElem,
ICollection <ElementId> memberIds, IFCElementAssemblyType assemblyType, ProductWrapper productWrapper)
{
HashSet <IFCAnyHandle> memberHnds = new HashSet <IFCAnyHandle>();
foreach (ElementId memberId in memberIds)
{
IFCAnyHandle memberHnd = ExporterCacheManager.ElementToHandleCache.Find(memberId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(memberHnd))
{
memberHnds.Add(memberHnd);
}
}
if (memberHnds.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, assemblyElem))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
string guid = GUIDUtil.CreateGUID(assemblyElem);
string name = NamingUtil.GetIFCName(assemblyElem);
string description = NamingUtil.GetDescriptionOverride(assemblyElem, null);
string objectType = NamingUtil.GetObjectTypeOverride(assemblyElem, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(assemblyElem);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, description, objectType, localPlacement, null, elementTag,
IFCAssemblyPlace.NotDefined, assemblyType);
productWrapper.AddElement(assemblyElem, assemblyInstanceHnd, placementSetter.LevelInfo, null, true);
string aggregateGuid = GUIDUtil.CreateSubElementGUID(assemblyElem, (int)IFCAssemblyInstanceSubElements.RelAggregates);
IFCInstanceExporter.CreateRelAggregates(file, aggregateGuid, ownerHistory, null, null, assemblyInstanceHnd, memberHnds);
ExporterCacheManager.ElementsInAssembliesCache.UnionWith(memberHnds);
// Update member local placements to be relative to the assembly.
SetLocalPlacementsRelativeToAssembly(exporterIFC, localPlacement, memberHnds);
}
tr.Commit();
}
}
/// <summary>
/// Exports mullion.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="mullion">
/// The mullion object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCPlacementSetter setter, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCPlacementSetter mullionSetter = IFCPlacementSetter.Create(exporterIFC, mullion, null, null, ExporterUtil.GetBaseLevelIdForElement(mullion)))
{
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
IFCAnyHandle mullionPlacement = mullionSetter.GetPlacement();
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(localPlacement, mullionPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle mullionRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandle mullionLocalPlacement = IFCInstanceExporter.CreateLocalPlacement(file, localPlacement, mullionRelativePlacement);
extraParams.SetLocalPlacement(mullionLocalPlacement);
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle repHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = GUIDUtil.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string name = NamingUtil.GetNameOverride(mullion, elemObjectType);
string description = NamingUtil.GetDescriptionOverride(mullion, null);
string objectType = NamingUtil.GetObjectTypeOverride(mullion, elemObjectType);
string elemTag = NamingUtil.GetTagOverride(mullion, NamingUtil.CreateIFCElementId(mullion));
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, name, description, objectType,
mullionLocalPlacement, repHnd, elemTag);
ExporterCacheManager.HandleToElementCache.Register(mullionHnd, mullion.Id);
productWrapper.AddElement(mullion, mullionHnd, mullionSetter, extraParams, false);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, mullion);
CategoryUtil.CreateMaterialAssociation(exporterIFC, mullionHnd, matId);
}
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoofAsParts(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
string ifcEnumType;
IFCExportInfoPair exportType = ExporterUtil.GetProductExportType(exporterIFC, element, out ifcEnumType);
if (exportType.IsUnKnown)
{
exportType = new IFCExportInfoPair(IFCEntityType.IfcRoof);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(exportType.ExportType))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = 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))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateGenericIFCEntity(
exportType, exporterIFC,
element, elementGUID, ownerHistory,
localPlacement, prodRepHnd);
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(element, roofHandle, setter, null, true, exportType);
transaction.Commit();
}
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoofAsParts(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;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcRoof", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
string elementName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementTag, ifcEnumType);
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(element, roofHandle, setter, null, true);
transaction.Commit();
}
}
}
/// <summary>
/// Exports an element as a group.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportAreaScheme(ExporterIFC exporterIFC, AreaScheme element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
HashSet <IFCAnyHandle> areaHandles = null;
if (!ExporterCacheManager.AreaSchemeCache.TryGetValue(element.Id, out areaHandles))
{
return;
}
if (areaHandles == null || areaHandles.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, element.Name);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle areaScheme = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, areaScheme);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, areaHandles, null, areaScheme);
tr.Commit();
return;
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoofAsParts(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.IfcRoof;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = 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))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
//ifcEnumType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(exporterIFC, element, elementGUID, ownerHistory,
localPlacement, prodRepHnd, ifcEnumType);
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(element, roofHandle, setter, null, true);
transaction.Commit();
}
}
}
/// <summary>
/// Exports a FabricArea as an IfcGroup. There is no geometry to export.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricArea(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
HashSet <IFCAnyHandle> fabricSheetHandles = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(element.Id, out fabricSheetHandles))
{
return(false);
}
if (fabricSheetHandles == null || fabricSheetHandles.Count == 0)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle fabricArea = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, fabricArea);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, fabricSheetHandles, null, fabricArea);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a Group as an IfcGroup.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportGroupElement(ExporterIFC exporterIFC, Group element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle groupHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string ifcEnumType;
IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs == IFCExportType.IfcGroup)
{
groupHnd = IFCInstanceExporter.CreateGroup(file, guid, ownerHistory, name, description, objectType);
}
if (groupHnd == null)
{
return(false);
}
productWrapper.AddElement(element, groupHnd);
ExporterCacheManager.GroupCache.RegisterGroup(element.Id, groupHnd);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as an IfcReinforcingMesh.
/// </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>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricSheet(ExporterIFC exporterIFC, FabricSheet sheet,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (sheet == null || geometryElement == null)
{
return(false);
}
Document doc = sheet.Document;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, sheet, null, null, ExporterUtil.GetBaseLevelIdForElement(sheet)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(sheet);
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(sheet, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
double scale = exporterIFC.LinearScale;
string guid = GUIDUtil.CreateGUID(sheet);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(sheet, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(sheet, null);
string objectType = NamingUtil.GetObjectTypeOverride(sheet, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(sheet);
string steelGrade = NamingUtil.GetOverrideStringValue(sheet, "SteelGrade", null);
double?meshLength = sheet.CutOverallLength;
double?meshWidth = sheet.CutOverallWidth;
Element fabricSheetTypeElem = doc.GetElement(sheet.GetTypeId());
FabricSheetType fabricSheetType = (fabricSheetTypeElem == null) ? null : (fabricSheetTypeElem as FabricSheetType);
double longitudinalBarNominalDiameter = 0.0;
double transverseBarNominalDiameter = 0.0;
double longitudinalBarCrossSectionArea = 0.0;
double transverseBarCrossSectionArea = 0.0;
double longitudinalBarSpacing = 0.0;
double transverseBarSpacing = 0.0;
if (fabricSheetType != null)
{
Element majorFabricWireTypeElem = doc.GetElement(fabricSheetType.MajorDirectionWireType);
FabricWireType majorFabricWireType = (majorFabricWireTypeElem == null) ? null : (majorFabricWireTypeElem as FabricWireType);
if (majorFabricWireType != null)
{
longitudinalBarNominalDiameter = majorFabricWireType.WireDiameter * scale;
double localRadius = longitudinalBarNominalDiameter / 2.0;
longitudinalBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
Element minorFabricWireTypeElem = doc.GetElement(fabricSheetType.MinorDirectionWireType);
FabricWireType minorFabricWireType = (minorFabricWireTypeElem == null) ? null : (minorFabricWireTypeElem as FabricWireType);
if (minorFabricWireType != null)
{
transverseBarNominalDiameter = minorFabricWireType.WireDiameter * scale;
double localRadius = transverseBarNominalDiameter / 2.0;
transverseBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
longitudinalBarSpacing = fabricSheetType.MajorSpacing * scale;
transverseBarSpacing = fabricSheetType.MinorSpacing * scale;
}
IList <IFCAnyHandle> bodyItems = new List <IFCAnyHandle>();
IList <Curve> wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Major);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, longitudinalBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Minor);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, transverseBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
IFCAnyHandle shapeRep = (bodyItems.Count > 0) ?
RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, sheet, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null) :
null;
IList <IFCAnyHandle> shapeReps = null;
if (shapeRep != null)
{
shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
}
IFCAnyHandle prodRep = (shapeReps != null) ? IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps) : null;
IFCAnyHandle fabricSheet = IFCInstanceExporter.CreateReinforcingMesh(file, guid,
ownerHistory, name, description, objectType, localPlacement, prodRep, elementTag,
steelGrade, meshLength, meshWidth, longitudinalBarNominalDiameter, transverseBarNominalDiameter,
longitudinalBarCrossSectionArea, transverseBarCrossSectionArea,
longitudinalBarSpacing, transverseBarSpacing);
ElementId fabricAreaId = sheet.FabricAreaOwnerId;
if (fabricAreaId != ElementId.InvalidElementId)
{
HashSet <IFCAnyHandle> fabricSheets = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(fabricAreaId, out fabricSheets))
{
fabricSheets = new HashSet <IFCAnyHandle>();
ExporterCacheManager.FabricAreaHandleCache[fabricAreaId] = fabricSheets;
}
fabricSheets.Add(fabricSheet);
}
productWrapper.AddElement(sheet, fabricSheet, placementSetter.GetLevelInfo(), ecData, true);
CategoryUtil.CreateMaterialAssociation(exporterIFC, fabricSheet, materialId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Export one IFCGrid in one level.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="levelId">The level ID.</param>
/// <param name="sameDirectionAxesU">The U axes of grids.</param>
/// <param name="sameDirectionAxesV">The V axes of grids.</param>
/// <param name="sameDirectionAxesW">The W axes of grids.</param>
public static void ExportGrid(ExporterIFC exporterIFC, ElementId levelId, string gridName, List <Grid> sameDirectionAxesU, List <Grid> sameDirectionAxesV, List <Grid> sameDirectionAxesW)
{
List <IFCAnyHandle> axesU = null;
List <IFCAnyHandle> axesV = null;
List <IFCAnyHandle> axesW = null;
List <IFCAnyHandle> representations = new List <IFCAnyHandle>();
using (ProductWrapper productWrapper = ProductWrapper.Create(exporterIFC, true))
{
IFCFile ifcFile = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(ifcFile))
{
GridRepresentationData gridRepresentationData = new GridRepresentationData();
axesU = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesU, representations, gridRepresentationData);
axesV = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesV, representations, gridRepresentationData);
if (sameDirectionAxesW != null)
{
axesW = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesW, representations, gridRepresentationData);
}
IFCAnyHandle contextOfItemsFootPrint = exporterIFC.Get3DContextHandle("FootPrint");
string identifierOpt = "FootPrint";
string representationTypeOpt = "GeometricCurveSet";
int numGridsToExport = gridRepresentationData.m_Grids.Count;
if (numGridsToExport == 0)
{
return;
}
bool useIFCCADLayer = !string.IsNullOrWhiteSpace(gridRepresentationData.m_IFCCADLayer);
IFCAnyHandle shapeRepresentation = null;
HashSet <IFCAnyHandle> allCurves = new HashSet <IFCAnyHandle>();
for (int ii = 0; ii < numGridsToExport; ii++)
{
allCurves.UnionWith(gridRepresentationData.m_curveSets[ii]);
}
if (useIFCCADLayer)
{
shapeRepresentation = RepresentationUtil.CreateShapeRepresentation(exporterIFC, contextOfItemsFootPrint,
identifierOpt, representationTypeOpt, allCurves, gridRepresentationData.m_IFCCADLayer);
}
else
{
ElementId catId = CategoryUtil.GetSafeCategoryId(gridRepresentationData.m_Grids[0]);
shapeRepresentation = RepresentationUtil.CreateShapeRepresentation(exporterIFC, gridRepresentationData.m_Grids[0], catId,
contextOfItemsFootPrint, identifierOpt, representationTypeOpt, allCurves);
}
representations.Add(shapeRepresentation);
IFCAnyHandle productRep = IFCInstanceExporter.CreateProductDefinitionShape(ifcFile, null, null, representations);
// We will associate the grid with its level, unless there are no levels in the file, in which case we'll associate it with the building.
IFCLevelInfo levelInfo = ExporterCacheManager.LevelInfoCache.GetLevelInfo(exporterIFC, levelId);
bool useLevelInfo = (levelInfo != null);
string gridGUID = GUIDUtil.CreateGUID();
//// Get the first grid's override name, if cannot find it, use null.
//string gridName = GetGridName(sameDirectionAxesU, sameDirectionAxesV, sameDirectionAxesW);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle gridLevelHandle = useLevelInfo ? levelInfo.GetBuildingStorey() : ExporterCacheManager.BuildingHandle;
IFCAnyHandle levelObjectPlacement = IFCAnyHandleUtil.GetObjectPlacement(gridLevelHandle);
double elev = useLevelInfo ? levelInfo.Elevation : 0.0;
double elevation = UnitUtil.ScaleLength(elev);
XYZ orig = new XYZ(0.0, 0.0, elevation);
IFCAnyHandle copyLevelPlacement = ExporterUtil.CopyLocalPlacement(ifcFile, levelObjectPlacement);
IFCAnyHandle ifcGrid = IFCInstanceExporter.CreateGrid(exporterIFC, gridGUID, ownerHistory, gridName, copyLevelPlacement, productRep, axesU, axesV, axesW);
productWrapper.AddElement(null, ifcGrid, levelInfo, null, true, null);
transaction.Commit();
}
}
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, ProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ecData.ReuseLocalPlacement = false;
GeometryElement rampGeom = GeometryUtil.GetOneLevelGeometryElement(geometryElement, numFlights);
BodyData bodyData;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
ramp, categoryId, rampGeom, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = GUIDUtil.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string rampName = NamingUtil.GetNameOverride(ramp, NamingUtil.GetIFCName(ramp));
string rampDescription = NamingUtil.GetDescriptionOverride(ramp, null);
string rampObjectType = NamingUtil.GetObjectTypeOverride(ramp, NamingUtil.CreateIFCObjectName(exporterIFC, ramp));
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CreateLocalPlacement(file, ecData.GetLocalPlacement(), null);
string elementTag = NamingUtil.GetTagOverride(ramp, NamingUtil.CreateIFCElementId(ramp));
string rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IList <IFCExtrusionCreationData> componentExtrusionData = new List <IFCExtrusionCreationData>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, containedRampGuid, ownerHistory, rampName,
rampDescription, rampObjectType, containedRampLocalPlacement, representation, elementTag, rampType);
components.Add(containedRampHnd);
componentExtrusionData.Add(ecData);
//productWrapper.AddElement(containedRampHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociations(exporterIFC, containedRampHnd, bodyData.MaterialIds);
string guid = GUIDUtil.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, rampName,
rampDescription, rampObjectType, localPlacement, null, elementTag, rampType);
productWrapper.AddElement(ramp, rampHnd, placementSetter.LevelInfo, ecData, true);
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, localPlacement);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights, rampHnd, components, componentExtrusionData, placementSetter,
productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports the top stories of a multistory ramp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="rampHnd">The stairs container handle.</param>
/// <param name="components">The components handles.</param>
/// <param name="ecData">The extrusion creation data.</param>
/// <param name="componentECData">The extrusion creation data for the components.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportMultistoryRamp(ExporterIFC exporterIFC, Element ramp, int numFlights,
IFCAnyHandle rampHnd, IList <IFCAnyHandle> components, IList <IFCExtrusionCreationData> componentECData,
PlacementSetter placementSetter, ProductWrapper productWrapper)
{
if (numFlights < 2)
{
return;
}
double heightNonScaled = GetRampHeight(exporterIFC, ramp);
if (heightNonScaled < MathUtil.Eps())
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rampHnd))
{
return;
}
IFCAnyHandle localPlacement = IFCAnyHandleUtil.GetObjectPlacement(rampHnd);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(localPlacement))
{
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
IList <IFCAnyHandle> rampLocalPlacementHnds = new List <IFCAnyHandle>();
IList <IFCLevelInfo> levelInfos = new List <IFCLevelInfo>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle newLevelHnd = null;
// We are going to avoid internal scaling routines, and instead scale in .NET.
double newOffsetUnscaled = 0.0;
IFCLevelInfo currLevelInfo =
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * (ii + 1), 1.0, ramp.Document, out newLevelHnd, out newOffsetUnscaled);
double newOffsetScaled = UnitUtil.ScaleLength(newOffsetUnscaled);
levelInfos.Add(currLevelInfo);
if (levelInfos[ii] == null)
{
levelInfos[ii] = placementSetter.LevelInfo;
}
XYZ orig;
if (ptHnd.HasValue)
{
orig = new XYZ(origCoords[0], origCoords[1], newOffsetScaled);
}
else
{
orig = new XYZ(0.0, 0.0, newOffsetScaled);
}
rampLocalPlacementHnds.Add(ExporterUtil.CreateLocalPlacement(file, newLevelHnd, orig, null, null));
}
IList <List <IFCAnyHandle> > newComponents = new List <List <IFCAnyHandle> >();
for (int ii = 0; ii < numFlights - 1; ii++)
{
newComponents.Add(new List <IFCAnyHandle>());
}
int compIdx = 0;
ElementId catId = CategoryUtil.GetSafeCategoryId(ramp);
foreach (IFCAnyHandle component in components)
{
string componentName = IFCAnyHandleUtil.GetStringAttribute(component, "Name");
string componentDescription = IFCAnyHandleUtil.GetStringAttribute(component, "Description");
string componentObjectType = IFCAnyHandleUtil.GetStringAttribute(component, "ObjectType");
string componentElementTag = IFCAnyHandleUtil.GetStringAttribute(component, "Tag");
IFCAnyHandle componentProdRep = IFCAnyHandleUtil.GetInstanceAttribute(component, "Representation");
IList <string> localComponentNames = new List <string>();
IList <IFCAnyHandle> componentPlacementHnds = new List <IFCAnyHandle>();
IFCAnyHandle localLocalPlacement = IFCAnyHandleUtil.GetObjectPlacement(component);
IFCAnyHandle localRelativePlacement =
(localLocalPlacement == null) ? null : IFCAnyHandleUtil.GetInstanceAttribute(localLocalPlacement, "RelativePlacement");
bool isSubRamp = component.IsSubTypeOf(IFCEntityType.IfcRamp.ToString());
for (int ii = 0; ii < numFlights - 1; ii++)
{
localComponentNames.Add((componentName == null) ? (ii + 2).ToString() : (componentName + ":" + (ii + 2)));
if (isSubRamp)
{
componentPlacementHnds.Add(ExporterUtil.CopyLocalPlacement(file, rampLocalPlacementHnds[ii]));
}
else
{
componentPlacementHnds.Add(IFCInstanceExporter.CreateLocalPlacement(file, rampLocalPlacementHnds[ii], localRelativePlacement));
}
}
IList <IFCAnyHandle> localComponentHnds = new List <IFCAnyHandle>();
if (isSubRamp)
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "ShapeType");
string localRampType = GetIFCRampType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateRamp(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localRampType));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcRampFlight))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateRampFlight(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, "NOTDEFINED"));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcSlab))
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "PredefinedType");
IFCSlabType localLandingType = FloorExporter.GetIFCSlabType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateSlab(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localLandingType.ToString()));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcMember))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateMember(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, "STRINGER"));
}
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
if (localComponentHnds[ii] != null)
{
newComponents[ii].Add(localComponentHnds[ii]);
productWrapper.AddElement(null, localComponentHnds[ii], levelInfos[ii], componentECData[compIdx], false);
}
}
compIdx++;
}
// finally add a copy of the container.
IList <IFCAnyHandle> rampCopyHnds = new List <IFCAnyHandle>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
string rampName = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Name");
string rampObjectType = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "ObjectType");
string rampDescription = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Description");
string rampElementTag = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Tag");
string rampTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(rampHnd, "ShapeType");
string rampType = GetIFCRampType(rampTypeAsString);
string containerRampName = rampName + ":" + (ii + 2);
rampCopyHnds.Add(IFCInstanceExporter.CreateRamp(file, GUIDUtil.CreateGUID(), ownerHistory,
containerRampName, rampDescription, rampObjectType, rampLocalPlacementHnds[ii], null, rampElementTag, rampType));
productWrapper.AddElement(ramp, rampCopyHnds[ii], levelInfos[ii], null, true);
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampCopyHnds[ii], newComponents[ii],
rampLocalPlacementHnds[ii]);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(ramp.Id, stairRampInfo);
}
}
/// <summary>
/// Exports a Group as an IfcGroup.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportGroupElement(ExporterIFC exporterIFC, Group element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcGroup;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle groupHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element));
string longName = NamingUtil.GetLongNameOverride(element, null);
string ifcEnumType;
IFCExportInfoPair exportAs = ExporterUtil.GetObjectExportType(exporterIFC, element, out ifcEnumType);
if (exportAs.ExportInstance == IFCEntityType.IfcGroup)
{
groupHnd = IFCInstanceExporter.CreateGroup(file, guid, ownerHistory, name, description, objectType);
}
else if (!ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
{
if (exportAs.ExportInstance == IFCEntityType.IfcBuildingSystem)
{
groupHnd = IFCInstanceExporter.CreateBuildingSystem(file, exportAs, guid, ownerHistory, name, description, objectType, longName);
}
else if (exportAs.ExportInstance == IFCEntityType.IfcFurniture)
{
groupHnd = IFCInstanceExporter.CreateGenericIFCEntity(exportAs, exporterIFC, element, guid, ownerHistory, null, null);
}
}
if (groupHnd == null)
{
return(false);
}
GroupInfo groupInfo = ExporterCacheManager.GroupCache.RegisterGroup(element.Id, groupHnd);
if (IFCAnyHandleUtil.IsSubTypeOf(groupHnd, IFCEntityType.IfcProduct))
{
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, groupHnd, setter.LevelInfo, null, !containedInSpace, exportAs);
if (containedInSpace)
{
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, groupHnd);
}
}
}
else
{
productWrapper.AddElement(element, groupHnd, exportAs);
}
// Check or set the cached Group's export type
if (groupInfo.GroupType.ExportInstance == IFCEntityType.UnKnown)
{
ExporterCacheManager.GroupCache.RegisterOrUpdateGroupType(element.Id, exportAs);
}
else if (groupInfo.GroupType.ExportInstance != exportAs.ExportInstance)
{
throw new InvalidOperationException("Inconsistent Group export entity type");
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a generic element as an IfcSlab.</summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="floor">The floor element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="ifcEnumType">The string value represents the IFC type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if the floor is exported successfully, false otherwise.</returns>
public static void ExportGenericSlab(ExporterIFC exporterIFC, Element slabElement, GeometryElement geometryElement, string ifcEnumType,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, slabElement))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
bool exportParts = PartExporter.CanExportParts(slabElement);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle prodDefHnd = null;
bool isBRepSlabHnd = false;
if (!exportParts)
{
ecData.SetLocalPlacement(localPlacement);
ElementId catId = CategoryUtil.GetSafeCategoryId(slabElement);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
BodyData bodyData;
prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
slabElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
isBRepSlabHnd = (bodyData.ShapeRepresentationType == ShapeRepresentationType.Brep);
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(slabElement);
string entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(slabElement, ifcEnumType, "FLOOR");
string ifcName = NamingUtil.GetNameOverride(slabElement, NamingUtil.GetIFCName(slabElement));
string ifcDescription = NamingUtil.GetDescriptionOverride(slabElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(slabElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(slabElement, NamingUtil.CreateIFCElementId(slabElement));
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, ifcGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacement, exportParts ? null : prodDefHnd,
ifcTag, entityType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, slabElement, slabHnd, productWrapper, placementSetter, localPlacement, null);
}
productWrapper.AddElement(slabElement, slabHnd, placementSetter, ecData, true);
if (!exportParts)
{
if (slabElement is HostObject)
{
HostObject hostObject = slabElement as HostObject;
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, slabHnd,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, isBRepSlabHnd);
}
else if (slabElement is FamilyInstance)
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
Document doc = slabElement.Document;
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
}
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, slabElement, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), placementSetter, productWrapper);
}
}
}
tr.Commit();
return;
}
}
}
/// <summary>
/// Exports a CeilingAndFloor element to IFC.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="floor">The floor element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCeilingAndFloorElement(ExporterIFC exporterIFC, CeilingAndFloor floorElement, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
// export parts or not
bool exportParts = PartExporter.CanExportParts(floorElement);
if (exportParts && !PartExporter.CanExportElementInPartExport(floorElement, floorElement.LevelId, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, floorElement, out ifcEnumType);
using (IFCTransaction tr = new IFCTransaction(file))
{
bool canExportAsContainerOrWithExtrusionAnalyzer = (!exportParts && (floorElement is Floor));
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
// The routine ExportExtrudedSlabOpenings is called if exportedAsInternalExtrusion is true, and it requires having a valid level association.
// Disable calling ExportSlabAsExtrusion if we can't handle potential openings.
bool canExportAsInternalExtrusion = placementSetter.LevelInfo != null;
bool exportedAsInternalExtrusion = false;
ElementId catId = CategoryUtil.GetSafeCategoryId(floorElement);
IList <IFCAnyHandle> prodReps = new List <IFCAnyHandle>();
IList <ShapeRepresentationType> repTypes = new List <ShapeRepresentationType>();
IList <IList <CurveLoop> > extrusionLoops = new List <IList <CurveLoop> >();
IList <IFCExtrusionCreationData> loopExtraParams = new List <IFCExtrusionCreationData>();
Plane floorPlane = GeometryUtil.CreateDefaultPlane();
IList <IFCAnyHandle> localPlacements = new List <IFCAnyHandle>();
if (canExportAsContainerOrWithExtrusionAnalyzer)
{
Floor floor = floorElement as Floor;
// First, try to use the ExtrusionAnalyzer for the limited cases it handles - 1 solid, no openings, end clippings only.
// Also limited to cases with line and arc boundaries.
//
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
bool completelyClipped;
// floorExtrusionDirection is set to (0, 0, -1) because extrusionAnalyzerFloorPlane is computed from the top face of the floor
XYZ floorExtrusionDirection = new XYZ(0, 0, -1);
XYZ modelOrigin = XYZ.Zero;
XYZ floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
if (floorOrigin == null)
{
// GetVerticalProjectionPoint may return null if FloorFace.Top is an edited face that doesn't
// go thruough te Revit model orgigin. We'll try the midpoint of the bounding box instead.
BoundingBoxXYZ boundingBox = floorElement.get_BoundingBox(null);
modelOrigin = (boundingBox.Min + boundingBox.Max) / 2.0;
floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
}
if (floorOrigin != null)
{
XYZ floorDir = floor.GetNormalAtVerticalProjectionPoint(floorOrigin, FloorFace.Top);
Plane extrusionAnalyzerFloorPlane = new Plane(floorDir, floorOrigin);
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floorElement,
catId, solids[0], extrusionAnalyzerFloorPlane, floorExtrusionDirection, null, out completelyClipped);
if (completelyClipped)
{
return;
}
if (floorAndProperties.Handle != null)
{
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(floorAndProperties.Handle);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
prodReps.Add(prodRep);
repTypes.Add(ShapeRepresentationType.SweptSolid);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (prodReps.Count == 0 && canExportAsInternalExtrusion)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out prodReps,
out extrusionLoops, out loopExtraParams, floorPlane);
for (int ii = 0; ii < prodReps.Count; ii++)
{
// all are extrusions
repTypes.Add(ShapeRepresentationType.SweptSolid);
}
}
if (prodReps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
prodReps.Add(prodDefHnd);
repTypes.Add(bodyData.ShapeRepresentationType);
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(floorElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = null;
switch (exportType)
{
case IFCExportType.IfcFooting:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCFootingType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCFootingType>(floorElement, ifcEnumType, null);
}
break;
case IFCExportType.IfcCovering:
entityType = IFCValidateEntry.GetValidIFCType <IFCCoveringType>(floorElement, ifcEnumType, "FLOORING");
break;
case IFCExportType.IfcRamp:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCRampType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCRampType>(floorElement, ifcEnumType, null);
}
break;
default:
bool isBaseSlab = false;
AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
if (analyticalModel != null)
{
AnalyzeAs slabFoundationType = analyticalModel.GetAnalyzeAs();
isBaseSlab = (slabFoundationType == AnalyzeAs.SlabOnGrade) || (slabFoundationType == AnalyzeAs.Mat);
}
entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(floorElement, ifcEnumType, isBaseSlab ? "BASESLAB" : "FLOOR");
break;
}
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.GetIFCNamePlusIndex(floorElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(floorElement, NamingUtil.CreateIFCElementId(floorElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = null;
// TODO: replace with CreateGenericBuildingElement.
switch (exportType)
{
case IFCExportType.IfcFooting:
slabHnd = IFCInstanceExporter.CreateFooting(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcCovering:
slabHnd = IFCInstanceExporter.CreateCovering(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcRamp:
slabHnd = IFCInstanceExporter.CreateRamp(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
default:
slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(floorElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
// This call to the native function appears to create Brep opening also when appropriate. But the creation of the IFC instances is not
// controllable from the managed code. Therefore in some cases BRep geometry for Opening will still be exported even in the Reference View
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
}
if (!exportParts)
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, ProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
IFCAnyHandle prodRep = null;
ElementId matId = ElementId.InvalidElementId;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string footingType = GetIFCFootingType(ifcEnumType); // need to keep it for legacy support when original data follows slightly diff naming
footingType = IFCValidateEntry.GetValidIFCType(element, footingType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceTag, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.LocalPlacement, null);
}
else
{
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, footing, matId);
}
}
productWrapper.AddElement(element, footing, setter, ecData, true);
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Export the individual part (IfcBuildingElementPart).
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="partElement">The part element to export.</param>
/// <param name="geometryElement">The geometry of part.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
public static void ExportPart(ExporterIFC exporterIFC, Element partElement, ProductWrapper productWrapper,
PlacementSetter placementSetter, IFCAnyHandle originalPlacement, IFCRange range, IFCExtrusionAxes ifcExtrusionAxes,
Element hostElement, ElementId overrideLevelId, bool asBuildingElement)
{
if (!ElementFilteringUtil.IsElementVisible(partElement))
{
return;
}
Part part = partElement as Part;
if (part == null)
{
return;
}
if (!asBuildingElement)
{
// 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>("IfcBuildingElementPart", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
}
else
{
string ifcEnumType = null;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
// 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>(exportType.ToString(), out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
}
PlacementSetter standalonePlacementSetter = null;
bool standaloneExport = hostElement == null && !asBuildingElement;
ElementId partExportLevel = null;
if (standaloneExport || asBuildingElement)
{
partExportLevel = partElement.LevelId;
}
else
{
if (part.OriginalCategoryId != hostElement.Category.Id)
{
return;
}
partExportLevel = hostElement.LevelId;
}
if (overrideLevelId != null)
{
partExportLevel = overrideLevelId;
}
if (ExporterCacheManager.PartExportedCache.HasExported(partElement.Id, partExportLevel))
{
return;
}
Options options = GeometryUtil.GetIFCExportGeometryOptions();
View ownerView = partElement.Document.GetElement(partElement.OwnerViewId) as View;
if (ownerView != null)
{
options.View = ownerView;
}
GeometryElement geometryElement = partElement.get_Geometry(options);
if (geometryElement == null)
{
return;
}
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IFCAnyHandle partPlacement = null;
if (standaloneExport || asBuildingElement)
{
Transform orientationTrf = Transform.Identity;
standalonePlacementSetter = PlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevel);
partPlacement = standalonePlacementSetter.LocalPlacement;
}
else
{
partPlacement = ExporterUtil.CreateLocalPlacement(file, originalPlacement, null);
}
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
SolidMeshGeometryInfo solidMeshInfo;
if (validRange)
{
solidMeshInfo = GeometryUtil.GetSplitClippedSolidMeshGeometry(geometryElement, range);
if (solidMeshInfo.GetSolids().Count == 0 && solidMeshInfo.GetMeshes().Count == 0)
{
return;
}
}
else
{
solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
}
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(partPlacement);
extrusionCreationData.ReuseLocalPlacement = false;
extrusionCreationData.PossibleExtrusionAxes = ifcExtrusionAxes;
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(partElement);
ElementId hostCatId = CategoryUtil.GetSafeCategoryId(hostElement);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, solids, meshes,
bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string partGUID = GUIDUtil.CreateGUID(partElement);
string partName = NamingUtil.GetNameOverride(partElement, NamingUtil.GetIFCName(partElement));
string partDescription = NamingUtil.GetDescriptionOverride(partElement, null);
string partObjectType = NamingUtil.GetObjectTypeOverride(partElement, NamingUtil.CreateIFCObjectName(exporterIFC, partElement));
string partTag = NamingUtil.GetTagOverride(partElement, NamingUtil.CreateIFCElementId(partElement));
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag);
}
else
{
string ifcEnumType = null;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
string defaultValue = null;
// This replicates old functionality before IFC4 addition, where the default for slab was "FLOOR".
// Really the export layer table should be fixed for this case.
if (string.IsNullOrWhiteSpace(ifcEnumType) && hostCatId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOOR";
}
ifcEnumType = IFCValidateEntry.GetValidIFCType(hostElement, ifcEnumType, defaultValue);
switch (exportType)
{
case IFCExportType.IfcColumnType:
ifcPart = IFCInstanceExporter.CreateColumn(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcCovering:
ifcPart = IFCInstanceExporter.CreateCovering(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcFooting:
ifcPart = IFCInstanceExporter.CreateFooting(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcPile:
ifcPart = IFCInstanceExporter.CreatePile(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType, null);
break;
case IFCExportType.IfcRoof:
ifcPart = IFCInstanceExporter.CreateRoof(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcSlab:
ifcPart = IFCInstanceExporter.CreateSlab(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcWall:
ifcPart = IFCInstanceExporter.CreateWall(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag, null);
break;
}
}
bool containedInLevel = (standaloneExport || asBuildingElement);
PlacementSetter whichPlacementSetter = containedInLevel ? standalonePlacementSetter : placementSetter;
productWrapper.AddElement(partElement, ifcPart, whichPlacementSetter, extrusionCreationData, containedInLevel);
OpeningUtil.CreateOpeningsIfNecessary(ifcPart, partElement, extrusionCreationData, bodyData.OffsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), whichPlacementSetter, productWrapper);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevel, standaloneExport || asBuildingElement ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
