/// <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 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>
/// 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 = 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>
/// Creates a new placement setter instance for the given element with the ability to specific overridden transformations
/// and level id.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="instanceOffsetTrf">The offset transformation for the instance of a type. Optional, can be <see langword="null"/>.</param>
/// <param name="orientationTrf">The orientation transformation for the local coordinates being used to export the element.
/// Optional, can be <see langword="null"/>.</param>
/// <param name="overrideLevelId">The level id to reference. This is intended for use when splitting walls and columns by level.</param>
public static PlacementSetter Create(ExporterIFC exporterIFC, Element elem, Transform instanceOffsetTrf, Transform orientationTrf, ElementId overrideLevelId, IFCAnyHandle containerOverrideHnd)
{
// Call a different PlacementSetter if the containment is overridden to the Site or the Building
if ((overrideLevelId == null || overrideLevelId == ElementId.InvalidElementId) && containerOverrideHnd != null)
{
if (IFCAnyHandleUtil.IsTypeOf(containerOverrideHnd, Common.Enums.IFCEntityType.IfcSite) ||
IFCAnyHandleUtil.IsTypeOf(containerOverrideHnd, Common.Enums.IFCEntityType.IfcBuilding))
{
return(new PlacementSetter(exporterIFC, elem, instanceOffsetTrf, orientationTrf, containerOverrideHnd));
}
else if (IFCAnyHandleUtil.IsTypeOf(containerOverrideHnd, Common.Enums.IFCEntityType.IfcBuildingStorey))
{
IFCAnyHandle contHnd = null;
overrideLevelId = ParameterUtil.OverrideContainmentParameter(exporterIFC, elem, out contHnd);
}
}
if (overrideLevelId == null || overrideLevelId == ElementId.InvalidElementId)
{
overrideLevelId = LevelUtil.GetBaseLevelIdForElement(elem);
}
return(new PlacementSetter(exporterIFC, elem, instanceOffsetTrf, orientationTrf, overrideLevelId));
}
/// <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>
private static IFCAnyHandle ExportRebarAsProxy(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))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
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, exportType);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <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())
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, slabElement, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, slabElement, null, null, overrideContainerId, overrideContainerHnd))
{
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 || bodyData.ShapeRepresentationType == ShapeRepresentationType.Tessellation);
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(slabElement);
string entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(slabElement, ifcEnumType, "FLOOR");
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, slabElement, ifcGUID, ownerHistory,
localPlacement, exportParts ? null : prodDefHnd, entityType);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcSlab, entityType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, slabElement, slabHnd, productWrapper, placementSetter, localPlacement, null);
}
productWrapper.AddElement(slabElement, slabHnd, placementSetter, ecData, true, exportInfo);
if (!exportParts)
{
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(slabElement, exportInfo, file, ownerHistory, entityType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, slabHnd);
if (slabElement is HostObject)
{
HostObject hostObject = slabElement as HostObject;
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, slabHnd,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, isBRepSlabHnd, typeHnd);
}
else if (slabElement is FamilyInstance)
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
//Document doc = slabElement.Document;
if (typeHnd != null)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, typeHnd, matId);
}
else
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
}
}
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, slabElement, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), placementSetter, productWrapper);
}
}
}
tr.Commit();
return;
}
}
}
/// <summary>
/// Export Curtain Walls and Roofs.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="allSubElements">Collection of elements contained in the host curtain element.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
private static void ExportBase(ExporterIFC exporterIFC, ICollection <ElementId> allSubElements, Element element, ProductWrapper wrapper)
{
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcRoof;
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elementClassTypeEnum = Common.Enums.IFCEntityType.IfcCurtainWall;
}
else if (element is RoofBase)
{
elementClassTypeEnum = Common.Enums.IFCEntityType.IfcRoof;
}
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
PlacementSetter setter = null;
using (ProductWrapper curtainWallSubWrapper = ProductWrapper.Create(wrapper, false))
{
try
{
Transform orientationTrf = Transform.Identity;
IFCAnyHandle localPlacement = null;
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
setter = PlacementSetter.Create(exporterIFC, element, null, orientationTrf, overrideContainerId, overrideContainerHnd);
localPlacement = setter.LocalPlacement;
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = GUIDUtil.CreateGUID(element);
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(exporterIFC, element, elemGUID, ownerHistory, localPlacement, prodRepHnd, null);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
//ifcEnumType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType);
elemHnd = IFCInstanceExporter.CreateRoof(exporterIFC, element, elemGUID, ownerHistory, localPlacement, prodRepHnd, ifcEnumType);
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(element, elemHnd, setter, null, true, null);
bool canExportCurtainWallAsContainer = CanExportCurtainWallAsContainer(allSubElements, element.Document);
IFCAnyHandle rep = null;
if (!canExportCurtainWallAsContainer)
{
rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
{
return;
}
}
else
{
ExportCurtainObjectCommonAsContainer(allSubElements, element, exporterIFC, curtainWallSubWrapper, setter);
}
ICollection <IFCAnyHandle> relatedElementIds = curtainWallSubWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = GUIDUtil.CreateSubElementGUID(element, (int)IFCCurtainWallSubElements.RelAggregates);
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(file, guid, ownerHistory, null, null, elemHnd, relatedElementIdSet);
}
ExportCurtainWallType(exporterIFC, wrapper, elemHnd, element);
SpaceBoundingElementUtil.RegisterSpaceBoundingElementHandle(exporterIFC, elemHnd, element.Id, ElementId.InvalidElementId);
}
finally
{
if (setter != null)
{
setter.Dispose();
}
}
}
}
/// <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);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcReinforcingMesh;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(false);
}
Document doc = sheet.Document;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, sheet, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, sheet, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(sheet);
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(sheet, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
string guid = GUIDUtil.CreateGUID(sheet);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = NamingUtil.GetFamilyAndTypeName(sheet);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
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 = UnitUtil.ScaleLength(majorFabricWireType.WireDiameter);
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 = UnitUtil.ScaleLength(minorFabricWireType.WireDiameter);
double localRadius = transverseBarNominalDiameter / 2.0;
transverseBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
longitudinalBarSpacing = UnitUtil.ScaleLength(fabricSheetType.MajorSpacing);
transverseBarSpacing = UnitUtil.ScaleLength(fabricSheetType.MinorSpacing);
}
ISet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
IList <Curve> wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Major);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = GeometryUtil.CreateSweptDiskSolid(exporterIFC, file, wireCenterline, longitudinalBarNominalDiameter, null);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Minor);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = GeometryUtil.CreateSweptDiskSolid(exporterIFC, file, wireCenterline, transverseBarNominalDiameter, null);
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(exporterIFC, sheet, guid, ownerHistory, localPlacement,
prodRep, steelGrade, meshLength, meshWidth, longitudinalBarNominalDiameter, transverseBarNominalDiameter,
longitudinalBarCrossSectionArea, transverseBarCrossSectionArea, longitudinalBarSpacing, transverseBarSpacing);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcReinforcingMesh);
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.LevelInfo, ecData, true, exportInfo);
CategoryUtil.CreateMaterialAssociation(exporterIFC, fabricSheet, materialId);
}
}
tr.Commit();
return(true);
}
}
/// <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 ExportGenericElement(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper, IFCExportInfoPair exportType)
{
if (element == null || geometryElement == null)
{
return(null);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
if (exportType.ExportInstance == IFCEntityType.UnKnown)
{
exportType.SetValueWithPair(IFCEntityType.IfcBuildingElementProxy, exportType.ValidatedPredefinedType);
}
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(exportType.ExportInstance))
{
return(null);
}
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle instanceHandle = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
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();
IFCAnyHandle styleHandle = null;
instanceHandle = FamilyExporterUtil.ExportGenericInstance(exportType, exporterIFC, element, productWrapper, placementSetter, ecData, guid, ownerHistory,
representation, exportType.ValidatedPredefinedType, null);
if (exportType.ExportType != IFCEntityType.UnKnown)
{
if (element is FamilyInstance)
{
FamilySymbol familySymbol = (element as FamilyInstance).Symbol;
if (familySymbol != null)
{
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
IList <IFCAnyHandle> repMapListOpt = new List <IFCAnyHandle>();
styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, exportType.ValidatedPredefinedType,
propertySetsOpt, repMapListOpt, element, familySymbol);
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
styleHandle = ExporterUtil.CreateGenericTypeFromElement(element, exportType, file, ownerHistory, exportType.ValidatedPredefinedType, productWrapper);
}
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
productWrapper.AddElement(element, instanceHandle, placementSetter.LevelInfo, ecData, true, exportType);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
ExporterCacheManager.TypeRelationsCache.Add(styleHandle, instanceHandle);
}
}
}
tr.Commit();
}
}
return(instanceHandle);
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <param name="exportRoofAsSingleGeometry">Export roof as single geometry.</param>
public static void ExportRoof(ExporterIFC exporterIFC, Element roof, ref GeometryElement geometryElement,
ProductWrapper productWrapper, bool exportRoofAsSingleGeometry = false)
{
if (roof == null || geometryElement == null)
{
return;
}
string ifcEnumType;
IFCExportInfoPair roofExportType = ExporterUtil.GetProductExportType(exporterIFC, roof, out ifcEnumType);
if (roofExportType.IsUnKnown)
{
roofExportType = new IFCExportInfoPair(IFCEntityType.IfcRoof, "");
}
MaterialLayerSetInfo layersetInfo = new MaterialLayerSetInfo(exporterIFC, roof, productWrapper);
IFCFile file = exporterIFC.GetFile();
Document doc = roof.Document;
using (SubTransaction tempPartTransaction = new SubTransaction(doc))
{
// For IFC4RV export, Roof will be split into its parts(temporarily) in order to export the roof by its parts
ExporterUtil.CreateParts(roof, layersetInfo.MaterialIds.Count, ref geometryElement);
bool exportByComponents = ExporterUtil.CanExportByComponentsOrParts(roof) == ExporterUtil.ExportPartAs.ShapeAspect;
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, roof, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, roof, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// If the roof is an in-place family, we will allow any arbitrary orientation. While this may result in some
// in-place "cubes" exporting with the wrong direction, it is unlikely that an in-place family would be
// used for this reason in the first place.
ecData.PossibleExtrusionAxes = (roof is FamilyInstance) ? IFCExtrusionAxes.TryXYZ : IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData = null;
IFCAnyHandle prodRep = null;
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
IList <ElementId> materialIds = new List <ElementId>();
if (!exportByComponents)
{
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (bodyData != null && bodyData.MaterialIds != null)
{
materialIds = bodyData.MaterialIds;
}
}
else
{
prodRep = RepresentationUtil.CreateProductDefinitionShapeWithoutBodyRep(exporterIFC, roof, categoryId, geometryElement, representations);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ((ecData.ScaledLength > MathUtil.Eps() || exportByComponents) &&
roofExportType.ExportInstance == IFCEntityType.IfcRoof && !exportRoofAsSingleGeometry);
string guid = GUIDUtil.CreateGUID(roof);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateGenericIFCEntity(
roofExportType, exporterIFC, roof, guid, ownerHistory,
localPlacement, exportSlab ? null : prodRep);
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(roof,
roofExportType, file, ownerHistory, roofExportType.ValidatedPredefinedType,
productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, roofHnd);
productWrapper.AddElement(roof, roofHnd, placementSetter.LevelInfo, ecData, true, roofExportType);
if (!(roof is RoofBase))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, materialIds);
}
if (exportByComponents && (exportSlab || exportRoofAsSingleGeometry))
{
IFCAnyHandle hostShapeRepFromParts = PartExporter.ExportHostPartAsShapeAspects(exporterIFC, roof, prodRep,
productWrapper, placementSetter, localPlacement, ElementId.InvalidElementId, layersetInfo, ecData);
}
Transform offsetTransform = (bodyData != null) ? bodyData.OffsetTransform : Transform.Identity;
if (exportSlab)
{
string slabGUID = GUIDUtil.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
string slabName = IFCAnyHandleUtil.GetStringAttribute(roofHnd, "Name") + ":1";
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, roof, slabGUID, ownerHistory,
slabLocalPlacementHnd, prodRep, slabRoofPredefinedType);
IFCAnyHandleUtil.OverrideNameAttribute(slabHnd, slabName);
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, offsetTransform,
exporterIFC, slabLocalPlacementHnd, placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
IFCExportInfoPair slabRoofExportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, slabRoofPredefinedType);
productWrapper.AddElement(null, slabHnd, placementSetter.LevelInfo, ecData, false, slabRoofExportType);
// Create type
IFCAnyHandle slabRoofTypeHnd = ExporterUtil.CreateGenericTypeFromElement(roof, slabRoofExportType, exporterIFC.GetFile(), ownerHistory, slabRoofPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(slabRoofTypeHnd, slabHnd);
ExporterUtil.AddIntoComplexPropertyCache(slabHnd, layersetInfo);
// For earlier than IFC4 version of IFC export, the material association will be done at the Roof host level with MaterialSetUsage
// This one is only for IFC4 and above
if ((roof is RoofBase) && !ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
{
if (layersetInfo != null && !IFCAnyHandleUtil.IsNullOrHasNoValue(layersetInfo.MaterialLayerSetHandle))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, layersetInfo.MaterialLayerSetHandle);
}
else if (bodyData != null)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, bodyData.MaterialIds);
}
}
}
else
{
OpeningUtil.CreateOpeningsIfNecessary(roofHnd, roof, ecData, offsetTransform,
exporterIFC, localPlacement, placementSetter, productWrapper);
// For earlier than IFC4 version of IFC export, the material association will be done at the Roof host level with MaterialSetUsage
// This one is only for IFC4 and above
if ((roof is RoofBase) && !ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
{
if (layersetInfo != null && !IFCAnyHandleUtil.IsNullOrHasNoValue(layersetInfo.MaterialLayerSetHandle))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, layersetInfo.MaterialLayerSetHandle);
}
else if (layersetInfo != null && layersetInfo.MaterialIds != null)
{
materialIds = layersetInfo.MaterialIds.Select(x => x.m_baseMatId).ToList();
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, materialIds);
}
}
}
}
tr.Commit();
}
}
}
}
/// <summary>
/// Exports a roof or floor as a container of multiple roof slabs. Returns the handle, if successful.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The roof or floor element.</param>
/// <param name="geometry">The geometry of the element.</param>
/// <param name="productWrapper">The product wrapper.</param>
/// <returns>The roof handle.</returns>
/// <remarks>For floors, if there is only one component, return null, as we do not want to create a container.</remarks>
public static IFCAnyHandle ExportRoofOrFloorAsContainer(ExporterIFC exporterIFC,
Element element, GeometryElement geometry, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
// We support ExtrusionRoofs, FootPrintRoofs, and Floors only.
bool elementIsRoof = (element is ExtrusionRoof) || (element is FootPrintRoof);
bool elementIsFloor = (element is Floor);
if (!elementIsRoof && !elementIsFloor)
{
return(null);
}
string subSlabType = null;
IFCExportInfoPair roofExportType = ExporterUtil.GetProductExportType(exporterIFC, element, out _);
if (roofExportType.IsUnKnown)
{
IFCEntityType elementClassTypeEnum =
elementIsFloor ? IFCEntityType.IfcSlab: IFCEntityType.IfcRoof;
roofExportType = new IFCExportInfoPair(elementClassTypeEnum, "");
}
else
{
if (elementIsFloor)
{
subSlabType = "FLOOR";
}
else if (elementIsRoof)
{
subSlabType = "ROOF";
}
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(roofExportType.ExportType))
{
return(null);
}
Document doc = element.Document;
using (SubTransaction tempPartTransaction = new SubTransaction(doc))
{
using (IFCTransaction transaction = new IFCTransaction(file))
{
MaterialLayerSetInfo layersetInfo = new MaterialLayerSetInfo(exporterIFC, element, productWrapper);
bool hasLayers = false;
if (layersetInfo.MaterialIds.Count > 1)
{
hasLayers = true;
}
bool exportByComponents = ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView && hasLayers;
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
// We want to delay creating entity handles until as late as possible, so that if we abort the IFC transaction,
// we don't have to delete elements. This is both for performance reasons and to potentially extend the number
// of projects that can be exported by reducing (a small amount) of waste.
IList <HostObjectSubcomponentInfo> hostObjectSubcomponents = null;
try
{
hostObjectSubcomponents = ExporterIFCUtils.ComputeSubcomponents(element as HostObject);
}
catch
{
return(null);
}
if (hostObjectSubcomponents == null)
{
return(null);
}
int numSubcomponents = hostObjectSubcomponents.Count;
if (numSubcomponents == 0 || (elementIsFloor && numSubcomponents == 1))
{
return(null);
}
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle hostObjectHandle = null;
try
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
extrusionCreationData.SetLocalPlacement(localPlacement);
extrusionCreationData.ReuseLocalPlacement = true;
using (TransformSetter trfSetter = TransformSetter.Create())
{
IList <GeometryObject> geometryList = new List <GeometryObject>();
geometryList.Add(geometry);
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, extrusionCreationData);
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
hostObjectHandle = IFCInstanceExporter.CreateGenericIFCEntity(
roofExportType, exporterIFC, element, elementGUID, ownerHistory,
localPlacement, prodRepHnd);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjectHandle))
{
return(null);
}
IList <IFCAnyHandle> elementHandles = new List <IFCAnyHandle>();
elementHandles.Add(hostObjectHandle);
// If element is floor, then the profile curve loop of hostObjectSubComponent is computed from the top face of the floor
// else if element is roof, then the profile curve loop is taken from the bottom face of the roof instead
XYZ extrusionDir = elementIsFloor ? new XYZ(0, 0, -1) : new XYZ(0, 0, 1);
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IList <IFCAnyHandle> slabHandles = new List <IFCAnyHandle>();
IList <CurveLoop> hostObjectOpeningLoops = new List <CurveLoop>();
double maximumScaledDepth = 0.0;
using (IFCExtrusionCreationData slabExtrusionCreationData = new IFCExtrusionCreationData())
{
slabExtrusionCreationData.SetLocalPlacement(extrusionCreationData.GetLocalPlacement());
slabExtrusionCreationData.ReuseLocalPlacement = false;
slabExtrusionCreationData.ForceOffset = true;
int loopNum = 0;
int subElementStart = elementIsRoof ? (int)IFCRoofSubElements.RoofSlabStart : (int)IFCSlabSubElements.SubSlabStart;
foreach (HostObjectSubcomponentInfo hostObjectSubcomponent in hostObjectSubcomponents)
{
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, slabExtrusionCreationData);
Plane plane = hostObjectSubcomponent.GetPlane();
Transform lcs = GeometryUtil.CreateTransformFromPlane(plane);
IList <CurveLoop> curveLoops = new List <CurveLoop>();
CurveLoop slabCurveLoop = hostObjectSubcomponent.GetCurveLoop();
curveLoops.Add(slabCurveLoop);
double slope = Math.Abs(plane.Normal.Z);
double scaledDepth = UnitUtil.ScaleLength(hostObjectSubcomponent.Depth);
double scaledExtrusionDepth = scaledDepth * slope;
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
IFCAnyHandle prodDefShape = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
string shapeIdent = "Body";
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle(shapeIdent);
string representationType = ShapeRepresentationType.SweptSolid.ToString();
// Create representation items based on the layers
// Because in this case, the Roof components are not derived from Parts, but by "splitting" geometry part that can be extruded,
// the creation of the Items for IFC4RV will be different by using "manual" split based on the layer thickness
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
if (!exportByComponents)
{
IFCAnyHandle itemShapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, lcs, extrusionDir, scaledExtrusionDepth, false);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(itemShapeRep))
{
productWrapper.ClearInternalHandleWrapperData(element);
return(null);
}
ElementId matId = HostObjectExporter.GetFirstLayerMaterialId(element as HostObject);
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, element.Document, false, itemShapeRep, matId);
bodyItems.Add(itemShapeRep);
}
else
{
double scaleProj = extrusionDir.DotProduct(plane.Normal);
foreach (MaterialLayerSetInfo.MaterialInfo matLayerInfo in layersetInfo.MaterialIds)
{
double itemExtrDepth = matLayerInfo.m_matWidth;
IFCAnyHandle itemShapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, lcs, extrusionDir, itemExtrDepth, false);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(itemShapeRep))
{
productWrapper.ClearInternalHandleWrapperData(element);
return(null);
}
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, element.Document, false, itemShapeRep, matLayerInfo.m_baseMatId);
bodyItems.Add(itemShapeRep);
RepresentationUtil.CreateRepForShapeAspect(exporterIFC, element, prodDefShape, representationType, matLayerInfo.m_layerName, itemShapeRep);
XYZ offset = new XYZ(0, 0, itemExtrDepth / scaleProj); // offset is calculated as extent in the direction of extrusion
lcs.Origin += offset;
}
}
IFCAnyHandle shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, catId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
shapeReps.Add(shapeRep);
IFCAnyHandleUtil.SetAttribute(prodDefShape, "Representations", shapeReps);
// Allow support for up to 256 named IfcSlab components, as defined in IFCSubElementEnums.cs.
string slabGUID = (loopNum < 256) ? GUIDUtil.CreateSubElementGUID(element, subElementStart + loopNum) : GUIDUtil.CreateGUID();
IFCAnyHandle slabPlacement = ExporterUtil.CreateLocalPlacement(file, slabExtrusionCreationData.GetLocalPlacement(), null);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, element, slabGUID, ownerHistory,
slabPlacement, prodDefShape, subSlabType);
IFCExportInfoPair exportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, subSlabType);
//slab quantities
slabExtrusionCreationData.ScaledLength = scaledExtrusionDepth;
slabExtrusionCreationData.ScaledArea = UnitUtil.ScaleArea(UnitUtil.ScaleArea(hostObjectSubcomponent.AreaOfCurveLoop));
slabExtrusionCreationData.ScaledOuterPerimeter = UnitUtil.ScaleLength(curveLoops[0].GetExactLength());
slabExtrusionCreationData.Slope = UnitUtil.ScaleAngle(MathUtil.SafeAcos(Math.Abs(slope)));
IFCExportInfoPair slabRoofExportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, subSlabType);
productWrapper.AddElement(null, slabHnd, setter, slabExtrusionCreationData, false, slabRoofExportType);
// Create type
IFCAnyHandle slabRoofTypeHnd = ExporterUtil.CreateGenericTypeFromElement(element, slabRoofExportType, exporterIFC.GetFile(), ownerHistory, subSlabType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(slabRoofTypeHnd, slabHnd);
elementHandles.Add(slabHnd);
slabHandles.Add(slabHnd);
hostObjectOpeningLoops.Add(slabCurveLoop);
maximumScaledDepth = Math.Max(maximumScaledDepth, scaledDepth);
loopNum++;
ExporterUtil.AddIntoComplexPropertyCache(slabHnd, layersetInfo);
// Create material association here
if (layersetInfo != null && !IFCAnyHandleUtil.IsNullOrHasNoValue(layersetInfo.MaterialLayerSetHandle))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, layersetInfo.MaterialLayerSetHandle);
}
}
}
productWrapper.AddElement(element, hostObjectHandle, setter, extrusionCreationData, true, roofExportType);
ExporterUtil.RelateObjects(exporterIFC, null, hostObjectHandle, slabHandles);
OpeningUtil.AddOpeningsToElement(exporterIFC, elementHandles, hostObjectOpeningLoops, element, null, maximumScaledDepth,
null, setter, localPlacement, productWrapper);
transaction.Commit();
return(hostObjectHandle);
}
}
}
catch
{
// SOmething wrong with the above process, unable to create the extrusion data. Reset any internal handles that may have been partially created since they are not committed
productWrapper.ClearInternalHandleWrapperData(element);
return(null);
}
finally
{
exporterIFC.ClearFaceWithElementHandleMap();
}
}
}
}
}
/// <summary>
/// Exports an element as IFC railing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportRailing(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, 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.IfcRailing;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
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))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
StairRampContainerInfo stairRampInfo = null;
ElementId hostId = GetStairOrRampHostId(exporterIFC, element as Railing);
Transform inverseTrf = Transform.Identity;
if (hostId != ElementId.InvalidElementId)
{
stairRampInfo = ExporterCacheManager.StairRampContainerInfoCache.GetStairRampContainerInfo(hostId);
IFCAnyHandle stairRampLocalPlacement = stairRampInfo.LocalPlacements[0];
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(stairRampLocalPlacement, localPlacement);
inverseTrf = relTrf.Inverse;
IFCAnyHandle railingLocalPlacement = ExporterUtil.CreateLocalPlacement(file, stairRampLocalPlacement,
inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
localPlacement = railingLocalPlacement;
}
ecData.SetLocalPlacement(localPlacement);
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geomElem);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
IList <GeometryObject> gObjs = FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(element.Document, exporterIFC, ref solids, ref meshes);
Railing railingElem = element as Railing;
IList <ElementId> subElementIds = CollectSubElements(railingElem);
foreach (ElementId subElementId in subElementIds)
{
Element subElement = railingElem.Document.GetElement(subElementId);
if (subElement != null)
{
GeometryElement subElementGeom = GeometryUtil.GetOneLevelGeometryElement(subElement.get_Geometry(geomOptions), 0);
SolidMeshGeometryInfo subElementSolidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(subElementGeom);
IList <Solid> subElemSolids = subElementSolidMeshInfo.GetSolids();
IList <Mesh> subElemMeshes = subElementSolidMeshInfo.GetMeshes();
IList <GeometryObject> partGObjs = FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(element.Document, exporterIFC, ref subElemSolids, ref subElemMeshes);
foreach (Solid subElSolid in subElemSolids)
{
solids.Add(subElSolid);
}
foreach (Mesh subElMesh in subElemMeshes)
{
meshes.Add(subElMesh);
}
}
}
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId, solids, meshes, bodyExporterOptions, ecData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geomElem);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId, geomlist, bodyExporterOptions, ecData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IList <GeometryObject> geomObjects = new List <GeometryObject>(solids);
foreach (Mesh mesh in meshes)
{
geomObjects.Add(mesh);
}
Transform boundingBoxTrf = (bodyData.OffsetTransform != null) ? bodyData.OffsetTransform.Inverse : Transform.Identity;
boundingBoxTrf = inverseTrf.Multiply(boundingBoxTrf);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geomObjects, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string instanceGUID = GUIDUtil.CreateGUID(element);
IFCAnyHandle railing = IFCInstanceExporter.CreateRailing(exporterIFC, element, instanceGUID, ownerHistory,
ecData.GetLocalPlacement(), prodRep, ifcEnumType);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(elementClassTypeEnum, ifcEnumType);
bool associateToLevel = (hostId == ElementId.InvalidElementId);
productWrapper.AddElement(element, railing, setter, ecData, associateToLevel, exportInfo);
OpeningUtil.CreateOpeningsIfNecessary(railing, element, ecData, bodyData.OffsetTransform,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
CategoryUtil.CreateMaterialAssociation(exporterIFC, railing, bodyData.MaterialIds);
// Create multi-story duplicates of this railing.
if (stairRampInfo != null)
{
stairRampInfo.AddComponent(0, railing);
List <IFCAnyHandle> stairHandles = stairRampInfo.StairOrRampHandles;
for (int ii = 1; ii < stairHandles.Count; ii++)
{
IFCAnyHandle railingLocalPlacement = stairRampInfo.LocalPlacements[ii];
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(railingLocalPlacement))
{
IFCAnyHandle railingHndCopy = CopyRailingHandle(exporterIFC, element, catId, railingLocalPlacement, railing);
stairRampInfo.AddComponent(ii, railingHndCopy);
productWrapper.AddElement(element, railingHndCopy, (IFCLevelInfo)null, ecData, false, exportInfo);
CategoryUtil.CreateMaterialAssociation(exporterIFC, railingHndCopy, bodyData.MaterialIds);
}
}
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(hostId, stairRampInfo);
}
}
transaction.Commit();
}
}
}
/// <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;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcFooting;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
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, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string footingType = GetIFCFootingType(ifcEnumType); // need to keep it for legacy support when original data follows slightly diff naming
IFCExportInfoPair exportInfo = new IFCExportInfoPair(elementClassTypeEnum, footingType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(exporterIFC, element, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
ecData.GetLocalPlacement(), prodRep, footingType);
// TODO: to allow shared geometry for Footings. For now, Footing export will not use shared geometry
if (exportInfo.ExportType != Common.Enums.IFCEntityType.UnKnown)
{
IFCAnyHandle type = ExporterUtil.CreateGenericTypeFromElement(element, exportInfo, file, ExporterCacheManager.OwnerHistoryHandle, exportInfo.ValidatedPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(type, footing);
}
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, exportInfo);
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Exports a curve element to IFC curve annotation.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="curveElement">
/// The curve element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportCurveElement(ExporterIFC exporterIFC, CurveElement curveElement, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (geometryElement == null || !ShouldCurveElementBeExported(curveElement))
{
return;
}
SketchPlane sketchPlane = curveElement.SketchPlane;
if (sketchPlane == 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.IfcAnnotation;
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, curveElement, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, curveElement, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle axisPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
Plane planeSK = sketchPlane.GetPlane();
XYZ projDir = planeSK.Normal;
XYZ origin = planeSK.Origin;
bool useOffsetTrf = false;
if (projDir.IsAlmostEqualTo(XYZ.BasisZ))
{
XYZ offset = XYZ.BasisZ * setter.Offset;
origin -= offset;
}
else
{
useOffsetTrf = true;
}
Transform curveLCS = GeometryUtil.CreateTransformFromPlane(planeSK);
curveLCS.Origin = origin;
IList <IFCAnyHandle> curves = null;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
Transform trf = null;
if (useOffsetTrf)
{
XYZ offsetOrig = -XYZ.BasisZ * setter.Offset;
trf = Transform.CreateTranslation(offsetOrig);
}
curves = new List <IFCAnyHandle>();
//Curve curve = (geometryElement as GeometryObject) as Curve;
List <Curve> curvesFromGeomElem = GeometryUtil.GetCurvesFromGeometryElement(geometryElement);
foreach (Curve curve in curvesFromGeomElem)
{
IFCAnyHandle curveHnd;
try
{
curveHnd = GeometryUtil.CreatePolyCurveFromCurve(exporterIFC, curve, trf);
}
catch
{
curveHnd = GeometryUtil.OutdatedCreatePolyCurveFromCurve(exporterIFC, curve, trf);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(curveHnd))
{
curves.Add(curveHnd);
}
}
}
else
{
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, curveLCS, projDir, false);
if (useOffsetTrf)
{
XYZ offsetOrig = -XYZ.BasisZ * setter.Offset;
Transform trf = Transform.CreateTranslation(offsetOrig);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, geometryElement, XYZ.Zero, false, trf);
}
else
{
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, geometryElement, XYZ.Zero, false);
}
curves = info.GetCurves();
}
if (curves.Count != 1)
{
throw new Exception("IFC: expected 1 curve when export curve element.");
}
HashSet <IFCAnyHandle> curveSet = new HashSet <IFCAnyHandle>(curves);
IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateGeometricCurveSet(file, curveSet);
IFCAnyHandle curveStyle = file.CreateStyle(exporterIFC, repItemHnd);
CurveAnnotationCache annotationCache = ExporterCacheManager.CurveAnnotationCache;
IFCAnyHandle curveAnno = annotationCache.GetAnnotation(sketchPlane.Id, curveStyle);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(curveAnno))
{
AddCurvesToAnnotation(curveAnno, curves);
}
else
{
curveAnno = CreateCurveAnnotation(exporterIFC, curveElement, curveElement.Category.Id, sketchPlane.Id, curveLCS, curveStyle, setter, localPlacement, repItemHnd);
productWrapper.AddAnnotation(curveAnno, setter.LevelInfo, true);
annotationCache.AddAnnotation(sketchPlane.Id, curveStyle, curveAnno);
}
}
transaction.Commit();
}
}
/// <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);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, sheet, out IFCAnyHandle overrideContainerHnd);
if (!(sheet.Document?.GetElement(sheet.GetTypeId()) is FabricSheetType fsType))
{
return(false);
}
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, sheet, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
FabricSheetExportConfig config = new FabricSheetExportConfig()
{
BodyItems = new HashSet <IFCAnyHandle>(),
CategoryId = CategoryUtil.GetSafeCategoryId(sheet),
Doc = sheet.Document,
Sheet = sheet,
EcData = ecData,
ExporterIFC = exporterIFC,
File = file,
PlacementSetter = placementSetter,
ProductWrapper = productWrapper,
SheetType = fsType
};
ParameterUtil.GetElementIdValueFromElementOrSymbol(config.Sheet, BuiltInParameter.MATERIAL_ID_PARAM, out ElementId materialId);
config.MaterialId = materialId;
bool status = true;
if (config.SheetType.IsCustom())
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(IFCEntityType.IfcElementAssembly))
{
return(false);
}
else
{
status = ExportCustomFabricSheet(config);
}
}
else
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(IFCEntityType.IfcReinforcingMesh))
{
return(false);
}
else
{
status = ExportStandardFabricSheet(config);
}
}
if (!status)
{
tr.RollBack();
return(false);
}
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a MEP family instance.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="exportType">The export type of the element.
/// <param name="ifcEnumType">The sub-type of the element.</param></param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if an entity was created, false otherwise.</returns>
public static bool Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
IFCExportInfoPair exportType, string ifcEnumType, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// CQ_TODO: Clean up this code by at least factoring it out.
// If we are exporting a duct segment, we may need to split it into parts by level. Create a list of ranges.
IList <ElementId> levels = new List <ElementId>();
IList <IFCRange> ranges = new List <IFCRange>();
// We will not split duct segments if the assemblyId is set, as we would like to keep the original duct segment
// associated with the assembly, on the level of the assembly.
if ((exportType.ExportType == IFCEntityType.IfcDuctSegmentType) &&
(ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting) &&
(element.AssemblyInstanceId == ElementId.InvalidElementId))
{
LevelUtil.CreateSplitLevelRangesForElement(exporterIFC, exportType, element, out levels,
out ranges);
}
int numPartsToExport = ranges.Count;
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (0 == numPartsToExport)
{
// 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 localPlacementToUse = setter.LocalPlacement;
BodyData bodyData = null;
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
extraParams.SetLocalPlacement(localPlacementToUse);
IFCAnyHandle productRepresentation =
RepresentationUtil.CreateAppropriateProductDefinitionShape(
exporterIFC, element, catId, geometryElement, bodyExporterOptions, null, extraParams, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return(false);
}
ExportAsMappedItem(exporterIFC, element, file, exportType, ifcEnumType, extraParams,
setter, localPlacementToUse, productRepresentation,
productWrapper);
}
}
}
else
{
for (int ii = 0; ii < numPartsToExport; ii++)
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, levels[ii], overrideContainerHnd))
{
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
SolidMeshGeometryInfo solidMeshCapsule =
GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, ranges[ii]);
IList <Solid> solids = solidMeshCapsule.GetSolids();
IList <Mesh> polyMeshes = solidMeshCapsule.GetMeshes();
IList <GeometryObject> geomObjects =
FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(element.Document,
exporterIFC, ref solids, ref polyMeshes);
if (geomObjects.Count == 0 && (solids.Count > 0 || polyMeshes.Count > 0))
{
return(false);
}
bool tryToExportAsExtrusion = (!exporterIFC.ExportAs2x2 ||
(exportType.ExportInstance == IFCEntityType.IfcColumn));
if (exportType.ExportInstance == IFCEntityType.IfcColumn)
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
}
else
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryXYZ;
}
BodyData bodyData = null;
if (geomObjects.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId,
ElementId.InvalidElementId, geomObjects,
bodyExporterOptions, extraParams);
}
else
{
IList <GeometryObject> exportedGeometries = new List <GeometryObject>();
exportedGeometries.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId,
ElementId.InvalidElementId,
exportedGeometries, bodyExporterOptions,
extraParams);
}
List <IFCAnyHandle> bodyReps = new List <IFCAnyHandle>();
bodyReps.Add(bodyData.RepresentationHnd);
IFCAnyHandle productRepresentation =
IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null,
null, bodyReps);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return(false);
}
ExportAsMappedItem(exporterIFC, element, file, exportType, ifcEnumType,
extraParams, setter, localPlacementToUse,
productRepresentation, productWrapper);
}
}
}
}
}
tr.Commit();
}
return(true);
}
/// <summary>
/// Exports an element to IfcPile.
/// </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 ExportPile(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, ProductWrapper productWrapper)
{
// NOTE: We expect to incorporate this code into the generic FamilyInstanceExporter at some point.
// 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))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
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, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
StructuralMemberAxisInfo axisInfo = StructuralMemberExporter.GetStructuralMemberAxisTransform(element);
if (axisInfo != null)
{
ecData.CustomAxis = axisInfo.AxisDirection;
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
}
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(Common.Enums.IFCEntityType.IfcPile, ifcEnumType);
IFCAnyHandle pile = IFCInstanceExporter.CreatePile(exporterIFC, element, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
ecData.GetLocalPlacement(), prodRep, ifcEnumType, null);
// TODO: to allow shared geometry for Piles. For now, Pile export will not use shared geometry
if (exportInfo.ExportType != Common.Enums.IFCEntityType.UnKnown)
{
IFCAnyHandle type = ExporterUtil.CreateGenericTypeFromElement(element, exportInfo, file, ExporterCacheManager.OwnerHistoryHandle, exportInfo.ValidatedPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(type, pile);
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, pile, productWrapper, setter, setter.LocalPlacement, null);
}
else
{
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, pile, matId);
}
}
productWrapper.AddElement(element, pile, setter, ecData, true, exportInfo);
OpeningUtil.CreateOpeningsIfNecessary(pile, 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>
/// <param name="placementSetter"></param>
/// <param name="originalPlacement"></param>
/// <param name="range"></param>
/// <param name="ifcExtrusionAxes"></param>
/// <param name="hostElement">The host of the part. This can be null.</param>
/// <param name="overrideLevelId">The id of the level that the part is one, overridding other sources.</param>
/// <param name="asBuildingElement">If true, export the Part as a building element instead of an IfcElementPart.</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;
}
// We don't know how to export a part as a building element if we don't know it's host.
if (asBuildingElement && (hostElement == 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 = Common.Enums.IFCEntityType.IfcBuildingElementPart;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
else
{
string ifcEnumType = null;
IFCExportInfoPair 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 partExportLevelId = (overrideLevelId != null) ? overrideLevelId : null;
if (partExportLevelId == null && standaloneExport)
{
partExportLevelId = partElement.LevelId;
}
if (partExportLevelId == null)
{
if (hostElement == null || (part.OriginalCategoryId != hostElement.Category.Id))
{
return;
}
partExportLevelId = hostElement.LevelId;
}
if (ExporterCacheManager.PartExportedCache.HasExported(partElement.Id, partExportLevelId))
{
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)
{
Transform orientationTrf = Transform.Identity;
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, partElement, out overrideContainerHnd);
if (overrideContainerId != ElementId.InvalidElementId && (partExportLevelId == null || partExportLevelId == ElementId.InvalidElementId))
{
partExportLevelId = overrideContainerId;
}
standalonePlacementSetter = PlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevelId, overrideContainerHnd);
partPlacement = standalonePlacementSetter.LocalPlacement;
}
else
{
//partPlacement = ExporterUtil.CreateLocalPlacement(file, null, null);
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 = new List <Solid>();;
IList <Mesh> meshes = new List <Mesh>();
IList <GeometryObject> gObjs = FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(partElement.Document, exporterIFC, solidMeshInfo.GetSolids(), solidMeshInfo.GetMeshes());
foreach (GeometryObject gObj in gObjs)
{
if (gObj is Solid)
{
solids.Add(gObj as Solid);
}
else if (gObj is Mesh)
{
meshes.Add(gObj as Mesh);
}
}
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 ifcEnumType = null;
IFCExportInfoPair exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep);
}
else
{
switch (exportType.ExportInstance)
{
case IFCEntityType.IfcColumn:
ifcPart = IFCInstanceExporter.CreateColumn(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
break;
case IFCEntityType.IfcCovering:
ifcPart = IFCInstanceExporter.CreateCovering(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
break;
case IFCEntityType.IfcFooting:
ifcPart = IFCInstanceExporter.CreateFooting(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
break;
case IFCEntityType.IfcPile:
ifcPart = IFCInstanceExporter.CreatePile(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType, null);
break;
case IFCEntityType.IfcRoof:
ifcPart = IFCInstanceExporter.CreateRoof(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
break;
case IFCEntityType.IfcSlab:
{
// TODO: fix this elsewhere.
if (ExporterUtil.IsNotDefined(ifcEnumType))
{
if (hostCatId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOOR";
}
else if (hostCatId == new ElementId(BuiltInCategory.OST_Roofs))
{
ifcEnumType = "ROOF";
}
}
ifcPart = IFCInstanceExporter.CreateSlab(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
}
break;
case IFCEntityType.IfcWall:
ifcPart = IFCInstanceExporter.CreateWall(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, ifcEnumType);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(exporterIFC, partElement, partGUID, ownerHistory,
extrusionCreationData.GetLocalPlacement(), prodRep, exportType.ValidatedPredefinedType);
break;
}
}
bool containedInLevel = standaloneExport;
PlacementSetter whichPlacementSetter = containedInLevel ? standalonePlacementSetter : placementSetter;
productWrapper.AddElement(partElement, ifcPart, whichPlacementSetter, extrusionCreationData, containedInLevel, exportType);
OpeningUtil.CreateOpeningsIfNecessary(ifcPart, partElement, extrusionCreationData, bodyData.OffsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), whichPlacementSetter, productWrapper);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevelId, standaloneExport ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
/// <summary>
/// Exports a beam to IFC beam if it has an axis representation and only one Solid as its geometry, ideally as an extrusion, potentially with clippings and openings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <param name="dontExport">An output value that says that the element shouldn't be exported at all.</param>
/// <returns>The created handle.</returns>
/// <remarks>In the original implementation, the ExportBeam function would export each beam as its own individual geometry (that is, not use representation maps).
/// For non-standard beams, this could result in massive IFC files. Now, we use the ExportBeamAsStandardElement function and limit its scope, and instead
/// resort to the standard FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem for more complicated objects categorized as beams. This has the following pros and cons:
/// Pro: possiblity for massively reduced file sizes for files containing repeated complex beam families
/// Con: some beams that may have had an "Axis" representation before will no longer have them, although this possibility is minimized.
/// Con: some beams that have 1 Solid and an axis, but that Solid will be heavily faceted, won't be helped by this improvement.
/// It is intended that we phase out this routine entirely and instead teach ExportFamilyInstanceAsMappedItem how to sometimes export the Axis representation for beams.</remarks>
public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
Element element, IFCExportInfoPair exportType, GeometryElement geometryElement, ProductWrapper productWrapper, out bool dontExport)
{
dontExport = true;
IList <GeometryObject> geomObjects = BeamGeometryToExport(exporterIFC, element, geometryElement, out dontExport);
if (dontExport)
{
return(null);
}
IFCAnyHandle beam = null;
IFCFile file = exporterIFC.GetFile();
MaterialAndProfile materialAndProfile = null;
IFCAnyHandle materialProfileSet = null;
using (IFCTransaction transaction = new IFCTransaction(file))
{
BeamAxisInfo axisInfo = GetBeamAxisTransform(element);
bool canExportAxis = (axisInfo != null);
Curve curve = canExportAxis ? axisInfo.Axis : null;
XYZ beamDirection = canExportAxis ? axisInfo.AxisDirection : null;
Transform orientTrf = canExportAxis ? axisInfo.LCSAsTransform : null;
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, orientTrf, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(localPlacement);
if (canExportAxis && (orientTrf.BasisX != null))
{
extrusionCreationData.CustomAxis = beamDirection;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
}
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
// There may be an offset to make the local coordinate system
// be near the origin. This offset will be used to move the axis to the new LCS.
Transform offsetTransform = null;
// The list of materials in the solids or meshes.
ICollection <ElementId> materialIds = null;
// If the beam is a FamilyInstance, and it uses transformed FamilySymbol geometry only, then
// let's only try to CreateBeamGeometryAsExtrusion unsuccesfully once. Otherwise, we can spend a lot of time trying
// unsuccessfully to do so.
bool tryToCreateBeamGeometryAsExtrusion = true;
//bool useFamilySymbolGeometry = (element is FamilyInstance) ? !ExporterIFCUtils.UsesInstanceGeometry(element as FamilyInstance) : false;
bool useFamilySymbolGeometry = (element is FamilyInstance) ? !GeometryUtil.UsesInstanceGeometry(element as FamilyInstance) : false;
ElementId beamTypeId = element.GetTypeId();
if (useFamilySymbolGeometry)
{
tryToCreateBeamGeometryAsExtrusion = !ExporterCacheManager.CanExportBeamGeometryAsExtrusionCache.ContainsKey(beamTypeId) ||
ExporterCacheManager.CanExportBeamGeometryAsExtrusionCache[beamTypeId];
}
// The representation handle generated from one of the methods below.
BeamBodyAsExtrusionInfo extrusionInfo = null;
if (tryToCreateBeamGeometryAsExtrusion)
{
extrusionInfo = CreateBeamGeometryAsExtrusion(exporterIFC, element, catId, geomObjects, axisInfo);
if (useFamilySymbolGeometry)
{
ExporterCacheManager.CanExportBeamGeometryAsExtrusionCache[beamTypeId] = (extrusionInfo != null);
}
}
if (extrusionInfo != null && extrusionInfo.DontExport)
{
dontExport = true;
return(null);
}
IFCAnyHandle repHnd = (extrusionInfo != null) ? extrusionInfo.RepresentationHandle : null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
materialIds = extrusionInfo.Materials;
extrusionCreationData.Slope = extrusionInfo.Slope;
}
else
{
// Here is where we limit the scope of how complex a case we will still try to export as a standard element.
// This is explicitly added so that many curved beams that can be represented by a reasonable facetation because of the
// SweptSolidExporter can still have an Axis representation.
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
bodyExporterOptions.CollectMaterialAndProfile = false;
}
else
{
bodyExporterOptions.CollectMaterialAndProfile = true;
}
if (geomObjects != null && geomObjects.Count == 1 && geomObjects[0] is Solid)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
geomObjects[0], bodyExporterOptions, extrusionCreationData);
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
if (!bodyData.OffsetTransform.IsIdentity)
{
offsetTransform = bodyData.OffsetTransform;
}
materialAndProfile = bodyData.MaterialAndProfile;
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
IFCAnyHandle axisRep = CreateBeamAxis(exporterIFC, element, catId, axisInfo, offsetTransform);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(axisRep))
{
representations.Add(axisRep);
}
representations.Add(repHnd);
Transform boundingBoxTrf = (offsetTransform == null) ? Transform.Identity : offsetTransform.Inverse;
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
string instanceGUID = GUIDUtil.CreateGUID(element);
beam = IFCInstanceExporter.CreateBeam(exporterIFC, element, instanceGUID, ExporterCacheManager.OwnerHistoryHandle, extrusionCreationData.GetLocalPlacement(), prodRep, exportType.ValidatedPredefinedType);
IFCAnyHandle mpSetUsage;
if (materialProfileSet != null)
{
mpSetUsage = IFCInstanceExporter.CreateMaterialProfileSetUsage(file, materialProfileSet, null, null);
}
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true, exportType);
ExportBeamType(exporterIFC, productWrapper, beam, element, exportType.ValidatedPredefinedType);
OpeningUtil.CreateOpeningsIfNecessary(beam, element, extrusionCreationData, offsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
typeInfo.ScaledDepth = extrusionCreationData.ScaledLength;
typeInfo.ScaledArea = extrusionCreationData.ScaledArea;
typeInfo.ScaledInnerPerimeter = extrusionCreationData.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extrusionCreationData.ScaledOuterPerimeter;
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, beam, element, typeInfo, null);
if (materialIds.Count != 0)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, beam, materialIds);
}
// Register the beam's IFC handle for later use by truss and beam system export.
ExporterCacheManager.ElementToHandleCache.Register(element.Id, beam, exportType);
}
}
transaction.Commit();
return(beam);
}
}
/// <summary>
/// Exports a gutter element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcPipeSegmentType;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle bodyRep = BodyExporter.ExportBody(exporterIFC, element, categoryId, ElementId.InvalidElementId,
geometryElement, bodyExporterOptions, ecData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
string originalTag = NamingUtil.CreateIFCElementId(element);
// In Revit, we don't have a corresponding type, so we create one for every gutter.
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRep);
List <IFCAnyHandle> repMapList = new List <IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
string elementTypeName = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string typeGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCHostedSweepSubElements.PipeSegmentType);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, null, null, repMapList, IFCPipeSegmentType.Gutter);
IFCAnyHandleUtil.OverrideNameAttribute(style, elementTypeName);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcPipeSegmentType, IFCPipeSegmentType.Gutter.ToString());
IFCAnyHandleUtil.SetAttribute(style, "Tag", originalTag);
ExporterUtil.SetGlobalId(style, typeGuid);
IFCAnyHandleUtil.SetAttribute(style, "ElementType", elementTypeName);
List <IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
ISet <IFCAnyHandle> representations = new HashSet <IFCAnyHandle>();
representations.Add(mappedItem);
IFCAnyHandle bodyMappedItemRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyMappedItemRep))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyMappedItemRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
shapeReps.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
if (roomId == ElementId.InvalidElementId)
{
localPlacementToUse = ecData.GetLocalPlacement();
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(exporterIFC, element, guid,
ExporterCacheManager.OwnerHistoryHandle, localPlacementToUse, prodRep);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.LevelInfo, ecData, !containedInSpace, exportInfo);
if (containedInSpace)
{
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, elemHnd);
}
// Associate segment with type.
ExporterCacheManager.TypeRelationsCache.Add(style, elemHnd);
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a roof or floor as a container of multiple roof slabs. Returns the handle, if successful.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="element">The roof or floor element.</param>
/// <param name="geometry">The geometry of the element.</param>
/// <param name="productWrapper">The product wrapper.</param>
/// <returns>The roof handle.</returns>
/// <remarks>For floors, if there is only one component, return null, as we do not want to create a container.</remarks>
public static IFCAnyHandle ExportRoofOrFloorAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Element element, GeometryElement geometry, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
// We support ExtrusionRoofs, FootPrintRoofs, and Floors only.
bool elementIsRoof = (element is ExtrusionRoof) || (element is FootPrintRoof);
bool elementIsFloor = (element is Floor);
if (!elementIsRoof && !elementIsFloor)
{
return(null);
}
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcRoof;
if (elementIsFloor)
{
elementClassTypeEnum = Common.Enums.IFCEntityType.IfcSlab;
}
IFCExportInfoPair roofExportType = new IFCExportInfoPair(elementClassTypeEnum, ifcEnumType);
// Check the intended IFC entity or type name is in the exclude list specified in the UI
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
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 localPlacement = setter.LocalPlacement;
IList <HostObjectSubcomponentInfo> hostObjectSubcomponents = null;
try
{
hostObjectSubcomponents = ExporterIFCUtils.ComputeSubcomponents(element as HostObject);
}
catch
{
return(null);
}
if (hostObjectSubcomponents == null)
{
return(null);
}
int numSubcomponents = hostObjectSubcomponents.Count;
if (numSubcomponents == 0 || (elementIsFloor && numSubcomponents == 1))
{
return(null);
}
IFCAnyHandle hostObjectHandle = null;
try
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
extrusionCreationData.SetLocalPlacement(localPlacement);
extrusionCreationData.ReuseLocalPlacement = true;
using (TransformSetter trfSetter = TransformSetter.Create())
{
IList <GeometryObject> geometryList = new List <GeometryObject>();
geometryList.Add(geometry);
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, extrusionCreationData);
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
//string hostObjectType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType);
if (elementIsRoof)
{
hostObjectHandle = IFCInstanceExporter.CreateRoof(exporterIFC, element, elementGUID, ownerHistory,
localPlacement, prodRepHnd, ifcEnumType);
}
else
{
hostObjectHandle = IFCInstanceExporter.CreateSlab(exporterIFC, element, elementGUID, ownerHistory,
localPlacement, prodRepHnd, ifcEnumType);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjectHandle))
{
return(null);
}
IList <IFCAnyHandle> elementHandles = new List <IFCAnyHandle>();
elementHandles.Add(hostObjectHandle);
// If element is floor, then the profile curve loop of hostObjectSubComponent is computed from the top face of the floor
// else if element is roof, then the profile curve loop is taken from the bottom face of the roof instead
XYZ extrusionDir = elementIsFloor ? new XYZ(0, 0, -1) : new XYZ(0, 0, 1);
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IList <IFCAnyHandle> slabHandles = new List <IFCAnyHandle>();
IList <CurveLoop> hostObjectOpeningLoops = new List <CurveLoop>();
double maximumScaledDepth = 0.0;
using (IFCExtrusionCreationData slabExtrusionCreationData = new IFCExtrusionCreationData())
{
slabExtrusionCreationData.SetLocalPlacement(extrusionCreationData.GetLocalPlacement());
slabExtrusionCreationData.ReuseLocalPlacement = false;
slabExtrusionCreationData.ForceOffset = true;
int loopNum = 0;
int subElementStart = elementIsRoof ? (int)IFCRoofSubElements.RoofSlabStart : (int)IFCSlabSubElements.SubSlabStart;
string subSlabType = elementIsRoof ? "ROOF" : ifcEnumType;
foreach (HostObjectSubcomponentInfo hostObjectSubcomponent in hostObjectSubcomponents)
{
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, slabExtrusionCreationData);
Plane plane = hostObjectSubcomponent.GetPlane();
Transform lcs = GeometryUtil.CreateTransformFromPlane(plane);
IList <CurveLoop> curveLoops = new List <CurveLoop>();
CurveLoop slabCurveLoop = hostObjectSubcomponent.GetCurveLoop();
curveLoops.Add(slabCurveLoop);
double slope = Math.Abs(plane.Normal.Z);
double scaledDepth = UnitUtil.ScaleLength(hostObjectSubcomponent.Depth);
double scaledExtrusionDepth = scaledDepth * slope;
IFCAnyHandle shapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, lcs, extrusionDir, scaledExtrusionDepth, false);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
{
productWrapper.ClearInternalHandleWrapperData(element);
return(null);
}
ElementId matId = HostObjectExporter.GetFirstLayerMaterialId(element as HostObject);
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, element.Document, shapeRep, matId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(shapeRep);
shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, catId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle repHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
// Allow support for up to 256 named IfcSlab components, as defined in IFCSubElementEnums.cs.
string slabGUID = (loopNum < 256) ? GUIDUtil.CreateSubElementGUID(element, subElementStart + loopNum) : GUIDUtil.CreateGUID();
IFCAnyHandle slabPlacement = ExporterUtil.CreateLocalPlacement(file, slabExtrusionCreationData.GetLocalPlacement(), null);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, element, slabGUID, ownerHistory,
slabPlacement, repHnd, subSlabType);
IFCExportInfoPair exportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, subSlabType);
//slab quantities
slabExtrusionCreationData.ScaledLength = scaledExtrusionDepth;
slabExtrusionCreationData.ScaledArea = UnitUtil.ScaleArea(UnitUtil.ScaleArea(hostObjectSubcomponent.AreaOfCurveLoop));
slabExtrusionCreationData.ScaledOuterPerimeter = UnitUtil.ScaleLength(curveLoops[0].GetExactLength());
slabExtrusionCreationData.Slope = UnitUtil.ScaleAngle(MathUtil.SafeAcos(Math.Abs(slope)));
ExporterUtil.RelateObject(exporterIFC, hostObjectHandle, slabHnd);
IFCExportInfoPair slabRoofExportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, slabRoofPredefinedType);
productWrapper.AddElement(null, slabHnd, setter, slabExtrusionCreationData, false, slabRoofExportType);
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
// Create type
IFCAnyHandle slabRoofTypeHnd = ExporterUtil.CreateGenericTypeFromElement(element, slabRoofExportType, exporterIFC.GetFile(), ownerHistory, slabRoofPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(slabRoofTypeHnd, slabHnd);
elementHandles.Add(slabHnd);
slabHandles.Add(slabHnd);
hostObjectOpeningLoops.Add(slabCurveLoop);
maximumScaledDepth = Math.Max(maximumScaledDepth, scaledDepth);
loopNum++;
}
}
productWrapper.AddElement(element, hostObjectHandle, setter, extrusionCreationData, true, roofExportType);
ExporterUtil.RelateObjects(exporterIFC, null, hostObjectHandle, slabHandles);
OpeningUtil.AddOpeningsToElement(exporterIFC, elementHandles, hostObjectOpeningLoops, element, null, maximumScaledDepth,
null, setter, localPlacement, productWrapper);
transaction.Commit();
return(hostObjectHandle);
}
}
}
catch
{
// SOmething wrong with the above process, unable to create the extrusion data. Reset any internal handles that may have been partially created since they are not committed
productWrapper.ClearInternalHandleWrapperData(element);
return(null);
}
finally
{
exporterIFC.ClearFaceWithElementHandleMap();
}
}
}
}
/// <summary>
/// Exports an element as an IFC assembly.
/// </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 ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle assemblyInstanceHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = null;
PlacementSetter placementSetter = null;
IFCLevelInfo levelInfo = null;
bool relateToLevel = true;
string ifcEnumType;
IFCExportInfoPair exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs.ExportInstance == IFCEntityType.IfcSystem)
{
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element));
assemblyInstanceHnd = IFCInstanceExporter.CreateSystem(file, guid, ownerHistory, name, description, objectType);
// Create classification reference when System has classification filed name assigned to it
ClassificationUtil.CreateClassification(exporterIFC, file, element, assemblyInstanceHnd);
HashSet <IFCAnyHandle> relatedBuildings = new HashSet <IFCAnyHandle>();
relatedBuildings.Add(ExporterCacheManager.BuildingHandle);
IFCAnyHandle relServicesBuildings = IFCInstanceExporter.CreateRelServicesBuildings(file, GUIDUtil.CreateGUID(),
ExporterCacheManager.OwnerHistoryHandle, null, null, assemblyInstanceHnd, relatedBuildings);
relateToLevel = false; // Already related to the building via IfcRelServicesBuildings.
}
else
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (placementSetter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle representation = null;
// We have limited support for exporting assemblies as other container types.
localPlacement = placementSetter.LocalPlacement;
levelInfo = placementSetter.LevelInfo;
switch (exportAs.ExportInstance)
{
case IFCEntityType.IfcCurtainWall:
//case IFCExportType.IfcCurtainWallType:
//string cwPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcCurtainWallType");
assemblyInstanceHnd = IFCInstanceExporter.CreateCurtainWall(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, ifcEnumType);
break;
case IFCEntityType.IfcRamp:
string rampPredefinedType = RampExporter.GetIFCRampType(ifcEnumType);
//rampPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, rampPredefinedType, "IfcRampType");
assemblyInstanceHnd = IFCInstanceExporter.CreateRamp(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, rampPredefinedType);
break;
case IFCEntityType.IfcRoof:
//string roofPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcRoofType");
assemblyInstanceHnd = IFCInstanceExporter.CreateRoof(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, ifcEnumType);
break;
case IFCEntityType.IfcStair:
string stairPredefinedType = StairsExporter.GetIFCStairType(ifcEnumType);
//stairPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, stairPredefinedType, "IfcStairType");
assemblyInstanceHnd = IFCInstanceExporter.CreateStair(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, stairPredefinedType);
break;
case IFCEntityType.IfcWall:
//string wallPredefinedType = IFCValidateEntry.GetValidIFCPredefinedType(element, ifcEnumType, "IfcWallType");
assemblyInstanceHnd = IFCInstanceExporter.CreateWall(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, ifcEnumType);
break;
default:
string objectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.GetFamilyAndTypeName(element));
IFCElementAssemblyType assemblyPredefinedType = GetPredefinedTypeFromObjectType(objectType);
assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(exporterIFC, element, guid,
ownerHistory, localPlacement, representation, IFCAssemblyPlace.NotDefined, assemblyPredefinedType);
break;
}
}
}
if (assemblyInstanceHnd == null)
{
return(false);
}
// relateToLevel depends on how the AssemblyInstance is being mapped to IFC, above.
productWrapper.AddElement(element, assemblyInstanceHnd, levelInfo, null, relateToLevel, exportAs);
ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, roof, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, roof, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// If the roof is an in-place family, we will allow any arbitrary orientation. While this may result in some
// in-place "cubes" exporting with the wrong direction, it is unlikely that an in-place family would be
// used for this reason in the first place.
ecData.PossibleExtrusionAxes = (roof is FamilyInstance) ? IFCExtrusionAxes.TryXYZ : IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData;
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = GUIDUtil.CreateGUID(roof);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
//string predefinedType = GetIFCRoofType(ifcEnumType);
string predefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(ifcEnumType, "NOTDEFINED", IFCEntityType.IfcRoofType.ToString());
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(exporterIFC, roof, guid, ownerHistory,
localPlacement, exportSlab ? null : representation, predefinedType);
// Export IfcRoofType
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcRoof, IFCEntityType.IfcRoofType, predefinedType);
if (exportInfo.ExportType != IFCEntityType.UnKnown)
{
string overridePDefType;
if (ParameterUtil.GetStringValueFromElementOrSymbol(roof, "IfcExportType", out overridePDefType) == null) // change IFCType to consistent parameter of IfcExportType
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(roof, "IfcType", out overridePDefType) == null) // support IFCType for legacy support
{
if (string.IsNullOrEmpty(predefinedType))
{
predefinedType = "NOTDEFINED";
}
}
}
if (!string.IsNullOrEmpty(overridePDefType))
{
exportInfo.ValidatedPredefinedType = overridePDefType;
}
else
{
exportInfo.ValidatedPredefinedType = predefinedType;
}
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(roof, exportInfo, file, ownerHistory, predefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, roofHnd);
}
productWrapper.AddElement(roof, roofHnd, placementSetter.LevelInfo, ecData, true, exportInfo);
// will export its host object materials later if it is a roof
if (!(roof is RoofBase))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, bodyData.MaterialIds);
}
if (exportSlab)
{
string slabGUID = GUIDUtil.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = IFCAnyHandleUtil.GetStringAttribute(roofHnd, "Name") + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, roof, slabGUID, ownerHistory,
slabLocalPlacementHnd, representation, slabRoofPredefinedType);
IFCAnyHandleUtil.OverrideNameAttribute(slabHnd, slabName);
Transform offsetTransform = (bodyData != null) ? bodyData.OffsetTransform : Transform.Identity;
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, offsetTransform,
exporterIFC, slabLocalPlacementHnd, placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
IFCExportInfoPair slabRoofExportType = new IFCExportInfoPair(IFCEntityType.IfcSlab, slabRoofPredefinedType);
productWrapper.AddElement(null, slabHnd, placementSetter.LevelInfo, ecData, false, slabRoofExportType);
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, bodyData.MaterialIds);
// Create type
IFCAnyHandle slabRoofTypeHnd = ExporterUtil.CreateGenericTypeFromElement(roof, slabRoofExportType, exporterIFC.GetFile(), ownerHistory, slabRoofPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(slabRoofTypeHnd, slabHnd);
}
}
tr.Commit();
}
}
}
/// <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;
IFCExportInfoPair exportType = ExporterUtil.GetExportType(exporterIFC, floorElement, out ifcEnumType);
IFCAnyHandle type = null;
MaterialLayerSetInfo layersetInfo = null;
if (!ElementFilteringUtil.IsElementVisible(floorElement))
{
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>(exportType.ExportInstance.ToString(), out elementClassTypeEnum) ||
Enum.TryParse <Common.Enums.IFCEntityType>(exportType.ExportType.ToString(), out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
Document doc = floorElement.Document;
using (SubTransaction tempPartTransaction = new SubTransaction(doc))
{
// For IFC4RV export, Floor will be split into its parts(temporarily) in order to export the floor by its parts
bool exportByComponents = ExporterUtil.ShouldExportByComponents(floorElement, exportParts);
using (IFCTransaction tr = new IFCTransaction(file))
{
bool canExportAsContainerOrWithExtrusionAnalyzer = (!exportParts && (floorElement is Floor));
if (canExportAsContainerOrWithExtrusionAnalyzer)
{
// Try to export the Floor slab as a container. If that succeeds, we are done.
// If we do export the floor as a container, it will take care of the local placement and transform there, so we need to leave
// this out of the IFCTransformSetter and PlacementSetter scopes below, or else we'll get double transforms.
IFCAnyHandle floorHnd = RoofExporter.ExportRoofOrFloorAsContainer(exporterIFC, floorElement, geometryElement, productWrapper);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(floorHnd))
{
tr.Commit();
return;
}
}
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, floorElement, out overrideContainerHnd);
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, floorElement, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
// 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;
// Next, 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();
IList <GeometryObject> gObjs = FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(floorElement.Document, exporterIFC, ref solids, ref meshes);
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 through the Revit model origin. 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 extrusionAnalyzerFloorBasePlane = GeometryUtil.CreatePlaneByNormalAtOrigin(floorDir);
GenerateAdditionalInfo additionalInfo = GenerateAdditionalInfo.GenerateBody;
additionalInfo |= ExporterCacheManager.ExportOptionsCache.ExportAs4 ?
GenerateAdditionalInfo.GenerateFootprint : GenerateAdditionalInfo.None;
// Skip generate body item for IFC4RV. It will be handled later in PartExporter.ExportHostPartAsShapeAspects()
if (exportByComponents)
{
additionalInfo &= ~GenerateAdditionalInfo.GenerateBody;
}
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floorElement,
catId, solids[0], extrusionAnalyzerFloorBasePlane, floorOrigin, floorExtrusionDirection, null, out completelyClipped,
addInfo: additionalInfo);
if (completelyClipped)
{
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
if (floorAndProperties.Handle != null)
{
representations.Add(floorAndProperties.Handle);
repTypes.Add(ShapeRepresentationType.SweptSolid);
}
// Footprint representation will only be exported in export to IFC4
if (((additionalInfo & GenerateAdditionalInfo.GenerateFootprint) != 0) && (floorAndProperties.FootprintInfo != null))
{
IFCAnyHandle footprintShapeRep = floorAndProperties.FootprintInfo.CreateFootprintShapeRepresentation(exporterIFC);
representations.Add(footprintShapeRep);
}
if (exportByComponents)
{
IFCAnyHandle prodRep = RepresentationUtil.CreateProductDefinitionShapeWithoutBodyRep(exporterIFC, floorElement, catId, geometryElement, representations);
prodReps.Add(prodRep);
}
else if (representations.Count > 0 && floorAndProperties.Handle != null) // Only when at least the body rep exists will come here
{
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
prodReps.Add(prodRep);
}
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
// Use internal routine as backup that handles openings.
if (prodReps.Count == 0 && canExportAsInternalExtrusion && !exportByComponents)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out prodReps,
out extrusionLoops, out loopExtraParams, floorPlane);
PotentiallyFixPresentationLayerAssignment(floorElement, prodReps);
for (int ii = 0; ii < prodReps.Count; ii++)
{
// all are extrusions
repTypes.Add(ShapeRepresentationType.SweptSolid);
// Footprint representation will only be exported in export to IFC4
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
if (extrusionLoops.Count > ii)
{
if (extrusionLoops[ii].Count > 0)
{
// Get the extrusion footprint using the first Curveloop. Transform needs to be obtained from the returned local placement
Transform lcs = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, localPlacements[ii]);
IFCAnyHandle footprintGeomRepItem = GeometryUtil.CreateIFCCurveFromCurveLoop(exporterIFC, extrusionLoops[ii][0], lcs, floorPlane.Normal);
IFCAnyHandle contextOfItemsFootprint = exporterIFC.Get3DContextHandle("FootPrint");
ISet <IFCAnyHandle> repItem = new HashSet <IFCAnyHandle>();
repItem.Add(footprintGeomRepItem);
IFCAnyHandle footprintShapeRepresentation = RepresentationUtil.CreateBaseShapeRepresentation(exporterIFC, contextOfItemsFootprint, "FootPrint", "Curve2D", repItem);
IList <IFCAnyHandle> reps = new List <IFCAnyHandle>();
reps.Add(footprintShapeRepresentation);
IFCAnyHandleUtil.AddRepresentations(prodReps[ii], reps);
}
}
}
}
}
IFCAnyHandle prodDefHnd;
if (prodReps.Count == 0)
{
if (exportByComponents)
{
prodDefHnd = RepresentationUtil.CreateProductDefinitionShapeWithoutBodyRep(exporterIFC, floorElement, catId, geometryElement, null);
prodReps.Add(prodDefHnd);
}
else
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// Brep representation using tesellation after ExportSlabAsExtrusion does not return prodReps
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
BodyData bodyData;
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;
// Deal with a couple of cases that have non-standard defaults.
switch (exportType.ExportInstance)
{
case IFCEntityType.IfcCovering:
exportType.ValidatedPredefinedType = IFCValidateEntry.GetValidIFCType <IFCCoveringType>(floorElement, ifcEnumType, "FLOORING");
break;
case IFCEntityType.IfcSlab:
bool isBaseSlab = false;
AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
if (analyticalModel != null)
{
AnalyzeAs slabFoundationType = analyticalModel.GetAnalyzeAs();
isBaseSlab = (slabFoundationType == AnalyzeAs.SlabOnGrade) || (slabFoundationType == AnalyzeAs.Mat);
}
exportType.ValidatedPredefinedType = 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 currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = null;
slabHnd = IFCInstanceExporter.CreateGenericIFCEntity(exportType, exporterIFC, floorElement, currentGUID, ownerHistory,
localPlacementHnd, exportParts ? null : prodReps[ii]);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (!string.IsNullOrEmpty(ifcName))
{
IFCAnyHandleUtil.OverrideNameAttribute(slabHnd, ifcName);
}
// Pre IFC4 Slab does not have PredefinedType
if (!string.IsNullOrEmpty(exportType.ValidatedPredefinedType) && !ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
{
IFCAnyHandleUtil.SetAttribute(slabHnd, "PredefinedType", exportType.ValidatedPredefinedType, true);
}
if (exportParts && !ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
else if (exportByComponents)
{
IFCExtrusionCreationData partECData = new IFCExtrusionCreationData();
IFCAnyHandle hostShapeRepFromParts = PartExporter.ExportHostPartAsShapeAspects(exporterIFC, floorElement, prodReps[ii],
productWrapper, placementSetter, localPlacement, ElementId.InvalidElementId, out layersetInfo, partECData);
loopExtraParams.Add(partECData);
}
slabHnds.Add(slabHnd);
// For IFC4RV, export of the geometry is already handled in PartExporter.ExportHostPartAsShapeAspects()
if (!exportParts && !exportByComponents)
{
if (repTypes[ii] == ShapeRepresentationType.Brep || repTypes[ii] == ShapeRepresentationType.Tessellation)
{
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, exportType);
type = ExporterUtil.CreateGenericTypeFromElement(floorElement, exportType, file, ownerHistory, exportType.ValidatedPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(type, slabHnds[ii]);
ExporterUtil.AddIntoComplexPropertyCache(slabHnds[ii], layersetInfo);
}
// 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)
{
ISet <IFCAnyHandle> oldCreatedObjects = productWrapper.GetAllObjects();
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
ISet <IFCAnyHandle> newCreatedObjects = productWrapper.GetAllObjects();
newCreatedObjects.ExceptWith(oldCreatedObjects);
PotentiallyFixPresentationLayerAssignment(floorElement, newCreatedObjects);
}
}
if (!exportParts)
{
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, productWrapper.GetAnElement(),
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false, type);
}
else
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false, type);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true, type);
}
}
}
}
tr.Commit();
return;
}
}
}
/// <summary>
/// Exports an element as IFC covering.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCovering(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, ProductWrapper productWrapper)
{
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
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.IfcCovering;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
MaterialLayerSetInfo layersetInfo = null;
using (IFCTransaction transaction = new IFCTransaction(file))
{
// For IFC4RV export, Ceiling will be split into its parts(temporarily) in order to export the ceiling by its parts
bool exportByComponents = ExporterUtil.ShouldExportByComponents(element, exportParts);
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (exportByComponents)
{
prodRep = RepresentationUtil.CreateProductDefinitionShapeWithoutBodyRep(exporterIFC, element, categoryId, geomElem, representations);
}
else
{
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geomElem, bodyExporterOptions, null, ecData, true);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
// We will use the category of the element to set a default value for the covering.
string defaultCoveringEnumType = null;
if (categoryId == new ElementId(BuiltInCategory.OST_Ceilings))
{
defaultCoveringEnumType = "CEILING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Floors))
{
defaultCoveringEnumType = "FLOORING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Roofs))
{
defaultCoveringEnumType = "ROOFING";
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string coveringType = IFCValidateEntry.GetValidIFCPredefinedTypeType(/*element,*/ ifcEnumType, defaultCoveringEnumType, "IfcCoveringType");
IFCAnyHandle covering = IFCInstanceExporter.CreateCovering(exporterIFC, element, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
setter.LocalPlacement, prodRep, coveringType);
if (exportParts && !ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.LocalPlacement, null);
}
else if (exportByComponents)
{
IFCAnyHandle hostShapeRepFromParts = PartExporter.ExportHostPartAsShapeAspects(exporterIFC, element, prodRep,
productWrapper, setter, setter.LocalPlacement, ElementId.InvalidElementId, out layersetInfo, ecData);
}
ExporterUtil.AddIntoComplexPropertyCache(covering, layersetInfo);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcCovering, IFCEntityType.IfcCoveringType, coveringType);
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(element, exportInfo, file, ExporterCacheManager.OwnerHistoryHandle, coveringType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, covering);
bool containInSpace = false;
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
// Ceiling containment in Space is generally required and not specific to any view
if (ExporterCacheManager.CeilingSpaceRelCache.ContainsKey(element.Id))
{
IList <ElementId> roomlist = ExporterCacheManager.CeilingSpaceRelCache[element.Id];
// Process Ceiling to be contained in a Space only when it is exactly bounding one Space
if (roomlist.Count == 1)
{
productWrapper.AddElement(element, covering, setter, ecData, false, exportInfo);
// Modify the Ceiling placement to be relative to the Space that it bounds
IFCAnyHandle roomPlacement = IFCAnyHandleUtil.GetObjectPlacement(ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(roomlist[0]));
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(roomPlacement, localPlacementToUse);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandleUtil.SetAttribute(localPlacementToUse, "PlacementRelTo", roomPlacement);
GeometryUtil.SetRelativePlacement(localPlacementToUse, relLocalPlacement);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomlist[0], covering);
containInSpace = true;
}
}
// if not contained in Space, assign it to default containment in Level
if (!containInSpace)
{
productWrapper.AddElement(element, covering, setter, ecData, true, exportInfo);
}
if (!exportParts)
{
Ceiling ceiling = element as Ceiling;
if (ceiling != null)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, null, null);
}
else
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geomElem, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, covering, matId);
}
}
OpeningUtil.CreateOpeningsIfNecessary(covering, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
transaction.Commit();
}
}
/// <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 an element as an annotation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="filledRegion">The filled region element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, FilledRegion filledRegion,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (filledRegion == null || geometryElement == 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.IfcAnnotation;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IList <CurveLoop> boundaries = filledRegion.GetBoundaries();
if (boundaries.Count == 0)
{
return;
}
Plane plane = null;
try
{
plane = boundaries[0].GetPlane();
}
catch
{
return;
}
Transform orientTrf = GeometryUtil.CreateTransformFromPlane(plane);
XYZ projectionDirection = plane.Normal;
IList <IList <CurveLoop> > sortedLoops = ExporterIFCUtils.SortCurveLoops(boundaries);
if (sortedLoops.Count == 0)
{
return;
}
FilledRegionType filledRegionType = filledRegion.Document.GetElement(filledRegion.GetTypeId()) as FilledRegionType;
Color color = filledRegionType != null?CategoryUtil.GetSafeColor(filledRegionType.ForegroundPatternColor) : new Color(0, 0, 0);
ElementId foregroundPatternId = filledRegionType != null ? filledRegionType.ForegroundPatternId : ElementId.InvalidElementId;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(filledRegion);
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, filledRegion, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, filledRegion, null, orientTrf, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
int loopCount = sortedLoops.Count;
for (int loopIndex = 0; loopIndex < loopCount; loopIndex++)
{
IList <CurveLoop> curveLoopList = sortedLoops[loopIndex];
IFCAnyHandle outerCurve = null;
HashSet <IFCAnyHandle> innerCurves = null;
for (int ii = 0; ii < curveLoopList.Count; ii++)
{
IFCAnyHandle ifcCurve = GeometryUtil.CreateIFCCurveFromCurveLoop(exporterIFC, curveLoopList[ii], orientTrf, projectionDirection);
if (ii == 0)
{
outerCurve = ifcCurve;
}
else
{
if (innerCurves == null)
{
innerCurves = new HashSet <IFCAnyHandle>();
}
innerCurves.Add(ifcCurve);
}
}
IFCAnyHandle representItem = IFCInstanceExporter.CreateAnnotationFillArea(file,
outerCurve, innerCurves);
file.CreateStyle(exporterIFC, representItem, color, foregroundPatternId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>()
{
representItem
};
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, filledRegion, categoryId,
exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>()
{
bodyRepHnd
};
string index = (loopIndex + 1).ToString();
string annotationGuid = GUIDUtil.GenerateIFCGuidFrom(filledRegion, index);
IFCAnyHandle productShape = IFCInstanceExporter.CreateProductDefinitionShape(file,
null, null, shapeReps);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(exporterIFC,
filledRegion, annotationGuid, ownerHistory, setter.LocalPlacement,
productShape);
productWrapper.AddAnnotation(annotation, setter.LevelInfo, true);
}
}
transaction.Commit();
}
}