/// <summary>
/// Exports an element as an IFC assembly.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element,
IFCProductWrapper productWrapper)
{
if (element == null)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, element))
{
string guid = ExporterIFCUtils.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = exporterIFC.GetName();
string objectType = exporterIFC.GetFamilyName();
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle representation = null;
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCElementAssemblyType predefinedType = GetPredefinedTypeFromObjectType(objectType);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, null, objectType, localPlacement, representation, elementTag,
IFCAssemblyPlace.NotDefined, predefinedType);
productWrapper.AddElement(assemblyInstanceHnd, placementSetter.GetLevelInfo(), null, true);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd);
}
tr.Commit();
return true;
}
}
/// <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="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCExtrusionCreationData extraParams, IFCPlacementSetter setter, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle repHnd = RepresentationUtil.CreateBRepProductDefinitionShape(mullion.Document.Application, exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = ExporterIFCUtils.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string elemId = NamingUtil.CreateIFCElementId(mullion);
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, elemObjectType, null, elemObjectType,
localPlacement, repHnd, elemId);
productWrapper.AddElement(mullionHnd, setter, extraParams, LevelUtil.AssociateElementToLevel(mullion));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, mullion, productWrapper);
}
/// <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="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCExtrusionCreationData extraParams, IFCPlacementSetter setter, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
IFCSolidMeshGeometryInfo solidMeshInfo = ExporterIFCUtils.GetSolidMeshGeometry(exporterIFC, geometryElement, Transform.Identity);
IList<Solid> solids = solidMeshInfo.GetSolids();
IList<Mesh> polyMeshes = solidMeshInfo.GetMeshes();
bool tryToExportAsExtrusion = true;
if (solids.Count != 1 || polyMeshes.Count != 0)
tryToExportAsExtrusion = false;
IFCAnyHandle shapeRep = BodyExporter.ExportBody(mullion.Document.Application, exporterIFC, catId, solids, polyMeshes, tryToExportAsExtrusion, extraParams);
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle repHnd = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), shapeReps);
IFCLabel elemGUID = IFCLabel.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCLabel elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
IFCLabel elemId = NamingUtil.CreateIFCElementId(mullion);
//IFCLabel elemType = IFCLabel.Create("MULLION");
IFCAnyHandle mullionHnd = file.CreateMember(elemGUID, ownerHistory, elemObjectType, IFCLabel.Create(), elemObjectType,
localPlacement, repHnd, elemId);
productWrapper.AddElement(mullionHnd, setter, extraParams, true);
}
/// <summary>
/// Standard static Create function.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="allowRelateToLevel">Whether or not handles are allowed to be related to levels.</param>
/// <returns>A new ProductWrapper.</returns>
public static ProductWrapper Create(ExporterIFC exporterIFC, bool allowRelateToLevel)
{
ProductWrapper productWrapper = new ProductWrapper(exporterIFC);
productWrapper.m_InternalWrapper = IFCProductWrapper.Create(exporterIFC, allowRelateToLevel);
return(productWrapper);
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, IFCProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.CreateIFCElementId(element);
Toolkit.IFCFootingType footingType = GetIFCFootingType(element, ifcEnumType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceElemId, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(footing, setter, ecData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Exports a hosted weep.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostedSweep">The hosted sweep element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, HostedSweep hostedSweep, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(hostedSweep);
if (catId == new ElementId(BuiltInCategory.OST_Gutter))
ExportGutter(exporterIFC, hostedSweep, geometryElement, productWrapper);
else
ProxyElementExporter.Export(exporterIFC, hostedSweep, geometryElement, productWrapper);
}
/// <summary>
/// Static Create function for a child wrapper.
/// </summary>
/// <param name="parentWrapper">The parent wrapper.</param>
/// <returns>A new ProductWrapper.</returns>
public static ProductWrapper Create(ProductWrapper parentWrapper)
{
ProductWrapper productWrapper = new ProductWrapper(parentWrapper.m_ExporterIFC);
productWrapper.m_InternalWrapper = IFCProductWrapper.Create(parentWrapper.m_InternalWrapper);
productWrapper.m_ParentWrapper = parentWrapper;
return(productWrapper);
}
/// <summary>
/// Static Create function for a child wrapper, with a different allowRelateToLevel value.
/// </summary>
/// <param name="parentWrapper">The parent wrapper.</param>
/// <param name="allowRelateToLevel">Whether or not handles are allowed to be related to levels.</param>
/// <returns>A new ProductWrapper.</returns>
public static ProductWrapper Create(ProductWrapper parentWrapper, bool allowRelateToLevel)
{
ProductWrapper productWrapper = new ProductWrapper(parentWrapper.m_ExporterIFC);
productWrapper.m_InternalWrapper = IFCProductWrapper.Create(parentWrapper.m_InternalWrapper, allowRelateToLevel);
productWrapper.m_ParentWrapper = parentWrapper;
return(productWrapper);
}
/// <summary>
/// Exports a floor to IFC slab.
/// </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 IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, HostObject floor, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, floor);
// export parts or not
bool exportParts = PartExporter.CanExportParts(floor);
if (exportParts && !PartExporter.CanExportElementInPartExport(floor, floor.Level.Id, false))
return;
ExportFloor(exporterIFC, floor, geometryElement, ifcEnumType, productWrapper, exportParts);
}
/// <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 datas.
/// </param>
/// <param name="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="originalPlacement">
/// The original placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="wrapper">
/// The IFCProductWrapper.
/// </param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList<IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, IFCPlacementSetter setter, IFCProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
return;
int sz = info.Count;
if (sz == 0)
return;
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--)
{
IFCAnyHandle extrusionHandle = ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element, info[curr]);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
continue;
IFCAnyHandle styledItemHnd = 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 = ExporterIFCUtils.CreateGUID();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string openingName = NamingUtil.GetNameOverride(element, NamingUtil.CreateIFCName(exporterIFC, openingNumber++));
string elementId = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(file, guid, ownerHistory,
openingName, null, openingObjectType, openingPlacement, openingRep, elementId);
wrapper.AddElement(openingElement, setter, extraParams, true);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
ExporterIFCUtils.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
string voidGuid = ExporterIFCUtils.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
/// <summary>
/// Export all the parts of the host element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostElement">The host element having parts to export.</param>
/// <param name="hostHandle">The host element handle.</param>
/// <param name="originalWrapper">The IFCProductWrapper object.</param>
public static void ExportHostPart(ExporterIFC exporterIFC, Element hostElement, IFCAnyHandle hostHandle,
IFCProductWrapper originalWrapper, IFCPlacementSetter placementSetter, IFCAnyHandle originalPlacement, ElementId overrideLevelId)
{
using (IFCProductWrapper subWrapper = IFCProductWrapper.Create(exporterIFC, true))
{
List <ElementId> associatedPartsList = PartUtils.GetAssociatedParts(hostElement.Document, hostElement.Id, false, true).ToList();
if (associatedPartsList.Count == 0)
{
return;
}
bool isWallOrColumn = IsHostWallOrColumn(exporterIFC, hostElement);
bool hasOverrideLevel = overrideLevelId != null && overrideLevelId != ElementId.InvalidElementId;
IFCExtrusionAxes ifcExtrusionAxes = GetDefaultExtrusionAxesForHost(exporterIFC, hostElement);
// Split parts if wall or column is split by level, and then export; otherwise, export parts normally.
if (isWallOrColumn && hasOverrideLevel && ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting)
{
if (!ExporterCacheManager.HostPartsCache.HasRegistered(hostElement.Id))
{
SplitParts(exporterIFC, hostElement, associatedPartsList); // Split parts and associate them with host.
}
// Find and export the parts that are split by specific level.
List <KeyValuePair <Part, IFCRange> > splitPartRangeList = new List <KeyValuePair <Part, IFCRange> >();
splitPartRangeList = ExporterCacheManager.HostPartsCache.Find(hostElement.Id, overrideLevelId);
foreach (KeyValuePair <Part, IFCRange> partRange in splitPartRangeList)
{
PartExporter.ExportPart(exporterIFC, partRange.Key, subWrapper, placementSetter, originalPlacement, partRange.Value, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
else
{
foreach (ElementId partId in associatedPartsList)
{
Part part = hostElement.Document.GetElement(partId) as Part;
PartExporter.ExportPart(exporterIFC, part, subWrapper, placementSetter, originalPlacement, null, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
// Create the relationship of Host and Parts.
ICollection <IFCAnyHandle> relatedElementIds = subWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateGUID();
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(exporterIFC.GetFile(), guid, exporterIFC.GetOwnerHistoryHandle(), null, null, hostHandle, relatedElementIdSet);
}
}
}
/// <summary>
/// Exports a wall swepp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="wallSweep">The WallSwepp.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, WallSweep wallSweep, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
WallSweepInfo wallSweepInfo = wallSweep.GetWallSweepInfo();
//Reveals are exported as openings with wall exporter.
if (wallSweepInfo.WallSweepType == WallSweepType.Reveal)
return;
if (!ProxyElementExporter.Export(exporterIFC, wallSweep, geometryElement, productWrapper))
return;
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, wallSweep, productWrapper.GetAnElement(),
geometryElement, productWrapper,
ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis2);
}
/// <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 datas.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="originalPlacement">
/// The original placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="wrapper">
/// The IFCProductWrapper.
/// </param>
public static void CreateOpeningsIfNecessary(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
ExporterIFC exporterIFC, IFCAnyHandle originalPlacement,
IFCPlacementSetter setter, IFCProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
CreateOpeningsIfNecessaryBase(elementHandle, element, info, extraParams, exporterIFC, originalPlacement, setter, wrapper);
}
}
/// <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 datas.
/// </param>
/// <param name="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="originalPlacement">
/// The original placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="wrapper">
/// The IFCProductWrapper.
/// </param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList<IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, IFCPlacementSetter setter, IFCProductWrapper wrapper)
{
if (!elementHandle.HasValue)
return;
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
int sz = info.Count;
if (sz == 0)
return;
IFCLabel openingObjectType = IFCLabel.Create("Opening");
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
IFCAnyHandle extrusionHandle = BodyExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, categoryId, info[curr]);
if (!extrusionHandle.HasValue)
continue;
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(extrusionHandle);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle();
IFCAnyHandle bodyRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, categoryId, contextOfItems, bodyItems,
IFCAnyHandle.Create());
IList<IFCAnyHandle> representations = new List<IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle openingRep = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
IFCLabel guid = IFCLabel.CreateGUID();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCLabel openingName = NamingUtil.GetNameOverride(element, NamingUtil.CreateIFCName(exporterIFC, openingNumber++));
IFCLabel elementId = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle openingElement = file.CreateOpeningElement(guid, ownerHistory,
openingName, IFCLabel.Create(), openingObjectType, openingPlacement, openingRep, elementId);
wrapper.AddElement(openingElement, setter, extraParams, true);
if (exporterIFC.ExportBaseQuantities && (extraParams != null))
ExporterIFCUtils.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
IFCLabel voidGuid = IFCLabel.CreateGUID();
file.CreateRelVoidsElement(voidGuid, ownerHistory, IFCLabel.Create(), IFCLabel.Create(), elementHandle, openingElement);
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = ExporterIFCUtils.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string objectType = exporterIFC.GetFamilyName();
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, objectType, null, objectType, localPlacement, representation, elementTag, IFCCoveringType.Wrapping);
productWrapper.AddElement(ductLining, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(element));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Export all the parts of the host element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostElement">The host element having parts to export.</param>
/// <param name="hostHandle">The host element handle.</param>
/// <param name="originalWrapper">The IFCProductWrapper object.</param>
public static void ExportHostPart(ExporterIFC exporterIFC, Element hostElement, IFCAnyHandle hostHandle,
IFCProductWrapper originalWrapper, IFCPlacementSetter placementSetter, IFCAnyHandle originalPlacement, ElementId overrideLevelId)
{
using (IFCProductWrapper subWrapper = IFCProductWrapper.Create(exporterIFC, true))
{
List<ElementId> associatedPartsList = PartUtils.GetAssociatedParts(hostElement.Document, hostElement.Id, false, true).ToList();
if (associatedPartsList.Count == 0)
return;
bool isWallOrColumn = IsHostWallOrColumn(exporterIFC, hostElement);
bool hasOverrideLevel = overrideLevelId != null && overrideLevelId != ElementId.InvalidElementId;
IFCExtrusionAxes ifcExtrusionAxes = GetDefaultExtrusionAxesForHost(exporterIFC, hostElement);
// Split parts if wall or column is split by level, and then export; otherwise, export parts normally.
if (isWallOrColumn && hasOverrideLevel && ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting)
{
if (!ExporterCacheManager.HostPartsCache.HasRegistered(hostElement.Id))
SplitParts(exporterIFC, hostElement, associatedPartsList); // Split parts and associate them with host.
// Find and export the parts that are split by specific level.
List<KeyValuePair<Part, IFCRange>> splitPartRangeList = new List<KeyValuePair<Part, IFCRange>>();
splitPartRangeList = ExporterCacheManager.HostPartsCache.Find(hostElement.Id, overrideLevelId);
foreach (KeyValuePair<Part, IFCRange> partRange in splitPartRangeList)
{
PartExporter.ExportPart(exporterIFC, partRange.Key, subWrapper, placementSetter, originalPlacement, partRange.Value, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
else
{
foreach (ElementId partId in associatedPartsList)
{
Part part = hostElement.Document.GetElement(partId) as Part;
PartExporter.ExportPart(exporterIFC, part, subWrapper, placementSetter, originalPlacement, null, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
// Create the relationship of Host and Parts.
ICollection<IFCAnyHandle> relatedElementIds = subWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateGUID();
HashSet<IFCAnyHandle> relatedElementIdSet = new HashSet<IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(exporterIFC.GetFile(), guid, exporterIFC.GetOwnerHistoryHandle(), null, null, hostHandle, relatedElementIdSet);
}
}
}
/// <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="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="originalPlacement">
/// The original placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="wrapper">
/// The IFCProductWrapper.
/// </param>
public static void CreateOpeningsIfNecessary(IFCAnyHandle elementHandle, Element element, IFCExtrusionCreationData extraParams,
ExporterIFC exporterIFC, IFCAnyHandle originalPlacement,
IFCPlacementSetter setter, IFCProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IList <IFCExtrusionData> info = extraParams.GetOpenings();
CreateOpeningsIfNecessaryBase(elementHandle, element, info, extraParams, exporterIFC, originalPlacement, setter, wrapper);
extraParams.ClearOpenings();
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return false;
}
string guid = ExporterIFCUtils.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string objectType = exporterIFC.GetFamilyName();
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, objectType, null, objectType, localPlacement, representation, elementTag, IFCCoveringType.Wrapping);
productWrapper.AddElement(ductLining, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(element));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
return true;
}
}
/// <summary>
/// Registers all of the created handles in the product wrapper that are of the right type to an AssemblyInstance.
/// </summary>
/// <param name="instanceId">The ElementId of the AssemblyInstance.</param>
/// <param name="instanceHnd">The product wrapper.</param>
public void RegisterElements(ElementId assemblyId, IFCProductWrapper productWrapper)
{
ICollection <IFCAnyHandle> objects = productWrapper.GetAllObjects();
HashSet <IFCAnyHandle> elementsToAdd = new HashSet <IFCAnyHandle>();
foreach (IFCAnyHandle hnd in objects)
{
if (IFCAnyHandleUtil.IsSubTypeOf(hnd, IFCEntityType.IfcProduct))
{
elementsToAdd.Add(hnd);
}
}
if (elementsToAdd.Count > 0)
{
RegisterAssemblyElements(assemblyId, elementsToAdd);
}
}
/// <summary>
/// Exports a curtain wall to IFC curtain wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="hostElement">
/// The host object element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportWall(ExporterIFC exporterIFC, Wall hostElement, IFCProductWrapper productWrapper)
{
// Don't export the Curtain Wall itself, which has no useful geometry; instead export all of the GReps of the
// mullions and panels.
CurtainGrid grid = hostElement.CurtainGrid;
if (grid == null)
{
return;
}
ICollection <ElementId> allSubElements = grid.GetPanelIds();
foreach (ElementId subElem in grid.GetMullionIds())
{
allSubElements.Add(subElem);
}
ExportBase(exporterIFC, allSubElements, hostElement, productWrapper);
}
/// <summary>
/// Exports an element as an IFC assembly.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element,
IFCProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, element))
{
string guid = ExporterIFCUtils.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = exporterIFC.GetName();
string objectType = exporterIFC.GetFamilyName();
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle representation = null;
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCElementAssemblyType predefinedType = GetPredefinedTypeFromObjectType(objectType);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, null, objectType, localPlacement, representation, elementTag,
IFCAssemblyPlace.NotDefined, predefinedType);
productWrapper.AddElement(assemblyInstanceHnd, placementSetter.GetLevelInfo(), null, true);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd);
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool Export(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
bool exported = false;
if (element == null || geometryElement == null)
{
return(exported);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
exported = ExportBuildingElementProxy(exporterIFC, element, geometryElement, productWrapper);
if (exported)
{
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
tr.Commit();
}
}
return(exported);
}
/// <summary>
/// Exports topography surface as IFC site object.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="topSurface">
/// The TopographySurface object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportTopographySurface(ExporterIFC exporterIFC, TopographySurface topSurface, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
ExportSiteBase(exporterIFC, null, topSurface, geometryElement, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, topSurface, productWrapper);
}
/// <summary>
/// Exports element as Wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportWall(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
IFCProductWrapper productWrapper)
{
IList<IFCAnyHandle> createdWalls = new List<IFCAnyHandle>();
// We will not split walls and columns if the assemblyId is set, as we would like to keep the original wall
// associated with the assembly, on the level of the assembly.
bool splitWall = ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting && (element.AssemblyInstanceId == ElementId.InvalidElementId);
if (splitWall)
{
Wall wallElement = element as Wall;
IList<ElementId> levels = new List<ElementId>();
IList<IFCRange> ranges = new List<IFCRange>();
if (wallElement != null && geometryElement != null)
{
LevelUtil.CreateSplitLevelRangesForElement(exporterIFC, IFCExportType.ExportWall, element, out levels, out ranges);
}
int numPartsToExport = ranges.Count;
if (numPartsToExport == 0)
{
IFCAnyHandle wallElemHnd = ExportWallBase(exporterIFC, element, geometryElement, productWrapper, ElementId.InvalidElementId, null);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(wallElemHnd))
createdWalls.Add(wallElemHnd);
}
else
{
IFCAnyHandle wallElemHnd = ExportWallBase(exporterIFC, element, geometryElement, productWrapper, levels[0], ranges[0]);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(wallElemHnd))
createdWalls.Add(wallElemHnd);
for (int ii = 1; ii < numPartsToExport; ii++)
{
wallElemHnd = ExportWallBase(exporterIFC, element, geometryElement, productWrapper, levels[ii], ranges[ii]);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(wallElemHnd))
createdWalls.Add(wallElemHnd);
}
}
if (ExporterCacheManager.DummyHostCache.HasRegistered(element.Id))
{
List<KeyValuePair<ElementId, IFCRange>> levelRangeList = ExporterCacheManager.DummyHostCache.Find(element.Id);
foreach (KeyValuePair<ElementId, IFCRange> levelRange in levelRangeList)
{
IFCAnyHandle wallElemHnd = ExportDummyWall(exporterIFC, element, geometryElement, productWrapper, levelRange.Key, levelRange.Value);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(wallElemHnd))
createdWalls.Add(wallElemHnd);
}
}
}
if (createdWalls.Count == 0)
ExportWallBase(exporterIFC, element, geometryElement, productWrapper, ElementId.InvalidElementId, null);
}
/// <summary>
/// Export the dummy wall to host an orphan part. It usually happens in the cases of associated parts are higher than split sub-wall.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The wall element.</param>
/// <param name="geometryElement">The geometry of wall.</param>
/// <param name="origWrapper">The IFCProductWrapper.</param>
/// <param name="overrideLevelId">The ElementId that will crate the dummy wall.</param>
/// <param name="range">The IFCRange corresponding to the dummy wall.</param>
/// <returns>The handle of dummy wall.</returns>
public static IFCAnyHandle ExportDummyWall(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
IFCProductWrapper origWrapper, ElementId overrideLevelId, IFCRange range)
{
using (IFCProductWrapper localWrapper = IFCProductWrapper.Create(origWrapper))
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
Wall wallElement = element as Wall;
if (wallElement == null)
return null;
if (wallElement != null && IsWallCompletelyClipped(wallElement, exporterIFC, range))
return null;
// get global values.
Document doc = element.Document;
double scale = exporterIFC.LinearScale;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
bool exportParts = PartExporter.CanExportParts(wallElement);
if (exportParts && !PartExporter.CanExportElementInPartExport(wallElement, validRange ? overrideLevelId : wallElement.Level.Id, validRange))
return null;
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle wallHnd = null;
string elemGUID = (validRange) ? ExporterIFCUtils.CreateGUID() : ExporterIFCUtils.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, exporterIFC.GetName());
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemId = NamingUtil.CreateIFCElementId(element);
Transform orientationTrf = Transform.Identity;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element, null, orientationTrf, overrideLevelId))
{
IFCAnyHandle localPlacement = setter.GetPlacement();
wallHnd = IFCInstanceExporter.CreateWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemObjectType,
localPlacement, null, elemId);
if (exportParts)
PartExporter.ExportHostPart(exporterIFC, wallElement, wallHnd, localWrapper, setter, localPlacement, overrideLevelId);
IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData();
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ; // only allow vertical extrusions!
extraParams.AreInnerRegionsOpenings = true;
localWrapper.AddElement(wallHnd, setter, extraParams, true);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, localWrapper);
ElementId wallLevelId = (validRange) ? setter.LevelId : ElementId.InvalidElementId;
exporterIFC.RegisterSpaceBoundingElementHandle(wallHnd, element.Id, wallLevelId);
}
return wallHnd;
}
}
/// <summary>
/// Exports a footing to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="footing">
/// The footing element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFootingElement(ExporterIFC exporterIFC,
ContFooting footing, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
String ifcEnumType = "STRIP_FOOTING";
ExportFooting(exporterIFC, footing, geometryElement, ifcEnumType, productWrapper);
}
/// <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 IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, TextNote textNote, IFCProductWrapper 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 (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, textNote))
{
double linScale = exporterIFC.LinearScale;
const double planScale = 100.0; // currently hardwired.
XYZ orig = textNote.Coord;
orig = orig.Multiply(linScale);
XYZ yDir = textNote.UpDirection;
XYZ xDir = textNote.BaseDirection;
XYZ zDir = xDir.CrossProduct(yDir);
double sizeX = textNote.LineWidth * linScale * planScale;
double sizeY = textNote.Height * linScale * 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, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, setter.GetPlacement(), prodShapeHnd);
productWrapper.AddAnnotation(annoHnd, setter.GetLevelInfo(), true);
}
tr.Commit();
}
}
/// <summary>
/// Exports materials for host object.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="hostObject">
/// The host object.
/// </param>
/// <param name="elemHnds">
/// The host IFC handles.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
/// <param name="levelId">
/// The level id.
/// </param>
/// <param name="direction">
/// The IFCLayerSetDirection.
/// </param>
/// <returns>
/// True if exported successfully, false otherwise.
/// </returns>
public static bool ExportHostObjectMaterials(ExporterIFC exporterIFC, HostObject hostObject,
IList <IFCAnyHandle> elemHnds, GeometryElement geometryElement, IFCProductWrapper productWrapper,
ElementId levelId, Toolkit.IFCLayerSetDirection direction)
{
if (hostObject == null)
{
return(true); //nothing to do
}
if (elemHnds == null || (elemHnds.Count == 0))
{
return(true); //nothing to do
}
IFCFile file = exporterIFC.GetFile();
// Roofs with no components are only allowed one material. We will arbitrarily choose the thickest material.
IFCAnyHandle primaryMaterialHnd = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
if (productWrapper != null)
{
productWrapper.ClearFinishMaterials();
}
double scale = exporterIFC.LinearScale;
double scaledOffset = 0.0, scaledWallWidth = 0.0, wallHeight = 0.0;
Wall wall = hostObject as Wall;
if (wall != null)
{
scaledWallWidth = wall.Width * scale;
scaledOffset = -scaledWallWidth / 2.0;
BoundingBoxXYZ boundingBox = wall.get_BoundingBox(null);
if (boundingBox != null)
{
wallHeight = boundingBox.Max.Z - boundingBox.Min.Z;
}
}
ElementId typeElemId = hostObject.GetTypeId();
IFCAnyHandle materialLayerSet = ExporterCacheManager.MaterialLayerSetCache.Find(typeElemId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(materialLayerSet))
{
HostObjAttributes hostObjAttr = hostObject.Document.GetElement(typeElemId) as HostObjAttributes;
if (hostObjAttr == null)
{
return(true); //nothing to do
}
List <ElementId> matIds = new List <ElementId>();
List <double> widths = new List <double>();
List <MaterialFunctionAssignment> functions = new List <MaterialFunctionAssignment>();
ElementId baseMatId = CategoryUtil.GetBaseMaterialIdForElement(hostObject);
CompoundStructure cs = hostObjAttr.GetCompoundStructure();
if (cs != null)
{
//TODO: Vertically compound structures are not yet supported by export.
if (!cs.IsVerticallyHomogeneous() && !MathUtil.IsAlmostZero(wallHeight))
{
cs = cs.GetSimpleCompoundStructure(wallHeight, wallHeight / 2.0);
}
for (int i = 0; i < cs.LayerCount; ++i)
{
ElementId matId = cs.GetMaterialId(i);
if (matId != ElementId.InvalidElementId)
{
matIds.Add(matId);
}
else
{
matIds.Add(baseMatId);
}
widths.Add(cs.GetLayerWidth(i));
// save layer function into IFCProductWrapper,
// it's used while exporting "Function" of Pset_CoveringCommon
functions.Add(cs.GetLayerFunction(i));
}
}
if (matIds.Count == 0)
{
matIds.Add(baseMatId);
widths.Add(cs != null ? cs.GetWidth() : 0);
functions.Add(MaterialFunctionAssignment.None);
}
List <IFCAnyHandle> layers = new List <IFCAnyHandle>();
double thickestLayer = 0.0;
for (int i = 0; i < matIds.Count; ++i)
{
if (widths[i] < MathUtil.Eps())
{
continue;
}
IFCAnyHandle materialHnd = CategoryUtil.GetOrCreateMaterialHandle(hostObjAttr.Document, exporterIFC, matIds[i]);
if (primaryMaterialHnd == null || (widths[i] > thickestLayer))
{
primaryMaterialHnd = materialHnd;
thickestLayer = widths[i];
}
double scaledWidth = widths[i] * scale;
IFCAnyHandle materialLayer = IFCInstanceExporter.CreateMaterialLayer(file, materialHnd, scaledWidth, null);
layers.Add(materialLayer);
if ((productWrapper != null) && (functions[i] == MaterialFunctionAssignment.Finish1 || functions[i] == MaterialFunctionAssignment.Finish2))
{
productWrapper.AddFinishMaterial(materialHnd);
}
}
if (layers.Count == 0)
{
return(false);
}
string layerSetName = NamingUtil.CreateIFCFamilyName(exporterIFC, -1);
materialLayerSet = IFCInstanceExporter.CreateMaterialLayerSet(file, layers, layerSetName);
ExporterCacheManager.MaterialLayerSetCache.Register(typeElemId, materialLayerSet);
}
// IfcMaterialLayerSetUsage is not supported for IfcWall, only IfcWallStandardCase.
IFCAnyHandle layerSetUsage = null;
for (int ii = 0; ii < elemHnds.Count; ii++)
{
IFCAnyHandle elemHnd = elemHnds[ii];
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
continue;
}
HashSet <IFCAnyHandle> relDecomposesSet = IFCAnyHandleUtil.GetRelDecomposes(elemHnd);
IList <IFCAnyHandle> subElemHnds = new List <IFCAnyHandle>();
if (relDecomposesSet != null && relDecomposesSet.Count == 1)
{
IFCAnyHandle relAggregates = relDecomposesSet.First();
if (IFCAnyHandleUtil.IsTypeOf(relAggregates, IFCEntityType.IfcRelAggregates))
{
IFCData ifcData = relAggregates.GetAttribute("RelatedObjects");
if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
{
IFCAggregate aggregate = ifcData.AsAggregate();
if (aggregate != null && aggregate.Count > 0)
{
foreach (IFCData val in aggregate)
{
if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
{
subElemHnds.Add(val.AsInstance());
}
}
}
}
}
}
bool hasSubElems = !(subElemHnds.Count == 0);
bool isRoof = IFCAnyHandleUtil.IsTypeOf(elemHnd, IFCEntityType.IfcRoof);
if (!hasSubElems && !isRoof && !IFCAnyHandleUtil.IsTypeOf(elemHnd, IFCEntityType.IfcWall))
{
if (layerSetUsage == null)
{
bool flipDirSense = true;
if (wall != null)
{
// if we have flipped the center curve on export, we need to take that into account here.
// We flip the center curve on export if it is an arc and it has a negative Z direction.
LocationCurve locCurve = wall.Location as LocationCurve;
if (locCurve != null)
{
Curve curve = locCurve.Curve;
Plane defPlane = new Plane(XYZ.BasisX, XYZ.BasisY, XYZ.Zero);
bool curveFlipped = GeometryUtil.MustFlipCurve(defPlane, curve);
flipDirSense = !(wall.Flipped ^ curveFlipped);
}
}
else if (hostObject is Floor)
{
flipDirSense = false;
}
double offsetFromReferenceLine = flipDirSense ? -scaledOffset : scaledOffset;
IFCDirectionSense sense = flipDirSense ? IFCDirectionSense.Negative : IFCDirectionSense.Positive;
layerSetUsage = IFCInstanceExporter.CreateMaterialLayerSetUsage(file, materialLayerSet, direction, sense, offsetFromReferenceLine);
}
ExporterCacheManager.MaterialLayerRelationsCache.Add(layerSetUsage, elemHnd);
}
else
{
if (hasSubElems)
{
foreach (IFCAnyHandle subElemHnd in subElemHnds)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(subElemHnd))
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(materialLayerSet, subElemHnd);
}
}
}
else if (!isRoof)
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(materialLayerSet, elemHnd);
}
else if (primaryMaterialHnd != null)
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(primaryMaterialHnd, elemHnd);
}
}
exporterIFC.RegisterSpaceBoundingElementHandle(elemHnd, hostObject.Id, levelId);
}
tr.Commit();
return(true);
}
}
/// <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 IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, TextNote textNote, IFCProductWrapper productWrapper, PresentationStyleAssignmentCache cache)
{
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.");
IFCAnyHandle presHnd = cache.Find(symId);
if (!presHnd.HasValue)
{
TextElementType textElemType = textNote.Symbol;
CreatePresentationStyleAssignmentForTextElementType(exporterIFC, textElemType, cache);
presHnd = cache.Find(symId);
if (!presHnd.HasValue)
throw new Exception("Failed to create presentation style assignment for TextElementType.");
}
IList<IFCAnyHandle> presHndSet = new List<IFCAnyHandle>();
presHndSet.Add(presHnd);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, textNote))
{
double linScale = exporterIFC.LinearScale;
const double planScale = 100.0; // currently hardwired.
XYZ orig = textNote.Coord;
orig = orig.Multiply(linScale);
XYZ yDir = textNote.UpDirection;
XYZ xDirection = textNote.BaseDirection;
XYZ zDirection = xDirection.CrossProduct(yDir);
double sizeX = textNote.LineWidth * linScale * planScale;
double sizeY = textNote.Height * linScale * planScale;
// When we display text on screen, we "flip" it if the xDirection is negative with relation to
// the X-axis. So if it is, we'll flip x and y.
bool flipOrig = false;
if (xDirection.X < 0)
{
xDirection = xDirection.Multiply(-1.0);
yDir = yDir.Multiply(-1.0);
flipOrig = true;
}
// xFactor, yFactor only used if flipOrig.
double xFactor = 0.0, yFactor = 0.0;
IFCLabel boxAlign = 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(xDirection.Multiply(sizeX * xFactor));
orig = orig.Add(yDir.Multiply(sizeY * yFactor));
}
IFCAnyHandle origin = ExporterUtil.CreateAxis(file, orig, zDirection, xDirection);
IFCLabel textStringLabel = IFCLabel.Create(textString);
IFCAnyHandle extent = file.CreatePlanarExtent(sizeX, sizeY);
IFCAnyHandle repItemHnd = file.CreateTextLiteralWithExtent(textStringLabel, origin, IFCTextPath.Left, extent, boxAlign);
IFCAnyHandle annoTextOccHnd = file.CreateStyledItem(repItemHnd, presHndSet, IFCLabel.Create());
ElementId catId = textNote.Category != null ? textNote.Category.Id : ElementId.InvalidElementId;
IFCLabel identifierOpt = IFCLabel.Create("Annotation");
IFCLabel repTypeOpt = IFCLabel.Create("Annotation2D"); // this is by IFC2x3 convention, not temporary
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateShapeRepresentation(exporterIFC, catId, exporterIFC.Get2DContextHandle(), identifierOpt, repTypeOpt, bodyItems);
if (!bodyRepHnd.HasValue)
throw new Exception("Failed to create shape representation.");
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle prodShapeHnd = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), shapeReps);
IFCAnyHandle annoHnd = file.CreateAnnotation(IFCLabel.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
IFCLabel.Create(), IFCLabel.Create(), IFCLabel.Create(), setter.GetPlacement(), prodShapeHnd);
productWrapper.AddAnnotation(annoHnd, setter.GetLevelInfo(), true);
}
tr.Commit();
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, IFCProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.CreateIFCElementId(element);
Toolkit.IFCFootingType footingType = GetIFCFootingType(element, ifcEnumType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceElemId, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(footing, setter, ecData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
}
}
/// <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 IFCProductWrapper.
/// </param>
public static void ExportBase(ExporterIFC exporterIFC, ICollection <ElementId> allSubElements,
Element element, IFCProductWrapper wrapper)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCPlacementSetter setter = null;
using (IFCProductWrapper curtainWallSubWrapper = IFCProductWrapper.Create(wrapper, false))
{
try
{
IFCAnyHandle localPlacement = null;
bool canExportCurtainWallAsContainer = CanExportCurtainWallAsContainer(allSubElements, element.Document);
IFCAnyHandle rep = null;
if (!canExportCurtainWallAsContainer)
{
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
{
return;
}
}
else
{
ExportCurtainObjectCommonAsContainer(allSubElements, element, exporterIFC, curtainWallSubWrapper);
// This has to go LAST. Why? Because otherwise we apply the level transform twice -- once in the familyTrf, once here.
// This will be used just to put the CurtainWall on the right level.
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
}
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
{
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = ExporterIFCUtils.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, exporterIFC.GetName());
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemId = NamingUtil.CreateIFCElementId(element);
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement, prodRepHnd, elemId);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
elemHnd = IFCInstanceExporter.CreateRoof(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement,
prodRepHnd, elemId, RoofExporter.GetIFCRoofType(ifcEnumType));
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(elemHnd, setter, null, true);
ExporterIFCUtils.CreateCurtainWallPropertySet(exporterIFC, element, wrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, wrapper);
ICollection <IFCAnyHandle> relatedElementIds = curtainWallSubWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateSubElementGUID(element, (int)IFCCurtainWallSubElements.RelAggregates);
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(file, guid, ownerHistory, null, null, elemHnd, relatedElementIdSet);
}
exporterIFC.RegisterSpaceBoundingElementHandle(elemHnd, element.Id, ElementId.InvalidElementId);
}
}
finally
{
if (setter != null)
{
setter.Dispose();
}
}
}
}
/// <summary>
/// Exports a floor to IFC slab.
/// </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 IFCProductWrapper.
/// </param>
/// <param name="exportParts">
/// Whether to export parts or not.
/// </param>
/// <returns>
/// True if the floor is exported successfully, false otherwise.
/// </returns>
public static void ExportFloor(ExporterIFC exporterIFC, Element floorElement, GeometryElement geometryElement, string ifcEnumType,
IFCProductWrapper productWrapper, bool exportParts)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool exportedAsInternalExtrusion = false;
double scale = exporterIFC.LinearScale;
ElementId catId = CategoryUtil.GetSafeCategoryId(floorElement);
IList <IFCAnyHandle> reps = new List <IFCAnyHandle>();
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)
{
// 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.
//
if (floorElement is Floor)
{
Floor floor = floorElement as Floor;
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
IList <Solid> splitVolumes = SolidUtils.SplitVolumes(solids[0]);
if (splitVolumes.Count == 1)
{
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 = floor.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, floor,
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);
reps.Add(prodRep);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (reps.Count == 0)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out reps,
out extrusionLoops, out loopExtraParams, floorPlane);
}
if (reps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateBRepProductDefinitionShape(floorElement.Document.Application, exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
reps.Add(prodDefHnd);
}
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = ExporterIFCUtils.CreateGUID(floorElement);
int numReps = exportParts ? 1 : reps.Count;
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.CreateIFCName(exporterIFC, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcElemId = NamingUtil.CreateIFCElementId(floorElement);
string currentGUID = (ii == 0) ? ifcGUID : ExporterIFCUtils.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCSlabType slabType = GetIFCSlabType(ifcEnumType);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : reps[ii], ifcElemId, slabType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
}
bool associateElementToLevel = LevelUtil.AssociateElementToLevel(floorElement);
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(slabHnds[ii], placementSetter, loopExtraParam, associateElementToLevel);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, floorElement, productWrapper);
}
if (!exportParts)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement as HostObject, slabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3);
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports a footing to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="footing">
/// The footing element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFootingElement(ExporterIFC exporterIFC,
ContFooting footing, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
String ifcEnumType = "STRIP_FOOTING";
ExportFooting(exporterIFC, footing, geometryElement, ifcEnumType, productWrapper);
}
/// <summary>
/// Exports a floor to IFC slab.
/// </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 IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, HostObject floor, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, floor);
// export parts or not
bool exportParts = PartExporter.CanExportParts(floor);
if (exportParts && !PartExporter.CanExportElementInPartExport(floor, floor.Level.Id, false))
{
return;
}
ExportFloor(exporterIFC, floor, geometryElement, ifcEnumType, productWrapper, exportParts);
}
/// <summary>
/// Exports a curtain system to IFC curtain system.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="hostElement">
/// The curtain system element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportCurtainSystem(ExporterIFC exporterIFC, CurtainSystem curtainSystem, IFCProductWrapper productWrapper)
{
CurtainGridSet grids = curtainSystem.CurtainGrids;
if (grids == null || grids.Size == 0)
{
return;
}
ICollection <ElementId> allSubElements = new HashSet <ElementId>();
foreach (CurtainGrid grid in grids)
{
foreach (ElementId panelId in grid.GetPanelIds())
{
allSubElements.Add(panelId);
}
foreach (ElementId subElem in grid.GetMullionIds())
{
allSubElements.Add(subElem);
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
ExportBase(exporterIFC, allSubElements, curtainSystem, productWrapper);
transaction.Commit();
}
}
/// <summary>
/// Exports materials for host object.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="hostObject">
/// The host object.
/// </param>
/// <param name="elemHnd">
/// The host IFC handle.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
/// <param name="levelId">
/// The level id.
/// </param>
/// <param name="direction">
/// The IFCLayerSetDirection.
/// </param>
/// <returns>
/// True if exported successfully, false otherwise.
/// </returns>
public static bool ExportHostObjectMaterials(ExporterIFC exporterIFC, HostObject hostObject,
IFCAnyHandle elemHnd, GeometryElement geometryElement, IFCProductWrapper productWrapper,
ElementId levelId, Toolkit.IFCLayerSetDirection direction)
{
IList <IFCAnyHandle> elemHnds = new List <IFCAnyHandle>();
elemHnds.Add(elemHnd);
return(ExportHostObjectMaterials(exporterIFC, hostObject, elemHnds, geometryElement, productWrapper, levelId, direction));
}
/// <summary>
/// Base implementation to export IFC site object.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="document">
/// The Revit document.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCAnyHandle siteHandle = exporterIFC.GetSite();
int numSiteElements = (!IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle) ? 1 : 0);
if (element == null && (numSiteElements != 0))
return;
Document doc = document;
if (doc == null)
{
if (element != null)
doc = element.Document;
else
throw new ArgumentException("Both document and element are null.");
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle siteRepresentation = null;
if (element != null)
{
// It would be possible that they actually represent several different sites with different buildings,
// but until we have a concept of a building in Revit, we have to assume 0-1 sites, 1 building.
bool appendedToSite = false;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle))
{
IList<IFCAnyHandle> representations = IFCAnyHandleUtil.GetProductRepresentations(siteHandle);
if (representations.Count > 0)
{
IFCAnyHandle bodyRep = representations[0];
IFCAnyHandle boundaryRep = null;
if (representations.Count > 1)
boundaryRep = representations[1];
siteRepresentation = RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC, element, geometryElement, true, true, ref bodyRep, ref boundaryRep);
appendedToSite = true;
}
}
if (!appendedToSite)
{
siteRepresentation = RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC, element, geometryElement, true, true);
}
}
List<int> latitude = new List<int>();
List<int> longitude = new List<int>();
ProjectLocation projLocation = doc.ActiveProjectLocation;
IFCAnyHandle relativePlacement = null;
double elevation = 0.0;
if (projLocation != null)
{
double latitudeInDeg = projLocation.SiteLocation.Latitude * 180 / Math.PI;
double longitudeInDeg = projLocation.SiteLocation.Longitude * 180 / Math.PI;
int latDeg = ((int)latitudeInDeg); latitudeInDeg -= latDeg; latitudeInDeg *= 60;
int latMin = ((int)latitudeInDeg); latitudeInDeg -= latMin; latitudeInDeg *= 60;
int latSec = ((int)latitudeInDeg); latitudeInDeg -= latSec; latitudeInDeg *= 1000000;
int latFracSec = ((int)latitudeInDeg);
latitude.Add(latDeg);
latitude.Add(latMin);
latitude.Add(latSec);
if (!exporterIFC.ExportAs2x2)
latitude.Add(latFracSec);
int longDeg = ((int)longitudeInDeg); longitudeInDeg -= longDeg; longitudeInDeg *= 60;
int longMin = ((int)longitudeInDeg); longitudeInDeg -= longMin; longitudeInDeg *= 60;
int longSec = ((int)longitudeInDeg); longitudeInDeg -= longSec; longitudeInDeg *= 1000000;
int longFracSec = ((int)longitudeInDeg);
longitude.Add(longDeg);
longitude.Add(longMin);
longitude.Add(longSec);
if (!exporterIFC.ExportAs2x2)
longitude.Add(longFracSec);
Transform siteSharedCoordinatesTrf = projLocation.GetTransform().Inverse;
if (!siteSharedCoordinatesTrf.IsIdentity)
{
XYZ orig = siteSharedCoordinatesTrf.Origin;
orig = orig.Multiply(exporterIFC.LinearScale);
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, orig, siteSharedCoordinatesTrf.BasisZ, siteSharedCoordinatesTrf.BasisX);
}
}
// Get elevation for site.
elevation = -LevelUtil.GetReferenceHeightForRelativeElevation(doc) * exporterIFC.LinearScale;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle localPlacement = IFCInstanceExporter.CreateLocalPlacement(file, null, relativePlacement);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
if (element != null)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle))
{
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
siteHandle = IFCInstanceExporter.CreateSite(file, instanceGUID, ownerHistory, instanceName, instanceDescription, instanceObjectType, localPlacement,
siteRepresentation, null, Toolkit.IFCElementComposition.Element, latitude, longitude, elevation, null, null);
}
}
else
{
// don't bother if we have nothing in the site whatsoever.
if ((latitude.Count == 0 || longitude.Count == 0) && IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
return;
string defaultSiteName = "Default";
siteHandle = IFCInstanceExporter.CreateSite(file, ExporterIFCUtils.CreateProjectLevelGUID(doc, IFCProjectLevelGUIDType.Site), ownerHistory, defaultSiteName, null, objectType, localPlacement,
null, null, Toolkit.IFCElementComposition.Element, latitude, longitude, elevation, null, null);
}
productWrapper.AddSite(siteHandle);
exporterIFC.SetSite(siteHandle);
tr.Commit();
}
}
/// <summary>
/// Exports a staircase to IfcStair.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The stairs element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
if (element is Stairs)
{
Stairs stair = element as Stairs;
int numFlights = stair.NumberOfStories;
if (numFlights > 0)
{
ExportStairsAsContainer(exporterIFC, ifcEnumType, stair, geometryElement, numFlights, productWrapper);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productWrapper.GetAnElement()))
ExportStairAsSingleGeometry(exporterIFC, ifcEnumType, element, geometryElement, numFlights, productWrapper);
}
}
else if (IsLegacyStairs(element))
{
ExportLegacyStairOrRampAsContainer(exporterIFC, ifcEnumType, element, geometryElement, true, productWrapper);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productWrapper.GetAnElement()))
{
double defaultHeight = GetDefaultHeightForLegacyStair(exporterIFC.LinearScale);
int numFlights = GetNumFlightsForLegacyStair(exporterIFC, element, defaultHeight);
if (numFlights > 0)
ExportStairAsSingleGeometry(exporterIFC, ifcEnumType, element, geometryElement, numFlights, productWrapper);
}
}
else
{
ExportStairAsSingleGeometry(exporterIFC, ifcEnumType, element, geometryElement, 1, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
tr.Commit();
}
}
/// <summary>
/// Exports an element as an annotation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="filledRegion">The filled region element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, FilledRegion filledRegion,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (filledRegion == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IList <CurveLoop> boundaries = filledRegion.GetBoundaries();
if (boundaries.Count == 0)
{
return;
}
Plane plane = null;
try
{
plane = boundaries[0].GetPlane();
}
catch
{
return;
}
Transform orientTrf = Transform.Identity;
orientTrf.BasisX = plane.XVec; orientTrf.BasisY = plane.YVec; orientTrf.BasisZ = plane.Normal;
orientTrf.Origin = plane.Origin;
XYZ projectionDirection = plane.Normal;
IList <IList <CurveLoop> > sortedLoops = ExporterIFCUtils.SortCurveLoops(boundaries);
if (sortedLoops.Count == 0)
{
return;
}
FilledRegionType filledRegionType = filledRegion.Document.GetElement(filledRegion.GetTypeId()) as FilledRegionType;
Color color = filledRegionType != null ? filledRegionType.Color : new Color(0, 0, 0);
ElementId fillPatternId = filledRegionType != null ? filledRegionType.FillPatternId : ElementId.InvalidElementId;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(filledRegion);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, filledRegion, null, orientTrf, ElementId.InvalidElementId))
{
foreach (IList <CurveLoop> curveLoopList in sortedLoops)
{
IFCAnyHandle outerCurve = null;
HashSet <IFCAnyHandle> innerCurves = null;
for (int ii = 0; ii < curveLoopList.Count; ii++)
{
IFCAnyHandle ifcCurve = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, curveLoopList[ii], plane, projectionDirection);
if (ii == 0)
{
outerCurve = ifcCurve;
}
else
{
if (innerCurves == null)
{
innerCurves = new HashSet <IFCAnyHandle>();
}
innerCurves.Add(ifcCurve);
}
}
IFCAnyHandle representItem = IFCInstanceExporter.CreateAnnotationFillArea(file, outerCurve, innerCurves);
file.CreateStyle(exporterIFC, representItem, color, fillPatternId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(representItem);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, filledRegion, categoryId,
exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle productShape = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, setter.GetPlacement(), productShape);
productWrapper.AddAnnotation(annotation, setter.GetLevelInfo(), true);
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports the top stories of a multistory staircase.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="stair">The stairs element.</param>
/// <param name="numFlights">The number of flights for a multistory staircase.</param>
/// <param name="stairHnd">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="materialIds">The materialIds.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportMultistoryStair(ExporterIFC exporterIFC, Element stair, int numFlights,
IFCAnyHandle stairHnd, IList<IFCAnyHandle> components, IList<IFCExtrusionCreationData> componentECData,
HashSet<ElementId> materialIds, IFCPlacementSetter placementSetter, IFCProductWrapper productWrapper)
{
if (numFlights < 2)
return;
double heightNonScaled = GetStairsHeight(exporterIFC, stair);
if (heightNonScaled < MathUtil.Eps())
return;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(stairHnd))
return;
IFCAnyHandle localPlacement = IFCAnyHandleUtil.GetInstanceAttribute(stairHnd, "ObjectPlacement");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(localPlacement))
return;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList<double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
double scale = exporterIFC.LinearScale;
ICollection<ElementId> runIds = null;
ICollection<ElementId> landingIds = null;
ICollection<ElementId> supportIds = null;
if (stair is Stairs)
{
Stairs stairAsStairs = stair as Stairs;
runIds = stairAsStairs.GetStairsRuns();
landingIds = stairAsStairs.GetStairsLandings();
supportIds = stairAsStairs.GetStairsSupports();
}
IList<IFCAnyHandle> stairLocalPlacementHnds = new List<IFCAnyHandle>();
IList<IFCLevelInfo> levelInfos = new List<IFCLevelInfo>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
double newOffsetScaled = 0.0;
IFCAnyHandle newLevelHnd = null;
levelInfos.Add(
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * (ii + 1), scale, out newLevelHnd, out newOffsetScaled));
if (levelInfos[ii] == null)
levelInfos[ii] = placementSetter.GetLevelInfo();
XYZ orig;
if (ptHnd.HasValue)
{
orig = new XYZ(origCoords[0], origCoords[1], newOffsetScaled);
}
else
{
orig = new XYZ(0.0, 0.0, newOffsetScaled);
}
IFCAnyHandle relativePlacementHnd = ExporterUtil.CreateAxis2Placement3D(file, orig);
stairLocalPlacementHnds.Add(IFCInstanceExporter.CreateLocalPlacement(file, newLevelHnd, relativePlacementHnd));
}
IList<List<IFCAnyHandle>> newComponents = new List<List<IFCAnyHandle>>();
for (int ii = 0; ii < numFlights - 1; ii++)
newComponents.Add(new List<IFCAnyHandle>());
int compIdx = 0;
IEnumerator<ElementId> runIter = null;
if (runIds != null)
{
runIter = runIds.GetEnumerator();
runIter.MoveNext();
}
IEnumerator<ElementId> landingIter = null;
if (landingIds != null)
{
landingIter = landingIds.GetEnumerator();
landingIter.MoveNext();
}
IEnumerator<ElementId> supportIter = null;
if (supportIds != null)
{
supportIter = supportIds.GetEnumerator();
supportIter.MoveNext();
}
foreach (IFCAnyHandle component in components)
{
string componentName = IFCAnyHandleUtil.GetStringAttribute(component, "Name");
string componentDescription = IFCAnyHandleUtil.GetStringAttribute(component, "Description");
string componentObjectType = IFCAnyHandleUtil.GetStringAttribute(component, "ObjectType");
string componentElementTag = IFCAnyHandleUtil.GetStringAttribute(component, "Tag");
IFCAnyHandle componentProdRep = IFCAnyHandleUtil.GetInstanceAttribute(component, "Representation");
IList<string> localComponentNames = new List<string>();
IList<IFCAnyHandle> componentPlacementHnds = new List<IFCAnyHandle>();
IFCAnyHandle localLocalPlacement = IFCAnyHandleUtil.GetInstanceAttribute(component, "ObjectPlacement");
IFCAnyHandle localRelativePlacement =
(localLocalPlacement == null) ? null : IFCAnyHandleUtil.GetInstanceAttribute(localLocalPlacement, "RelativePlacement");
bool isSubStair = component.IsSubTypeOf(IFCEntityType.IfcStair.ToString());
for (int ii = 0; ii < numFlights - 1; ii++)
{
localComponentNames.Add((componentName == null) ? (ii + 2).ToString() : (componentName + ":" + (ii + 2)));
if (isSubStair)
componentPlacementHnds.Add(ExporterUtil.CopyLocalPlacement(file, stairLocalPlacementHnds[ii]));
else
componentPlacementHnds.Add(IFCInstanceExporter.CreateLocalPlacement(file, stairLocalPlacementHnds[ii], localRelativePlacement));
}
IList<IFCAnyHandle> localComponentHnds = new List<IFCAnyHandle>();
if (isSubStair)
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "ShapeType");
IFCStairType localStairType = GetIFCStairType(componentType);
ElementId catId = CategoryUtil.GetSafeCategoryId(stair);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, stair, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateStair(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localStairType));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcStairFlight))
{
Element runElem = (runIter == null) ? stair : stair.Document.GetElement(runIter.Current);
Element runElemToUse = (runElem == null) ? stair : runElem;
ElementId catId = CategoryUtil.GetSafeCategoryId(runElemToUse);
int? numberOfRiser = IFCAnyHandleUtil.GetIntAttribute(component, "NumberOfRiser");
int? numberOfTreads = IFCAnyHandleUtil.GetIntAttribute(component, "NumberOfTreads");
double? riserHeight = IFCAnyHandleUtil.GetDoubleAttribute(component, "RiserHeight");
double? treadLength = IFCAnyHandleUtil.GetDoubleAttribute(component, "TreadLength");
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, runElemToUse, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateStairFlight(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, numberOfRiser, numberOfTreads, riserHeight, treadLength));
}
runIter.MoveNext();
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcSlab))
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "PredefinedType");
IFCSlabType localLandingType = FloorExporter.GetIFCSlabType(componentType);
Element landingElem = (landingIter == null) ? stair : stair.Document.GetElement(landingIter.Current);
Element landingElemToUse = (landingElem == null) ? stair : landingElem;
ElementId catId = CategoryUtil.GetSafeCategoryId(landingElemToUse);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, landingElemToUse, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateSlab(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localLandingType));
}
landingIter.MoveNext();
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcMember))
{
Element supportElem = (supportIter == null) ? stair : stair.Document.GetElement(supportIter.Current);
Element supportElemToUse = (supportElem == null) ? stair : supportElem;
ElementId catId = CategoryUtil.GetSafeCategoryId(supportElemToUse);
IFCAnyHandle memberType = (supportElemToUse != stair) ? GetMemberTypeHandle(exporterIFC, supportElemToUse) : null;
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, supportElemToUse, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateMember(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag));
if (memberType != null)
ExporterCacheManager.TypeRelationsCache.Add(memberType, localComponentHnds[ii]);
}
supportIter.MoveNext();
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
if (localComponentHnds[ii] != null)
{
newComponents[ii].Add(localComponentHnds[ii]);
productWrapper.AddElement(localComponentHnds[ii], levelInfos[ii], componentECData[compIdx], false);
}
}
compIdx++;
}
// finally add a copy of the container.
IList<IFCAnyHandle> stairCopyHnds = new List<IFCAnyHandle>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
string stairName = IFCAnyHandleUtil.GetStringAttribute(stairHnd, "Name");
string stairObjectType = IFCAnyHandleUtil.GetStringAttribute(stairHnd, "ObjectType");
string stairDescription = IFCAnyHandleUtil.GetStringAttribute(stairHnd, "Description");
string stairElementTag = IFCAnyHandleUtil.GetStringAttribute(stairHnd, "Tag");
string stairTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(stairHnd, "ShapeType");
IFCStairType stairType = GetIFCStairType(stairTypeAsString);
string containerStairName = stairName + ":" + (ii + 2);
stairCopyHnds.Add(IFCInstanceExporter.CreateStair(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
containerStairName, stairDescription, stairObjectType, stairLocalPlacementHnds[ii], null, stairElementTag, stairType));
productWrapper.AddElement(stairCopyHnds[ii], levelInfos[ii], null, LevelUtil.AssociateElementToLevel(stair));
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(stairCopyHnds[ii], newComponents[ii],
stairLocalPlacementHnds[ii]);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(stair.Id, stairRampInfo);
CategoryUtil.CreateMaterialAssociations(stair.Document, exporterIFC, stairCopyHnds[ii], materialIds);
}
}
/// <summary>
/// Exports a ramp to IfcRamp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
if (!(element is FamilyInstance))
{
StairsExporter.ExportLegacyStairOrRampAsContainer(exporterIFC, ifcEnumType, element, geometryElement, true, productWrapper);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productWrapper.GetAnElement()))
{
int numFlights = GetNumFlightsForRamp(exporterIFC, element);
if (numFlights > 0)
{
ExportRamp(exporterIFC, ifcEnumType, element, geometryElement, numFlights, productWrapper);
}
}
else
{
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
else
{
ExportRamp(exporterIFC, ifcEnumType, element, geometryElement, 1, productWrapper);
}
tr.Commit();
}
}
/// <summary>
/// Exports a staircase to IfcStair, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The stairs type.</param>
/// <param name="stair">The stairs element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory staircase.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportStairAsSingleGeometry(ExporterIFC exporterIFC, string ifcEnumType, Element stair, GeometryElement geometryElement,
int numFlights, IFCProductWrapper productWrapper)
{
if (stair == null || geometryElement == null)
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, stair))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ecData.ReuseLocalPlacement = false;
GeometryElement stairsGeom = GeometryUtil.GetOneLevelGeometryElement(geometryElement);
BodyData bodyData;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(stair);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(stair.Document.Application, exporterIFC,
stair, categoryId, stairsGeom, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedStairGuid = ExporterIFCUtils.CreateSubElementGUID(stair, (int)IFCStairSubElements.ContainedStair);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origStairName = exporterIFC.GetName();
string stairName = NamingUtil.GetNameOverride(stair, origStairName);
string stairDescription = NamingUtil.GetDescriptionOverride(stair, null);
string stairObjectType = NamingUtil.GetObjectTypeOverride(stair, NamingUtil.CreateIFCObjectName(exporterIFC, stair));
IFCAnyHandle containedStairLocalPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(stair);
IFCStairType stairType = GetIFCStairType(ifcEnumType);
List<IFCAnyHandle> components = new List<IFCAnyHandle>();
IList<IFCExtrusionCreationData> componentExtrusionData = new List<IFCExtrusionCreationData>();
IFCAnyHandle containedStairHnd = IFCInstanceExporter.CreateStair(file, containedStairGuid, ownerHistory, stairName,
stairDescription, stairObjectType, containedStairLocalPlacement, representation, elementTag, stairType);
components.Add(containedStairHnd);
componentExtrusionData.Add(ecData);
//productWrapper.AddElement(containedStairHnd, placementSetter.GetLevelInfo(), ecData, false);
string guid = ExporterIFCUtils.CreateGUID(stair);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle stairHnd = IFCInstanceExporter.CreateStair(file, guid, ownerHistory, stairName,
stairDescription, stairObjectType, localPlacement, null, elementTag, stairType);
productWrapper.AddElement(stairHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(stair));
IFCAnyHandle emptyPlacement = null;
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(stairHnd, components, emptyPlacement);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(stair.Id, stairRampInfo);
ExportMultistoryStair(exporterIFC, stair, numFlights, stairHnd, components, componentExtrusionData,
bodyData.MaterialIds, placementSetter, productWrapper);
}
tr.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="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacementToUse = setter.GetPlacement();
IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData();
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IFCSolidMeshGeometryInfo solidMeshInfo = ExporterIFCUtils.GetSolidMeshGeometry(exporterIFC, geometryElement, Transform.Identity);
IList<Solid> solids = solidMeshInfo.GetSolids();
IList<Mesh> polyMeshes = solidMeshInfo.GetMeshes();
bool tryToExportAsExtrusion = true;
if (solids.Count != 1 || polyMeshes.Count != 0)
tryToExportAsExtrusion = false;
IFCAnyHandle shapeRep = BodyExporter.ExportBody(element.Document.Application, exporterIFC, catId, solids, polyMeshes, tryToExportAsExtrusion, extraParams);
if (!shapeRep.HasValue)
return;
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle productRepresentation = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), shapeReps);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.get_Element(typeId) as ElementType;
IFCTypeInfo currentTypeInfo = exporterIFC.FindType(typeId, false);
bool found = currentTypeInfo.IsValid();
if (!found)
{
IFCLabel typeGUID = IFCLabel.CreateGUID(type);
IFCLabel origTypeName = NamingUtil.CreateIFCName(exporterIFC, -1);
IFCLabel typeName = NamingUtil.GetNameOverride(type, origTypeName);
IFCLabel typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
IFCLabel applicableOccurance = NamingUtil.GetObjectTypeOverride(type, typeObjectType);
IFCLabel typeDescription = NamingUtil.GetDescriptionOverride(type, IFCLabel.Create());
IFCLabel typeElemId = NamingUtil.CreateIFCElementId(type);
HashSet<IFCAnyHandle> propertySetsOpt = new HashSet<IFCAnyHandle>();
IList<IFCAnyHandle> repMapListOpt = new List<IFCAnyHandle>();
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(file, exportType, ifcEnumType, typeGUID, ownerHistory, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMapListOpt, typeElemId, typeName, element, type);
if (styleHandle.HasValue)
{
currentTypeInfo.SetStyle(styleHandle);
exporterIFC.AddType(typeId, false, currentTypeInfo);
}
}
IFCLabel instanceGUID = IFCLabel.CreateGUID(element);
IFCLabel origInstanceName = NamingUtil.CreateIFCName(exporterIFC, -1);
IFCLabel instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
IFCLabel objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCLabel instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
IFCLabel instanceDescription = NamingUtil.GetDescriptionOverride(element, IFCLabel.Create());
IFCLabel instanceElemId = NamingUtil.CreateIFCElementId(element);
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = IFCAnyHandle.Create();
if (FamilyExporterUtil.IsFurnishingElementSubType(exportType))
{
instanceHandle = file.CreateFurnishingElement(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsDistributionFlowElementSubType(exportType))
{
instanceHandle = file.CreateDistributionFlowElement(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsEnergyConversionDeviceSubType(exportType))
{
instanceHandle = file.CreateEnergyConversionDevice(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowFittingSubType(exportType))
{
instanceHandle = file.CreateFlowFitting(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowMovingDeviceSubType(exportType))
{
instanceHandle = file.CreateFlowMovingDevice(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowSegmentSubType(exportType))
{
instanceHandle = file.CreateFlowSegment(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowStorageDeviceSubType(exportType))
{
instanceHandle = file.CreateFlowStorageDevice(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTerminalSubType(exportType))
{
instanceHandle = file.CreateFlowTerminal(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTreatmentDeviceSubType(exportType))
{
instanceHandle = file.CreateFlowTreatmentDevice(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowControllerSubType(exportType))
{
instanceHandle = file.CreateFlowController(instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
if (!instanceHandle.HasValue)
return;
if (roomId != ElementId.InvalidElementId)
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
productWrapper.AddElement(instanceHandle, setter, extraParams, false);
}
else
{
productWrapper.AddElement(instanceHandle, setter, extraParams, true);
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, exporterIFC, localPlacementToUse, setter, productWrapper);
if (currentTypeInfo.IsValid())
exporterIFC.AddTypeRelation(currentTypeInfo.GetStyle(), instanceHandle);
ExporterIFCUtils.CreateGenericElementPropertySet(exporterIFC, element, productWrapper);
tr.Commit();
}
}
}
/// <summary>
/// Exports a staircase to IfcStair, composing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The stairs type.</param>
/// <param name="stair">The stairs element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory staircase.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportStairsAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Stairs stair, GeometryElement geometryElement,
int numFlights, IFCProductWrapper productWrapper)
{
if (stair == null || geometryElement == null)
return;
Document doc = stair.Document;
Autodesk.Revit.ApplicationServices.Application app = doc.Application;
IFCFile file = exporterIFC.GetFile();
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(stair);
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, stair))
{
HashSet<ElementId> materialIds = new HashSet<ElementId>();
List<IFCAnyHandle> componentHandles = new List<IFCAnyHandle>();
IList<IFCExtrusionCreationData> componentExtrusionData = new List<IFCExtrusionCreationData>();
IFCAnyHandle contextOfItemsFootPrint = exporterIFC.Get3DContextHandle("FootPrint");
Transform trf = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, placementSetter.GetPlacement());
Plane boundaryPlane = new Plane(trf.BasisX, trf.BasisY, trf.Origin);
XYZ boundaryProjDir = trf.BasisZ;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string stairGUID = ExporterIFCUtils.CreateGUID(stair);
string origStairName = exporterIFC.GetName();
string stairName = NamingUtil.GetNameOverride(stair, origStairName);
string stairDescription = NamingUtil.GetDescriptionOverride(stair, null);
string stairObjectType = NamingUtil.GetObjectTypeOverride(stair, NamingUtil.CreateIFCObjectName(exporterIFC, stair));
IFCAnyHandle stairLocalPlacement = placementSetter.GetPlacement();
string stairElementTag = NamingUtil.CreateIFCElementId(stair);
IFCStairType stairType = GetIFCStairType(ifcEnumType);
IFCAnyHandle stairContainerHnd = IFCInstanceExporter.CreateStair(file, stairGUID, ownerHistory, stairName,
stairDescription, stairObjectType, stairLocalPlacement, null, stairElementTag, stairType);
productWrapper.AddElement(stairContainerHnd, placementSetter.GetLevelInfo(), null, LevelUtil.AssociateElementToLevel(stair));
// Get List of runs to export their geometry.
ICollection<ElementId> runIds = stair.GetStairsRuns();
int index = 0;
foreach (ElementId runId in runIds)
{
index++;
StairsRun run = doc.GetElement(runId) as StairsRun;
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.AllowVerticalOffsetOfBReps = false;
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ecData.ReuseLocalPlacement = false;
GeometryElement runGeometryElement = run.get_Geometry(geomOptions);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
BodyData bodyData = BodyExporter.ExportBody(app, exporterIFC, run, categoryId, runGeometryElement,
bodyExporterOptions, ecData);
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
ecData.ClearOpenings();
continue;
}
foreach (ElementId materialId in bodyData.MaterialIds)
materialIds.Add(materialId);
IList<IFCAnyHandle> reps = new List<IFCAnyHandle>();
reps.Add(bodyRep);
Transform runBoundaryTrf = trf.Multiply(bodyData.BrepOffsetTransform);
Plane runBoundaryPlane = new Plane(runBoundaryTrf.BasisX, runBoundaryTrf.BasisY, runBoundaryTrf.Origin);
XYZ runBoundaryProjDir = runBoundaryTrf.BasisZ;
CurveLoop boundary = run.GetFootprintBoundary();
IFCAnyHandle boundaryHnd = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, boundary,
runBoundaryPlane, runBoundaryProjDir);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(boundaryHnd))
{
HashSet<IFCAnyHandle> geomSelectSet = new HashSet<IFCAnyHandle>();
geomSelectSet.Add(boundaryHnd);
HashSet<IFCAnyHandle> boundaryItems = new HashSet<IFCAnyHandle>();
boundaryItems.Add(IFCInstanceExporter.CreateGeometricSet(file, geomSelectSet));
IFCAnyHandle boundaryRep = RepresentationUtil.CreateGeometricSetRep(exporterIFC, run, categoryId, "FootPrint",
contextOfItemsFootPrint, boundaryItems);
reps.Add(boundaryRep);
}
CurveLoop walkingLine = run.GetStairsPath();
IFCAnyHandle walkingLineHnd = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, walkingLine,
runBoundaryPlane, runBoundaryProjDir);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(walkingLineHnd))
{
HashSet<IFCAnyHandle> geomSelectSet = new HashSet<IFCAnyHandle>();
geomSelectSet.Add(walkingLineHnd);
HashSet<IFCAnyHandle> walkingLineItems = new HashSet<IFCAnyHandle>();
walkingLineItems.Add(IFCInstanceExporter.CreateGeometricSet(file, geomSelectSet));
IFCAnyHandle walkingLineRep = RepresentationUtil.CreateGeometricSetRep(exporterIFC, run, categoryId, "Axis",
contextOfItemsFootPrint, walkingLineItems);
reps.Add(walkingLineRep);
}
IFCAnyHandle representation = IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null, null, reps);
string runGUID = ExporterIFCUtils.CreateGUID(run);
string origRunName = origStairName + " Run " + index;
string runName = NamingUtil.GetNameOverride(run, origRunName);
string runDescription = NamingUtil.GetDescriptionOverride(run, stairDescription);
string runObjectType = NamingUtil.GetObjectTypeOverride(run, stairObjectType);
IFCAnyHandle runLocalPlacement = ecData.GetLocalPlacement();
string runElementTag = NamingUtil.CreateIFCElementId(run);
IFCAnyHandle stairFlightHnd = IFCInstanceExporter.CreateStairFlight(file, runGUID, ownerHistory,
runName, runDescription, runObjectType, runLocalPlacement, representation, runElementTag,
run.ActualRisersNumber, run.ActualTreadsNumber, stair.ActualRiserHeight, stair.ActualTreadDepth);
componentHandles.Add(stairFlightHnd);
componentExtrusionData.Add(ecData);
productWrapper.AddElement(stairFlightHnd, placementSetter.GetLevelInfo(), ecData, false);
ExporterCacheManager.HandleToElementCache.Register(stairFlightHnd, run.Id);
}
}
// Get List of landings to export their geometry.
ICollection<ElementId> landingIds = stair.GetStairsLandings();
index = 0;
foreach (ElementId landingId in landingIds)
{
index++;
StairsLanding landing = doc.GetElement(landingId) as StairsLanding;
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.AllowVerticalOffsetOfBReps = false;
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ecData.ReuseLocalPlacement = false;
GeometryElement landingGeometryElement = landing.get_Geometry(geomOptions);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
BodyData bodyData = BodyExporter.ExportBody(app, exporterIFC, landing, categoryId, landingGeometryElement,
bodyExporterOptions, ecData);
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
ecData.ClearOpenings();
continue;
}
foreach (ElementId materialId in bodyData.MaterialIds)
materialIds.Add(materialId);
// create Boundary rep.
IList<IFCAnyHandle> reps = new List<IFCAnyHandle>();
reps.Add(bodyRep);
Transform landingBoundaryTrf = trf.Multiply(bodyData.BrepOffsetTransform);
Plane landingBoundaryPlane = new Plane(landingBoundaryTrf.BasisX, landingBoundaryTrf.BasisY, landingBoundaryTrf.Origin);
XYZ landingBoundaryProjDir = landingBoundaryTrf.BasisZ;
CurveLoop boundary = landing.GetFootprintBoundary();
IFCAnyHandle boundaryHnd = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, boundary,
landingBoundaryPlane, landingBoundaryProjDir);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(boundaryHnd))
{
HashSet<IFCAnyHandle> geomSelectSet = new HashSet<IFCAnyHandle>();
geomSelectSet.Add(boundaryHnd);
HashSet<IFCAnyHandle> boundaryItems = new HashSet<IFCAnyHandle>();
boundaryItems.Add(IFCInstanceExporter.CreateGeometricSet(file, geomSelectSet));
IFCAnyHandle boundaryRep = RepresentationUtil.CreateGeometricSetRep(exporterIFC, landing, categoryId, "FootPrint",
contextOfItemsFootPrint, boundaryItems);
reps.Add(boundaryRep);
}
CurveLoop walkingLine = landing.GetStairsPath();
IFCAnyHandle walkingLineHnd = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, walkingLine,
landingBoundaryPlane, landingBoundaryProjDir);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(walkingLineHnd))
{
HashSet<IFCAnyHandle> geomSelectSet = new HashSet<IFCAnyHandle>();
geomSelectSet.Add(walkingLineHnd);
HashSet<IFCAnyHandle> walkingLineItems = new HashSet<IFCAnyHandle>();
walkingLineItems.Add(IFCInstanceExporter.CreateGeometricSet(file, geomSelectSet));
IFCAnyHandle walkingLineRep = RepresentationUtil.CreateGeometricSetRep(exporterIFC, landing, categoryId, "Axis",
contextOfItemsFootPrint, walkingLineItems);
reps.Add(walkingLineRep);
}
string landingGUID = ExporterIFCUtils.CreateGUID(landing);
string origLandingName = origStairName + " Landing " + index;
string landingName = NamingUtil.GetNameOverride(landing, origLandingName);
string landingDescription = NamingUtil.GetDescriptionOverride(landing, stairDescription);
string landingObjectType = NamingUtil.GetObjectTypeOverride(landing, stairObjectType);
IFCAnyHandle landingLocalPlacement = ecData.GetLocalPlacement();
string landingElementTag = NamingUtil.CreateIFCElementId(landing);
IFCAnyHandle representation = IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null, null, reps);
IFCAnyHandle landingHnd = IFCInstanceExporter.CreateSlab(file, landingGUID, ownerHistory,
landingName, landingDescription, landingObjectType, landingLocalPlacement, representation, landingElementTag,
IFCSlabType.Landing);
componentHandles.Add(landingHnd);
componentExtrusionData.Add(ecData);
productWrapper.AddElement(landingHnd, placementSetter.GetLevelInfo(), ecData, false);
ExporterCacheManager.HandleToElementCache.Register(landingHnd, landing.Id);
}
}
// Get List of supports to export their geometry. Supports are not exposed to API, so export as generic Element.
ICollection<ElementId> supportIds = stair.GetStairsSupports();
index = 0;
foreach (ElementId supportId in supportIds)
{
index++;
Element support = doc.GetElement(supportId);
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ecData.ReuseLocalPlacement = false;
GeometryElement supportGeometryElement = support.get_Geometry(geomOptions);
BodyData bodyData;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(app, exporterIFC,
support, categoryId, supportGeometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
continue;
}
foreach (ElementId materialId in bodyData.MaterialIds)
materialIds.Add(materialId);
string supportGUID = ExporterIFCUtils.CreateGUID(support);
string origSupportName = origStairName + " Stringer " + index;
string supportName = NamingUtil.GetNameOverride(support, origSupportName);
string supportDescription = NamingUtil.GetDescriptionOverride(support, stairDescription);
string supportObjectType = NamingUtil.GetObjectTypeOverride(support, stairObjectType);
IFCAnyHandle supportLocalPlacement = ecData.GetLocalPlacement();
string supportElementTag = NamingUtil.CreateIFCElementId(support);
IFCAnyHandle type = GetMemberTypeHandle(exporterIFC, support);
IFCAnyHandle supportHnd = IFCInstanceExporter.CreateMember(file, supportGUID, ownerHistory,
supportName, supportDescription, supportObjectType, supportLocalPlacement, representation, supportElementTag);
componentHandles.Add(supportHnd);
componentExtrusionData.Add(ecData);
productWrapper.AddElement(supportHnd, placementSetter.GetLevelInfo(), ecData, false);
ExporterCacheManager.TypeRelationsCache.Add(type, supportHnd);
}
}
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(stairContainerHnd, componentHandles, null);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(stair.Id, stairRampInfo);
CategoryUtil.CreateMaterialAssociations(stair.Document, exporterIFC, stairContainerHnd, materialIds);
ExportMultistoryStair(exporterIFC, stair, numFlights, stairContainerHnd, componentHandles, componentExtrusionData,
materialIds, placementSetter, productWrapper);
}
tr.Commit();
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
IFCProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, roof))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(roof.Document.Application, exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = ExporterIFCUtils.CreateGUID(roof);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origRoofName = exporterIFC.GetName();
string roofName = NamingUtil.GetNameOverride(roof, origRoofName);
string roofDescription = NamingUtil.GetDescriptionOverride(roof, null);
string roofObjectType = NamingUtil.GetObjectTypeOverride(roof, NamingUtil.CreateIFCObjectName(exporterIFC, roof));
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(roof);
IFCRoofType roofType = GetIFCRoofType(ifcEnumType);
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, roofName, roofDescription,
roofObjectType, localPlacement, exportSlab ? null : representation, elementTag, roofType);
productWrapper.AddElement(roofHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(roof));
if (exportSlab)
{
string slabGUID = ExporterIFCUtils.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = roofName + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, slabName,
roofDescription, roofObjectType, slabLocalPlacementHnd, representation, elementTag, IFCSlabType.Roof);
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, exporterIFC, slabLocalPlacementHnd,
placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(slabHnd, placementSetter.GetLevelInfo(), ecData, false);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a legacy staircase or ramp to IfcStair or IfcRamp, composing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">>The ifc type.</param>
/// <param name="legacyStair">The legacy stairs or ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="useCoarseTessellation">Export using a coarse tessellation if true.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportLegacyStairOrRampAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Element legacyStair, GeometryElement geometryElement,
bool useCoarseTessellation, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
Autodesk.Revit.ApplicationServices.Application app = legacyStair.Document.Application;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(legacyStair);
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, legacyStair))
{
IFCLegacyStairOrRamp legacyStairOrRamp = ExporterIFCUtils.GetLegacyStairOrRampComponents(exporterIFC, legacyStair);
if (legacyStairOrRamp == null)
return;
bool isRamp = legacyStairOrRamp.IsRamp;
using (IFCExtrusionCreationData ifcECData = new IFCExtrusionCreationData())
{
ifcECData.SetLocalPlacement(placementSetter.GetPlacement());
string stairDescription = NamingUtil.GetDescriptionOverride(legacyStair, null);
string stairObjectType = NamingUtil.GetObjectTypeOverride(legacyStair, NamingUtil.CreateIFCObjectName(exporterIFC, legacyStair));
string stairElementTag = NamingUtil.CreateIFCElementId(legacyStair);
double defaultHeight = GetDefaultHeightForLegacyStair(exporterIFC.LinearScale);
double stairHeight = GetStairsHeightForLegacyStair(exporterIFC, legacyStair, defaultHeight);
int numFlights = GetNumFlightsForLegacyStair(exporterIFC, legacyStair, defaultHeight);
List<IFCLevelInfo> localLevelInfoForFlights = new List<IFCLevelInfo>();
List<IFCAnyHandle> localPlacementForFlights = new List<IFCAnyHandle>();
List<List<IFCAnyHandle>> components = new List<List<IFCAnyHandle>>();
components.Add(new List<IFCAnyHandle>());
if (numFlights > 1)
{
XYZ zDir = new XYZ(0.0, 0.0, 1.0);
XYZ xDir = new XYZ(1.0, 0.0, 0.0);
for (int ii = 1; ii < numFlights; ii++)
{
components.Add(new List<IFCAnyHandle>());
double newOffsetScaled = 0.0;
IFCAnyHandle newLevelHnd = null;
localLevelInfoForFlights.Add(
placementSetter.GetOffsetLevelInfoAndHandle(stairHeight * ii, exporterIFC.LinearScale, out newLevelHnd, out newOffsetScaled));
XYZ orig = new XYZ(0.0, 0.0, newOffsetScaled);
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, orig, zDir, xDir);
localPlacementForFlights.Add(IFCInstanceExporter.CreateLocalPlacement(file, newLevelHnd, relativePlacement));
}
}
IList<IFCAnyHandle> walkingLineReps = legacyStairOrRamp.GetWalkingLineRepresentations();
IList<IFCAnyHandle> boundaryReps = legacyStairOrRamp.GetBoundaryRepresentations();
IList<IList<GeometryObject>> geometriesOfRuns = legacyStairOrRamp.GetRunGeometries();
IList<int> numRisers = legacyStairOrRamp.GetNumberOfRisers();
IList<int> numTreads = legacyStairOrRamp.GetNumberOfTreads();
IList<double> treadsLength = legacyStairOrRamp.GetTreadsLength();
double riserHeight = legacyStairOrRamp.RiserHeight;
int runCount = geometriesOfRuns.Count;
for (int ii = 0; ii < runCount; ii++)
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if (useCoarseTessellation)
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
IList<GeometryObject> geometriesOfARun = geometriesOfRuns[ii];
BodyData bodyData = BodyExporter.ExportBody(app, exporterIFC, legacyStair, categoryId, geometriesOfARun,
bodyExporterOptions, null);
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
continue;
}
HashSet<IFCAnyHandle> flightHnds = new HashSet<IFCAnyHandle>();
List<IFCAnyHandle> representations = new List<IFCAnyHandle>();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(walkingLineReps[ii]))
{
representations.Add(walkingLineReps[ii]);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(boundaryReps[ii]))
{
representations.Add(boundaryReps[ii]);
}
representations.Add(bodyRep);
IFCAnyHandle flightRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle flightLocalPlacement = ExporterUtil.CopyLocalPlacement(file, placementSetter.GetPlacement());
IFCAnyHandle flightHnd;
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, ii + 1));
if (isRamp)
{
flightHnd = IFCInstanceExporter.CreateRampFlight(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, flightLocalPlacement, flightRep, stairElementTag);
flightHnds.Add(flightHnd);
productWrapper.AddElement(flightHnd, placementSetter.GetLevelInfo(), null, false);
}
else
{
flightHnd = IFCInstanceExporter.CreateStairFlight(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, flightLocalPlacement, flightRep, stairElementTag, numRisers[ii], numTreads[ii],
riserHeight, treadsLength[ii]);
flightHnds.Add(flightHnd);
productWrapper.AddElement(flightHnd, placementSetter.GetLevelInfo(), null, false);
}
components[0].Add(flightHnd);
for (int compIdx = 1; compIdx < numFlights; compIdx++)
{
if (isRamp)
{
IFCAnyHandle newLocalPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacementForFlights[compIdx - 1]);
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, legacyStair, categoryId, IFCAnyHandleUtil.GetRepresentation(flightHnd));
flightHnd = IFCInstanceExporter.CreateRampFlight(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, newLocalPlacement, newProdRep, stairElementTag);
components[compIdx].Add(flightHnd);
}
else
{
IFCAnyHandle newLocalPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacementForFlights[compIdx - 1]);
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, legacyStair, categoryId, IFCAnyHandleUtil.GetRepresentation(flightHnd));
flightHnd = IFCInstanceExporter.CreateStairFlight(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, newLocalPlacement, newProdRep, stairElementTag,
numRisers[ii], numTreads[ii], riserHeight, treadsLength[ii]);
components[compIdx].Add(flightHnd);
}
productWrapper.AddElement(flightHnd, placementSetter.GetLevelInfo(), null, false);
flightHnds.Add(flightHnd);
}
}
IList<IList<GeometryObject>> geometriesOfLandings = legacyStairOrRamp.GetLandingGeometries();
for (int ii = 0; ii < geometriesOfLandings.Count; ii++)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
IList<GeometryObject> geometriesOfALanding = geometriesOfLandings[ii];
BodyData bodyData = BodyExporter.ExportBody(app, exporterIFC, legacyStair, categoryId, geometriesOfALanding,
bodyExporterOptions, ecData);
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
ecData.ClearOpenings();
continue;
}
List<IFCAnyHandle> representations = new List<IFCAnyHandle>();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(walkingLineReps[ii + runCount]))
{
representations.Add(walkingLineReps[ii + runCount]);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(boundaryReps[ii + runCount]))
{
representations.Add(boundaryReps[ii + runCount]);
}
representations.Add(bodyRep);
IFCAnyHandle shapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle landingLocalPlacement = ExporterUtil.CopyLocalPlacement(file, placementSetter.GetPlacement());
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, ii + 1));
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, landingLocalPlacement, shapeHnd, stairElementTag, IFCSlabType.Landing);
productWrapper.AddElement(slabHnd, placementSetter.GetLevelInfo(), ecData, false);
components[0].Add(slabHnd);
for (int compIdx = 1; compIdx < numFlights; compIdx++)
{
IFCAnyHandle newLocalPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacementForFlights[compIdx - 1]);
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, legacyStair, categoryId, IFCAnyHandleUtil.GetRepresentation(slabHnd));
IFCAnyHandle newSlabHnd = IFCInstanceExporter.CreateSlab(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, newLocalPlacement, newProdRep, stairElementTag, IFCSlabType.Landing);
components[compIdx].Add(newSlabHnd);
productWrapper.AddElement(newSlabHnd, placementSetter.GetLevelInfo(), ecData, false);
}
}
}
IList<GeometryObject> geometriesOfStringer = legacyStairOrRamp.GetStringerGeometries();
for (int ii = 0; ii < geometriesOfStringer.Count; ii++)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
GeometryObject geometryOfStringer = geometriesOfStringer[ii];
BodyData bodyData = BodyExporter.ExportBody(app, exporterIFC, legacyStair, categoryId, geometryOfStringer,
bodyExporterOptions, ecData);
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
ecData.ClearOpenings();
continue;
}
List<IFCAnyHandle> representations = new List<IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle stringerRepHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle stringerLocalPlacement = ExporterUtil.CopyLocalPlacement(file, placementSetter.GetPlacement());
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, ii + 1));
IFCAnyHandle memberHnd = IFCInstanceExporter.CreateMember(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, stringerLocalPlacement, stringerRepHnd, stairElementTag);
productWrapper.AddElement(memberHnd, placementSetter.GetLevelInfo(), ecData, false);
PropertyUtil.CreateBeamColumnMemberBaseQuantities(exporterIFC, memberHnd, null, ecData);
components[0].Add(memberHnd);
for (int compIdx = 1; compIdx < numFlights; compIdx++)
{
IFCAnyHandle newLocalPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacementForFlights[compIdx - 1]);
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, legacyStair, categoryId, IFCAnyHandleUtil.GetRepresentation(memberHnd));
IFCAnyHandle newMemberHnd = IFCInstanceExporter.CreateMember(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, newLocalPlacement, newProdRep, stairElementTag);
components[compIdx].Add(newMemberHnd);
productWrapper.AddElement(newMemberHnd, placementSetter.GetLevelInfo(), ecData, false);
}
}
}
List<IFCAnyHandle> createdStairs = new List<IFCAnyHandle>();
if (isRamp)
{
IFCRampType rampType = RampExporter.GetIFCRampType(ifcEnumType);
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, 0));
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(legacyStair), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, placementSetter.GetPlacement(), null, stairElementTag, rampType);
productWrapper.AddElement(containedRampHnd, placementSetter.GetLevelInfo(), ifcECData, true);
createdStairs.Add(containedRampHnd);
}
else
{
IFCStairType stairType = GetIFCStairType(ifcEnumType);
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, 0));
IFCAnyHandle containedStairHnd = IFCInstanceExporter.CreateStair(file, ExporterIFCUtils.CreateGUID(legacyStair), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, placementSetter.GetPlacement(), null, stairElementTag, stairType);
productWrapper.AddElement(containedStairHnd, placementSetter.GetLevelInfo(), ifcECData, true);
createdStairs.Add(containedStairHnd);
}
// multi-story stairs.
if (numFlights > 1)
{
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList<double> origCoords = null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ptHnd))
origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
for (int ii = 1; ii < numFlights; ii++)
{
IFCLevelInfo levelInfo = localLevelInfoForFlights[ii - 1];
if (levelInfo == null)
levelInfo = placementSetter.GetLevelInfo();
localPlacement = localPlacementForFlights[ii - 1];
// relate to bottom stair or closest level? For code checking, we need closest level, and
// that seems good enough for the general case.
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ptHnd))
{
IFCAnyHandle relPlacement2 = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle newPt = IFCAnyHandleUtil.GetLocation(relPlacement2);
List<double> newCoords = new List<double>();
newCoords.Add(origCoords[0]);
newCoords.Add(origCoords[1]);
newCoords.Add(origCoords[2]);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(newPt))
{
IList<double> addToCoords;
addToCoords = IFCAnyHandleUtil.GetCoordinates(newPt);
newCoords[0] += addToCoords[0];
newCoords[1] += addToCoords[1];
newCoords[2] = addToCoords[2];
}
IFCAnyHandle locPt = ExporterUtil.CreateCartesianPoint(file, newCoords);
IFCAnyHandleUtil.SetAttribute(relPlacement2, "Location", locPt);
}
if (isRamp)
{
IFCRampType rampType = RampExporter.GetIFCRampType(ifcEnumType);
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, 0));
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(legacyStair), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, localPlacement, null, stairElementTag, rampType);
productWrapper.AddElement(containedRampHnd, levelInfo, ifcECData, true);
//createdStairs.Add(containedRampHnd) ???????????????????????
}
else
{
IFCStairType stairType = GetIFCStairType(ifcEnumType);
string stairName = NamingUtil.GetNameOverride(legacyStair, NamingUtil.CreateIFCName(exporterIFC, 0));
IFCAnyHandle containedStairHnd = IFCInstanceExporter.CreateStair(file, ExporterIFCUtils.CreateGUID(legacyStair), exporterIFC.GetOwnerHistoryHandle(),
stairName, stairDescription, stairObjectType, localPlacement, null, stairElementTag, stairType);
productWrapper.AddElement(containedStairHnd, levelInfo, ifcECData, true);
createdStairs.Add(containedStairHnd);
}
}
}
localPlacementForFlights.Insert(0, null);
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(createdStairs, components, localPlacementForFlights);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(legacyStair.Id, stairRampInfo);
}
}
tr.Commit();
}
}
/// <summary>
/// Main implementation to export walls.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="origWrapper">
/// The IFCProductWrapper.
/// </param>
/// <param name="overrideLevelId">
/// The level id.
/// </param>
/// <param name="range">
/// The range to be exported for the element.
/// </param>
/// <returns>
/// The exported wall handle.
/// </returns>
public static IFCAnyHandle ExportWallBase(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
IFCProductWrapper origWrapper, ElementId overrideLevelId, IFCRange range)
{
using (IFCProductWrapper localWrapper = IFCProductWrapper.Create(origWrapper))
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
Wall wallElement = element as Wall;
FamilyInstance famInstWallElem = element as FamilyInstance;
if (wallElement == null && famInstWallElem == null)
return null;
if (wallElement != null && IsWallCompletelyClipped(wallElement, exporterIFC, range))
return null;
// get global values.
Document doc = element.Document;
double scale = exporterIFC.LinearScale;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle contextOfItemsAxis = exporterIFC.Get3DContextHandle("Axis");
IFCAnyHandle contextOfItemsBody = exporterIFC.Get3DContextHandle("Body");
IFCRange zSpan = new IFCRange();
double depth = 0.0;
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
bool exportParts = PartExporter.CanExportParts(wallElement);
if (exportParts && !PartExporter.CanExportElementInPartExport(wallElement, validRange? overrideLevelId : wallElement.Level.Id, validRange))
return null;
// get bounding box height so that we can subtract out pieces properly.
// only for Wall, not FamilyInstance.
if (wallElement != null && geometryElement != null)
{
BoundingBoxXYZ boundingBox = element.get_BoundingBox(null);
if (boundingBox == null)
return null;
zSpan = new IFCRange(boundingBox.Min.Z, boundingBox.Max.Z);
// if we have a top clipping plane, modify depth accordingly.
double bottomHeight = validRange ? Math.Max(zSpan.Start, range.Start) : zSpan.Start;
double topHeight = validRange ? Math.Min(zSpan.End, range.End) : zSpan.End;
depth = topHeight - bottomHeight;
if (MathUtil.IsAlmostZero(depth))
return null;
depth *= scale;
}
IFCAnyHandle axisRep = null;
IFCAnyHandle bodyRep = null;
bool exportingAxis = false;
Curve curve = null;
bool exportedAsWallWithAxis = false;
bool exportedBodyDirectly = false;
bool exportingInplaceOpenings = false;
Curve centerCurve = GetWallAxis(wallElement);
XYZ localXDir = new XYZ(1, 0, 0);
XYZ localYDir = new XYZ(0, 1, 0);
XYZ localZDir = new XYZ(0, 0, 1);
XYZ localOrig = new XYZ(0, 0, 0);
double eps = MathUtil.Eps();
if (centerCurve != null)
{
Curve baseCurve = GetWallAxisAtBaseHeight(wallElement);
curve = GetWallTrimmedCurve(wallElement, baseCurve);
IFCRange curveBounds;
XYZ oldOrig;
GeometryUtil.GetAxisAndRangeFromCurve(curve, out curveBounds, out localXDir, out oldOrig);
localOrig = oldOrig;
if (baseCurve != null)
{
if (!validRange || (MathUtil.IsAlmostEqual(range.Start, zSpan.Start)))
{
XYZ newOrig = baseCurve.Evaluate(curveBounds.Start, false);
if (!validRange && (zSpan.Start < newOrig[2] - eps))
localOrig = new XYZ(localOrig.X, localOrig.Y, zSpan.Start);
else
localOrig = new XYZ(localOrig.X, localOrig.Y, newOrig[2]);
}
else
{
localOrig = new XYZ(localOrig.X, localOrig.Y, range.Start);
}
}
double dist = localOrig[2] - oldOrig[2];
if (!MathUtil.IsAlmostZero(dist))
{
XYZ moveVec = new XYZ(0, 0, dist);
curve = GeometryUtil.MoveCurve(curve, moveVec);
}
localYDir = localZDir.CrossProduct(localXDir);
// ensure that X and Z axes are orthogonal.
double xzDot = localZDir.DotProduct(localXDir);
if (!MathUtil.IsAlmostZero(xzDot))
localXDir = localYDir.CrossProduct(localZDir);
}
Transform orientationTrf = Transform.Identity;
orientationTrf.BasisX = localXDir;
orientationTrf.BasisY = localYDir;
orientationTrf.BasisZ = localZDir;
orientationTrf.Origin = localOrig;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element, null, orientationTrf, overrideLevelId))
{
IFCAnyHandle localPlacement = setter.GetPlacement();
Plane plane = new Plane(localXDir, localYDir, localOrig); // project curve to XY plane.
XYZ projDir = XYZ.BasisZ;
// two representations: axis, body.
{
if ((centerCurve != null) && (GeometryUtil.CurveIsLineOrArc(centerCurve)))
{
exportingAxis = true;
string identifierOpt = "Axis"; // IFC2x2 convention
string representationTypeOpt = "Curve2D"; // IFC2x2 convention
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, plane, projDir, false);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, curve, XYZ.Zero, true);
IList<IFCAnyHandle> axisItems = info.GetCurves();
if (axisItems.Count == 0)
{
exportingAxis = false;
}
else
{
HashSet<IFCAnyHandle> axisItemSet = new HashSet<IFCAnyHandle>();
foreach (IFCAnyHandle axisItem in axisItems)
axisItemSet.Add(axisItem);
axisRep = RepresentationUtil.CreateShapeRepresentation(exporterIFC, element, catId, contextOfItemsAxis,
identifierOpt, representationTypeOpt, axisItemSet);
}
}
}
IList<IFCExtrusionData> cutPairOpenings = new List<IFCExtrusionData>();
Document document = element.Document;
if (wallElement != null && exportingAxis && curve != null)
{
SolidMeshGeometryInfo solidMeshInfo =
(range == null) ? GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity) :
GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, range);
IList<Solid> solids = solidMeshInfo.GetSolids();
IList<Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 0 && meshes.Count == 0)
return null;
bool useNewCode = false;
if (useNewCode && solids.Count == 1 && meshes.Count == 0)
{
bool completelyClipped;
bodyRep = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, wallElement, catId, solids[0],
plane, projDir, range, out completelyClipped);
if (completelyClipped)
return null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
exportedAsWallWithAxis = true;
exportedBodyDirectly = true;
}
else
{
exportedAsWallWithAxis = false;
exportedBodyDirectly = false;
}
}
if (!exportedAsWallWithAxis)
{
// Fallback - use native routines to try to export wall.
bool isCompletelyClipped;
bodyRep = FallbackTryToCreateAsExtrusion(exporterIFC, wallElement, solidMeshInfo,
catId, curve, plane, depth, zSpan, range, setter,
out cutPairOpenings, out isCompletelyClipped);
if (isCompletelyClipped)
return null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
exportedAsWallWithAxis = true;
}
}
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
ElementId matId = ElementId.InvalidElementId;
if (!exportedAsWallWithAxis)
{
SolidMeshGeometryInfo solidMeshCapsule = null;
if (wallElement != null)
{
if (validRange)
{
solidMeshCapsule = GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, range);
}
else
{
solidMeshCapsule = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
}
if (solidMeshCapsule.SolidsCount() == 0 && solidMeshCapsule.MeshesCount() == 0)
{
return null;
}
}
else
{
GeometryElement geomElemToUse = GetGeometryFromInplaceWall(famInstWallElem);
if (geomElemToUse != null)
{
exportingInplaceOpenings = true;
}
else
{
exportingInplaceOpenings = false;
geomElemToUse = geometryElement;
}
Transform trf = Transform.Identity;
if (geomElemToUse != geometryElement)
trf = famInstWallElem.GetTransform();
solidMeshCapsule = GeometryUtil.GetSolidMeshGeometry(geomElemToUse, trf);
}
IList<Solid> solids = solidMeshCapsule.GetSolids();
IList<Mesh> meshes = solidMeshCapsule.GetMeshes();
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ; // only allow vertical extrusions!
extraParams.AreInnerRegionsOpenings = true;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if ((solids.Count > 0) || (meshes.Count > 0))
{
matId = BodyExporter.GetBestMaterialIdForGeometry(solids, meshes);
bodyRep = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId,
solids, meshes, bodyExporterOptions, extraParams).RepresentationHnd;
}
else
{
IList<GeometryObject> geomElemList = new List<GeometryObject>();
geomElemList.Add(geometryElement);
BodyData bodyData = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId,
geomElemList, bodyExporterOptions, extraParams);
bodyRep = bodyData.RepresentationHnd;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extraParams.ClearOpenings();
return null;
}
// We will be able to export as a IfcWallStandardCase as long as we have an axis curve.
XYZ extrDirUsed = XYZ.Zero;
if (extraParams.HasExtrusionDirection)
{
extrDirUsed = extraParams.ExtrusionDirection;
if (MathUtil.IsAlmostEqual(Math.Abs(extrDirUsed[2]), 1.0))
{
if ((solids.Count == 1) && (meshes.Count == 0))
exportedAsWallWithAxis = exportingAxis;
exportedBodyDirectly = true;
}
}
}
IFCAnyHandle prodRep = null;
IList<IFCAnyHandle> representations = new List<IFCAnyHandle>();
if (exportingAxis)
representations.Add(axisRep);
representations.Add(bodyRep);
prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle wallHnd = null;
string elemGUID = (validRange) ? ExporterIFCUtils.CreateGUID() : ExporterIFCUtils.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, exporterIFC.GetName());
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemId = NamingUtil.CreateIFCElementId(element);
if (exportedAsWallWithAxis)
{
wallHnd = IFCInstanceExporter.CreateWallStandardCase(file, elemGUID, ownerHistory, elemName, elemDesc, elemObjectType,
localPlacement, exportParts ? null : prodRep, elemId);
if (exportParts)
PartExporter.ExportHostPart(exporterIFC, wallElement, wallHnd, localWrapper, setter, localPlacement, overrideLevelId);
localWrapper.AddElement(wallHnd, setter, extraParams, true);
OpeningUtil.CreateOpeningsIfNecessary(wallHnd, element, cutPairOpenings, exporterIFC, localPlacement, setter, localWrapper);
if (exportedBodyDirectly)
{
OpeningUtil.CreateOpeningsIfNecessary(wallHnd, element, extraParams, exporterIFC, localPlacement, setter, localWrapper);
}
else
{
double scaledWidth = wallElement.Width * scale;
ExporterIFCUtils.AddOpeningsToElement(exporterIFC, wallHnd, wallElement, scaledWidth, range, setter, localPlacement, localWrapper);
}
// export Base Quantities
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
CreateWallBaseQuantities(exporterIFC, wallElement, wallHnd, depth);
}
}
else
{
wallHnd = IFCInstanceExporter.CreateWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemObjectType,
localPlacement, exportParts ? null : prodRep, elemId);
if (exportParts)
PartExporter.ExportHostPart(exporterIFC, wallElement, wallHnd, localWrapper, setter, localPlacement, overrideLevelId);
localWrapper.AddElement(wallHnd, setter, extraParams, true);
// Only export one material for 2x2; for future versions, export the whole list.
if (exporterIFC.ExportAs2x2 && (matId != ElementId.InvalidElementId) && !exportParts)
{
CategoryUtil.CreateMaterialAssociation(doc, exporterIFC, wallHnd, matId);
}
if (exportingInplaceOpenings)
{
ExporterIFCUtils.AddOpeningsToElement(exporterIFC, wallHnd, famInstWallElem, 0.0, range, setter, localPlacement, localWrapper);
}
if (exportedBodyDirectly)
OpeningUtil.CreateOpeningsIfNecessary(wallHnd, element, extraParams, exporterIFC, localPlacement, setter, localWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, localWrapper);
ElementId wallLevelId = (validRange) ? setter.LevelId : ElementId.InvalidElementId;
if (wallElement != null && !exportParts)
{
if (!exporterIFC.ExportAs2x2 || exportedAsWallWithAxis) //will move this check into ExportHostObject
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, wallElement, localWrapper.GetAnElement(),
geometryElement, localWrapper, wallLevelId, Toolkit.IFCLayerSetDirection.Axis2);
}
exporterIFC.RegisterSpaceBoundingElementHandle(wallHnd, element.Id, wallLevelId);
return wallHnd;
}
}
}
}
/// <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 IFCProductWrapper.
/// </param>
public static void ExportCurtainObjectCommonAsContainer(ICollection <ElementId> allSubElements, Element wallElement,
ExporterIFC exporterIFC, IFCProductWrapper origWrapper)
{
if (wallElement == null)
{
return;
}
HashSet <ElementId> alreadyVisited = new HashSet <ElementId>(); // just in case.
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
{
foreach (ElementId subElemId in allSubElements)
{
using (IFCProductWrapper productWrapper = IFCProductWrapper.Create(origWrapper))
{
Element subElem = wallElement.Document.GetElement(subElemId);
if (subElem == null)
{
continue;
}
GeometryElement geomElem = subElem.get_Geometry(geomOptions);
if (geomElem == null)
{
continue;
}
if (alreadyVisited.Contains(subElem.Id))
{
continue;
}
alreadyVisited.Add(subElem.Id);
try
{
if (subElem is FamilyInstance)
{
if (subElem is Mullion)
{
if (exporterIFC.ExportAs2x2)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
else
{
using (IFCPlacementSetter currSetter = IFCPlacementSetter.Create(exporterIFC, wallElement))
{
IFCAnyHandle currLocalPlacement = currSetter.GetPlacement();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
MullionExporter.Export(exporterIFC, subElem as Mullion, geomElem, currLocalPlacement, extraParams, currSetter,
productWrapper);
}
}
}
}
else
{
FamilyInstance subFamInst = subElem as FamilyInstance;
string ifcEnumType;
ElementId catId = CategoryUtil.GetSafeCategoryId(subElem);
IFCExportType exportType = ElementFilteringUtil.GetExportTypeFromCategoryId(catId, out ifcEnumType);
if (exporterIFC.ExportAs2x2)
{
if ((exportType == IFCExportType.DontExport) || (exportType == IFCExportType.ExportPlateType) ||
(exportType == IFCExportType.ExportMemberType))
{
exportType = IFCExportType.ExportBuildingElementProxy;
}
}
else
{
if (exportType == IFCExportType.DontExport)
{
ifcEnumType = "CURTAIN_PANEL";
exportType = IFCExportType.ExportPlateType;
}
}
FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem(exporterIFC, subFamInst, exportType, ifcEnumType, productWrapper,
ElementId.InvalidElementId, null);
}
}
else if (subElem is CurtainGridLine)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
}
catch (Exception ex)
{
if (ExporterUtil.IsFatalException(wallElement.Document, ex))
{
throw ex;
}
continue;
}
}
}
}
}
/// <summary>
/// Exports Walls.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="wallElement">
/// The wall element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Wall wallElement, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
//stacked wall is not supported yet.
if (wallElement.WallType.Kind == WallKind.Stacked)
return;
bool exportAsCurtainWall = wallElement.CurtainGrid != null;
bool isOldCurtainWall = IsLegacyCurtainWall(wallElement); ;
if (exportAsCurtainWall)
{
if (!isOldCurtainWall)
CurtainSystemExporter.ExportWall(exporterIFC, wallElement, productWrapper);
else
CurtainSystemExporter.ExportLegacyCurtainElement(exporterIFC, wallElement, productWrapper);
}
else
ExportWall(exporterIFC, wallElement, geometryElement, productWrapper);
// create join information.
ElementId id = wallElement.Id;
IList<IList<IFCConnectedWallData>> connectedWalls = new List<IList<IFCConnectedWallData>>();
connectedWalls.Add(ExporterIFCUtils.GetConnectedWalls(wallElement, IFCConnectedWallDataLocation.Start));
connectedWalls.Add(ExporterIFCUtils.GetConnectedWalls(wallElement, IFCConnectedWallDataLocation.End));
for (int ii = 0; ii < 2; ii++)
{
int count = connectedWalls[ii].Count;
IFCConnectedWallDataLocation currConnection = (ii == 0) ? IFCConnectedWallDataLocation.Start : IFCConnectedWallDataLocation.End;
for (int jj = 0; jj < count; jj++)
{
ElementId otherId = connectedWalls[ii][jj].ElementId;
IFCConnectedWallDataLocation joinedEnd = connectedWalls[ii][jj].Location;
if ((otherId == id) && (joinedEnd == currConnection)) //self-reference
continue;
ExporterCacheManager.WallConnectionDataCache.Add(new WallConnectionData(id, otherId, GetIFCConnectionTypeFromLocation(currConnection),
GetIFCConnectionTypeFromLocation(joinedEnd), null));
}
}
// look for connected columns. Note that this is only for columns that interrupt the wall path.
IList<FamilyInstance> attachedColumns = ExporterIFCUtils.GetAttachedColumns(wallElement);
int numAttachedColumns = attachedColumns.Count;
for (int ii = 0; ii < numAttachedColumns; ii++)
{
ElementId otherId = attachedColumns[ii].Id;
IFCConnectionType connect1 = IFCConnectionType.NotDefined; // can't determine at the moment.
IFCConnectionType connect2 = IFCConnectionType.NotDefined; // meaningless for column
ExporterCacheManager.WallConnectionDataCache.Add(new WallConnectionData(id, otherId, connect1, connect2, null));
}
tr.Commit();
}
}
/// <summary>
/// Exports a legacy curtain element to IFC curtain wall.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="curtainElement">The curtain element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportLegacyCurtainElement(ExporterIFC exporterIFC, Element curtainElement, IFCProductWrapper productWrapper)
{
ICollection <ElementId> allSubElements = ExporterIFCUtils.GetLegacyCurtainSubElements(curtainElement);
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
ExportBase(exporterIFC, allSubElements, curtainElement, 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="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacementToUse = setter.GetPlacement();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle productRepresentation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application,
exporterIFC, element, catId, geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.GetElement(typeId) as ElementType;
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(typeId, false);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeGUID = ExporterIFCUtils.CreateGUID(type);
string origTypeName = exporterIFC.GetName();
string typeName = NamingUtil.GetNameOverride(type, origTypeName);
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
string applicableOccurance = NamingUtil.GetObjectTypeOverride(type, typeObjectType);
string typeDescription = NamingUtil.GetDescriptionOverride(type, null);
string typeElemId = NamingUtil.CreateIFCElementId(type);
HashSet<IFCAnyHandle> propertySetsOpt = new HashSet<IFCAnyHandle>();
IList<IFCAnyHandle> repMapListOpt = new List<IFCAnyHandle>();
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(file, exportType, ifcEnumType, typeGUID, ownerHistory, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMapListOpt, typeElemId, typeName, element, type);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.TypeObjectsCache.Register(typeId, false, currentTypeInfo);
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = null;
if (FamilyExporterUtil.IsFurnishingElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFurnishingElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsDistributionFlowElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateDistributionFlowElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsEnergyConversionDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateEnergyConversionDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowFittingSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowFitting(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowMovingDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowMovingDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowSegmentSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowSegment(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowStorageDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowStorageDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTerminalSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTerminal(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTreatmentDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTreatmentDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowControllerSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowController(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
return;
if (roomId != ElementId.InvalidElementId)
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
productWrapper.AddElement(instanceHandle, setter, extraParams, false);
}
else
{
productWrapper.AddElement(instanceHandle, setter, extraParams, LevelUtil.AssociateElementToLevel(element));
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, exporterIFC, localPlacementToUse, setter, productWrapper);
if (currentTypeInfo.IsValid())
ExporterCacheManager.TypeRelationsCache.Add(currentTypeInfo.Style, instanceHandle);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
tr.Commit();
}
}
}
}
/// <summary>
/// Exports a curve element to IFC curve annotation.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="curveElement">
/// The curve element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportCurveElement(ExporterIFC exporterIFC, CurveElement curveElement, GeometryElement geometryElement,
IFCProductWrapper productWrapper)
{
if (geometryElement == null || !ShouldCurveElementBeExported(curveElement))
{
return;
}
SketchPlane sketchPlane = curveElement.SketchPlane;
if (sketchPlane == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, curveElement))
{
IFCAnyHandle localPlacement = setter.GetPlacement();
IFCAnyHandle axisPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
Plane planeSK = sketchPlane.Plane;
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;
}
Plane plane = new Plane(planeSK.XVec, planeSK.YVec, origin);
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, plane, projDir, false);
if (useOffsetTrf)
{
XYZ offsetOrig = -XYZ.BasisZ * setter.Offset;
Transform trf = Transform.get_Translation(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, plane, curveStyle, setter, localPlacement, repItemHnd);
productWrapper.AddAnnotation(curveAnno, setter.GetLevelInfo(), true);
annotationCache.AddAnnotation(sketchPlane.Id, curveStyle, curveAnno);
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports IFC site object if having latitude and longitude.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="document">
/// The Revit document.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportDefaultSite(ExporterIFC exporterIFC, Document document, IFCProductWrapper productWrapper)
{
ExportSiteBase(exporterIFC, document, null, null, productWrapper);
}
/// <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="ownerHistory">The owner history.</param>
/// <param name="localPlacement">The local placement of the IfcRamp container.</param>
/// <param name="containedRampLocalPlacement">The local placement of the IfcRamp containing the ramp geometry.</param>
/// <param name="representation">The ramp geometry representation.</param>
/// <param name="rampName">The ramp name.</param>
/// <param name="rampObjectType">The ramp object type.</param>
/// <param name="rampDescription">The ramp description.</param>
/// <param name="elementTag">The ramp element tag.</param>
/// <param name="rampType">The ramp type.</param>
/// <param name="ecData">The extrusion creation data.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportMultistoryRamp(ExporterIFC exporterIFC, Element ramp, int numFlights,
IFCAnyHandle ownerHistory, IFCAnyHandle localPlacement, IFCAnyHandle containedRampLocalPlacement, IFCAnyHandle representation,
string rampName, string rampObjectType, string rampDescription, string elementTag, IFCRampType rampType,
IFCExtrusionCreationData ecData, IFCPlacementSetter placementSetter, IFCProductWrapper productWrapper)
{
if (numFlights < 2)
{
return;
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
double heightNonScaled = GetRampHeight(exporterIFC, ramp);
double scale = exporterIFC.LinearScale;
for (int ii = 1; ii < numFlights; ii++)
{
double newOffsetScaled = 0.0;
IFCAnyHandle newLevelHnd = null;
IFCLevelInfo currLevelInfo =
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * ii, scale, out newLevelHnd, out newOffsetScaled);
if (currLevelInfo == null)
{
currLevelInfo = placementSetter.GetLevelInfo();
}
XYZ orig = new XYZ(0.0, 0.0, newOffsetScaled);
IFCAnyHandle relativePlacementHnd = ExporterUtil.CreateAxis2Placement3D(file, orig);
IFCAnyHandle containedLocalPlacementCopy = IFCInstanceExporter.CreateLocalPlacement(file, newLevelHnd, relativePlacementHnd);
if (ptHnd.HasValue)
{
IFCAnyHandle relPlacementCopy = GeometryUtil.GetRelativePlacementFromLocalPlacement(containedLocalPlacementCopy);
IFCAnyHandle newPt = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> newCoords = new List <double>();
newCoords.Add(origCoords[0]);
newCoords.Add(origCoords[1]);
newCoords.Add(origCoords[2]);
if (newPt.HasValue)
{
IList <double> addToCoords = IFCAnyHandleUtil.GetCoordinates(newPt);
newCoords[0] += addToCoords[0];
newCoords[1] += addToCoords[1];
newCoords[2] = addToCoords[2];
}
IFCAnyHandle locPt = IFCInstanceExporter.CreateCartesianPoint(file, newCoords);
IFCAnyHandleUtil.SetAttribute(relPlacementCopy, "Location", locPt);
}
ElementId catId = CategoryUtil.GetSafeCategoryId(ramp);
IFCAnyHandle representationCopy = ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, representation);
string localRampName = rampName + ":" + (ii + 1);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IFCAnyHandle containedRampCopyHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localRampName, rampDescription, rampObjectType, containedLocalPlacementCopy, representationCopy, elementTag, rampType);
components.Add(containedRampCopyHnd);
productWrapper.AddElement(containedRampCopyHnd, currLevelInfo, ecData, false);
IFCAnyHandle rampLocalPlacementCopy = ExporterUtil.CopyLocalPlacement(file, containedRampLocalPlacement);
IFCAnyHandle rampCopyHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(), ownerHistory, localRampName,
rampDescription, rampObjectType, rampLocalPlacementCopy, null, elementTag, rampType);
productWrapper.AddElement(rampCopyHnd, currLevelInfo, ecData, LevelUtil.AssociateElementToLevel(ramp));
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampCopyHnd, components, rampLocalPlacementCopy);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(ramp.Id, stairRampInfo);
}
}
/// <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="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacementToUse = setter.GetPlacement();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle productRepresentation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application,
exporterIFC, element, catId, geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.GetElement(typeId) as ElementType;
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(typeId, false);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeGUID = ExporterIFCUtils.CreateGUID(type);
string origTypeName = exporterIFC.GetName();
string typeName = NamingUtil.GetNameOverride(type, origTypeName);
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
string applicableOccurance = NamingUtil.GetObjectTypeOverride(type, typeObjectType);
string typeDescription = NamingUtil.GetDescriptionOverride(type, null);
string typeElemId = NamingUtil.CreateIFCElementId(type);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
IList <IFCAnyHandle> repMapListOpt = new List <IFCAnyHandle>();
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(file, exportType, ifcEnumType, typeGUID, ownerHistory, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMapListOpt, typeElemId, typeName, element, type);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.TypeObjectsCache.Register(typeId, false, currentTypeInfo);
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = null;
if (FamilyExporterUtil.IsFurnishingElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFurnishingElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsDistributionFlowElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateDistributionFlowElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsEnergyConversionDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateEnergyConversionDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowFittingSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowFitting(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowMovingDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowMovingDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowSegmentSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowSegment(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowStorageDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowStorageDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTerminalSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTerminal(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTreatmentDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTreatmentDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowControllerSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowController(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
return;
}
if (roomId != ElementId.InvalidElementId)
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
productWrapper.AddElement(instanceHandle, setter, extraParams, false);
}
else
{
productWrapper.AddElement(instanceHandle, setter, extraParams, LevelUtil.AssociateElementToLevel(element));
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, exporterIFC, localPlacementToUse, setter, productWrapper);
if (currentTypeInfo.IsValid())
{
ExporterCacheManager.TypeRelationsCache.Add(currentTypeInfo.Style, instanceHandle);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
tr.Commit();
}
}
}
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, IFCProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(ramp.Document.Application,
exporterIFC, ramp, categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = ExporterIFCUtils.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origRampName = exporterIFC.GetName();
string rampName = NamingUtil.GetNameOverride(ramp, origRampName);
string rampDescription = NamingUtil.GetDescriptionOverride(ramp, null);
string rampObjectType = NamingUtil.GetObjectTypeOverride(ramp, NamingUtil.CreateIFCObjectName(exporterIFC, ramp));
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CopyLocalPlacement(file, ecData.GetLocalPlacement());
string elementTag = NamingUtil.CreateIFCElementId(ramp);
IFCRampType rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, containedRampGuid, ownerHistory, rampName,
rampDescription, rampObjectType, containedRampLocalPlacement, representation, elementTag, rampType);
components.Add(containedRampHnd);
productWrapper.AddElement(containedRampHnd, placementSetter.GetLevelInfo(), ecData, false);
string guid = ExporterIFCUtils.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, rampName,
rampDescription, rampObjectType, localPlacement, null, elementTag, rampType);
productWrapper.AddElement(rampHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(ramp));
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, null);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights,
ownerHistory, localPlacement, containedRampLocalPlacement, representation,
rampName, rampObjectType, rampDescription, elementTag, rampType,
ecData, placementSetter, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, ramp, productWrapper);
tr.Commit();
}
}
}
/// <summary>
/// Export spatial elements, including rooms, areas and spaces. 1st level space boundaries.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="spatialElement">
/// The spatial element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportSpatialElement(ExporterIFC exporterIFC, SpatialElement spatialElement, IFCProductWrapper productWrapper)
{
//quick reject
bool isArea = spatialElement is Area;
if (isArea)
{
if (!IsAreaGrossInterior(exporterIFC, spatialElement))
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
ElementId levelId = spatialElement.Level != null ? spatialElement.Level.Id : ElementId.InvalidElementId;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, spatialElement, null, null, levelId))
{
CreateIFCSpace(exporterIFC, spatialElement, productWrapper, setter);
// Do not create boundary information, or extra property sets.
if (spatialElement is Area)
{
tr.Commit();
return;
}
if (exporterIFC.SpaceBoundaryLevel == 1)
{
Document document = spatialElement.Document;
IFCLevelInfo levelInfo = exporterIFC.GetLevelInfo(levelId);
double baseHeightNonScaled = levelInfo.Elevation;
SpatialElementGeometryResults spatialElemGeomResult = s_SpatialElemGeometryCalculator.CalculateSpatialElementGeometry(spatialElement);
Solid spatialElemGeomSolid = spatialElemGeomResult.GetGeometry();
FaceArray faces = spatialElemGeomSolid.Faces;
foreach (Face face in faces)
{
IList<SpatialElementBoundarySubface> spatialElemBoundarySubfaces = spatialElemGeomResult.GetBoundaryFaceInfo(face);
foreach (SpatialElementBoundarySubface spatialElemBSubface in spatialElemBoundarySubfaces)
{
if (spatialElemBSubface.SubfaceType == SubfaceType.Side)
continue;
if (spatialElemBSubface.GetSubface() == null)
continue;
ElementId elemId = spatialElemBSubface.SpatialBoundaryElement.LinkInstanceId;
if (elemId == ElementId.InvalidElementId)
{
elemId = spatialElemBSubface.SpatialBoundaryElement.HostElementId;
}
Element boundingElement = document.get_Element(elemId);
if (boundingElement == null)
continue;
bool isObjectExt = CategoryUtil.IsElementExternal(boundingElement);
IFCGeometryInfo info = IFCGeometryInfo.CreateSurfaceGeometryInfo(spatialElement.Document.Application.VertexTolerance);
Face subFace = spatialElemBSubface.GetSubface();
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, subFace, XYZ.Zero, false);
IFCAnyHandle ifcOptionalHnd = IFCAnyHandle.Create();
foreach (IFCAnyHandle surfaceHnd in info.GetSurfaces())
{
IFCAnyHandle connectionGeometry = file.CreateConnectionSurfaceGeometry(surfaceHnd, ifcOptionalHnd);
IFCSpaceBoundary spaceBoundary = IFCSpaceBoundary.Create(spatialElement.Id, boundingElement.Id, connectionGeometry, IFCSpaceBoundaryType.Physical, isObjectExt);
if (!ProcessIFCSpaceBoundary(exporterIFC, spaceBoundary, file))
exporterIFC.RegisterIFCSpaceBoundary(spaceBoundary);
}
}
}
IList<IList<BoundarySegment>> roomBoundaries = spatialElement.GetBoundarySegments(ExporterIFCUtils.GetSpatialElementBoundaryOptions(exporterIFC, spatialElement));
double roomHeight = GetHeight(spatialElement, exporterIFC.LinearScale, levelInfo);
XYZ zDir = new XYZ(0, 0, 1);
foreach (IList<BoundarySegment> roomBoundaryList in roomBoundaries)
{
foreach (BoundarySegment roomBoundary in roomBoundaryList)
{
Element boundingElement = roomBoundary.Element;
if (boundingElement == null)
continue;
ElementId buildingElemId = boundingElement.Id;
Curve trimmedCurve = roomBoundary.Curve;
if (trimmedCurve == null)
continue;
//trimmedCurve.Visibility = Visibility.Visible; readonly
IFCAnyHandle connectionGeometry = ExporterIFCUtils.CreateExtrudedSurfaceFromCurve(
exporterIFC, trimmedCurve, zDir, roomHeight, baseHeightNonScaled);
IFCSpaceBoundaryType physOrVirt = IFCSpaceBoundaryType.Physical;
if (boundingElement is CurveElement)
physOrVirt = IFCSpaceBoundaryType.Virtual;
else if (boundingElement is Autodesk.Revit.DB.Architecture.Room)
physOrVirt = IFCSpaceBoundaryType.Undefined;
bool isObjectExt = CategoryUtil.IsElementExternal(boundingElement);
bool isObjectPhys = (physOrVirt == IFCSpaceBoundaryType.Physical);
ElementId actualBuildingElemId = isObjectPhys ? buildingElemId : ElementId.InvalidElementId;
IFCSpaceBoundary boundary = IFCSpaceBoundary.Create(spatialElement.Id, actualBuildingElemId, connectionGeometry, physOrVirt, isObjectExt);
if (!ProcessIFCSpaceBoundary(exporterIFC, boundary, file))
exporterIFC.RegisterIFCSpaceBoundary(boundary);
// try to add doors and windows for host objects if appropriate.
if (isObjectPhys && boundingElement is HostObject)
{
HostObject hostObj = boundingElement as HostObject;
IList<ElementId> elemIds = hostObj.FindInserts(false, false, false, false);
foreach (ElementId elemId in elemIds)
{
// we are going to do a simple bbox export, not complicated geometry.
Element instElem = document.get_Element(elemId);
if (instElem == null)
continue;
BoundingBoxXYZ instBBox = instElem.get_BoundingBox(null);
// make copy of original trimmed curve.
Curve instCurve = trimmedCurve.Clone();
XYZ instOrig = instCurve.get_EndPoint(0);
// make sure that the insert is on this level.
if (instBBox.Max.Z < instOrig.Z)
continue;
if (instBBox.Min.Z > instOrig.Z + roomHeight)
continue;
double insHeight = Math.Min(instBBox.Max.Z, instOrig.Z + roomHeight) - Math.Max(instOrig.Z, instBBox.Min.Z);
if (insHeight < (1.0 / (12.0 * 16.0)))
continue;
// move base curve to bottom of bbox.
XYZ moveDir = new XYZ(0.0, 0.0, instBBox.Min.Z - instOrig.Z);
Transform moveTrf = Transform.get_Translation(moveDir);
instCurve = instCurve.get_Transformed(moveTrf);
bool isHorizOrVert = false;
if (instCurve is Line)
{
Line instLine = instCurve as Line;
XYZ lineDir = instLine.Direction;
if (MathUtil.IsAlmostEqual(Math.Abs(lineDir.X), 1.0) || (MathUtil.IsAlmostEqual(Math.Abs(lineDir.Y), 1.0)))
isHorizOrVert = true;
}
double[] parameters = new double[2];
double[] origEndParams = new double[2];
if (isHorizOrVert)
{
parameters[0] = instCurve.Project(instBBox.Min).Parameter;
parameters[1] = instCurve.Project(instBBox.Max).Parameter;
}
else
{
FamilyInstance famInst = instElem as FamilyInstance;
if (famInst == null)
continue;
ElementType elementType = document.get_Element(famInst.GetTypeId()) as ElementType;
if (elementType == null)
continue;
BoundingBoxXYZ symBBox = elementType.get_BoundingBox(null);
Curve symCurve = trimmedCurve.Clone();
Transform trf = famInst.GetTransform();
Transform invTrf = trf.Inverse;
Curve trfCurve = symCurve.get_Transformed(invTrf);
parameters[0] = trfCurve.Project(symBBox.Min).Parameter;
parameters[1] = trfCurve.Project(symBBox.Max).Parameter;
}
// ignore if less than 1/16".
if (Math.Abs(parameters[1] - parameters[0]) < 1.0 / (12.0 * 16.0))
continue;
if (parameters[0] > parameters[1])
{
//swap
double tempParam = parameters[0];
parameters[0] = parameters[1];
parameters[1] = tempParam;
}
origEndParams[0] = instCurve.get_EndParameter(0);
origEndParams[1] = instCurve.get_EndParameter(1);
if (origEndParams[0] > parameters[1] - (1.0 / (12.0 * 16.0)))
continue;
if (origEndParams[1] < parameters[0] + (1.0 / (12.0 * 16.0)))
continue;
if (parameters[0] > origEndParams[0])
instCurve.set_EndParameter(0, parameters[0]);
if (parameters[1] < origEndParams[1])
instCurve.set_EndParameter(1, parameters[1]);
IFCAnyHandle insConnectionGeom = ExporterIFCUtils.CreateExtrudedSurfaceFromCurve(exporterIFC, instCurve, zDir,
insHeight, baseHeightNonScaled);
IFCSpaceBoundary instBoundary = IFCSpaceBoundary.Create(spatialElement.Id, elemId, insConnectionGeom, physOrVirt, isObjectExt);
if (!ProcessIFCSpaceBoundary(exporterIFC, instBoundary, file))
exporterIFC.RegisterIFCSpaceBoundary(instBoundary);
}
}
}
}
}
ExporterIFCUtils.CreateSpatialElementPropertySet(exporterIFC, spatialElement, productWrapper);
}
tr.Commit();
}
}
/// <summary>
/// Exports a curtain roof to IFC curtain wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="hostElement">
/// The host object element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFootPrintRoof(ExporterIFC exporterIFC, FootPrintRoof hostElement, IFCProductWrapper productWrapper)
{
// Don't export the Curtain Wall itself, which has no useful geometry; instead export all of the GReps of the
// mullions and panels.
CurtainGridSet grids = hostElement.CurtainGrids;
if (grids == null || grids.Size == 0)
{
return;
}
ICollection <ElementId> allSubElements = new HashSet <ElementId>();
foreach (CurtainGrid grid in grids)
{
foreach (ElementId panelId in grid.GetPanelIds())
{
allSubElements.Add(panelId);
}
foreach (ElementId subElem in grid.GetMullionIds())
{
allSubElements.Add(subElem);
}
}
ExportBase(exporterIFC, allSubElements, hostElement, productWrapper);
}
/// <summary>
/// Exports a floor to IFC slab.
/// </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 IFCProductWrapper.
/// </param>
/// <returns>
/// True if the floor is exported successfully, false otherwise.
/// </returns>
public static void ExportFloor(ExporterIFC exporterIFC, Floor floor, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (geometryElement == null)
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, floor))
{
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, floor);
double scale = exporterIFC.LinearScale;
ElementId catId = CategoryUtil.GetSafeCategoryId(floor);
IList<IFCAnyHandle> reps = new List<IFCAnyHandle>();
IList<IList<CurveLoop>> extrusionLoops = new List<IList<CurveLoop>>();
IList<IFCExtrusionCreationData> loopExtraParams = new List<IFCExtrusionCreationData>();
Plane floorPlane = GeometryUtil.CreateDefaultPlane();
IList<IFCAnyHandle> localPlacements = new List<IFCAnyHandle>();
bool exportedAsExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floor, geometryElement,
transformSetter, localPlacement, out localPlacements, out reps, out extrusionLoops, out loopExtraParams, floorPlane);
// We will use the ExtrusionAnalyzer when it is ready.
// XYZ extrusionDirection = { 0, 0, -1 };
// XYZ modelOrigin = { 0, 0, 0 };
// XYZ floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
// XYZ floorDir = floor.GetNormalAtVerticalProjectionPoint(floorOrigin, FloorFace.Top);
// Plane floorPlane(floorDir, floorOrigin);
// ExtrusionAnalyzer floorExtrusion =
// ExtrusionAnalyzer.Create(geometryElement, floorPlane, extrusionDirection);
if (!exportedAsExtrusion)
{
IFCAnyHandle bodyRep = null;
IList<GeometryObject> geomObjects = new List<GeometryObject>();
geomObjects.Add(geometryElement);
bodyRep = BodyExporter.ExportBody(floor.Document.Application, exporterIFC, catId, geomObjects, true, null);
if (bodyRep == null || !bodyRep.HasValue)
{
tr.Commit();
return;
}
IFCAnyHandle prodDefHnd = file.CreateProductDefinitionShape(bodyRep);
if (!prodDefHnd.HasValue)
return;
reps.Add(prodDefHnd);
}
// Create the slab from either the extrusion or the BRep information.
IFCLabel ifcGUID = IFCLabel.CreateGUID(floor);
IList<IFCAnyHandle> slabHnds = new List<IFCAnyHandle>();
int numReps = reps.Count;
for (int ii = 0; ii < numReps; ii++)
{
IFCLabel ifcName = NamingUtil.GetNameOverride(floor, NamingUtil.CreateIFCName(exporterIFC, ii == 0 ? -1 : ii + 1));
IFCLabel ifcDescription = NamingUtil.GetDescriptionOverride(floor, IFCLabel.Create());
IFCLabel ifcObjectType = NamingUtil.GetObjectTypeOverride(floor, exporterIFC.GetFamilyNameFromExportState());
IFCLabel ifcElemId = NamingUtil.CreateIFCElementId(floor);
IFCLabel currentGUID = (ii == 0) ? ifcGUID : IFCLabel.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = file.CreateSlab(currentGUID,
ownerHistory,
ifcName,
ifcDescription,
ifcObjectType,
localPlacementHnd,
ifcElemId,
ifcEnumType,
reps[ii]);
if (!slabHnd.HasValue)
return;
slabHnds.Add(slabHnd);
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(slabHnds[ii], placementSetter, loopExtraParam, true);
}
if (exportedAsExtrusion)
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floor, placementSetter,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper);
ExporterIFCUtils.CreateGenericElementPropertySet(exporterIFC, floor, productWrapper);
ExporterIFCUtils.ExportHostObject(exporterIFC, floor, geometryElement, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Create IFC room/space/area item, not include boundaries.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="spatialElement">
/// The spatial element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <returns>
/// True if created successfully, false otherwise.
/// </returns>
static void CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElement, IFCProductWrapper productWrapper, IFCPlacementSetter setter)
{
Autodesk.Revit.DB.Document document = spatialElement.Document;
ElementId levelId = spatialElement.Level != null ? spatialElement.Level.Id : ElementId.InvalidElementId;
double scale = exporterIFC.LinearScale;
ElementId catId = spatialElement.Category != null ? spatialElement.Category.Id : ElementId.InvalidElementId;
double dArea = 0.0;
Parameter param = spatialElement.get_Parameter(BuiltInParameter.ROOM_AREA);
if (param != null)
{
dArea = param.AsDouble();
dArea *= (scale * scale);
}
SpatialElementBoundaryOptions options = ExporterIFCUtils.GetSpatialElementBoundaryOptions(exporterIFC, spatialElement);
IList<CurveLoop> curveLoops = ExporterIFCUtils.GetRoomBoundaryAsCurveLoopArray(spatialElement, options, true);
IFCLevelInfo levelInfo = exporterIFC.GetLevelInfo(levelId);
string strSpaceNumber = null;
string strSpaceName = null;
string strSpaceDesc = null;
bool isArea = spatialElement is Area;
if (!isArea)
{
Parameter paramRoomNum = spatialElement.get_Parameter(BuiltInParameter.ROOM_NUMBER);
if (paramRoomNum != null)
{
strSpaceNumber = paramRoomNum.AsString();
}
Parameter paramRoomName = spatialElement.get_Parameter(BuiltInParameter.ROOM_NAME);
if (paramRoomName != null)
{
strSpaceName = paramRoomName.AsString();
}
Parameter paramRoomComm = spatialElement.get_Parameter(BuiltInParameter.ALL_MODEL_INSTANCE_COMMENTS);
if (paramRoomComm != null)
{
strSpaceDesc = paramRoomComm.AsString();
}
}
else
{
Element level = document.get_Element(levelId);
if (level != null)
{
strSpaceNumber = level.Name + " GSA Design Gross Area";
}
}
//assign empty string if it is null
if (strSpaceNumber == null) strSpaceNumber = "";
if (strSpaceName == null) strSpaceName = "";
if (strSpaceDesc == null) strSpaceDesc = "";
IFCLabel name = IFCLabel.Create(strSpaceNumber);
IFCLabel longName = IFCLabel.Create(strSpaceName);
IFCLabel desc = IFCLabel.Create(strSpaceDesc);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle localPlacement = setter.GetPlacement();
ElementType elemType = document.get_Element(spatialElement.GetTypeId()) as ElementType;
bool isObjectExternal = CategoryUtil.IsElementExternal(spatialElement);
IFCMeasureValue elevationWithFlooring = IFCMeasureValue.Create();
double roomHeight = 0.0;
roomHeight = GetHeight(spatialElement, scale, levelInfo);
double bottomOffset = 0.0;
Parameter paramBottomOffset = spatialElement.get_Parameter(BuiltInParameter.ROOM_LOWER_OFFSET);
bottomOffset = paramBottomOffset != null ? paramBottomOffset.AsDouble() : 0.0;
XYZ zDir = new XYZ(0, 0, 1);
XYZ orig = new XYZ(0, 0, levelInfo.Elevation + bottomOffset);
Plane plane = new Plane(zDir, orig); // room calculated as level offset.
GeometryElement geomElem = null;
if (spatialElement is Autodesk.Revit.DB.Architecture.Room)
{
Autodesk.Revit.DB.Architecture.Room room = spatialElement as Autodesk.Revit.DB.Architecture.Room;
geomElem = room.ClosedShell;
}
else if (spatialElement is Autodesk.Revit.DB.Mechanical.Space)
{
Autodesk.Revit.DB.Mechanical.Space space = spatialElement as Autodesk.Revit.DB.Mechanical.Space;
geomElem = space.ClosedShell;
}
IFCAnyHandle spaceHnd = null;
IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData();
extraParams.SetLocalPlacement(localPlacement);
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
using (IFCTransaction tr2 = new IFCTransaction(file))
{
IFCAnyHandle repHnd = null;
if (!(exporterIFC.ExportAs2x2 || Use2DRoomBoundaryForRoomVolumeCalculation()) && geomElem != null)
{
IFCSolidMeshGeometryInfo solidMeshInfo = ExporterIFCUtils.GetSolidMeshGeometry(exporterIFC, geomElem, Transform.Identity);
IList<Solid> solids = solidMeshInfo.GetSolids();
IList<Mesh> polyMeshes = solidMeshInfo.GetMeshes();
bool tryToExportAsExtrusion = true;
if (solids.Count != 1 || polyMeshes.Count != 0)
tryToExportAsExtrusion = false;
IList<GeometryObject> geomObjects = new List<GeometryObject>();
foreach (Solid solid in solids)
geomObjects.Add(solid);
IFCAnyHandle shapeRep = BodyExporter.ExportBody(spatialElement.Document.Application, exporterIFC, catId, geomObjects, tryToExportAsExtrusion, extraParams);
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
repHnd = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), shapeReps);
}
else
{
IFCAnyHandle shapeRep = file.CreateExtrudedSolidFromCurveLoop(exporterIFC, catId, curveLoops, plane, zDir, roomHeight); //pScaledOrig?
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(shapeRep);
shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, catId, exporterIFC.Get3DContextHandle(), bodyItems, IFCAnyHandle.Create());
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
repHnd = file.CreateProductDefinitionShape(IFCLabel.Create(), IFCLabel.Create(), shapeReps);
}
extraParams.ScaledHeight = roomHeight;
extraParams.ScaledArea = dArea;
spaceHnd = file.CreateSpace(IFCLabel.CreateGUID(spatialElement),
exporterIFC.GetOwnerHistoryHandle(),
NamingUtil.GetNameOverride(spatialElement, name),
NamingUtil.GetDescriptionOverride(spatialElement, desc),
NamingUtil.GetObjectTypeOverride(spatialElement, IFCLabel.Create()),
extraParams.GetLocalPlacement(), repHnd, longName, IFCElementComposition.Element
, isObjectExternal, elevationWithFlooring);
tr2.Commit();
}
productWrapper.AddSpace(spaceHnd, levelInfo, extraParams, true);
// Save room handle for later use/relationships
exporterIFC.RegisterSpatialElementHandle(spatialElement.Id, spaceHnd);
if (!MathUtil.IsAlmostZero(dArea) && !(exporterIFC.FileVersion == IFCVersion.IFCCOBIE))
{
ExporterIFCUtils.CreatePreCOBIEGSAQuantities(exporterIFC, spaceHnd, "GSA Space Areas", (isArea ? "GSA Design Gross Area" : "GSA BIM Area"), dArea);
}
// Export BaseQuantities for RoomElem
if (exporterIFC.ExportBaseQuantities && !(exporterIFC.FileVersion == IFCVersion.IFCCOBIE))
{
ExporterIFCUtils.CreateNonCOBIERoomQuantities(exporterIFC, spaceHnd, spatialElement, dArea, roomHeight);
}
}
