/// <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;
}
bool exportParts = PartExporter.CanExportParts(slabElement);
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, slabElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool exportedAsInternalExtrusion = false;
ElementId catId = CategoryUtil.GetSafeCategoryId(slabElement);
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>();
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporter.GetTessellationLevel();
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
slabElement, 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(slabElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(slabElement, ifcEnumType, "FLOOR");
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(slabElement, NamingUtil.GetIFCNamePlusIndex(slabElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(slabElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(slabElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(slabElement, NamingUtil.CreateIFCElementId(slabElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, slabElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(slabElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, slabElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
}
if (!exportParts)
{
if (slabElement is HostObject)
{
HostObject hostObject = slabElement as HostObject;
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
else if (slabElement is FamilyInstance && slabHnds.Count > 0)
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
Document doc = slabElement.Document;
foreach (IFCAnyHandle slabHnd in slabHnds)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
}
}
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Adds openings to an element.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="elementHandles">The parent handles.</param>
/// <param name="curveLoops">The parent CurveLoops.</param>
/// <param name="element">The element.</param>
/// <param name="lcs">The local coordinate system.</param>
/// <param name="scaledWidth">The width.</param>
/// <param name="range">The range.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="localWrapper">The wrapper.</param>
public static void AddOpeningsToElement(ExporterIFC exporterIFC, IList <IFCAnyHandle> elementHandles,
IList <CurveLoop> curveLoops, Element element, Transform lcs, double scaledWidth,
IFCRange range, PlacementSetter setter, IFCAnyHandle localPlacement, ProductWrapper localWrapper)
{
IList <IFCOpeningData> openingDataList = ExporterIFCUtils.GetOpeningData(exporterIFC, element, lcs, range);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
foreach (IFCOpeningData openingData in openingDataList)
{
Element openingElem = element.Document.GetElement(openingData.OpeningElementId);
if (openingElem == null)
{
openingElem = element;
}
// Don't export the opening if WallSweep category has been turned off.
// This is currently restricted to WallSweeps because the element responsible for the opening could be a variety of things,
// including a line as part of the elevation profile of the wall.
// As such, we will restrict which element types we check for CanExportElement.
if ((openingElem is WallSweep) && (!ElementFilteringUtil.CanExportElement(exporterIFC, openingElem, true)))
{
continue;
}
IList <IFCExtrusionData> extrusionDataList = openingData.GetExtrusionData();
IFCAnyHandle parentHandle = null;
if (elementHandles.Count > 1 && extrusionDataList.Count > 0)
{
parentHandle = FindParentHandle(elementHandles, curveLoops, extrusionDataList[0].GetLoops()[0]);
}
if (parentHandle == null)
{
parentHandle = elementHandles[0];
}
bool isDoorOrWindowOpening = IsDoorOrWindowOpening(exporterIFC, openingElem, element);
if (isDoorOrWindowOpening)
{
DoorWindowDelayedOpeningCreator delayedCreator =
DoorWindowDelayedOpeningCreator.Create(exporterIFC, openingData, scaledWidth, element.Id, parentHandle, setter.LevelId);
if (delayedCreator != null)
{
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
continue;
}
}
// If the opening is "filled" by another element (either a door or window as determined above,
// or an embedded wall, then we can't use the element GUID for the opening.
bool canUseElementGUID = !isDoorOrWindowOpening && !(openingElem is Wall);
IList <Solid> solids = openingData.GetOpeningSolids();
foreach (Solid solid in solids)
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
extrusionCreationData.ReuseLocalPlacement = true;
string openingGUID = CreateOpeningGUID(openingElem, canUseElementGUID);
canUseElementGUID = false; // Either it was used above, and therefore is now false, or it was already false.
CreateOpening(exporterIFC, parentHandle, element, openingElem, openingGUID, solid, scaledWidth, openingData.IsRecess, extrusionCreationData,
setter, localWrapper);
}
}
foreach (IFCExtrusionData extrusionData in extrusionDataList)
{
if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
{
extrusionData.ScaledExtrusionLength = scaledWidth;
}
string openingGUID = CreateOpeningGUID(openingElem, canUseElementGUID);
canUseElementGUID = false; // Either it was used above, and therefore is now false, or it was already false.
CreateOpening(exporterIFC, parentHandle, localPlacement, element, openingElem, openingGUID, extrusionData, lcs, openingData.IsRecess,
setter, localWrapper);
}
}
}
/// <summary>
/// Creates an opening from extrusion data.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host handle.</param>
/// <param name="hostPlacement">The host placement.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The opening element.</param>
/// <param name="openingGUID">The opening GUID.</param>
/// <param name="extrusionData">The extrusion data.</param>
/// <param name="lcs">The local coordinate system of the base of the extrusion.</param>
/// <param name="isRecess">True if it is a recess.</param>
/// <returns>The opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, IFCAnyHandle hostPlacement, Element hostElement,
Element insertElement, string openingGUID, IFCExtrusionData extrusionData, Transform lcs, bool isRecess,
PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
IList <CurveLoop> curveLoops = extrusionData.GetLoops();
if (curveLoops.Count == 0)
{
return(null);
}
if (lcs == null)
{
// assumption: first curve loop defines the plane.
if (!curveLoops[0].HasPlane())
{
return(null);
}
lcs = GeometryUtil.CreateTransformFromPlane(curveLoops[0].GetPlane());
}
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
IFCAnyHandle openingProdRepHnd = RepresentationUtil.CreateExtrudedProductDefShape(exporterIFC, insertElement, catId,
curveLoops, lcs, extrusionData.ExtrusionDirection, extrusionData.ScaledExtrusionLength);
string openingObjectType = isRecess ? "Recess" : "Opening";
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(exporterIFC, null, openingGUID, ownerHistory,
ExporterUtil.CreateLocalPlacement(file, hostPlacement, null), openingProdRepHnd, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingHnd, openingName);
IFCAnyHandleUtil.SetAttribute(openingHnd, "ObjectType", openingObjectType);
IFCExtrusionCreationData ecData = null;
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
double height, width;
ecData = new IFCExtrusionCreationData();
if (GeometryUtil.ComputeHeightWidthOfCurveLoop(curveLoops[0], lcs, out height, out width))
{
ecData.ScaledHeight = UnitUtil.ScaleLength(height);
ecData.ScaledWidth = UnitUtil.ScaleLength(width);
}
else
{
double area = ExporterIFCUtils.ComputeAreaOfCurveLoops(curveLoops);
ecData.ScaledArea = UnitUtil.ScaleArea(area);
}
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, ecData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(elementForProperties, openingHnd, setter, ecData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
/// <summary>
/// Adds openings to an element.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="elementHandles">The parent handles.</param>
/// <param name="curveLoops">The parent CurveLoops.</param>
/// <param name="element">The element.</param>
/// <param name="lcs">The local coordinate system.</param>
/// <param name="scaledWidth">The width.</param>
/// <param name="range">The range.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="localWrapper">The wrapper.</param>
public static void AddOpeningsToElement(ExporterIFC exporterIFC,
IList <IFCAnyHandle> elementHandles, IList <CurveLoop> curveLoops, Element element,
Transform lcs, double scaledWidth, IFCRange range, PlacementSetter setter,
IFCAnyHandle localPlacement, ProductWrapper localWrapper)
{
if (lcs == null && ((curveLoops?.Count ?? 0) > 0))
{
// assumption: first curve loop defines the plane.
Plane hostObjPlane = curveLoops[0].HasPlane() ? curveLoops[0].GetPlane(): null;
if (hostObjPlane != null)
{
lcs = GeometryUtil.CreateTransformFromPlane(hostObjPlane);
}
}
IList <IFCOpeningData> openingDataList = ExporterIFCUtils.GetOpeningData(exporterIFC,
element, lcs, range);
IFCFile file = exporterIFC.GetFile();
int openingIndex = 0;
foreach (IFCOpeningData openingData in openingDataList)
{
openingIndex++;
Element openingElem = element.Document.GetElement(openingData.OpeningElementId);
if (openingElem == null)
{
openingElem = element;
}
bool currentWallIsHost = false;
FamilyInstance openingFInst = openingElem as FamilyInstance;
if (openingFInst != null && openingFInst.Host != null)
{
if (openingFInst.Host.Id == element.Id)
{
currentWallIsHost = true;
}
}
// Don't export the opening if WallSweep category has been turned off.
// This is currently restricted to WallSweeps because the element responsible for the opening could be a variety of things,
// including a line as part of the elevation profile of the wall.
// As such, we will restrict which element types we check for CanExportElement.
if ((openingElem is WallSweep) &&
(!ElementFilteringUtil.CanExportElement(exporterIFC, openingElem, true)))
{
continue;
}
IList <IFCExtrusionData> extrusionDataList = openingData.GetExtrusionData();
IFCAnyHandle parentHandle = FindParentHandle(elementHandles, curveLoops, extrusionDataList);
string predefinedType;
IFCExportInfoPair exportType = ExporterUtil.GetProductExportType(exporterIFC,
openingElem, out predefinedType);
bool exportingDoorOrWindow = (exportType.ExportInstance == IFCEntityType.IfcDoor ||
exportType.ExportType == IFCEntityType.IfcDoorType ||
exportType.ExportInstance == IFCEntityType.IfcWindow ||
exportType.ExportType == IFCEntityType.IfcWindowType);
bool isDoorOrWindowOpening = IsDoorOrWindowOpening(openingElem, element,
exportingDoorOrWindow);
if (isDoorOrWindowOpening && currentWallIsHost)
{
DoorWindowDelayedOpeningCreator delayedCreator =
DoorWindowDelayedOpeningCreator.Create(exporterIFC, openingData, scaledWidth,
element.Id, parentHandle, setter.LevelId);
if (delayedCreator != null)
{
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
continue;
}
}
IList <Solid> solids = openingData.GetOpeningSolids();
int solidIndex = 0;
foreach (Solid solid in solids)
{
solidIndex++;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
extrusionCreationData.ReuseLocalPlacement = true;
string openingGUID = CreateOpeningGUID(openingElem, range, openingIndex, solidIndex);
CreateOpening(exporterIFC, parentHandle, element, openingElem, openingGUID, solid, scaledWidth, openingData.IsRecess, extrusionCreationData,
setter, localWrapper);
}
}
foreach (IFCExtrusionData extrusionData in extrusionDataList)
{
solidIndex++;
if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
{
extrusionData.ScaledExtrusionLength = scaledWidth;
}
string openingGUID = CreateOpeningGUID(openingElem, range, openingIndex, solidIndex);
CreateOpening(exporterIFC, parentHandle, localPlacement, element, openingElem,
openingGUID, extrusionData, lcs, openingData.IsRecess, setter, localWrapper);
}
}
}
/// <summary>
/// Export the individual part (IfcBuildingElementPart).
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="partElement">The part element to export.</param>
/// <param name="geometryElement">The geometry of part.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
public static void ExportPart(ExporterIFC exporterIFC, Element partElement, ProductWrapper productWrapper,
PlacementSetter placementSetter, IFCAnyHandle originalPlacement, IFCRange range, IFCExtrusionAxes ifcExtrusionAxes,
Element hostElement, ElementId overrideLevelId, bool asBuildingElement)
{
if (!ElementFilteringUtil.IsElementVisible(partElement))
{
return;
}
Part part = partElement as Part;
if (part == null)
{
return;
}
PlacementSetter standalonePlacementSetter = null;
bool standaloneExport = hostElement == null && !asBuildingElement;
ElementId partExportLevel = null;
if (standaloneExport || asBuildingElement)
{
partExportLevel = partElement.LevelId;
}
else
{
if (part.OriginalCategoryId != hostElement.Category.Id)
{
return;
}
partExportLevel = hostElement.LevelId;
}
if (overrideLevelId != null)
{
partExportLevel = overrideLevelId;
}
if (ExporterCacheManager.PartExportedCache.HasExported(partElement.Id, partExportLevel))
{
return;
}
Options options = GeometryUtil.GetIFCExportGeometryOptions();
View ownerView = partElement.Document.GetElement(partElement.OwnerViewId) as View;
if (ownerView != null)
{
options.View = ownerView;
}
GeometryElement geometryElement = partElement.get_Geometry(options);
if (geometryElement == null)
{
return;
}
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IFCAnyHandle partPlacement = null;
if (standaloneExport || asBuildingElement)
{
Transform orientationTrf = Transform.Identity;
standalonePlacementSetter = PlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevel);
partPlacement = standalonePlacementSetter.LocalPlacement;
}
else
{
partPlacement = ExporterUtil.CreateLocalPlacement(file, originalPlacement, null);
}
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
SolidMeshGeometryInfo solidMeshInfo;
if (validRange)
{
solidMeshInfo = GeometryUtil.GetSplitClippedSolidMeshGeometry(geometryElement, range);
if (solidMeshInfo.GetSolids().Count == 0 && solidMeshInfo.GetMeshes().Count == 0)
{
return;
}
}
else
{
solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
}
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(partPlacement);
extrusionCreationData.ReuseLocalPlacement = false;
extrusionCreationData.PossibleExtrusionAxes = ifcExtrusionAxes;
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(partElement);
ElementId hostCatId = CategoryUtil.GetSafeCategoryId(hostElement);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, solids, meshes,
bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string partGUID = GUIDUtil.CreateGUID(partElement);
string partName = NamingUtil.GetNameOverride(partElement, NamingUtil.GetIFCName(partElement));
string partDescription = NamingUtil.GetDescriptionOverride(partElement, null);
string partObjectType = NamingUtil.GetObjectTypeOverride(partElement, NamingUtil.CreateIFCObjectName(exporterIFC, partElement));
string partTag = NamingUtil.GetTagOverride(partElement, NamingUtil.CreateIFCElementId(partElement));
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag);
}
else
{
string ifcEnumType = null;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
string defaultValue = null;
// This replicates old functionality before IFC4 addition, where the default for slab was "FLOOR".
// Really the export layer table should be fixed for this case.
if (string.IsNullOrWhiteSpace(ifcEnumType) && hostCatId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOOR";
}
ifcEnumType = IFCValidateEntry.GetValidIFCType(hostElement, ifcEnumType, defaultValue);
switch (exportType)
{
case IFCExportType.IfcColumnType:
ifcPart = IFCInstanceExporter.CreateColumn(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcCovering:
ifcPart = IFCInstanceExporter.CreateCovering(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcFooting:
ifcPart = IFCInstanceExporter.CreateFooting(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcPile:
ifcPart = IFCInstanceExporter.CreatePile(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType, null);
break;
case IFCExportType.IfcRoof:
ifcPart = IFCInstanceExporter.CreateRoof(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcSlab:
ifcPart = IFCInstanceExporter.CreateSlab(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcWall:
ifcPart = IFCInstanceExporter.CreateWall(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag, null);
break;
}
}
bool containedInLevel = (standaloneExport || asBuildingElement);
PlacementSetter whichPlacementSetter = containedInLevel ? standalonePlacementSetter : placementSetter;
productWrapper.AddElement(partElement, ifcPart, whichPlacementSetter, extrusionCreationData, containedInLevel);
OpeningUtil.CreateOpeningsIfNecessary(ifcPart, partElement, extrusionCreationData, bodyData.OffsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), whichPlacementSetter, productWrapper);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevel, standaloneExport || asBuildingElement ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
/// <summary>
/// Exports the top stories of a multistory ramp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="rampHnd">The stairs container handle.</param>
/// <param name="components">The components handles.</param>
/// <param name="ecData">The extrusion creation data.</param>
/// <param name="componentECData">The extrusion creation data for the components.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportMultistoryRamp(ExporterIFC exporterIFC, Element ramp, int numFlights,
IFCAnyHandle rampHnd, IList <IFCAnyHandle> components, IList <IFCExtrusionCreationData> componentECData,
PlacementSetter placementSetter, ProductWrapper productWrapper)
{
if (numFlights < 2)
{
return;
}
double heightNonScaled = GetRampHeight(exporterIFC, ramp);
if (heightNonScaled < MathUtil.Eps())
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rampHnd))
{
return;
}
IFCAnyHandle localPlacement = IFCAnyHandleUtil.GetObjectPlacement(rampHnd);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(localPlacement))
{
return;
}
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
IList <IFCAnyHandle> rampLocalPlacementHnds = new List <IFCAnyHandle>();
IList <IFCLevelInfo> levelInfos = new List <IFCLevelInfo>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle newLevelHnd = null;
// We are going to avoid internal scaling routines, and instead scale in .NET.
double newOffsetUnscaled = 0.0;
IFCLevelInfo currLevelInfo =
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * (ii + 1), 1.0, ramp.Document, out newLevelHnd, out newOffsetUnscaled);
double newOffsetScaled = UnitUtil.ScaleLength(newOffsetUnscaled);
if (currLevelInfo != null)
{
levelInfos.Add(currLevelInfo);
}
else
{
levelInfos.Add(placementSetter.LevelInfo);
}
XYZ orig;
if (ptHnd.HasValue)
{
orig = new XYZ(origCoords[0], origCoords[1], newOffsetScaled);
}
else
{
orig = new XYZ(0.0, 0.0, newOffsetScaled);
}
rampLocalPlacementHnds.Add(ExporterUtil.CreateLocalPlacement(file, newLevelHnd, orig, null, null));
}
IList <List <IFCAnyHandle> > newComponents = new List <List <IFCAnyHandle> >();
for (int ii = 0; ii < numFlights - 1; ii++)
{
newComponents.Add(new List <IFCAnyHandle>());
}
int compIdx = 0;
ElementId catId = CategoryUtil.GetSafeCategoryId(ramp);
foreach (IFCAnyHandle component in components)
{
string componentName = IFCAnyHandleUtil.GetStringAttribute(component, "Name");
IFCAnyHandle componentProdRep = IFCAnyHandleUtil.GetInstanceAttribute(component, "Representation");
IList <string> localComponentNames = new List <string>();
IList <IFCAnyHandle> componentPlacementHnds = new List <IFCAnyHandle>();
IFCAnyHandle localLocalPlacement = IFCAnyHandleUtil.GetObjectPlacement(component);
IFCAnyHandle localRelativePlacement =
(localLocalPlacement == null) ? null : IFCAnyHandleUtil.GetInstanceAttribute(localLocalPlacement, "RelativePlacement");
bool isSubRamp = component.IsSubTypeOf(IFCEntityType.IfcRamp.ToString());
for (int ii = 0; ii < numFlights - 1; ii++)
{
localComponentNames.Add((componentName == null) ? (ii + 2).ToString() : (componentName + ":" + (ii + 2)));
if (isSubRamp)
{
componentPlacementHnds.Add(ExporterUtil.CopyLocalPlacement(file, rampLocalPlacementHnds[ii]));
}
else
{
componentPlacementHnds.Add(IFCInstanceExporter.CreateLocalPlacement(file, rampLocalPlacementHnds[ii], localRelativePlacement));
}
}
IList <IFCAnyHandle> localComponentHnds = new List <IFCAnyHandle>();
if (isSubRamp)
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, ExporterCacheManager.ExportOptionsCache.ExportAs4 ? "PredefinedType" : "ShapeType");
string localRampType = GetIFCRampType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
IFCAnyHandle localComponent = IFCInstanceExporter.CreateRamp(exporterIFC, ramp, GUIDUtil.CreateGUID(), ownerHistory,
componentPlacementHnds[ii], representationCopy, localRampType);
localComponentHnds.Add(localComponent);
IFCAnyHandleUtil.OverrideNameAttribute(localComponent, localComponentNames[ii]);
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcRampFlight))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
IFCAnyHandle localComponent = IFCInstanceExporter.CreateRampFlight(exporterIFC, ramp, GUIDUtil.CreateGUID(), ownerHistory,
componentPlacementHnds[ii], representationCopy, "NOTDEFINED");
IFCAnyHandleUtil.OverrideNameAttribute(localComponent, localComponentNames[ii]);
localComponentHnds.Add(localComponent);
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcSlab))
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "PredefinedType");
IFCSlabType localLandingType = FloorExporter.GetIFCSlabType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
IFCAnyHandle localComponent = IFCInstanceExporter.CreateSlab(exporterIFC, ramp, GUIDUtil.CreateGUID(), ownerHistory,
componentPlacementHnds[ii], representationCopy, localLandingType.ToString());
localComponentHnds.Add(localComponent);
IFCAnyHandleUtil.OverrideNameAttribute(localComponent, localComponentNames[ii]);
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcMember))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
IFCAnyHandle localComponent = IFCInstanceExporter.CreateMember(exporterIFC, ramp, GUIDUtil.CreateGUID(), ownerHistory,
componentPlacementHnds[ii], representationCopy, "STRINGER");
localComponentHnds.Add(localComponent);
IFCAnyHandleUtil.OverrideNameAttribute(localComponent, localComponentNames[ii]);
}
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
if (localComponentHnds[ii] != null)
{
newComponents[ii].Add(localComponentHnds[ii]);
productWrapper.AddElement(null, localComponentHnds[ii], levelInfos[ii], componentECData[compIdx], false);
}
}
compIdx++;
}
// finally add a copy of the container.
IList <IFCAnyHandle> rampCopyHnds = new List <IFCAnyHandle>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
string rampTypeAsString = null;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
rampTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(rampHnd, "PredefinedType");
}
else
{
rampTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(rampHnd, "ShapeType");
}
string rampType = GetIFCRampType(rampTypeAsString);
string containerRampName = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Name") + ":" + (ii + 2);
IFCAnyHandle rampCopyHnd = IFCInstanceExporter.CreateRamp(exporterIFC, ramp, GUIDUtil.CreateGUID(), ownerHistory,
rampLocalPlacementHnds[ii], null, rampType);
rampCopyHnds.Add(rampCopyHnd);
IFCAnyHandleUtil.OverrideNameAttribute(rampCopyHnd, containerRampName);
productWrapper.AddElement(ramp, rampCopyHnds[ii], levelInfos[ii], null, true);
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampCopyHnds[ii], newComponents[ii],
rampLocalPlacementHnds[ii]);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(ramp.Id, stairRampInfo);
}
}
/// <summary>
/// Exports a 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, ref GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
string ifcEnumType;
IFCExportInfoPair exportType = ExporterUtil.GetProductExportType(exporterIFC, floorElement, out ifcEnumType);
if (!ElementFilteringUtil.IsElementVisible(floorElement))
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
IFCEntityType elementClassTypeEnum;
if (Enum.TryParse(exportType.ExportInstance.ToString(), out elementClassTypeEnum) ||
Enum.TryParse(exportType.ExportType.ToString(), out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
Document doc = floorElement.Document;
using (SubTransaction tempPartTransaction = new SubTransaction(doc))
{
MaterialLayerSetInfo layersetInfo = new MaterialLayerSetInfo(exporterIFC, floorElement, productWrapper);
// For IFC4RV export, Element will be split into its parts(temporarily) in order to export the wall by its parts
// If Parts are created by code and not by user then their names should be equal to Material names.
bool setMaterialNameToPartName = ExporterUtil.CreateParts(floorElement, layersetInfo.MaterialIds.Count, ref geometryElement);
ExporterUtil.ExportPartAs exportPartAs = ExporterUtil.CanExportByComponentsOrParts(floorElement);
bool exportByComponents = exportPartAs == ExporterUtil.ExportPartAs.ShapeAspect;
bool exportParts = exportPartAs == ExporterUtil.ExportPartAs.Part;
if (exportParts && !PartExporter.CanExportElementInPartExport(floorElement, floorElement.LevelId, false))
{
return;
}
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;
IFCAnyHandle typeHandle = null;
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 && !ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView;
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();
IFCExtrusionCreationData ecData = new IFCExtrusionCreationData();
IList <IFCAnyHandle> localPlacements = new List <IFCAnyHandle>();
if (!exportParts)
{
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)
{
// 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;
}
ExtrusionExporter.ExtraClippingData extraClippingData = null;
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floorElement, false,
catId, solids[0], extrusionAnalyzerFloorBasePlane, floorOrigin, floorExtrusionDirection, null,
out extraClippingData,
addInfo: additionalInfo);
if (extraClippingData.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);
if (exportedAsInternalExtrusion)
{
AugmentHandleInformation(exporterIFC, floorElement, geometryElement, 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
{
// 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;
AnalyticalToPhysicalAssociationManager manager = AnalyticalToPhysicalAssociationManager.GetAnalyticalToPhysicalAssociationManager(doc);
if (manager != null)
{
ElementId counterPartId = manager.GetAssociatedElementId(floorElement.Id);
if (counterPartId != ElementId.InvalidElementId)
{
Element counterpartElem = doc.GetElement(counterPartId);
if (counterpartElem != null && counterpartElem is AnalyticalElement)
{
AnalyzeAs slabAnalyzeAs = (counterpartElem as AnalyticalElement).AnalyzeAs;
isBaseSlab = (slabAnalyzeAs == AnalyzeAs.SlabOnGrade) || (slabAnalyzeAs == 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.GenerateIFCGuidFrom(floorElement, "Slab Copy " + ii.ToString());
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)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null, setMaterialNameToPartName);
}
else if (exportByComponents)
{
IFCExtrusionCreationData partECData = new IFCExtrusionCreationData();
IFCAnyHandle hostShapeRepFromParts = PartExporter.ExportHostPartAsShapeAspects(exporterIFC, floorElement, prodReps[ii],
productWrapper, placementSetter, localPlacement, ElementId.InvalidElementId, 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);
}
}
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, floorElement, ecData, null,
exporterIFC, localPlacement, placementSetter, productWrapper);
}
typeHandle = ExporterUtil.CreateGenericTypeFromElement(floorElement, exportType, file, ownerHistory, exportType.ValidatedPredefinedType, productWrapper);
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(floorElement, slabHnds[ii], placementSetter, loopExtraParam, true, exportType);
ExporterCacheManager.TypeRelationsCache.Add(typeHandle, 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);
AugmentHandleInformation(exporterIFC, floorElement, geometryElement, newCreatedObjects);
}
}
if (!exportParts)
{
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, productWrapper.GetAnElement(),
geometryElement, productWrapper, ElementId.InvalidElementId, IFCLayerSetDirection.Axis3, false, typeHandle);
}
else
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, IFCLayerSetDirection.Axis3, false, typeHandle);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, IFCLayerSetDirection.Axis3, true, typeHandle);
}
}
}
}
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;
setter = PlacementSetter.Create(exporterIFC, element, null, orientationTrf);
localPlacement = setter.LocalPlacement;
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = GUIDUtil.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement, prodRepHnd, elemTag);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
elemHnd = IFCInstanceExporter.CreateRoof(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement,
prodRepHnd, elemTag, ifcEnumType);
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(element, elemHnd, setter, null, true);
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 curtain object as container.
/// </summary>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="wallElement">
/// The curtain wall element.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportCurtainObjectCommonAsContainer(ICollection <ElementId> allSubElements, Element wallElement,
ExporterIFC exporterIFC, ProductWrapper origWrapper, PlacementSetter currSetter)
{
if (wallElement == null)
{
return;
}
string overrideCADLayer = null;
ParameterUtil.GetStringValueFromElementOrSymbol(wallElement, "IFCCadLayer", out overrideCADLayer);
using (ExporterStateManager.CADLayerOverrideSetter layerSetter = new ExporterStateManager.CADLayerOverrideSetter(overrideCADLayer))
{
HashSet <ElementId> alreadyVisited = new HashSet <ElementId>(); // just in case.
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
{
foreach (ElementId subElemId in allSubElements)
{
using (ProductWrapper productWrapper = ProductWrapper.Create(origWrapper))
{
Element subElem = wallElement.Document.GetElement(subElemId);
if (subElem == null)
{
continue;
}
if (alreadyVisited.Contains(subElem.Id))
{
continue;
}
alreadyVisited.Add(subElem.Id);
// Respect element visibility settings.
if (!ElementFilteringUtil.CanExportElement(exporterIFC, subElem, false) || !ElementFilteringUtil.IsElementVisible(subElem))
{
continue;
}
GeometryElement geomElem = subElem.get_Geometry(geomOptions);
if (geomElem == null)
{
continue;
}
try
{
if (subElem is FamilyInstance)
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, subElem, out ifcEnumType);
if (subElem is Mullion)
{
if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
else
{
IFCAnyHandle currLocalPlacement = currSetter.LocalPlacement;
if (exportType == IFCExportType.IfcCurtainWallType)
{
// By default, panels and mullions are set to the same category as their parent. In this case,
// ask to get the exportType from the category id, since we don't want to inherit the parent class.
exportType = IFCExportType.IfcMemberType;
ifcEnumType = "MULLION";
}
FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem(exporterIFC, subElem as Mullion, exportType, ifcEnumType, productWrapper,
ElementId.InvalidElementId, null, currLocalPlacement);
}
}
else
{
FamilyInstance subFamInst = subElem as FamilyInstance;
if (exportType == IFCExportType.IfcCurtainWallType)
{
// By default, panels and mullions are set to the same category as their parent. In this case,
// ask to get the exportType from the category id, since we don't want to inherit the parent class.
ElementId catId = CategoryUtil.GetSafeCategoryId(subElem);
exportType = ElementFilteringUtil.GetExportTypeFromCategoryId(catId, out ifcEnumType);
}
if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
{
if ((exportType == IFCExportType.DontExport) || (exportType == IFCExportType.IfcPlateType) ||
(exportType == IFCExportType.IfcMemberType))
{
exportType = IFCExportType.IfcBuildingElementProxyType;
}
}
else
{
if (exportType == IFCExportType.DontExport)
{
ifcEnumType = "CURTAIN_PANEL";
exportType = IFCExportType.IfcPlateType;
}
}
IFCAnyHandle currLocalPlacement = currSetter.LocalPlacement;
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem(exporterIFC, subFamInst, exportType, ifcEnumType, productWrapper,
ElementId.InvalidElementId, null, currLocalPlacement);
}
}
}
else if (subElem is CurtainGridLine)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
else if (subElem is Wall)
{
WallExporter.ExportWall(exporterIFC, subElem, null, geomElem, productWrapper);
}
}
catch (Exception ex)
{
if (ExporterUtil.IsFatalException(wallElement.Document, ex))
{
throw ex;
}
continue;
}
}
}
}
}
}
/// <summary>
/// Exports mullion.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="mullion">
/// The mullion object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <param name="setter">
/// The PlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, PlacementSetter setter, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (PlacementSetter mullionSetter = PlacementSetter.Create(exporterIFC, mullion))
{
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
IFCAnyHandle mullionPlacement = mullionSetter.LocalPlacement;
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(localPlacement, mullionPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle mullionLocalPlacement = ExporterUtil.CreateLocalPlacement(file, localPlacement,
inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
extraParams.SetLocalPlacement(mullionLocalPlacement);
Transform extrusionLCS = null;
// Add a custom direction for trying to create an extrusion based on the base curve of the mullion, if it is a line and not an arc.
Curve baseCurve = mullion.LocationCurve;
if ((baseCurve != null) && (baseCurve is Line))
{
// We won't use curveBounds and origin yet; just need the axis for now.
IFCRange curveBounds;
XYZ origin, mullionDirection;
GeometryUtil.GetAxisAndRangeFromCurve(baseCurve, out curveBounds, out mullionDirection, out origin);
// approx 1.0/sqrt(2.0)
XYZ planeY = (Math.Abs(mullionDirection.Z) < 0.707) ? XYZ.BasisZ.CrossProduct(mullionDirection) : XYZ.BasisX.CrossProduct(mullionDirection);
planeY.Normalize();
XYZ projDir = mullionDirection.CrossProduct(planeY);
extrusionLCS = Transform.Identity;
extrusionLCS.BasisX = mullionDirection; extrusionLCS.BasisY = planeY; extrusionLCS.BasisZ = projDir; extrusionLCS.Origin = origin;
}
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyExporterOptions.ExtrusionLocalCoordinateSystem = extrusionLCS;
IFCAnyHandle repHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = GUIDUtil.CreateGUID(mullion);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string name = NamingUtil.GetNameOverride(mullion, elemObjectType);
string description = NamingUtil.GetDescriptionOverride(mullion, null);
string objectType = NamingUtil.GetObjectTypeOverride(mullion, elemObjectType);
string elemTag = NamingUtil.GetTagOverride(mullion, NamingUtil.CreateIFCElementId(mullion));
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, name, description, objectType,
mullionLocalPlacement, repHnd, elemTag, "MULLION");
ExporterCacheManager.HandleToElementCache.Register(mullionHnd, mullion.Id);
productWrapper.AddElement(mullion, mullionHnd, mullionSetter, extraParams, false);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, mullion);
CategoryUtil.CreateMaterialAssociation(exporterIFC, mullionHnd, matId);
}
}
}
/// <summary>
/// Exports curtain object as one Brep.
/// </summary>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="wallElement">
/// The curtain wall element.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="setter">
/// The PlacementSetter object.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <returns>
/// The handle.
/// </returns>
public static IFCAnyHandle ExportCurtainObjectCommonAsOneBRep(ICollection <ElementId> allSubElements, Element wallElement,
ExporterIFC exporterIFC, PlacementSetter setter, IFCAnyHandle localPlacement)
{
IFCAnyHandle prodDefRep = null;
Document document = wallElement.Document;
double eps = UnitUtil.ScaleLength(document.Application.VertexTolerance);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCGeometryInfo info = IFCGeometryInfo.CreateFaceGeometryInfo(eps);
ISet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
// Want to make sure we don't accidentally add a mullion or curtain line more than once.
HashSet <ElementId> alreadyVisited = new HashSet <ElementId>();
bool useFallbackBREP = true;
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
foreach (ElementId subElemId in allSubElements)
{
Element subElem = wallElement.Document.GetElement(subElemId);
GeometryElement geomElem = subElem.get_Geometry(geomOptions);
if (geomElem == null)
{
continue;
}
if (alreadyVisited.Contains(subElem.Id))
{
continue;
}
alreadyVisited.Add(subElem.Id);
// Export tessellated geometry when IFC4 Reference View is selected
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(false, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle triFaceSet = BodyExporter.ExportBodyAsTessellatedFaceSet(exporterIFC, subElem, bodyExporterOptions, geomElem);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(triFaceSet))
{
bodyItems.Add(triFaceSet);
useFallbackBREP = false; // no need to do Brep since it is successful
}
}
// Export AdvancedFace before use fallback BREP
else if (ExporterCacheManager.ExportOptionsCache.ExportAs4DesignTransferView)
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(false, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle advancedBRep = BodyExporter.ExportBodyAsAdvancedBrep(exporterIFC, subElem, bodyExporterOptions, geomElem);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(advancedBRep))
{
bodyItems.Add(advancedBRep);
useFallbackBREP = false; // no need to do Brep since it is successful
}
}
if (useFallbackBREP)
{
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, geomElem, XYZ.Zero, false);
HashSet <IFCAnyHandle> faces = new HashSet <IFCAnyHandle>(info.GetSurfaces());
IFCAnyHandle outer = IFCInstanceExporter.CreateClosedShell(file, faces);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(outer))
{
bodyItems.Add(RepresentationUtil.CreateFacetedBRep(exporterIFC, document, outer, ElementId.InvalidElementId));
}
}
}
if (bodyItems.Count == 0)
{
return(prodDefRep);
}
ElementId catId = CategoryUtil.GetSafeCategoryId(wallElement);
IFCAnyHandle shapeRep;
// Use tessellated geometry in Reference View
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView && !useFallbackBREP)
{
shapeRep = RepresentationUtil.CreateTessellatedRep(exporterIFC, wallElement, catId, contextOfItems, bodyItems, null);
}
else if (ExporterCacheManager.ExportOptionsCache.ExportAs4DesignTransferView && !useFallbackBREP)
{
shapeRep = RepresentationUtil.CreateAdvancedBRepRep(exporterIFC, wallElement, catId, contextOfItems, bodyItems, null);
}
else
{
shapeRep = RepresentationUtil.CreateBRepRep(exporterIFC, wallElement, catId, contextOfItems, bodyItems);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
{
return(prodDefRep);
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, wallElement.get_Geometry(geomOptions), Transform.Identity);
if (boundingBoxRep != null)
{
shapeReps.Add(boundingBoxRep);
}
prodDefRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
return(prodDefRep);
}
/// <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;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
IFCAnyHandle localPlacement = null;
PlacementSetter placementSetter = null;
IFCLevelInfo levelInfo = null;
bool relateToLevel = true;
string ifcEnumType;
IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs == IFCExportType.IfcSystem)
{
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
{
using (placementSetter = PlacementSetter.Create(exporterIFC, element))
{
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle representation = null;
// We have limited support for exporting assemblies as other container types.
localPlacement = placementSetter.LocalPlacement;
levelInfo = placementSetter.LevelInfo;
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
switch (exportAs)
{
case IFCExportType.IfcCurtainWall:
case IFCExportType.IfcCurtainWallType:
assemblyInstanceHnd = IFCInstanceExporter.CreateCurtainWall(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag);
break;
case IFCExportType.IfcRamp:
string rampPredefinedType = RampExporter.GetIFCRampType(ifcEnumType);
assemblyInstanceHnd = IFCInstanceExporter.CreateRamp(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
rampPredefinedType);
break;
case IFCExportType.IfcRoof:
assemblyInstanceHnd = IFCInstanceExporter.CreateRoof(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
ifcEnumType);
break;
case IFCExportType.IfcStair:
string stairPredefinedType = StairsExporter.GetIFCStairType(ifcEnumType);
assemblyInstanceHnd = IFCInstanceExporter.CreateStair(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
stairPredefinedType);
break;
case IFCExportType.IfcWall:
assemblyInstanceHnd = IFCInstanceExporter.CreateWall(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
ifcEnumType);
break;
default:
IFCElementAssemblyType assemblyPredefinedType = GetPredefinedTypeFromObjectType(objectType);
assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
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);
ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as an IFC assembly with its members.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="assemblyElem">The element to be exported as IFC assembly.</param>
/// <param name="memberIds">The member element ids.</param>
/// <param name="assemblyType">The IFC assembly type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
static void ExportAssemblyInstanceWithMembers(ExporterIFC exporterIFC, Element assemblyElem,
ICollection <ElementId> memberIds, IFCElementAssemblyType assemblyType, ProductWrapper productWrapper)
{
HashSet <IFCAnyHandle> memberHnds = new HashSet <IFCAnyHandle>();
foreach (ElementId memberId in memberIds)
{
IFCAnyHandle memberHnd = ExporterCacheManager.ElementToHandleCache.Find(memberId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(memberHnd))
{
memberHnds.Add(memberHnd);
}
}
if (memberHnds.Count == 0)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcElementAssembly", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, assemblyElem))
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
string guid = GUIDUtil.CreateGUID(assemblyElem);
string name = NamingUtil.GetIFCName(assemblyElem);
string description = NamingUtil.GetDescriptionOverride(assemblyElem, null);
string objectType = NamingUtil.GetObjectTypeOverride(assemblyElem, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(assemblyElem);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, description, objectType, localPlacement, null, elementTag,
IFCAssemblyPlace.NotDefined, assemblyType);
productWrapper.AddElement(assemblyElem, assemblyInstanceHnd, placementSetter.LevelInfo, null, true);
string aggregateGuid = GUIDUtil.CreateSubElementGUID(assemblyElem, (int)IFCAssemblyInstanceSubElements.RelAggregates);
IFCInstanceExporter.CreateRelAggregates(file, aggregateGuid, ownerHistory, null, null, assemblyInstanceHnd, memberHnds);
ExporterCacheManager.ElementsInAssembliesCache.UnionWith(memberHnds);
// Update member local placements to be relative to the assembly.
SetLocalPlacementsRelativeToAssembly(exporterIFC, localPlacement, memberHnds);
}
tr.Commit();
}
}
/// <summary>
/// Exports 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, ref 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.IfcCovering;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
MaterialLayerSetInfo layersetInfo = new MaterialLayerSetInfo(exporterIFC, element, productWrapper);
using (IFCTransaction transaction = new IFCTransaction(file))
{
// For IFC4RV export, Element will be split into its parts(temporarily) in order to export the wall by its parts
// If Parts are created by code and not by user then their name should be equal to Material name.
bool setMaterialNameToPartName = ExporterUtil.CreateParts(element, layersetInfo.MaterialIds.Count, ref geomElem);
ExporterUtil.ExportPartAs exportPartAs = ExporterUtil.CanExportByComponentsOrParts(element);
bool exportByComponents = exportPartAs == ExporterUtil.ExportPartAs.ShapeAspect;
bool exportParts = exportPartAs == ExporterUtil.ExportPartAs.Part;
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
// 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)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.LocalPlacement, null, setMaterialNameToPartName);
}
else if (exportByComponents)
{
IFCAnyHandle hostShapeRepFromParts = PartExporter.ExportHostPartAsShapeAspects(exporterIFC, element, prodRep,
productWrapper, setter, setter.LocalPlacement, ElementId.InvalidElementId, 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 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, solids, 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 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;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcAnnotation", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, curveElement))
{
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;
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);
}
IList <IFCAnyHandle> 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 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);
IFCExportInfoPair exportInfo = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
IFCAnyHandle railing = IFCInstanceExporter.CreateGenericIFCEntity(exportInfo, exporterIFC, element, instanceGUID, ownerHistory,
ecData.GetLocalPlacement(), prodRep);
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);
IFCAnyHandle singleMaterialOverrideHnd = null;
IList <ElementId> matIds = null;
ElementId defaultMatId = ElementId.InvalidElementId;
ElementId matId = CategoryUtil.GetBaseMaterialIdForElement(element);
// Get IfcSingleMaterialOverride to work for railing
singleMaterialOverrideHnd = ExporterUtil.GetSingleMaterial(exporterIFC, element, matId);
if (singleMaterialOverrideHnd != null)
{
matIds = new List <ElementId> {
matId
};
}
else
{
matIds = bodyData.MaterialIds;
defaultMatId = matIds[0];
// Check if all the items are the same, then get the first material id
if (matIds.All(x => x == defaultMatId))
{
matIds = new List <ElementId> {
defaultMatId
};
}
}
CategoryUtil.CreateMaterialAssociationWithShapeAspect(exporterIFC, element, railing, bodyData.RepresentationItemInfo);
// 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.CreateMaterialAssociationWithShapeAspect(exporterIFC, element, railingHndCopy, bodyData.RepresentationItemInfo);
}
}
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(hostId, stairRampInfo);
}
}
transaction.Commit();
}
}
}
/// <summary>
/// Creates a new IfcAnnotation object.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="curveElement">The curve element.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="sketchPlaneId">The sketch plane id.</param>
/// <param name="curveLCS">The curve local coordinate system.</param>
/// <param name="curveStyle">The curve style.</param>
/// <param name="placementSetter">The placemenet setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="repItemHnd">The representation item.</param>
/// <returns>The handle.</returns>
static IFCAnyHandle CreateCurveAnnotation(ExporterIFC exporterIFC, Element curveElement, ElementId categoryId, ElementId sketchPlaneId,
Transform curveLCS, IFCAnyHandle curveStyle, PlacementSetter placementSetter, IFCAnyHandle localPlacement, IFCAnyHandle repItemHnd)
{
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, curveElement, categoryId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
throw new Exception("Failed to create shape representation.");
}
List <IFCAnyHandle> shapes = new List <IFCAnyHandle>();
shapes.Add(bodyRepHnd);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapes);
XYZ xDir = curveLCS.BasisX; XYZ zDir = curveLCS.BasisZ; XYZ origin = curveLCS.Origin;
// subtract out level origin if we didn't already before.
IFCLevelInfo levelInfo = placementSetter.LevelInfo;
if (levelInfo != null && !MathUtil.IsAlmostEqual(zDir.Z, 1.0))
{
zDir -= new XYZ(0, 0, levelInfo.Elevation);
}
origin = UnitUtil.ScaleLength(origin);
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis(file, origin, zDir, xDir);
GeometryUtil.SetRelativePlacement(localPlacement, relativePlacement);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle,
null, null, null, localPlacement, prodShapeHnd);
return(annotation);
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, ProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcRamp;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ecData.ReuseLocalPlacement = false;
GeometryElement rampGeom = GeometryUtil.GetOneLevelGeometryElement(geometryElement, numFlights);
BodyData bodyData;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
ramp, categoryId, rampGeom, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = GUIDUtil.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CreateLocalPlacement(file, ecData.GetLocalPlacement(), null);
string rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IList <IFCExtrusionCreationData> componentExtrusionData = new List <IFCExtrusionCreationData>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(exporterIFC, ramp, containedRampGuid, ownerHistory,
containedRampLocalPlacement, representation, rampType);
components.Add(containedRampHnd);
componentExtrusionData.Add(ecData);
//productWrapper.AddElement(containedRampHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociation(exporterIFC, containedRampHnd, bodyData.MaterialIds);
string guid = GUIDUtil.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(exporterIFC, ramp, guid, ownerHistory,
localPlacement, null, rampType);
productWrapper.AddElement(ramp, rampHnd, placementSetter.LevelInfo, ecData, true);
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, localPlacement);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights, rampHnd, components, componentExtrusionData, placementSetter,
productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports text note elements.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="textNote">
/// The text note element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, TextNote textNote, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string textString = textNote.Text;
if (String.IsNullOrEmpty(textString))
{
throw new Exception("TextNote does not have test string.");
}
ElementId symId = textNote.GetTypeId();
if (symId == ElementId.InvalidElementId)
{
throw new Exception("TextNote does not have valid type id.");
}
PresentationStyleAssignmentCache cache = ExporterCacheManager.PresentationStyleAssignmentCache;
IFCAnyHandle presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
{
TextElementType textElemType = textNote.Symbol;
CreatePresentationStyleAssignmentForTextElementType(exporterIFC, textElemType, cache);
presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
{
throw new Exception("Failed to create presentation style assignment for TextElementType.");
}
}
HashSet <IFCAnyHandle> presHndSet = new HashSet <IFCAnyHandle>();
presHndSet.Add(presHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, textNote))
{
const double planScale = 100.0; // currently hardwired.
XYZ orig = UnitUtil.ScaleLength(textNote.Coord);
XYZ yDir = textNote.UpDirection;
XYZ xDir = textNote.BaseDirection;
XYZ zDir = xDir.CrossProduct(yDir);
double sizeX = UnitUtil.ScaleLength(textNote.Width * planScale);
double sizeY = UnitUtil.ScaleLength(textNote.Height * planScale);
// When we display text on screen, we "flip" it if the xDir is negative with relation to
// the X-axis. So if it is, we'll flip x and y.
bool flipOrig = false;
if (xDir.X < 0)
{
xDir = xDir.Multiply(-1.0);
yDir = yDir.Multiply(-1.0);
flipOrig = true;
}
// xFactor, yFactor only used if flipOrig.
double xFactor = 0.0, yFactor = 0.0;
string boxAlignment = ConvertTextNoteAlignToBoxAlign(textNote, out xFactor, out yFactor);
// modify the origin to match the alignment. In Revit, the origin is at the top-left (unless flipped,
// then bottom-right).
if (flipOrig)
{
orig = orig.Add(xDir.Multiply(sizeX * xFactor));
orig = orig.Add(yDir.Multiply(sizeY * yFactor));
}
IFCAnyHandle origin = ExporterUtil.CreateAxis(file, orig, zDir, xDir);
IFCAnyHandle extent = IFCInstanceExporter.CreatePlanarExtent(file, sizeX, sizeY);
IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateTextLiteralWithExtent(file, textString, origin, Toolkit.IFCTextPath.Left, extent, boxAlignment);
IFCAnyHandle annoTextOccHnd = IFCInstanceExporter.CreateStyledItem(file, repItemHnd, presHndSet, null);
ElementId catId = textNote.Category != null ? textNote.Category.Id : ElementId.InvalidElementId;
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, textNote, catId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
throw new Exception("Failed to create shape representation.");
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle annoHnd = IFCInstanceExporter.CreateAnnotation(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle,
null, null, null, setter.LocalPlacement, prodShapeHnd);
productWrapper.AddAnnotation(annoHnd, setter.LevelInfo, true);
}
tr.Commit();
}
}
/// <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, 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>
/// 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;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
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);
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 instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string coveringType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType, defaultCoveringEnumType);
IFCAnyHandle covering = IFCInstanceExporter.CreateCovering(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, setter.LocalPlacement, prodRep, instanceTag, coveringType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.LocalPlacement, null);
}
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, null, false);
// 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, null, true);
}
if (!exportParts)
{
Ceiling ceiling = element as Ceiling;
if (ceiling != null)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, 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>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
IFCAnyHandle extrusionHandle =
ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element,
info[curr], out _);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
// Openings shouldn't have surface styles for their geometry.
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>()
{
extrusionHandle
};
IFCAnyHandle representationHnd = RepresentationUtil.CreateSweptSolidRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> representations = IFCAnyHandleUtil.IsNullOrHasNoValue(representationHnd) ?
null : new List <IFCAnyHandle>()
{
representationHnd
};
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null,
null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = GUIDUtil.GenerateIFCGuidFrom(IFCEntityType.IfcOpeningElement,
openingNumber.ToString(), elementHandle);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
string openingDescription = NamingUtil.GetDescriptionOverride(element, null);
string openingTag = NamingUtil.GetTagOverride(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(exporterIFC,
guid, ownerHistory, openingName, openingDescription, openingObjectType,
openingPlacement, openingRep, openingTag);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcOpeningElement);
wrapper.AddElement(null, openingElement, setter, extraParams, true, exportInfo);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.GenerateIFCGuidFrom(IFCEntityType.IfcRelVoidsElement,
elementHandle, openingElement);
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null,
elementHandle, openingElement);
}
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper, IFCExportInfoPair exportType = null)
{
if (element == null || geometryElement == null)
{
return(null);
}
if (exportType == null)
{
exportType = new IFCExportInfoPair(IFCEntityType.IfcBuildingElementProxy, IFCEntityType.IfcBuildingElementProxyType, "NOTDEFINED");
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcBuildingElementProxy;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
// 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 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, 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;
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, orientTrf))
{
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;
// The representation handle generated from one of the methods below.
BeamBodyAsExtrusionInfo extrusionInfo = CreateBeamGeometryAsExtrusion(exporterIFC, element, catId, geomObjects, axisInfo);
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);
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);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string preDefinedType = "BEAM"; // Default predefined type for Beam
preDefinedType = IFCValidateEntry.GetValidIFCType(element, preDefinedType);
beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceTag, preDefinedType);
IFCAnyHandle mpSetUsage;
if (materialProfileSet != null)
{
mpSetUsage = IFCInstanceExporter.CreateMaterialProfileSetUsage(file, materialProfileSet, null, null);
}
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
ExportBeamType(exporterIFC, productWrapper, beam, element, preDefinedType);
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);
}
}
transaction.Commit();
return(beam);
}
}
/// <summary>
/// Exports a generic family instance as IFC instance.
/// </summary>
/// <param name="type">The export type.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="familyInstance">The element.</param>
/// <param name="wrapper">The ProductWrapper.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="instanceGUID">The guid.</param>
/// <param name="ownerHistory">The owner history handle.</param>
/// <param name="instanceName">The name.</param>
/// <param name="instanceDescription">The description.</param>
/// <param name="instanceObjectType">The object type.</param>
/// <param name="productRepresentation">The representation handle.</param>
/// <param name="instanceTag">The tag for the entity, usually based on the element id.</param>
/// <param name="ifcEnumType">The predefined type/shape type, if any, for the object.</param>
/// <param name="overrideLocalPlacement">The local placement to use instead of the one in the placement setter, if appropriate.</param>
/// <returns>The handle.</returns>
public static IFCAnyHandle ExportGenericInstance(IFCExportInfoPair type,
ExporterIFC exporterIFC, Element familyInstance,
ProductWrapper wrapper, PlacementSetter setter, IFCExtrusionCreationData extraParams,
string instanceGUID, IFCAnyHandle ownerHistory, IFCAnyHandle productRepresentation,
string ifcEnumType, IFCAnyHandle overrideLocalPlacement)
{
IFCFile file = exporterIFC.GetFile();
Document doc = familyInstance.Document;
bool isRoomRelated = IsRoomRelated(type);
bool isChildInContainer = familyInstance.AssemblyInstanceId != ElementId.InvalidElementId;
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
ElementId roomId = ElementId.InvalidElementId;
if (isRoomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(familyInstance, out localPlacementToUse);
}
//should remove the create method where there is no use of this handle for API methods
//some places uses the return value of ExportGenericInstance as input parameter for API methods
IFCAnyHandle instanceHandle = null;
switch (type.ExportInstance)
{
case IFCEntityType.IfcBeam:
//case IFCEntityType.IfcBeamType:
{
string preDefinedType = string.IsNullOrWhiteSpace(ifcEnumType) ? "BEAM" : ifcEnumType;
instanceHandle = IFCInstanceExporter.CreateBeam(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, preDefinedType);
break;
}
case IFCEntityType.IfcColumn:
{
string preDefinedType = string.IsNullOrWhiteSpace(ifcEnumType) ? "COLUMN" : ifcEnumType;
instanceHandle = IFCInstanceExporter.CreateColumn(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, preDefinedType);
break;
}
case IFCEntityType.IfcCurtainWall:
{
instanceHandle = IFCInstanceExporter.CreateCurtainWall(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, ifcEnumType);
break;
}
case IFCEntityType.IfcMember:
{
string preDefinedType = string.IsNullOrWhiteSpace(ifcEnumType) ? "BRACE" : ifcEnumType;
instanceHandle = IFCInstanceExporter.CreateMember(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, preDefinedType);
// Register the members's IFC handle for later use by truss export.
ExporterCacheManager.ElementToHandleCache.Register(familyInstance.Id, instanceHandle);
break;
}
case IFCEntityType.IfcPlate:
{
IFCAnyHandle localPlacement = localPlacementToUse;
if (overrideLocalPlacement != null)
{
isChildInContainer = true;
localPlacement = overrideLocalPlacement;
}
string preDefinedType = string.IsNullOrWhiteSpace(ifcEnumType) ? "NOTDEFINED" : ifcEnumType;
instanceHandle = IFCInstanceExporter.CreatePlate(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacement, productRepresentation, preDefinedType);
break;
}
case IFCEntityType.IfcMechanicalFastener:
{
double?nominalDiameter = null;
double?nominalLength = null;
double nominalDiameterVal, nominalLengthVal;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "NominalDiameter", out nominalDiameterVal) != null)
{
nominalDiameter = UnitUtil.ScaleLength(nominalDiameterVal);
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "NominalLength", out nominalLengthVal) != null)
{
nominalLength = UnitUtil.ScaleLength(nominalLengthVal);
}
string preDefinedType = string.IsNullOrWhiteSpace(ifcEnumType) ? "NOTDEFINED" : ifcEnumType;
instanceHandle = IFCInstanceExporter.CreateMechanicalFastener(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, nominalDiameter, nominalLength, preDefinedType);
break;
}
case IFCEntityType.IfcRailing:
{
string strEnumType;
IFCExportInfoPair exportAs = ExporterUtil.GetExportType(exporterIFC, familyInstance, out strEnumType);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
instanceHandle = IFCInstanceExporter.CreateRailing(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, GetPreDefinedType <Toolkit.IFC4.IFCRailingType>(familyInstance, strEnumType).ToString());
}
else
{
instanceHandle = IFCInstanceExporter.CreateRailing(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, GetPreDefinedType <Toolkit.IFCRailingType>(familyInstance, strEnumType).ToString());
}
break;
}
case IFCEntityType.IfcSpace:
{
IFCInternalOrExternal internalOrExternal = CategoryUtil.IsElementExternal(familyInstance) ? IFCInternalOrExternal.External : IFCInternalOrExternal.Internal;
instanceHandle = IFCInstanceExporter.CreateSpace(exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation, IFCElementComposition.Element, internalOrExternal);
break;
}
default:
{
// !!! These entities are deprecated in IFC4 and will be made abstract in the next version.
// It is still kept as it is because if we generate an IfcBuildingElementProxy, teh connectivity will be lost
if (ExporterCacheManager.ExportOptionsCache.ExportAs4 &&
(type.ExportInstance == IFCEntityType.IfcDistributionElement ||
type.ExportInstance == IFCEntityType.IfcEnergyConversionDevice ||
type.ExportInstance == IFCEntityType.IfcFlowController ||
type.ExportInstance == IFCEntityType.IfcFlowFitting ||
type.ExportInstance == IFCEntityType.IfcFlowMovingDevice ||
type.ExportInstance == IFCEntityType.IfcFlowSegment ||
type.ExportInstance == IFCEntityType.IfcFlowStorageDevice ||
type.ExportInstance == IFCEntityType.IfcFlowTerminal ||
type.ExportInstance == IFCEntityType.IfcFlowTreatmentDevice))
{
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(type, exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation);
}
else
{
if (type.ExportInstance != IFCEntityType.UnKnown)
{
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(type, exporterIFC, familyInstance, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation);
}
}
break;
}
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
bool containedInSpace = (roomId != ElementId.InvalidElementId);
bool associateToLevel = containedInSpace ? false : !isChildInContainer;
wrapper.AddElement(familyInstance, instanceHandle, setter, extraParams, associateToLevel);
if (containedInSpace)
{
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
}
}
return(instanceHandle);
}
/// <summary>
/// Creates an opening from a solid.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host object handle.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The insert element.</param>
/// <param name="openingGUID">The GUID for the opening, depending on how the opening is created.</param>
/// <param name="solid">The solid.</param>
/// <param name="scaledHostWidth">The scaled host width.</param>
/// <param name="isRecess">True if it is recess.</param>
/// <param name="extrusionCreationData">The extrusion creation data.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localWrapper">The product wrapper.</param>
/// <returns>The created opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, Element hostElement, Element insertElement, string openingGUID,
Solid solid, double scaledHostWidth, bool isRecess, IFCExtrusionCreationData extrusionCreationData, PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
XYZ prepToWall;
bool isLinearWall = GetOpeningDirection(hostElement, out prepToWall);
if (isLinearWall)
{
extrusionCreationData.CustomAxis = prepToWall;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData = BodyExporter.ExportBody(exporterIFC, insertElement, catId, ElementId.InvalidElementId,
solid, bodyExporterOptions, extrusionCreationData);
IFCAnyHandle openingRepHnd = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(openingRepHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(openingRepHnd);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = extrusionCreationData.GetLocalPlacement();
IFCAnyHandle hostObjPlacementHnd = IFCAnyHandleUtil.GetObjectPlacement(hostObjHnd);
Transform relTransform = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(openingPlacement, hostObjPlacementHnd);
openingPlacement = ExporterUtil.CreateLocalPlacement(file, hostObjPlacementHnd,
relTransform.Origin, relTransform.BasisZ, relTransform.BasisX);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
double scaledOpeningLength = extrusionCreationData.ScaledLength;
string openingObjectType = "Opening";
if (!MathUtil.IsAlmostZero(scaledHostWidth) && !MathUtil.IsAlmostZero(scaledOpeningLength))
{
openingObjectType = scaledOpeningLength < (scaledHostWidth - MathUtil.Eps()) ? "Recess" : "Opening";
}
else
{
openingObjectType = isRecess ? "Recess" : "Opening";
}
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjHnd))
{
openingName = IFCAnyHandleUtil.GetStringAttribute(hostObjHnd, "Name");
}
else
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(exporterIFC, hostElement, openingGUID, ownerHistory,
openingPlacement, prodRep, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingHnd, openingName);
IFCAnyHandleUtil.SetAttribute(openingHnd, "ObjectType", openingObjectType);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, extrusionCreationData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(insertElement, openingHnd, setter, extrusionCreationData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element, IFCFile file, IFCExportInfoPair exportType, string ifcEnumType, IFCExtrusionCreationData extraParams,
PlacementSetter setter, IFCAnyHandle localPlacementToUse, IFCAnyHandle productRepresentation, ProductWrapper productWrapper)
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.GetElement(typeId) as ElementType;
IFCAnyHandle styleHandle = null;
ElementId matId = ElementId.InvalidElementId;
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
bool hasMaterialAssociatedToType = false;
if (type != null)
{
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.FamilySymbolToTypeInfoCache.Find(typeId, false, exportType);
if (!currentTypeInfo.IsValid())
{
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
IList <IFCAnyHandle> repMapListOpt = new List <IFCAnyHandle>();
styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType, propertySetsOpt, repMapListOpt, element, type);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
propertySetsOpt = ExporterUtil.ExtractElementTypeProperties(exporterIFC, type, styleHandle);
productWrapper.RegisterHandleWithElementType(type, exportType, styleHandle, propertySetsOpt);
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.FamilySymbolToTypeInfoCache.Register(typeId, false, exportType, currentTypeInfo);
Element elementType = element.Document.GetElement(element.GetTypeId());
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, elementType);
if (matId == ElementId.InvalidElementId)
{
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, element);
}
if (matId != ElementId.InvalidElementId)
{
currentTypeInfo.MaterialIds = new HashSet <ElementId>()
{
matId
};
hasMaterialAssociatedToType = true;
CategoryUtil.CreateMaterialAssociation(exporterIFC, styleHandle, matId);
}
}
}
else
{
styleHandle = currentTypeInfo.Style;
if (currentTypeInfo.MaterialIds != null && currentTypeInfo.MaterialIds.Count > 0)
{
hasMaterialAssociatedToType = true;
}
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = null;
// For MEP objects
//string exportEntityStr = exportType.ToString();
//Common.Enums.IFCEntityType exportEntity;
//if (String.Compare(exportEntityStr.Substring(exportEntityStr.Length - 4), "Type", true) == 0)
// exportEntityStr = exportEntityStr.Substring(0, (exportEntityStr.Length - 4));
//if (Enum.TryParse(exportEntityStr, out exportEntity))
//{
// For MEP object creation
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(exportType, exporterIFC, element, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation);
//}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
return;
}
if (matId == ElementId.InvalidElementId && !hasMaterialAssociatedToType)
{
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, element);
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, instanceHandle, matId);
}
}
if (roomId != ElementId.InvalidElementId)
{
//exporterIFC.RelateSpatialElement(roomId, instanceHandle);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
productWrapper.AddElement(element, instanceHandle, setter, extraParams, false, exportType);
}
else
{
productWrapper.AddElement(element, instanceHandle, setter, extraParams, true, exportType);
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, null, exporterIFC, localPlacementToUse, setter, productWrapper);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
ExporterCacheManager.TypeRelationsCache.Add(styleHandle, instanceHandle);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper.GetAllObjects());
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
// add to system export cache
// SystemExporter.ExportSystem(exporterIFC, element, instanceHandle);
}
/// <summary>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
Document document = element.Document;
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
Transform extrusionTrf = Transform.Identity;
IFCAnyHandle extrusionHandle = ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element, info[curr]);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, document, extrusionHandle, ElementId.InvalidElementId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(extrusionHandle);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCAnyHandle bodyRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItems, null);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = GUIDUtil.CreateGUID();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(exporterIFC, element, guid, ownerHistory,
openingPlacement, openingRep, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingElement, openingName);
IFCAnyHandleUtil.SetAttribute(openingElement, "ObjectType", openingObjectType);
wrapper.AddElement(null, openingElement, setter, extraParams, true);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
}
/// <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;
}
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, floorElement, out ifcEnumType);
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
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 (!exportParts && (floorElement is Floor))
{
Floor floor = floorElement as Floor;
// First, try to use the ExtrusionAnalyzer for the limited cases it handles - 1 solid, no openings, end clippings only.
// Also limited to cases with line and arc boundaries.
//
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
bool completelyClipped;
XYZ floorExtrusionDirection = new XYZ(0, 0, -1);
XYZ modelOrigin = XYZ.Zero;
XYZ floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
if (floorOrigin == null)
{
// GetVerticalProjectionPoint may return null if FloorFace.Top is an edited face that doesn't
// go thruough te Revit model orgigin. We'll try the midpoint of the bounding box instead.
BoundingBoxXYZ boundingBox = floorElement.get_BoundingBox(null);
modelOrigin = (boundingBox.Min + boundingBox.Max) / 2.0;
floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
}
if (floorOrigin != null)
{
XYZ floorDir = floor.GetNormalAtVerticalProjectionPoint(floorOrigin, FloorFace.Top);
Plane extrusionAnalyzerFloorPlane = new Plane(floorDir, floorOrigin);
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floorElement,
catId, solids[0], extrusionAnalyzerFloorPlane, floorExtrusionDirection, null, out completelyClipped);
if (completelyClipped)
{
return;
}
if (floorAndProperties.Handle != null)
{
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(floorAndProperties.Handle);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
prodReps.Add(prodRep);
repTypes.Add(ShapeRepresentationType.SweptSolid);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (prodReps.Count == 0)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out prodReps,
out extrusionLoops, out loopExtraParams, floorPlane);
for (int ii = 0; ii < prodReps.Count; ii++)
{
// all are extrusions
repTypes.Add(ShapeRepresentationType.SweptSolid);
}
}
if (prodReps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporter.GetTessellationLevel();
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
prodReps.Add(prodDefHnd);
repTypes.Add(bodyData.ShapeRepresentationType);
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(floorElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = null;
switch (exportType)
{
case IFCExportType.IfcFooting:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCFootingType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCFootingType>(floorElement, ifcEnumType, null);
}
break;
case IFCExportType.IfcCovering:
entityType = IFCValidateEntry.GetValidIFCType <IFCCoveringType>(floorElement, ifcEnumType, "FLOORING");
break;
case IFCExportType.IfcRamp:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCRampType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCRampType>(floorElement, ifcEnumType, null);
}
break;
default:
bool isBaseSlab = false;
AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
if (analyticalModel != null)
{
AnalyzeAs slabFoundationType = analyticalModel.GetAnalyzeAs();
isBaseSlab = (slabFoundationType == AnalyzeAs.SlabOnGrade) || (slabFoundationType == AnalyzeAs.Mat);
}
entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(floorElement, ifcEnumType, isBaseSlab ? "BASESLAB" : "FLOOR");
break;
}
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.GetIFCNamePlusIndex(floorElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(floorElement, NamingUtil.CreateIFCElementId(floorElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = null;
// TODO: replace with CreateGenericBuildingElement.
switch (exportType)
{
case IFCExportType.IfcFooting:
slabHnd = IFCInstanceExporter.CreateFooting(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcCovering:
slabHnd = IFCInstanceExporter.CreateCovering(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcRamp:
slabHnd = IFCInstanceExporter.CreateRamp(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
default:
slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(floorElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
}
if (!exportParts)
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
}
tr.Commit();
return;
}
}