/// <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 a FabricArea as an IfcGroup. There is no geometry to export.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricArea(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (element == null)
return false;
HashSet<IFCAnyHandle> fabricSheetHandles = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(element.Id, out fabricSheetHandles))
return false;
if (fabricSheetHandles == null || fabricSheetHandles.Count == 0)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle fabricArea = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, fabricArea);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, fabricSheetHandles, null, fabricArea);
tr.Commit();
return true;
}
}
/// <summary>
/// Exports 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>
/// Creates uniformat classification.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC.</param>
/// <param name="file">The file.</param>
/// <param name="element">The element.</param>
/// <param name="elemHnd">The element handle.</param>
public static void CreateUniformatClassification(ExporterIFC exporterIFC, IFCFile file, Element element, IFCAnyHandle elemHnd)
{
// Create Uniformat classification, if it is set.
string uniformatCode = "";
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_CODE, false, out uniformatCode) ||
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Code", out uniformatCode))
{
string uniformatDescription = "";
if (!ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_DESCRIPTION, false, out uniformatDescription))
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Description", out uniformatDescription);
IFCAnyHandle classification;
if (!ExporterCacheManager.ClassificationCache.TryGetValue("UniFormat", out classification))
{
classification = IFCInstanceExporter.CreateClassification(file, "http://www.csiorg.net/uniformat", "1998", null, "UniFormat");
ExporterCacheManager.ClassificationCache.Add("UniFormat", classification);
}
IFCAnyHandle classificationReference = IFCInstanceExporter.CreateClassificationReference(file,
"http://www.csiorg.net/uniformat", uniformatCode, uniformatDescription, classification);
HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
relatedObjects.Add(elemHnd);
IFCAnyHandle relAssociates = IFCInstanceExporter.CreateRelAssociatesClassification(file, ExporterIFCUtils.CreateGUID(),
exporterIFC.GetOwnerHistoryHandle(), "UniFormatClassification", "", relatedObjects, classificationReference);
}
}
/// <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>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoofAsParts(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle localPlacement = setter.LocalPlacement;
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
string elementName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementTag, ifcEnumType);
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(element, roofHandle, setter, null, true);
transaction.Commit();
}
}
}
/// <summary>
/// Exports 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>
/// Exports a Rebar, AreaReinforcement or PathReinforcement to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
ISet<IFCAnyHandle> createdRebars = null;
if (element is Rebar)
{
ExportRebar(exporterIFC, element, productWrapper);
}
else if (element is AreaReinforcement)
{
AreaReinforcement areaReinforcement = element as AreaReinforcement;
IList<ElementId> rebarIds = areaReinforcement.GetRebarInSystemIds();
Document doc = areaReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
else if (element is PathReinforcement)
{
PathReinforcement pathReinforcement = element as PathReinforcement;
IList<ElementId> rebarIds = pathReinforcement.GetRebarInSystemIds();
Document doc = pathReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
if (createdRebars != null && createdRebars.Count > 1)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle rebarGroup = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, rebarGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebars, null, rebarGroup);
tr.Commit();
}
}
}
/// <summary>
/// Exports a Rebar, AreaReinforcement or PathReinforcement to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
ISet <IFCAnyHandle> createdRebars = null;
if (element is Rebar)
{
ExportRebar(exporterIFC, element, productWrapper);
}
else if (element is AreaReinforcement)
{
AreaReinforcement areaReinforcement = element as AreaReinforcement;
IList <ElementId> rebarIds = areaReinforcement.GetRebarInSystemIds();
Document doc = areaReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
else if (element is PathReinforcement)
{
PathReinforcement pathReinforcement = element as PathReinforcement;
IList <ElementId> rebarIds = pathReinforcement.GetRebarInSystemIds();
Document doc = pathReinforcement.Document;
foreach (ElementId id in rebarIds)
{
Element rebarInSystem = doc.GetElement(id);
createdRebars = ExportRebar(exporterIFC, rebarInSystem, productWrapper);
}
}
if (createdRebars != null && createdRebars.Count > 1)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle rebarGroup = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, rebarGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebars, null, rebarGroup);
tr.Commit();
}
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, "Wrapping");
ExporterCacheManager.ElementToHandleCache.Register(element.Id, ductLining);
productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(null);
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(null);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, null);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <summary>
/// Exports an element as a zone.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportZone(ExporterIFC exporterIFC, Zone element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
HashSet <IFCAnyHandle> spaceHnds = new HashSet <IFCAnyHandle>();
SpaceSet spaces = element.Spaces;
foreach (Space space in spaces)
{
if (space == null)
{
continue;
}
IFCAnyHandle spaceHnd = ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(space.Id);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(spaceHnd))
{
spaceHnds.Add(spaceHnd);
}
}
if (spaceHnds.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
IFCAnyHandle zoneHnd = IFCInstanceExporter.CreateZone(file, guid, ownerHistory, name, description, objectType);
productWrapper.AddElement(element, zoneHnd);
string relAssignsGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCZoneSubElements.RelAssignsToGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, relAssignsGuid, ownerHistory, null, null, spaceHnds, null, zoneHnd);
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return false;
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, "Wrapping");
ExporterCacheManager.ElementToHandleCache.Register(element.Id, ductLining);
productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
}
}
tr.Commit();
return true;
}
}
/// <summary>
/// Exports an element as an IFC assembly with its members.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="assemblyElem">The element to be exported as IFC assembly.</param>
/// <param name="memberIds">The member element ids.</param>
/// <param name="assemblyType">The IFC assembly type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
static void ExportAssemblyInstanceWithMembers(ExporterIFC exporterIFC, Element assemblyElem,
ICollection <ElementId> memberIds, IFCElementAssemblyType assemblyType, ProductWrapper productWrapper)
{
HashSet <IFCAnyHandle> memberHnds = new HashSet <IFCAnyHandle>();
foreach (ElementId memberId in memberIds)
{
IFCAnyHandle memberHnd = ExporterCacheManager.ElementToHandleCache.Find(memberId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(memberHnd))
{
memberHnds.Add(memberHnd);
}
}
if (memberHnds.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, assemblyElem))
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
string guid = GUIDUtil.CreateGUID(assemblyElem);
string name = NamingUtil.GetIFCName(assemblyElem);
string description = NamingUtil.GetDescriptionOverride(assemblyElem, null);
string objectType = NamingUtil.GetObjectTypeOverride(assemblyElem, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(assemblyElem);
IFCAnyHandle assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, description, objectType, localPlacement, null, elementTag,
IFCAssemblyPlace.NotDefined, assemblyType);
productWrapper.AddElement(assemblyElem, assemblyInstanceHnd, placementSetter.LevelInfo, null, true);
string aggregateGuid = GUIDUtil.CreateSubElementGUID(assemblyElem, (int)IFCAssemblyInstanceSubElements.RelAggregates);
IFCInstanceExporter.CreateRelAggregates(file, aggregateGuid, ownerHistory, null, null, assemblyInstanceHnd, memberHnds);
ExporterCacheManager.ElementsInAssembliesCache.UnionWith(memberHnds);
// Update member local placements to be relative to the assembly.
SetLocalPlacementsRelativeToAssembly(exporterIFC, localPlacement, memberHnds);
}
tr.Commit();
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (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.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return false;
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, IFCCoveringType.Wrapping);
productWrapper.AddElement(ductLining, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(element));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
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="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCPlacementSetter setter, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCPlacementSetter mullionSetter = IFCPlacementSetter.Create(exporterIFC, mullion, null, null, ExporterUtil.GetBaseLevelIdForElement(mullion)))
{
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
IFCAnyHandle mullionPlacement = mullionSetter.GetPlacement();
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(localPlacement, mullionPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle mullionRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandle mullionLocalPlacement = IFCInstanceExporter.CreateLocalPlacement(file, localPlacement, mullionRelativePlacement);
extraParams.SetLocalPlacement(mullionLocalPlacement);
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle repHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = GUIDUtil.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string name = NamingUtil.GetNameOverride(mullion, elemObjectType);
string description = NamingUtil.GetDescriptionOverride(mullion, null);
string objectType = NamingUtil.GetObjectTypeOverride(mullion, elemObjectType);
string elemTag = NamingUtil.GetTagOverride(mullion, NamingUtil.CreateIFCElementId(mullion));
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, name, description, objectType,
mullionLocalPlacement, repHnd, elemTag);
ExporterCacheManager.HandleToElementCache.Register(mullionHnd, mullion.Id);
productWrapper.AddElement(mullion, mullionHnd, mullionSetter, extraParams, false);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, mullion);
CategoryUtil.CreateMaterialAssociation(exporterIFC, mullionHnd, matId);
}
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
return null;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return null;
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, null);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return buildingElementProxy;
}
/// <summary>
/// Exports an element as a 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>
/// Exports an element as a group.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportAreaScheme(ExporterIFC exporterIFC, AreaScheme element,
ProductWrapper productWrapper)
{
if (element == null)
{
return;
}
HashSet <IFCAnyHandle> areaHandles = null;
if (!ExporterCacheManager.AreaSchemeCache.TryGetValue(element.Id, out areaHandles))
{
return;
}
if (areaHandles == null || areaHandles.Count == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, element.Name);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle areaScheme = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, areaScheme);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, areaHandles, null, areaScheme);
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportBuildingElementProxy(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 buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, objectType, null, objectType, localPlacement, representation, elementTag, Toolkit.IFCElementComposition.Element);
productWrapper.AddElement(buildingElementProxy, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(element));
}
tr.Commit();
return true;
}
}
}
/// <summary>
/// Creates window panel properties.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="doorWindowInfo">
/// The IFCDoorWindowInfo object.
/// </param>
/// <param name="familyInstance">
/// The family instance of a window.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <returns>
/// The list of handles created.
/// </returns>
public static IList <IFCAnyHandle> CreateWindowPanelProperties(ExporterIFC exporterIFC,
Element familyInstance, string description)
{
IList <IFCAnyHandle> panels = new List <IFCAnyHandle>();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
double lengthScale = exporterIFC.LinearScale;
const int maxPanels = 1000; // arbitrary large number to prevent infinite loops.
for (int panelNumber = 1; panelNumber < maxPanels; panelNumber++)
{
string frameDepthCurrString = "FrameDepth" + panelNumber.ToString();
string frameThicknessCurrString = "FrameThickness" + panelNumber.ToString();
IFCWindowPanelOperation panelOperation = GetIFCWindowPanelOperation("", familyInstance, panelNumber);
IFCWindowPanelPosition panelPosition = GetIFCWindowPanelPosition("", familyInstance, panelNumber);
if (panelOperation == IFCWindowPanelOperation.NotDefined && panelPosition == IFCWindowPanelPosition.NotDefined)
{
break;
}
double?frameDepth = null;
double?frameThickness = null;
double value1, value2;
if (((ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, frameDepthCurrString, out value1) != null) ||
((panelNumber == 1) && (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FrameDepth", out value1) != null))) &&
((ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, frameThicknessCurrString, out value2) != null) ||
((panelNumber == 1) && (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FrameThickness", out value2) != null))))
{
frameDepth = value1 * lengthScale;
frameThickness = value2 * lengthScale;
}
string panelGUID = GUIDUtil.CreateGUID();
string panelName = NamingUtil.GetIFCNamePlusIndex(familyInstance, panelNumber);
panels.Add(IFCInstanceExporter.CreateWindowPanelProperties(file, panelGUID, ownerHistory,
panelName, description, panelOperation, panelPosition, frameDepth, frameThickness, null));
}
return(panels);
}
/// <summary>
/// Exports an element as a zone.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportZone(ExporterIFC exporterIFC, Zone element,
ProductWrapper productWrapper)
{
if (element == null)
return;
HashSet<IFCAnyHandle> spaceHnds = new HashSet<IFCAnyHandle>();
SpaceSet spaces = element.Spaces;
foreach (Space space in spaces)
{
if (space == null)
continue;
IFCAnyHandle spaceHnd = ExporterCacheManager.SpatialElementHandleCache.Find(space.Id);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(spaceHnd))
spaceHnds.Add(spaceHnd);
}
if (spaceHnds.Count == 0)
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
IFCAnyHandle zoneHnd = IFCInstanceExporter.CreateZone(file, guid, ownerHistory, name, description, objectType);
productWrapper.AddElement(element, zoneHnd);
string relAssignsGuid = GUIDUtil.CreateSubElementGUID(element, (int) IFCZoneSubElements.RelAssignsToGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, relAssignsGuid, ownerHistory, null, null, spaceHnds, null, zoneHnd);
tr.Commit();
return;
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRoofAsParts(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle localPlacement = setter.GetPlacement();
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(setter.GetPlacement());
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
IFCAnyHandle prodRepHnd = null;
string elementGUID = ExporterIFCUtils.CreateGUID(element);
string origElementName = exporterIFC.GetName();
string elementName = NamingUtil.GetNameOverride(element, origElementName);
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementId = NamingUtil.CreateIFCElementId(element);
//need to convert the string to enum
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription, elementObjectType, localPlacement, prodRepHnd, elementId, GetIFCRoofType(ifcEnumType));
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(roofHandle, setter, extrusionCreationData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(roofHandle, element, extrusionCreationData, exporterIFC, extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
transaction.Commit();
}
}
}
/// <summary>
/// Exports a FabricArea as an IfcGroup. There is no geometry to export.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricArea(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
HashSet <IFCAnyHandle> fabricSheetHandles = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(element.Id, out fabricSheetHandles))
{
return(false);
}
if (fabricSheetHandles == null || fabricSheetHandles.Count == 0)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle fabricArea = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, fabricArea);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, fabricSheetHandles, null, fabricArea);
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a Group as an IfcGroup.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportGroupElement(ExporterIFC exporterIFC, Group element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle groupHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string ifcEnumType;
IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs == IFCExportType.IfcGroup)
{
groupHnd = IFCInstanceExporter.CreateGroup(file, guid, ownerHistory, name, description, objectType);
}
if (groupHnd == null)
{
return(false);
}
productWrapper.AddElement(element, groupHnd);
ExporterCacheManager.GroupCache.RegisterGroup(element.Id, groupHnd);
tr.Commit();
return(true);
}
}
/// <summary>
/// The IfcMemberType shared by all stringers to keep their type. This is a placeholder IfcMemberType.
/// </summary>
public static IFCAnyHandle GetMemberTypeHandle(ExporterIFC exporterIFC, Element stringer)
{
Element stringerType = stringer.Document.GetElement(stringer.GetTypeId());
IFCAnyHandle memberType = ExporterCacheManager.ElementToHandleCache.Find(stringerType.Id);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(memberType))
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string stringerTypeGUID = ExporterIFCUtils.CreateGUID(stringerType);
string origInstanceName = stringerType.Name;
string stringerTypeName = NamingUtil.GetNameOverride(stringerType, origInstanceName);
string stringerTypeDescription = NamingUtil.GetDescriptionOverride(stringerType, null);
string stringerTypeElemId = NamingUtil.CreateIFCElementId(stringerType);
memberType = IFCInstanceExporter.CreateMemberType(file, ExporterIFCUtils.CreateGUID(),
ownerHistory, stringerTypeName, stringerTypeDescription, null, null, null, stringerTypeElemId,
null, IFCMemberType.Stringer);
ExporterCacheManager.ElementToHandleCache.Register(stringerType.Id, memberType);
}
return memberType;
}
/// <summary>
/// The IfcMemberType shared by all stringers to keep their type. This is a placeholder IfcMemberType.
/// </summary>
public static IFCAnyHandle GetMemberTypeHandle(ExporterIFC exporterIFC, Element stringer)
{
Element stringerType = stringer.Document.GetElement(stringer.GetTypeId());
IFCAnyHandle memberType = ExporterCacheManager.ElementToHandleCache.Find(stringerType.Id);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(memberType))
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string stringerTypeGUID = GUIDUtil.CreateGUID(stringerType);
string stringerTypeName = NamingUtil.GetNameOverride(stringerType, NamingUtil.GetIFCName(stringerType));
string stringerTypeDescription = NamingUtil.GetDescriptionOverride(stringerType, null);
string stringerTypeTag = NamingUtil.GetTagOverride(stringerType, NamingUtil.CreateIFCElementId(stringerType));
string stringerApplicableOccurence = NamingUtil.GetOverrideStringValue(stringerType, "IfcApplicableOccurence", null);
string stringerElementType = NamingUtil.GetOverrideStringValue(stringerType, "IfcElementType", null);
memberType = IFCInstanceExporter.CreateMemberType(file, stringerTypeGUID,
ownerHistory, stringerTypeName, stringerTypeDescription, stringerApplicableOccurence, null, null, stringerTypeTag,
stringerElementType, IFCMemberType.Stringer);
ExporterCacheManager.ElementToHandleCache.Register(stringerType.Id, memberType);
}
return memberType;
}
/// <summary>
/// Exports an element as a group.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportAreaScheme(ExporterIFC exporterIFC, AreaScheme element,
ProductWrapper productWrapper)
{
if (element == null)
return;
HashSet<IFCAnyHandle> areaHandles = null;
if (!ExporterCacheManager.AreaSchemeCache.TryGetValue(element.Id, out areaHandles))
return;
if (areaHandles == null || areaHandles.Count == 0)
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, element.Name);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle areaScheme = IFCInstanceExporter.CreateGroup(file, guid,
ownerHistory, name, description, objectType);
productWrapper.AddElement(element, areaScheme);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, areaHandles, null, areaScheme);
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element as 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 a Group as an IfcGroup.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportGroupElement(ExporterIFC exporterIFC, Group element,
ProductWrapper productWrapper)
{
if (element == null)
return false;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle groupHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string ifcEnumType;
IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs == IFCExportType.ExportGroup)
{
groupHnd = IFCInstanceExporter.CreateGroup(file, guid, ownerHistory, name, description, objectType);
}
if (groupHnd == null)
return false;
productWrapper.AddElement(element, groupHnd);
ExporterCacheManager.GroupCache.RegisterGroup(element.Id, groupHnd);
tr.Commit();
return true;
}
}
/// <summary>
/// Exports 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 family instance as a mapped item.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="familyInstance">
/// The family instance to be exported.
/// </param>
/// <param name="exportType">
/// The export type.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="wrapper">
/// The ProductWrapper.
/// </param>
/// <param name="overrideLevelId">
/// The level id.
/// </param>
/// <param name="range">
/// The range of this family instance to be exported.
/// </param>
public static void ExportFamilyInstanceAsMappedItem(ExporterIFC exporterIFC,
FamilyInstance familyInstance, IFCExportType exportType, string ifcEnumType,
ProductWrapper wrapper, ElementId overrideLevelId, IFCRange range, IFCAnyHandle parentLocalPlacement)
{
bool exportParts = PartExporter.CanExportParts(familyInstance);
bool isSplit = range != null;
if (exportParts && !PartExporter.CanExportElementInPartExport(familyInstance, isSplit ? overrideLevelId : familyInstance.Level.Id, isSplit))
return;
Document doc = familyInstance.Document;
IFCFile file = exporterIFC.GetFile();
FamilySymbol familySymbol = ExporterIFCUtils.GetOriginalSymbol(familyInstance);
if (familySymbol == null)
return;
ProductWrapper familyProductWrapper = ProductWrapper.Create(wrapper);
double scale = exporterIFC.LinearScale;
Options options = GeometryUtil.GetIFCExportGeometryOptions();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
HostObject hostElement = familyInstance.Host as HostObject; //hostElement could be null
ElementId categoryId = CategoryUtil.GetSafeCategoryId(familySymbol);
//string emptyString = "";
string familyName = familySymbol.Name;
string objectType = familyName;
// A Family Instance can have its own copy of geometry, or use the symbol's copy with a transform.
// The routine below tells us whether to use the Instance's copy or the Symbol's copy.
bool useInstanceGeometry = ExporterIFCUtils.UsesInstanceGeometry(familyInstance);
IList<IFCExtrusionData> cutPairOpeningsForColumns = new List<IFCExtrusionData>();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
Transform trf = familyInstance.GetTransform();
// Extra information if we are exporting a door or a window.
IFCDoorWindowInfo doorWindowInfo = null;
if (exportType == IFCExportType.ExportDoorType)
doorWindowInfo = IFCDoorWindowInfo.CreateDoorInfo(exporterIFC, familyInstance, familySymbol, hostElement, overrideLevelId, trf);
else if (exportType == IFCExportType.ExportWindowType)
doorWindowInfo = IFCDoorWindowInfo.CreateWindowInfo(exporterIFC, familyInstance, familySymbol, hostElement, overrideLevelId, trf);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
XYZ extraOffset = XYZ.Zero;
bool flipped = doorWindowInfo != null ? doorWindowInfo.IsSymbolFlipped : false;
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(familySymbol.Id, flipped);
bool found = currentTypeInfo.IsValid();
Family family = familySymbol.Family;
// TODO: this code to be removed by ExtrusionAnalyzer code.
bool trySpecialColumnCreation = ((exportType == IFCExportType.ExportColumnType) && (!family.IsInPlace));
IList<GeometryObject> geomObjects = new List<GeometryObject>();
Transform brepOffsetTransform = null;
Transform doorWindowTrf = Transform.Identity;
// We will create a new mapped type if:
// 1. We are exporting part of a column or in-place wall (range != null), OR
// 2. We are using the instance's copy of the geometry (that it, it has unique geometry), OR
// 3. We haven't already created the type.
bool creatingType = ((range != null) || useInstanceGeometry || !found);
if (creatingType)
{
IFCAnyHandle bodyRepresentation = null;
IFCAnyHandle planRepresentation = null;
// If we are using the instance geometry, ignore the transformation.
if (useInstanceGeometry)
trf = Transform.Identity;
// TODO: this code to be removed by ExtrusionAnalyzer code.
if (trySpecialColumnCreation)
{
XYZ rangeOffset = trf.Origin;
IFCFamilyInstanceExtrusionExportResults results;
results = ExporterIFCUtils.ExportFamilyInstanceAsExtrusion(exporterIFC, familyInstance, useInstanceGeometry, range, overrideLevelId, extraParams);
bodyRepresentation = results.GetExtrusionHandle();
extraOffset = results.ExtraOffset;
cutPairOpeningsForColumns = results.GetCutPairOpenings();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation))
{
typeInfo.MaterialIds.Add(results.MaterialId);
// add in level for real columns, not in-place ones.
Element actualLevel =
(overrideLevelId == ElementId.InvalidElementId) ? familyInstance.Level : doc.GetElement(overrideLevelId);
if (actualLevel != null)
{
IFCLevelInfo levelInfo = exporterIFC.GetLevelInfo(actualLevel.Id);
double nonStoryLevelOffset = LevelUtil.GetNonStoryLevelOffsetIfAny(exporterIFC, actualLevel as Level);
if (range != null)
{
rangeOffset = new XYZ(rangeOffset.X, rangeOffset.Y, levelInfo.Elevation + nonStoryLevelOffset);
}
}
}
rangeOffset += extraOffset;
trf.Origin = rangeOffset;
}
IFCAnyHandle dummyPlacement = null;
if (doorWindowInfo != null)
{
doorWindowTrf = ExporterIFCUtils.GetTransformForDoorOrWindow(familyInstance, familySymbol, doorWindowInfo);
}
else
{
dummyPlacement = IFCInstanceExporter.CreateLocalPlacement(file, null, ExporterUtil.CreateAxis2Placement3D(file));
extraParams.SetLocalPlacement(dummyPlacement);
}
bool needToCreate2d = ExporterCacheManager.ExportOptionsCache.ExportAnnotations;
bool needToCreate3d = IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation);
if (needToCreate2d || needToCreate3d)
{
using (IFCTransformSetter trfSetter = IFCTransformSetter.Create())
{
if (doorWindowInfo != null)
{
trfSetter.Initialize(exporterIFC, doorWindowTrf);
}
GeometryElement exportGeometry =
useInstanceGeometry ? familyInstance.get_Geometry(options) : familySymbol.get_Geometry(options);
if (exportGeometry == null)
return;
if (needToCreate3d)
{
SolidMeshGeometryInfo solidMeshCapsule = null;
if (range == null)
{
solidMeshCapsule = GeometryUtil.GetSolidMeshGeometry(exportGeometry, Transform.Identity);
}
else
{
solidMeshCapsule = GeometryUtil.GetClippedSolidMeshGeometry(exportGeometry, range);
}
IList<Solid> solids = solidMeshCapsule.GetSolids();
IList<Mesh> polyMeshes = solidMeshCapsule.GetMeshes();
if (range != null && (solids.Count == 0 && polyMeshes.Count == 0))
return; // no proper split geometry
geomObjects = FamilyExporterUtil.RemoveSolidsAndMeshesSetToDontExport(doc, exporterIFC, solids, polyMeshes);
if (geomObjects.Count == 0 && (solids.Count > 0 || polyMeshes.Count > 0))
return;
bool tryToExportAsExtrusion = (!exporterIFC.ExportAs2x2 || (exportType == IFCExportType.ExportColumnType));
if (exportType == IFCExportType.ExportColumnType)
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3CoordinationView2 &&
solids.Count > 0)
{
LocationPoint point = familyInstance.Location as LocationPoint;
XYZ orig = XYZ.Zero;
if (point != null)
orig = point.Point;
Plane plane = new Plane(XYZ.BasisX, XYZ.BasisY, orig);
bool completelyClipped = false;
HashSet<ElementId> materialIds = null;
bodyRepresentation = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, familyInstance,
categoryId, solids, plane, XYZ.BasisZ, null, out completelyClipped, out materialIds);
typeInfo.MaterialIds = materialIds;
}
}
else
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryXYZ;
}
BodyData bodyData = null;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation))
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(tryToExportAsExtrusion);
if (geomObjects.Count > 0)
{
bodyData = BodyExporter.ExportBody(familyInstance.Document.Application, exporterIFC, familyInstance, categoryId, ElementId.InvalidElementId,
geomObjects, bodyExporterOptions, extraParams);
typeInfo.MaterialIds = bodyData.MaterialIds;
}
else
{
IList<GeometryObject> exportedGeometries = new List<GeometryObject>();
exportedGeometries.Add(exportGeometry);
bodyData = BodyExporter.ExportBody(familyInstance.Document.Application, exporterIFC, familyInstance, categoryId, ElementId.InvalidElementId,
exportedGeometries, bodyExporterOptions, extraParams);
}
bodyRepresentation = bodyData.RepresentationHnd;
brepOffsetTransform = bodyData.BrepOffsetTransform;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation))
{
extraParams.ClearOpenings();
return;
}
}
// By default: if exporting IFC2x3 or later, export 2D plan rep of family, if it exists, unless we are exporting Coordination View V2.
// This default can be overridden in the export options.
if (needToCreate2d)
{
XYZ curveOffset = new XYZ(0, 0, 0);
if (brepOffsetTransform != null)
curveOffset = -brepOffsetTransform.Origin / scale;
HashSet<IFCAnyHandle> curveSet = new HashSet<IFCAnyHandle>();
{
Transform planeTrf = doorWindowTrf.Inverse;
Plane plane = new Plane(planeTrf.get_Basis(0), planeTrf.get_Basis(1), planeTrf.Origin);
XYZ projDir = new XYZ(0, 0, 1);
IFCGeometryInfo IFCGeometryInfo = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, plane, projDir, true);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, IFCGeometryInfo, exportGeometry, curveOffset, false);
IList<IFCAnyHandle> curves = IFCGeometryInfo.GetCurves();
foreach (IFCAnyHandle curve in curves)
curveSet.Add(curve);
if (curveSet.Count > 0)
{
IFCAnyHandle contextOfItems2d = exporterIFC.Get2DContextHandle();
IFCAnyHandle curveRepresentationItem = IFCInstanceExporter.CreateGeometricSet(file, curveSet);
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(curveRepresentationItem);
planRepresentation = RepresentationUtil.CreateGeometricSetRep(exporterIFC, familyInstance, categoryId, "Annotation",
contextOfItems2d, bodyItems);
}
}
}
}
}
if (doorWindowInfo != null)
{
typeInfo.StyleTransform = doorWindowTrf.Inverse;
}
else
{
if (!MathUtil.IsAlmostZero(extraOffset.DotProduct(extraOffset)))
{
Transform newTransform = typeInfo.StyleTransform;
XYZ newOrig = newTransform.Origin + extraOffset;
newTransform.Origin = newOrig;
typeInfo.StyleTransform = newTransform;
}
typeInfo.StyleTransform = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, extraParams.GetLocalPlacement());
}
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap2dHnd = null;
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRepresentation);
IList<IFCAnyHandle> repMapList = new List<IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(planRepresentation))
{
repMap2dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, planRepresentation);
repMapList.Add(repMap2dHnd);
}
// for Door, Window
bool paramTakesPrecedence = false; // For Revit, this is currently always false.
bool sizeable = false;
// for many
HashSet<IFCAnyHandle> propertySets = new HashSet<IFCAnyHandle>();
string guid = GUIDUtil.CreateGUID(familySymbol);
string symId = NamingUtil.CreateIFCElementId(familySymbol);
// This covers many generic types. If we can't find it in the list here, do custom exports.
IFCAnyHandle typeStyle = FamilyExporterUtil.ExportGenericType(file, exportType, ifcEnumType, guid,
ownerHistory, objectType, null, null, propertySets, repMapList, symId, objectType,
familyInstance, familySymbol);
// Cover special cases not covered above.
if (IFCAnyHandleUtil.IsNullOrHasNoValue(typeStyle))
{
switch (exportType)
{
case IFCExportType.ExportColumnType:
{
// If we are using the instance GRep, then we have to create a generic GUID for the
// column type, as they share the same ElementId.
string colGUID = null;
string colElemId = null;
if (useInstanceGeometry)
colGUID = GUIDUtil.CreateGUID();
else
colGUID = guid;
colElemId = NamingUtil.CreateIFCElementId(familySymbol);
string columnType = "Column";
typeStyle = IFCInstanceExporter.CreateColumnType(file, colGUID, ownerHistory, objectType,
null, null, propertySets, repMapList, colElemId,
objectType, GetColumnType(familyInstance, columnType));
break;
}
case IFCExportType.ExportDoorType:
{
string constructionType = string.Empty;
ParameterUtil.GetStringValueFromElementOrSymbol(familyInstance, "Construction", out constructionType);
IFCAnyHandle doorLining = DoorWindowUtil.CreateDoorLiningProperties(exporterIFC, familyInstance);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(doorLining))
propertySets.Add(doorLining);
IList<IFCAnyHandle> doorPanels = DoorWindowUtil.CreateDoorPanelProperties(exporterIFC, doorWindowInfo,
familyInstance);
propertySets.UnionWith(doorPanels);
string doorStyleGUID = GUIDUtil.CreateGUID();
string doorStyleElemId = NamingUtil.CreateIFCElementId(familySymbol);
typeStyle = IFCInstanceExporter.CreateDoorStyle(file, doorStyleGUID, ownerHistory, objectType,
null, null, propertySets, repMapList, doorStyleElemId,
GetDoorStyleOperation(doorWindowInfo.DoorOperationType), GetDoorStyleConstruction(familyInstance, constructionType),
paramTakesPrecedence, sizeable);
break;
}
case IFCExportType.ExportSystemFurnitureElementType:
{
string furnitureId = NamingUtil.CreateIFCElementId(familySymbol);
typeStyle = IFCInstanceExporter.CreateSystemFurnitureElementType(file, guid, ownerHistory, objectType,
null, null, propertySets, repMapList, furnitureId,
objectType);
break;
}
case IFCExportType.ExportWindowType:
{
Toolkit.IFCWindowStyleOperation operationType = DoorWindowUtil.GetIFCWindowStyleOperation(familySymbol);
IFCWindowStyleConstruction constructionType = DoorWindowUtil.GetIFCWindowStyleConstruction(familyInstance, "");
IFCAnyHandle windowLining = DoorWindowUtil.CreateWindowLiningProperties(exporterIFC, familyInstance, null);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(windowLining))
propertySets.Add(windowLining);
IList<IFCAnyHandle> windowPanels =
DoorWindowUtil.CreateWindowPanelProperties(exporterIFC, familyInstance, null);
propertySets.UnionWith(windowPanels);
string windowStyleGUID = GUIDUtil.CreateGUID();
string windowStyleElemId = NamingUtil.CreateIFCElementId(familySymbol);
typeStyle = IFCInstanceExporter.CreateWindowStyle(file, windowStyleGUID, ownerHistory, objectType,
null, null, propertySets, repMapList, windowStyleElemId,
constructionType, operationType, paramTakesPrecedence, sizeable);
break;
}
case IFCExportType.ExportBuildingElementProxy:
default:
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd))
typeInfo.Map2DHandle = repMap2dHnd;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd))
typeInfo.Map3DHandle = repMap3dHnd;
break;
}
}
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(typeStyle))
{
CategoryUtil.CreateMaterialAssociations(doc, exporterIFC, typeStyle, typeInfo.MaterialIds);
typeInfo.Style = typeStyle;
if (((exportType == IFCExportType.ExportColumnType) && trySpecialColumnCreation) ||
(exportType == IFCExportType.ExportMemberType))
{
typeInfo.ScaledArea = extraParams.ScaledArea;
typeInfo.ScaledDepth = extraParams.ScaledLength;
typeInfo.ScaledInnerPerimeter = extraParams.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extraParams.ScaledOuterPerimeter;
}
ClassificationUtil.CreateUniformatClassification(exporterIFC, file, familySymbol, typeStyle);
}
}
else if (!creatingType && (trySpecialColumnCreation))
{
// still need to modify instance trf for columns.
trf.Origin += GetLevelOffsetForExtrudedColumns(exporterIFC, familyInstance, overrideLevelId, extraParams);
}
if (found && !typeInfo.IsValid())
{
typeInfo = currentTypeInfo;
}
// we'll pretend we succeeded, but we'll do nothing.
if (!typeInfo.IsValid())
return;
// add to the map, as long as we are not using range, not using instance geometry, and don't have extra openings.
if ((range == null) && !useInstanceGeometry && (extraParams.GetOpenings().Count == 0))
ExporterCacheManager.TypeObjectsCache.Register(familySymbol.Id, flipped, typeInfo);
Transform oldTrf = new Transform(trf);
XYZ scaledMapOrigin = XYZ.Zero;
trf = trf.Multiply(typeInfo.StyleTransform);
// create instance.
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
{
IFCAnyHandle contextOfItems2d = exporterIFC.Get2DContextHandle();
IFCAnyHandle contextOfItems3d = exporterIFC.Get3DContextHandle("Body");
// for proxies, we store the IfcRepresentationMap directly since there is no style.
IFCAnyHandle style = typeInfo.Style;
IList<IFCAnyHandle> repMapList = !IFCAnyHandleUtil.IsNullOrHasNoValue(style) ?
GeometryUtil.GetRepresentationMaps(style) : null;
int numReps = repMapList != null ? repMapList.Count : 0;
IFCAnyHandle repMap2dHnd = typeInfo.Map2DHandle;
IFCAnyHandle repMap3dHnd = typeInfo.Map3DHandle;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd) && (numReps > 0))
repMap3dHnd = repMapList[0];
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd) && (numReps > 1))
repMap2dHnd = repMapList[1];
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd))
{
IList<IFCAnyHandle> representations = new List<IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMap3dHnd, scaledMapOrigin));
IFCAnyHandle shapeRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC, familyInstance, categoryId, contextOfItems3d,
representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
return;
shapeReps.Add(shapeRep);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd))
{
HashSet<IFCAnyHandle> representations = new HashSet<IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMap2dHnd, scaledMapOrigin));
IFCAnyHandle shapeRep = RepresentationUtil.CreatePlanMappedItemRep(exporterIFC, familyInstance, categoryId, contextOfItems2d,
representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
return;
shapeReps.Add(shapeRep);
}
}
IFCAnyHandle boundingBoxRep = null;
Transform boundingBoxTrf = (brepOffsetTransform != null) ? brepOffsetTransform.Inverse : Transform.Identity;
if (geomObjects.Count > 0)
boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geomObjects, boundingBoxTrf);
else
{
boundingBoxTrf = boundingBoxTrf.Multiply(trf.Inverse);
boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, familyInstance.get_Geometry(options), boundingBoxTrf);
}
if (boundingBoxRep != null)
shapeReps.Add(boundingBoxRep);
IFCAnyHandle rep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle instanceHandle = null;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, familyInstance, trf, null, overrideLevelId))
{
string instanceGUID = GUIDUtil.CreateGUID(familyInstance);
string instanceName = NamingUtil.GetIFCName(familyInstance);
string instanceDescription = NamingUtil.GetDescriptionOverride(familyInstance, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(familyInstance, objectType);
string instanceElemId = NamingUtil.CreateIFCElementId(familyInstance);
IFCAnyHandle localPlacement = setter.GetPlacement();
IFCAnyHandle overrideLocalPlacement = null;
if (parentLocalPlacement != null)
{
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(parentLocalPlacement, localPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandle plateLocalPlacement = IFCInstanceExporter.CreateLocalPlacement(file, parentLocalPlacement, relativePlacement);
overrideLocalPlacement = plateLocalPlacement;
}
instanceHandle = FamilyExporterUtil.ExportGenericInstance(exportType, exporterIFC, familyInstance,
wrapper, setter, extraParams, instanceGUID, ownerHistory, instanceName, instanceDescription, instanceObjectType,
exportParts ? null : rep, instanceElemId, overrideLocalPlacement);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, familyInstance, instanceHandle, familyProductWrapper, setter, setter.GetPlacement(), overrideLevelId);
}
if (ElementFilteringUtil.IsMEPType(exportType))
ExporterCacheManager.MEPCache.Register(familyInstance, instanceHandle);
switch (exportType)
{
case IFCExportType.ExportColumnType:
{
IFCAnyHandle placementToUse = localPlacement;
if (!useInstanceGeometry)
{
bool needToCreateOpenings =
(cutPairOpeningsForColumns.Count != 0) || OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = new Transform(oldTrf);
Transform extraRot = new Transform(oldTrf);
extraRot.Origin = XYZ.Zero;
openingTrf = openingTrf.Multiply(extraRot);
openingTrf = openingTrf.Multiply(typeInfo.StyleTransform);
IFCAnyHandle openingRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, openingTrf.Origin * scale,
openingTrf.get_Basis(2), openingTrf.get_Basis(0));
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacement);
GeometryUtil.SetRelativePlacement(openingPlacement, openingRelativePlacement);
placementToUse = openingPlacement;
}
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, cutPairOpeningsForColumns,
exporterIFC, placementToUse, setter, wrapper);
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, exporterIFC,
placementToUse, setter, wrapper);
//export Base Quantities.
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, instanceHandle, familyInstance, typeInfo);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
case IFCExportType.ExportDoorType:
case IFCExportType.ExportWindowType:
{
double doorHeight = doorWindowInfo.OpeningHeight;
if (doorHeight < MathUtil.Eps())
doorHeight = GetMinSymbolHeight(familySymbol);
double doorWidth = doorWindowInfo.OpeningWidth;
if (doorWidth < MathUtil.Eps())
doorWidth = GetMinSymbolWidth(familySymbol);
double height = doorHeight * scale;
double width = doorWidth * scale;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(doorWindowInfo.GetLocalPlacement()))
doorWindowInfo.SetLocalPlacement(localPlacement);
IFCAnyHandle doorWindowOrigLocalPlacement = doorWindowInfo.GetLocalPlacement();
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(localPlacement, doorWindowOrigLocalPlacement);
IFCAnyHandle doorWindowRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, relTrf.Origin, relTrf.BasisZ, relTrf.BasisX);
IFCAnyHandle doorWindowLocalPlacement =
IFCInstanceExporter.CreateLocalPlacement(file, doorWindowOrigLocalPlacement, doorWindowRelativePlacement);
if (exportType == IFCExportType.ExportDoorType)
instanceHandle = IFCInstanceExporter.CreateDoor(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, doorWindowLocalPlacement,
rep, instanceElemId, height, width);
else if (exportType == IFCExportType.ExportWindowType)
instanceHandle = IFCInstanceExporter.CreateWindow(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, doorWindowLocalPlacement,
rep, instanceElemId, height, width);
wrapper.AddElement(instanceHandle, setter, extraParams, true);
exporterIFC.RegisterSpaceBoundingElementHandle(instanceHandle, familyInstance.Id, setter.LevelId);
IFCAnyHandle placementToUse = doorWindowLocalPlacement;
if (!useInstanceGeometry)
{
// correct the placement to the symbol space
bool needToCreateOpenings = OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = Transform.Identity;
openingTrf.Origin = new XYZ(0, 0, setter.Offset);
openingTrf = openingTrf.Multiply(doorWindowTrf);
XYZ scaledOrigin = openingTrf.Origin * exporterIFC.LinearScale;
IFCAnyHandle openingRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, scaledOrigin, openingTrf.BasisZ, openingTrf.BasisX);
IFCAnyHandle openingLocalPlacement =
IFCInstanceExporter.CreateLocalPlacement(file, doorWindowLocalPlacement, openingRelativePlacement);
placementToUse = openingLocalPlacement;
}
}
// only necessary when exporting as possible breps.
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, exporterIFC,
placementToUse, setter, wrapper);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
ExporterIFCUtils.CreateDoorWindowBaseQuantities(exporterIFC, instanceHandle, (doorHeight * scale), (doorWidth * scale));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
case IFCExportType.ExportMemberType:
{
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, exporterIFC,
localPlacement, setter, wrapper);
//export Base Quantities.
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, instanceHandle, familyInstance, typeInfo);
// TODO: create PropertySet!
//createMemberPropertySet(exporter, pFamInst, pWrapper, extraParams);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
case IFCExportType.ExportPlateType:
{
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, exporterIFC,
localPlacement, setter, wrapper);
// TODO: create PropertySet!
//createPlatePropertySet(exporter, pFamInst, pWrapper, extraParams);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
case IFCExportType.ExportTransportElementType:
{
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(familyInstance, out localPlacementToUse);
instanceHandle = IFCInstanceExporter.CreateTransportElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, rep, instanceElemId, null, null, null);
if (roomId == ElementId.InvalidElementId)
{
wrapper.AddElement(instanceHandle, setter, extraParams, true);
}
else
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
wrapper.AddElement(instanceHandle, setter, extraParams, false);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
case IFCExportType.ExportBuildingElementProxy:
default:
{
bool isBuildingElementProxy = (exportType == IFCExportType.ExportBuildingElementProxy);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(familyInstance, out localPlacementToUse);
if (!isBuildingElementProxy)
{
if (FamilyExporterUtil.IsDistributionControlElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateDistributionControlElement(file, instanceGUID,
ownerHistory, instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, rep, instanceElemId, null);
if (roomId == ElementId.InvalidElementId)
{
wrapper.AddElement(instanceHandle, setter, extraParams, true);
}
else
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
wrapper.AddElement(instanceHandle, setter, extraParams, false);
}
}
else if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
isBuildingElementProxy = true;
}
}
if (isBuildingElementProxy)
{
Toolkit.IFCElementComposition proxyType = Toolkit.IFCElementComposition.Element;
instanceHandle = IFCInstanceExporter.CreateBuildingElementProxy(file, instanceGUID,
ownerHistory, instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, rep, instanceElemId, proxyType);
if (roomId == ElementId.InvalidElementId)
{
wrapper.AddElement(instanceHandle, setter, extraParams, true);
}
else
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
wrapper.AddElement(instanceHandle, setter, extraParams, false);
}
}
IFCAnyHandle placementToUse = localPlacement;
if (!useInstanceGeometry)
{
bool needToCreateOpenings = OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = new Transform(oldTrf);
Transform extraRot = new Transform(oldTrf);
extraRot.Origin = XYZ.Zero;
openingTrf = openingTrf.Multiply(extraRot);
openingTrf = openingTrf.Multiply(typeInfo.StyleTransform);
IFCAnyHandle openingRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, openingTrf.Origin * scale,
openingTrf.get_Basis(2), openingTrf.get_Basis(0));
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacement);
GeometryUtil.SetRelativePlacement(openingPlacement, openingRelativePlacement);
placementToUse = openingPlacement;
}
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, exporterIFC,
placementToUse, setter, wrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, familyInstance, wrapper);
break;
}
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
if (doorWindowInfo != null)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(doorWindowInfo.GetOpening()))
{
string relGUID = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelFillsElement(file, relGUID, ownerHistory, null, null, doorWindowInfo.GetOpening(), instanceHandle);
}
else if (doorWindowInfo.NeedsOpening)
{
bool added = doorWindowInfo.SetDelayedFamilyInstance(instanceHandle, localPlacement, doorWindowInfo.AssignedLevelId);
if (added)
exporterIFC.RegisterDoorWindowForOpeningUpdate(doorWindowInfo);
else
{
// we need to fill a later opening.
exporterIFC.RegisterDoorWindowForUncreatedOpening(familyInstance.Id, instanceHandle);
}
}
}
if (!exportParts)
CategoryUtil.CreateMaterialAssociations(doc, exporterIFC, instanceHandle, typeInfo.MaterialIds);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(typeInfo.Style))
ExporterCacheManager.TypeRelationsCache.Add(typeInfo.Style, instanceHandle);
}
}
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, ProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
IFCAnyHandle prodRep = null;
ElementId matId = ElementId.InvalidElementId;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string footingType = GetIFCFootingType(ifcEnumType); // need to keep it for legacy support when original data follows slightly diff naming
footingType = IFCValidateEntry.GetValidIFCType(element, footingType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceTag, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.LocalPlacement, null);
}
else
{
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, footing, matId);
}
}
productWrapper.AddElement(element, footing, setter, ecData, true);
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Creates a new IfcAnnotation object.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="curveElement">The curve element.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="sketchPlaneId">The sketch plane id.</param>
/// <param name="refPlane">The reference plane.</param>
/// <param name="curveStyle">The curve style.</param>
/// <param name="placementSetter">The placemenet setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="repItemHnd">The representation item.</param>
/// <returns>The handle.</returns>
static IFCAnyHandle CreateCurveAnnotation(ExporterIFC exporterIFC, Element curveElement, ElementId categoryId, ElementId sketchPlaneId,
Plane refPlane, IFCAnyHandle curveStyle, IFCPlacementSetter placementSetter, IFCAnyHandle localPlacement, IFCAnyHandle repItemHnd)
{
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, curveElement, categoryId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
throw new Exception("Failed to create shape representation.");
}
List <IFCAnyHandle> shapes = new List <IFCAnyHandle>();
shapes.Add(bodyRepHnd);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapes);
XYZ xDir = refPlane.XVec; XYZ zDir = refPlane.Normal; XYZ origin = refPlane.Origin;
// subtract out level origin if we didn't already before.
IFCLevelInfo levelInfo = placementSetter.GetLevelInfo();
if (levelInfo != null && !MathUtil.IsAlmostEqual(zDir.Z, 1.0))
{
zDir -= new XYZ(0, 0, levelInfo.Elevation);
}
origin = origin * exporterIFC.LinearScale;
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis(file, origin, zDir, xDir);
GeometryUtil.SetRelativePlacement(localPlacement, relativePlacement);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, localPlacement, prodShapeHnd);
return(annotation);
}
/// <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>
/// Creates a new IfcAnnotation object.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="curveElement">The curve element.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="sketchPlaneId">The sketch plane id.</param>
/// <param name="refPlane">The reference plane.</param>
/// <param name="curveStyle">The curve style.</param>
/// <param name="placementSetter">The placemenet setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="repItemHnd">The representation item.</param>
/// <returns>The handle.</returns>
static IFCAnyHandle CreateCurveAnnotation(ExporterIFC exporterIFC, Element curveElement, ElementId categoryId, ElementId sketchPlaneId,
Plane refPlane, IFCAnyHandle curveStyle, PlacementSetter placementSetter, IFCAnyHandle localPlacement, IFCAnyHandle repItemHnd)
{
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, curveElement, categoryId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
throw new Exception("Failed to create shape representation.");
List<IFCAnyHandle> shapes = new List<IFCAnyHandle>();
shapes.Add(bodyRepHnd);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapes);
XYZ xDir = refPlane.XVec; XYZ zDir = refPlane.Normal; XYZ origin = refPlane.Origin;
// subtract out level origin if we didn't already before.
IFCLevelInfo levelInfo = placementSetter.LevelInfo;
if (levelInfo != null && !MathUtil.IsAlmostEqual(zDir.Z, 1.0))
{
zDir -= new XYZ(0, 0, levelInfo.Elevation);
}
origin = UnitUtil.ScaleLength(origin);
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis(file, origin, zDir, xDir);
GeometryUtil.SetRelativePlacement(localPlacement, relativePlacement);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, GUIDUtil.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, localPlacement, prodShapeHnd);
return annotation;
}
/// <summary>
/// Exports the IFC element quantities.
/// </summary>
/// <param name="exporterIFC">The IFC exporter object.</param>
/// <param name="element ">The element whose quantities are exported.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
private static void ExportElementQuantities(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (productWrapper.IsEmpty())
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
Document doc = element.Document;
ElementType elemType = doc.GetElement(element.GetTypeId()) as ElementType;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ICollection<IFCAnyHandle> productSet = productWrapper.GetAllObjects();
IList<IList<QuantityDescription>> quantitiesToCreate = ExporterCacheManager.ParameterCache.Quantities;
foreach (IList<QuantityDescription> currStandard in quantitiesToCreate)
{
foreach (QuantityDescription currDesc in currStandard)
{
foreach (IFCAnyHandle prodHnd in productSet)
{
if (currDesc.IsAppropriateType(prodHnd))
{
IFCExtrusionCreationData ifcParams = productWrapper.FindExtrusionCreationParameters(prodHnd);
HashSet<IFCAnyHandle> quantities = currDesc.ProcessEntries(file, exporterIFC, ifcParams, element, elemType);
if (quantities.Count > 0)
{
string paramSetName = currDesc.Name;
string methodName = currDesc.MethodOfMeasurement;
IFCAnyHandle propertySet = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, paramSetName, methodName, null, quantities);
IFCAnyHandle prodHndToUse = prodHnd;
DescriptionCalculator ifcRDC = currDesc.DescriptionCalculator;
if (ifcRDC != null)
{
IFCAnyHandle overrideHnd = ifcRDC.RedirectDescription(exporterIFC, element);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(overrideHnd))
prodHndToUse = overrideHnd;
}
HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
relatedObjects.Add(prodHndToUse);
IFCInstanceExporter.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, propertySet);
}
}
}
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports a gutter element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle bodyRep = BodyExporter.ExportBody(exporterIFC, element, categoryId, ElementId.InvalidElementId,
geometryElement, bodyExporterOptions, ecData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
ecData.ClearOpenings();
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string originalTag = NamingUtil.CreateIFCElementId(element);
// In Revit, we don't have a corresponding type, so we create one for every gutter.
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRep);
List<IFCAnyHandle> repMapList = new List<IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
string elementTypeName = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string typeGuid = GUIDUtil.CreateSubElementGUID(element, (int) IFCHostedSweepSubElements.PipeSegmentType);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, typeGuid, ownerHistory,
elementTypeName, null, null, null, repMapList, originalTag,
elementTypeName, IFCPipeSegmentType.Gutter);
List<IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
ISet<IFCAnyHandle> representations = new HashSet<IFCAnyHandle>();
representations.Add(mappedItem);
IFCAnyHandle bodyMappedItemRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyMappedItemRep))
return;
List<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(bodyMappedItemRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
shapeReps.Add(boundingBoxRep);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
if (roomId == ElementId.InvalidElementId)
localPlacementToUse = ecData.GetLocalPlacement();
string guid = GUIDUtil.CreateGUID(element);
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, elementTypeName);
string tag = NamingUtil.GetTagOverride(element, originalTag);
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(file, guid,
ownerHistory, name, description, objectType, localPlacementToUse, prodRep, tag);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.LevelInfo, ecData, !containedInSpace);
if (containedInSpace)
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, elemHnd);
// Associate segment with type.
ExporterCacheManager.TypeRelationsCache.Add(style, elemHnd);
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports the top stories of a multistory ramp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="rampHnd">The stairs container handle.</param>
/// <param name="components">The components handles.</param>
/// <param name="ecData">The extrusion creation data.</param>
/// <param name="componentECData">The extrusion creation data for the components.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportMultistoryRamp(ExporterIFC exporterIFC, Element ramp, int numFlights,
IFCAnyHandle rampHnd, IList <IFCAnyHandle> components, IList <IFCExtrusionCreationData> componentECData,
PlacementSetter placementSetter, ProductWrapper productWrapper)
{
if (numFlights < 2)
{
return;
}
double heightNonScaled = GetRampHeight(exporterIFC, ramp);
if (heightNonScaled < MathUtil.Eps())
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rampHnd))
{
return;
}
IFCAnyHandle localPlacement = IFCAnyHandleUtil.GetObjectPlacement(rampHnd);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(localPlacement))
{
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
IList <IFCAnyHandle> rampLocalPlacementHnds = new List <IFCAnyHandle>();
IList <IFCLevelInfo> levelInfos = new List <IFCLevelInfo>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle newLevelHnd = null;
// We are going to avoid internal scaling routines, and instead scale in .NET.
double newOffsetUnscaled = 0.0;
IFCLevelInfo currLevelInfo =
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * (ii + 1), 1.0, ramp.Document, out newLevelHnd, out newOffsetUnscaled);
double newOffsetScaled = UnitUtil.ScaleLength(newOffsetUnscaled);
levelInfos.Add(currLevelInfo);
if (levelInfos[ii] == null)
{
levelInfos[ii] = placementSetter.LevelInfo;
}
XYZ orig;
if (ptHnd.HasValue)
{
orig = new XYZ(origCoords[0], origCoords[1], newOffsetScaled);
}
else
{
orig = new XYZ(0.0, 0.0, newOffsetScaled);
}
rampLocalPlacementHnds.Add(ExporterUtil.CreateLocalPlacement(file, newLevelHnd, orig, null, null));
}
IList <List <IFCAnyHandle> > newComponents = new List <List <IFCAnyHandle> >();
for (int ii = 0; ii < numFlights - 1; ii++)
{
newComponents.Add(new List <IFCAnyHandle>());
}
int compIdx = 0;
ElementId catId = CategoryUtil.GetSafeCategoryId(ramp);
foreach (IFCAnyHandle component in components)
{
string componentName = IFCAnyHandleUtil.GetStringAttribute(component, "Name");
string componentDescription = IFCAnyHandleUtil.GetStringAttribute(component, "Description");
string componentObjectType = IFCAnyHandleUtil.GetStringAttribute(component, "ObjectType");
string componentElementTag = IFCAnyHandleUtil.GetStringAttribute(component, "Tag");
IFCAnyHandle componentProdRep = IFCAnyHandleUtil.GetInstanceAttribute(component, "Representation");
IList <string> localComponentNames = new List <string>();
IList <IFCAnyHandle> componentPlacementHnds = new List <IFCAnyHandle>();
IFCAnyHandle localLocalPlacement = IFCAnyHandleUtil.GetObjectPlacement(component);
IFCAnyHandle localRelativePlacement =
(localLocalPlacement == null) ? null : IFCAnyHandleUtil.GetInstanceAttribute(localLocalPlacement, "RelativePlacement");
bool isSubRamp = component.IsSubTypeOf(IFCEntityType.IfcRamp.ToString());
for (int ii = 0; ii < numFlights - 1; ii++)
{
localComponentNames.Add((componentName == null) ? (ii + 2).ToString() : (componentName + ":" + (ii + 2)));
if (isSubRamp)
{
componentPlacementHnds.Add(ExporterUtil.CopyLocalPlacement(file, rampLocalPlacementHnds[ii]));
}
else
{
componentPlacementHnds.Add(IFCInstanceExporter.CreateLocalPlacement(file, rampLocalPlacementHnds[ii], localRelativePlacement));
}
}
IList <IFCAnyHandle> localComponentHnds = new List <IFCAnyHandle>();
if (isSubRamp)
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "ShapeType");
string localRampType = GetIFCRampType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateRamp(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localRampType));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcRampFlight))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateRampFlight(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, "NOTDEFINED"));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcSlab))
{
string componentType = IFCAnyHandleUtil.GetEnumerationAttribute(component, "PredefinedType");
IFCSlabType localLandingType = FloorExporter.GetIFCSlabType(componentType);
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateSlab(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, localLandingType.ToString()));
}
}
else if (IFCAnyHandleUtil.IsSubTypeOf(component, IFCEntityType.IfcMember))
{
for (int ii = 0; ii < numFlights - 1; ii++)
{
IFCAnyHandle representationCopy =
ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, componentProdRep);
localComponentHnds.Add(IFCInstanceExporter.CreateMember(file, GUIDUtil.CreateGUID(), ownerHistory,
localComponentNames[ii], componentDescription, componentObjectType, componentPlacementHnds[ii], representationCopy,
componentElementTag, "STRINGER"));
}
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
if (localComponentHnds[ii] != null)
{
newComponents[ii].Add(localComponentHnds[ii]);
productWrapper.AddElement(null, localComponentHnds[ii], levelInfos[ii], componentECData[compIdx], false);
}
}
compIdx++;
}
// finally add a copy of the container.
IList <IFCAnyHandle> rampCopyHnds = new List <IFCAnyHandle>();
for (int ii = 0; ii < numFlights - 1; ii++)
{
string rampName = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Name");
string rampObjectType = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "ObjectType");
string rampDescription = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Description");
string rampElementTag = IFCAnyHandleUtil.GetStringAttribute(rampHnd, "Tag");
string rampTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(rampHnd, "ShapeType");
string rampType = GetIFCRampType(rampTypeAsString);
string containerRampName = rampName + ":" + (ii + 2);
rampCopyHnds.Add(IFCInstanceExporter.CreateRamp(file, GUIDUtil.CreateGUID(), ownerHistory,
containerRampName, rampDescription, rampObjectType, rampLocalPlacementHnds[ii], null, rampElementTag, rampType));
productWrapper.AddElement(ramp, rampCopyHnds[ii], levelInfos[ii], null, true);
}
for (int ii = 0; ii < numFlights - 1; ii++)
{
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampCopyHnds[ii], newComponents[ii],
rampLocalPlacementHnds[ii]);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(ramp.Id, stairRampInfo);
}
}
/// <summary>
/// Exports an element as an IfcReinforcingMesh.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricSheet(ExporterIFC exporterIFC, FabricSheet sheet,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (sheet == null || geometryElement == null)
return false;
Document doc = sheet.Document;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, sheet, null, null, ExporterUtil.GetBaseLevelIdForElement(sheet)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(sheet);
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(sheet, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
double scale = exporterIFC.LinearScale;
string guid = GUIDUtil.CreateGUID(sheet);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(sheet, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(sheet, null);
string objectType = NamingUtil.GetObjectTypeOverride(sheet, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(sheet);
string steelGrade = NamingUtil.GetOverrideStringValue(sheet, "SteelGrade", null);
double? meshLength = sheet.CutOverallLength;
double? meshWidth = sheet.CutOverallWidth;
Element fabricSheetTypeElem = doc.GetElement(sheet.GetTypeId());
FabricSheetType fabricSheetType = (fabricSheetTypeElem == null) ? null : (fabricSheetTypeElem as FabricSheetType);
double longitudinalBarNominalDiameter = 0.0;
double transverseBarNominalDiameter = 0.0;
double longitudinalBarCrossSectionArea = 0.0;
double transverseBarCrossSectionArea = 0.0;
double longitudinalBarSpacing = 0.0;
double transverseBarSpacing = 0.0;
if (fabricSheetType != null)
{
Element majorFabricWireTypeElem = doc.GetElement(fabricSheetType.MajorDirectionWireType);
FabricWireType majorFabricWireType = (majorFabricWireTypeElem == null) ? null : (majorFabricWireTypeElem as FabricWireType);
if (majorFabricWireType != null)
{
longitudinalBarNominalDiameter = majorFabricWireType.WireDiameter * scale;
double localRadius = longitudinalBarNominalDiameter / 2.0;
longitudinalBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
Element minorFabricWireTypeElem = doc.GetElement(fabricSheetType.MinorDirectionWireType);
FabricWireType minorFabricWireType = (minorFabricWireTypeElem == null) ? null : (minorFabricWireTypeElem as FabricWireType);
if (minorFabricWireType != null)
{
transverseBarNominalDiameter = minorFabricWireType.WireDiameter * scale;
double localRadius = transverseBarNominalDiameter / 2.0;
transverseBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
longitudinalBarSpacing = fabricSheetType.MajorSpacing * scale;
transverseBarSpacing = fabricSheetType.MinorSpacing * scale;
}
IList<IFCAnyHandle> bodyItems = new List<IFCAnyHandle>();
IList<Curve> wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Major);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, longitudinalBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
bodyItems.Add(bodyItem);
}
wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Minor);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, transverseBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
bodyItems.Add(bodyItem);
}
IFCAnyHandle shapeRep = (bodyItems.Count > 0) ?
RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, sheet, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null) :
null;
IList<IFCAnyHandle> shapeReps = null;
if (shapeRep != null)
{
shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
}
IFCAnyHandle prodRep = (shapeReps != null) ? IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps) : null;
IFCAnyHandle fabricSheet = IFCInstanceExporter.CreateReinforcingMesh(file, guid,
ownerHistory, name, description, objectType, localPlacement, prodRep, elementTag,
steelGrade, meshLength, meshWidth, longitudinalBarNominalDiameter, transverseBarNominalDiameter,
longitudinalBarCrossSectionArea, transverseBarCrossSectionArea,
longitudinalBarSpacing, transverseBarSpacing);
ElementId fabricAreaId = sheet.FabricAreaOwnerId;
if (fabricAreaId != ElementId.InvalidElementId)
{
HashSet<IFCAnyHandle> fabricSheets = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(fabricAreaId, out fabricSheets))
{
fabricSheets = new HashSet<IFCAnyHandle>();
ExporterCacheManager.FabricAreaHandleCache[fabricAreaId] = fabricSheets;
}
fabricSheets.Add(fabricSheet);
}
productWrapper.AddElement(sheet, fabricSheet, placementSetter.GetLevelInfo(), ecData, true);
CategoryUtil.CreateMaterialAssociation(exporterIFC, fabricSheet, materialId);
}
}
tr.Commit();
return true;
}
}
static void AddConnection(ExporterIFC exporterIFC, Connector connector, Connector connected, bool isBiDirectional, bool isElectricalDomain)
{
Element inElement = connector.Owner;
Element outElement = connected.Owner;
if (isElectricalDomain)
{
// We may get a connection back to the original element. Ignore it.
if (inElement.Id == outElement.Id)
return;
// Check the outElement to see if it is a Wire; if so, get its connections and "skip" the wire.
if (outElement is Wire)
{
if (m_ProcessedWires.Contains(outElement.Id))
return;
m_ProcessedWires.Add(outElement.Id);
try
{
ConnectorSet wireConnectorSet = MEPCache.GetConnectorsForWire(outElement as Wire);
if (wireConnectorSet != null)
{
foreach (Connector connectedToWire in wireConnectorSet)
ProcessConnections(exporterIFC, connectedToWire, connector);
}
}
catch
{
}
return;
}
}
// Check if the connection already exist
if (ConnectionExists(inElement.Id, outElement.Id))
return;
if (isBiDirectional)
{
if (ConnectionExists(outElement.Id, inElement.Id))
return;
}
IFCAnyHandle inElementIFCHandle = ExporterCacheManager.MEPCache.Find(inElement.Id);
IFCAnyHandle outElementIFCHandle = ExporterCacheManager.MEPCache.Find(outElement.Id);
if (inElementIFCHandle == null || outElementIFCHandle == null ||
!IFCAnyHandleUtil.IsSubTypeOf(inElementIFCHandle, IFCEntityType.IfcElement)
|| !IFCAnyHandleUtil.IsSubTypeOf(outElementIFCHandle, IFCEntityType.IfcElement))
return;
IFCFile ifcFile = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle portOut = null;
IFCAnyHandle portIn = null;
// ----------------------- In Port ----------------------
{
string guid = GUIDUtil.CreateGUID();
IFCFlowDirection flowDir = (isBiDirectional) ? IFCFlowDirection.SourceAndSink : IFCFlowDirection.Sink;
IFCAnyHandle localPlacement = CreateLocalPlacementForConnector(exporterIFC, connector, inElementIFCHandle, flowDir);
string portName = "InPort_" + inElement.Id;
string portType = "Flow"; // Assigned as Port.Description
portIn = IFCInstanceExporter.CreateDistributionPort(ifcFile, guid, ownerHistory, portName, portType, null, localPlacement, null, flowDir);
// Attach the port to the element
guid = GUIDUtil.CreateGUID();
string connectionName = inElement.Id + "|" + guid;
IFCAnyHandle connectorIn = IFCInstanceExporter.CreateRelConnectsPortToElement(ifcFile, guid, ownerHistory, connectionName, portType, portIn, inElementIFCHandle);
}
// ----------------------- Out Port----------------------
{
string guid = GUIDUtil.CreateGUID();
IFCFlowDirection flowDir = (isBiDirectional) ? IFCFlowDirection.SourceAndSink : IFCFlowDirection.Source;
IFCAnyHandle localPlacement = CreateLocalPlacementForConnector(exporterIFC, connected, outElementIFCHandle, flowDir);
string portName = "OutPort_" + outElement.Id;
string portType = "Flow"; // Assigned as Port.Description
portOut = IFCInstanceExporter.CreateDistributionPort(ifcFile, guid, ownerHistory, portName, portType, null, localPlacement, null, flowDir);
// Attach the port to the element
guid = GUIDUtil.CreateGUID();
string connectionName = outElement.Id + "|" + guid;
IFCAnyHandle connectorOut = IFCInstanceExporter.CreateRelConnectsPortToElement(ifcFile, guid, ownerHistory, connectionName, portType, portOut, outElementIFCHandle);
}
// ----------------------- Out Port -> In Port ----------------------
if (portOut != null && portIn != null)
{
Element elemToUse = (inElement.Id.IntegerValue < outElement.Id.IntegerValue) ? inElement : outElement;
string guid = GUIDUtil.CreateGUID();
IFCAnyHandle realizingElement = null;
string connectionName = IFCAnyHandleUtil.GetStringAttribute(portIn, "GlobalId") + "|" + IFCAnyHandleUtil.GetStringAttribute(portOut, "GlobalId");
string connectionType = "Flow"; // Assigned as Description
IFCInstanceExporter.CreateRelConnectsPorts(ifcFile, guid, ownerHistory, connectionName, connectionType, portIn, portOut, realizingElement);
AddConnectionInternal(inElement.Id, outElement.Id);
}
// Add the handles to the connector system.
HashSet<MEPSystem> systemList = new HashSet<MEPSystem>();
try
{
MEPSystem system = connector.MEPSystem;
if (system != null)
systemList.Add(system);
}
catch
{
}
try
{
MEPSystem system = connected.MEPSystem;
if (system != null)
systemList.Add(system);
}
catch
{
}
if (isElectricalDomain)
{
foreach (MEPSystem system in systemList)
{
ExporterCacheManager.SystemsCache.AddElectricalSystem(system.Id);
ExporterCacheManager.SystemsCache.AddHandleToElectricalSystem(system.Id, inElementIFCHandle);
ExporterCacheManager.SystemsCache.AddHandleToElectricalSystem(system.Id, outElementIFCHandle);
ExporterCacheManager.SystemsCache.AddHandleToElectricalSystem(system.Id, portIn);
ExporterCacheManager.SystemsCache.AddHandleToElectricalSystem(system.Id, portOut);
}
}
else
{
foreach (MEPSystem system in systemList)
{
ExporterCacheManager.SystemsCache.AddHandleToBuiltInSystem(system, inElementIFCHandle);
ExporterCacheManager.SystemsCache.AddHandleToBuiltInSystem(system, outElementIFCHandle);
ExporterCacheManager.SystemsCache.AddHandleToBuiltInSystem(system, portIn);
ExporterCacheManager.SystemsCache.AddHandleToBuiltInSystem(system, portOut);
}
}
}
/// <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>
/// Exports Pset_Draughting for IFC 2x2 standard.
/// </summary>
/// <param name="exporterIFC">The IFC exporter object.</param>
/// <param name="element ">The element whose properties are exported.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
private static void ExportPsetDraughtingFor2x2(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string catName = CategoryUtil.GetCategoryName(element);
Color color = CategoryUtil.GetElementColor(element);
HashSet<IFCAnyHandle> nameAndColorProps = new HashSet<IFCAnyHandle>();
nameAndColorProps.Add(PropertyUtil.CreateLabelPropertyFromCache(file, null, "Layername", catName, PropertyValueType.SingleValue, true, null));
//color
{
HashSet<IFCAnyHandle> colorProps = new HashSet<IFCAnyHandle>();
colorProps.Add(PropertyUtil.CreateIntegerPropertyFromCache(file, "Red", color.Red, PropertyValueType.SingleValue));
colorProps.Add(PropertyUtil.CreateIntegerPropertyFromCache(file, "Green", color.Green, PropertyValueType.SingleValue));
colorProps.Add(PropertyUtil.CreateIntegerPropertyFromCache(file, "Blue", color.Blue, PropertyValueType.SingleValue));
string propertyName = "Color";
nameAndColorProps.Add(IFCInstanceExporter.CreateComplexProperty(file, propertyName, null, propertyName, colorProps));
}
string name = "Pset_Draughting"; // IFC 2x2 standard
IFCAnyHandle propertySet2 = IFCInstanceExporter.CreatePropertySet(file, GUIDUtil.CreateGUID(), ownerHistory, name, null, nameAndColorProps);
HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>(productWrapper.GetAllObjects());
IFCInstanceExporter.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, propertySet2);
transaction.Commit();
}
}
/// <summary>
/// Exports an element as an IfcReinforcingMesh.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricSheet(ExporterIFC exporterIFC, FabricSheet sheet,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (sheet == null || geometryElement == null)
{
return(false);
}
Document doc = sheet.Document;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, sheet, null, null, ExporterUtil.GetBaseLevelIdForElement(sheet)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(sheet);
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(sheet, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
double scale = exporterIFC.LinearScale;
string guid = GUIDUtil.CreateGUID(sheet);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(sheet, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(sheet, null);
string objectType = NamingUtil.GetObjectTypeOverride(sheet, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(sheet);
string steelGrade = NamingUtil.GetOverrideStringValue(sheet, "SteelGrade", null);
double?meshLength = sheet.CutOverallLength;
double?meshWidth = sheet.CutOverallWidth;
Element fabricSheetTypeElem = doc.GetElement(sheet.GetTypeId());
FabricSheetType fabricSheetType = (fabricSheetTypeElem == null) ? null : (fabricSheetTypeElem as FabricSheetType);
double longitudinalBarNominalDiameter = 0.0;
double transverseBarNominalDiameter = 0.0;
double longitudinalBarCrossSectionArea = 0.0;
double transverseBarCrossSectionArea = 0.0;
double longitudinalBarSpacing = 0.0;
double transverseBarSpacing = 0.0;
if (fabricSheetType != null)
{
Element majorFabricWireTypeElem = doc.GetElement(fabricSheetType.MajorDirectionWireType);
FabricWireType majorFabricWireType = (majorFabricWireTypeElem == null) ? null : (majorFabricWireTypeElem as FabricWireType);
if (majorFabricWireType != null)
{
longitudinalBarNominalDiameter = majorFabricWireType.WireDiameter * scale;
double localRadius = longitudinalBarNominalDiameter / 2.0;
longitudinalBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
Element minorFabricWireTypeElem = doc.GetElement(fabricSheetType.MinorDirectionWireType);
FabricWireType minorFabricWireType = (minorFabricWireTypeElem == null) ? null : (minorFabricWireTypeElem as FabricWireType);
if (minorFabricWireType != null)
{
transverseBarNominalDiameter = minorFabricWireType.WireDiameter * scale;
double localRadius = transverseBarNominalDiameter / 2.0;
transverseBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
longitudinalBarSpacing = fabricSheetType.MajorSpacing * scale;
transverseBarSpacing = fabricSheetType.MinorSpacing * scale;
}
IList <IFCAnyHandle> bodyItems = new List <IFCAnyHandle>();
IList <Curve> wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Major);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, longitudinalBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Minor);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, transverseBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
IFCAnyHandle shapeRep = (bodyItems.Count > 0) ?
RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, sheet, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null) :
null;
IList <IFCAnyHandle> shapeReps = null;
if (shapeRep != null)
{
shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
}
IFCAnyHandle prodRep = (shapeReps != null) ? IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps) : null;
IFCAnyHandle fabricSheet = IFCInstanceExporter.CreateReinforcingMesh(file, guid,
ownerHistory, name, description, objectType, localPlacement, prodRep, elementTag,
steelGrade, meshLength, meshWidth, longitudinalBarNominalDiameter, transverseBarNominalDiameter,
longitudinalBarCrossSectionArea, transverseBarCrossSectionArea,
longitudinalBarSpacing, transverseBarSpacing);
ElementId fabricAreaId = sheet.FabricAreaOwnerId;
if (fabricAreaId != ElementId.InvalidElementId)
{
HashSet <IFCAnyHandle> fabricSheets = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(fabricAreaId, out fabricSheets))
{
fabricSheets = new HashSet <IFCAnyHandle>();
ExporterCacheManager.FabricAreaHandleCache[fabricAreaId] = fabricSheets;
}
fabricSheets.Add(fabricSheet);
}
productWrapper.AddElement(sheet, fabricSheet, placementSetter.GetLevelInfo(), ecData, true);
CategoryUtil.CreateMaterialAssociation(exporterIFC, fabricSheet, materialId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports the element properties.
/// </summary>
/// <param name="exporterIFC">The IFC exporter object.</param>
/// <param name="element">The element whose properties are exported.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
private static void ExportElementProperties(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
if (productWrapper.IsEmpty())
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
Document doc = element.Document;
ElementType elemType = doc.GetElement(element.GetTypeId()) as ElementType;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ICollection<IFCAnyHandle> productSet = productWrapper.GetAllObjects();
IList<IList<PropertySetDescription>> psetsToCreate = ExporterCacheManager.ParameterCache.PropertySets;
// In some cases, like multi-story stairs and ramps, we may have the same Pset used for multiple levels.
// If ifcParams is null, re-use the property set.
ISet<string> locallyUsedGUIDs = new HashSet<string>();
IDictionary<Tuple<Element, Element, string>, IFCAnyHandle> createdPropertySets =
new Dictionary<Tuple<Element, Element, string>, IFCAnyHandle>();
IDictionary<IFCAnyHandle, HashSet<IFCAnyHandle>> relDefinesByPropertiesMap =
new Dictionary<IFCAnyHandle, HashSet<IFCAnyHandle>>();
foreach (IFCAnyHandle prodHnd in productSet)
{
IList<PropertySetDescription> currPsetsToCreate = GetCurrPSetsToCreate(prodHnd, psetsToCreate);
if (currPsetsToCreate.Count == 0)
continue;
ElementId overrideElementId = ExporterCacheManager.HandleToElementCache.Find(prodHnd);
Element elementToUse = (overrideElementId == ElementId.InvalidElementId) ? element : doc.GetElement(overrideElementId);
ElementType elemTypeToUse = (overrideElementId == ElementId.InvalidElementId) ? elemType : doc.GetElement(elementToUse.GetTypeId()) as ElementType;
if (elemTypeToUse == null)
elemTypeToUse = elemType;
IFCExtrusionCreationData ifcParams = productWrapper.FindExtrusionCreationParameters(prodHnd);
foreach (PropertySetDescription currDesc in currPsetsToCreate)
{
// Last conditional check: if the property set comes from a ViewSchedule, check if the element is in the schedule.
if (currDesc.ViewScheduleId != ElementId.InvalidElementId)
if (!ExporterCacheManager.ViewScheduleElementCache[currDesc.ViewScheduleId].Contains(elementToUse.Id))
continue;
Tuple<Element, Element, string> propertySetKey = new Tuple<Element, Element, string>(elementToUse, elemTypeToUse, currDesc.Name);
IFCAnyHandle propertySet = null;
if ((ifcParams != null) || (!createdPropertySets.TryGetValue(propertySetKey, out propertySet)))
{
HashSet<IFCAnyHandle> props = currDesc.ProcessEntries(file, exporterIFC, ifcParams, elementToUse, elemTypeToUse);
if (props.Count > 0)
{
int subElementIndex = CheckElementTypeValidityForSubIndex(currDesc, prodHnd, element);
string guid = GUIDUtil.CreateSubElementGUID(elementToUse, subElementIndex);
if (locallyUsedGUIDs.Contains(guid))
guid = GUIDUtil.CreateGUID();
else
locallyUsedGUIDs.Add(guid);
string paramSetName = currDesc.Name;
propertySet = IFCInstanceExporter.CreatePropertySet(file, guid, ownerHistory, paramSetName, null, props);
if (ifcParams == null)
createdPropertySets[propertySetKey] = propertySet;
}
}
if (propertySet != null)
{
IFCAnyHandle prodHndToUse = prodHnd;
DescriptionCalculator ifcRDC = currDesc.DescriptionCalculator;
if (ifcRDC != null)
{
IFCAnyHandle overrideHnd = ifcRDC.RedirectDescription(exporterIFC, elementToUse);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(overrideHnd))
prodHndToUse = overrideHnd;
}
HashSet<IFCAnyHandle> relatedObjects = null;
if (!relDefinesByPropertiesMap.TryGetValue(propertySet, out relatedObjects))
{
relatedObjects = new HashSet<IFCAnyHandle>();
relDefinesByPropertiesMap[propertySet] = relatedObjects;
}
relatedObjects.Add(prodHndToUse);
}
}
}
foreach (KeyValuePair<IFCAnyHandle, HashSet<IFCAnyHandle>> relDefinesByProperties in relDefinesByPropertiesMap)
{
IFCInstanceExporter.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null,
relDefinesByProperties.Value, relDefinesByProperties.Key);
}
transaction.Commit();
}
if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
ExportPsetDraughtingFor2x2(exporterIFC, element, productWrapper);
}
/// <summary>
/// Adds openings to an element.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="elementHandles">The parent handles.</param>
/// <param name="curveLoops">The parent CurveLoops.</param>
/// <param name="element">The element.</param>
/// <param name="plane">The plane.</param>
/// <param name="scaledWidth">The width.</param>
/// <param name="range">The range.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="localWrapper">The wrapper.</param>
public static void AddOpeningsToElement(ExporterIFC exporterIFC, IList <IFCAnyHandle> elementHandles, IList <CurveLoop> curveLoops, Element element, Plane plane, double scaledWidth,
IFCRange range, PlacementSetter setter, IFCAnyHandle localPlacement, ProductWrapper localWrapper)
{
IList <IFCOpeningData> openingDataList = ExporterIFCUtils.GetOpeningData(exporterIFC, element, plane, range);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
foreach (IFCOpeningData openingData in openingDataList)
{
Element openingElem = element.Document.GetElement(openingData.OpeningElementId);
if (openingElem == null)
{
openingElem = element;
}
// Don't export the opening if WallSweep category has been turned off.
// This is currently restricted to WallSweeps because the element responsible for the opening could be a variety of things, including a line as part of the elevation profile of the wall.
// As such, we will restrict which element types we check for CanExportElement.
if ((openingElem is WallSweep) && (!ElementFilteringUtil.CanExportElement(exporterIFC, openingElem, true)))
{
continue;
}
IList <IFCExtrusionData> extrusionDataList = openingData.GetExtrusionData();
IFCAnyHandle parentHandle = null;
if (elementHandles.Count > 1 && extrusionDataList.Count > 0)
{
parentHandle = FindParentHandle(elementHandles, curveLoops, extrusionDataList[0].GetLoops()[0]);
}
if (parentHandle == null)
{
parentHandle = elementHandles[0];
}
bool isDoorOrWindowOpening = IsDoorOrWindowOpening(exporterIFC, openingElem, element);
if (isDoorOrWindowOpening)
{
DoorWindowDelayedOpeningCreator delayedCreator =
DoorWindowDelayedOpeningCreator.Create(exporterIFC, openingData, scaledWidth, element.Id, parentHandle, setter.LevelId);
if (delayedCreator != null)
{
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
continue;
}
}
bool canUseElementGUID = !isDoorOrWindowOpening;
IList <Solid> solids = openingData.GetOpeningSolids();
foreach (Solid solid in solids)
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
extrusionCreationData.ReuseLocalPlacement = true;
string openingGUID = null;
if (canUseElementGUID)
{
openingGUID = GUIDUtil.CreateGUID(openingElem);
canUseElementGUID = false;
}
else
{
openingGUID = GUIDUtil.CreateGUID();
}
CreateOpening(exporterIFC, parentHandle, element, openingElem, openingGUID, solid, scaledWidth, openingData.IsRecess, extrusionCreationData,
setter, localWrapper);
}
}
foreach (IFCExtrusionData extrusionData in extrusionDataList)
{
if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
{
extrusionData.ScaledExtrusionLength = scaledWidth;
}
string openingGUID = null;
if (canUseElementGUID)
{
openingGUID = GUIDUtil.CreateGUID(element);
canUseElementGUID = false;
}
else
{
openingGUID = GUIDUtil.CreateGUID();
}
CreateOpening(exporterIFC, parentHandle, localPlacement, element, openingElem, openingGUID, extrusionData, plane, openingData.IsRecess,
setter, localWrapper);
}
}
}
/// <summary>
/// Relates one object to a collection of others.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="optionalGUID">
/// A GUID value, or null to generate a random GUID.
/// </param>
/// <param name="relatingObject">
/// The relating object.
/// </param>
/// <param name="relatedObjects">
/// The related objects.
/// </param>
public static void RelateObjects(ExporterIFC exporterIFC, string optionalGUID, IFCAnyHandle relatingObject, ICollection<IFCAnyHandle> relatedObjects)
{
string guid = (optionalGUID != null) ? optionalGUID : GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelAggregates(exporterIFC.GetFile(), guid, exporterIFC.GetOwnerHistoryHandle(), null, null, relatingObject, new HashSet<IFCAnyHandle>(relatedObjects));
}
/// <summary>
/// Creates an opening from extrusion data.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host handle.</param>
/// <param name="hostPlacement">The host placement.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The opening element.</param>
/// <param name="openingGUID">The opening GUID.</param>
/// <param name="extrusionData">The extrusion data.</param>
/// <param name="plane">The plane.</param>
/// <param name="isRecess">True if it is a recess.</param>
/// <returns>The opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, IFCAnyHandle hostPlacement, Element hostElement,
Element insertElement, string openingGUID, IFCExtrusionData extrusionData, Plane plane, bool isRecess,
PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
IList <CurveLoop> curveLoops = extrusionData.GetLoops();
if (curveLoops.Count == 0)
{
return(null);
}
if (plane == null)
{
// assumption: first curve loop defines the plane.
if (!curveLoops[0].HasPlane())
{
return(null);
}
plane = curveLoops[0].GetPlane();
}
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
IFCAnyHandle openingProdRepHnd = RepresentationUtil.CreateExtrudedProductDefShape(exporterIFC, insertElement, catId,
curveLoops, plane, extrusionData.ExtrusionDirection, extrusionData.ScaledExtrusionLength);
string openingObjectType = isRecess ? "Recess" : "Opening";
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(file, openingGUID, ownerHistory, openingName, null,
openingObjectType, ExporterUtil.CreateLocalPlacement(file, hostPlacement, null), openingProdRepHnd, null);
IFCExtrusionCreationData ecData = null;
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
double height, width;
ecData = new IFCExtrusionCreationData();
if (GeometryUtil.ComputeHeightWidthOfCurveLoop(curveLoops[0], plane, out height, out width))
{
ecData.ScaledHeight = UnitUtil.ScaleLength(height);
ecData.ScaledWidth = UnitUtil.ScaleLength(width);
}
else
{
double area = ExporterIFCUtils.ComputeAreaOfCurveLoops(curveLoops);
ecData.ScaledArea = UnitUtil.ScaleArea(area);
}
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, ecData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(elementForProperties, openingHnd, setter, ecData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
/// <summary>
/// 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>
/// Exports a roof as a container of multiple roof slabs. Returns the handle, if successful.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometry">The geometry of the element.</param>
/// <param name="productWrapper">The product wrapper.</param>
/// <returns>The roof handle.</returns>
public static IFCAnyHandle ExportRoofAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Element element, GeometryElement geometry, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
if (!(element is ExtrusionRoof) && !(element is FootPrintRoof))
{
return(null);
}
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
RoofComponents roofComponents = null;
try
{
roofComponents = ExporterIFCUtils.GetRoofComponents(exporterIFC, element as RoofBase);
}
catch
{
return(null);
}
if (roofComponents == null)
{
return(null);
}
try
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
extrusionCreationData.SetLocalPlacement(localPlacement);
extrusionCreationData.ReuseLocalPlacement = true;
using (TransformSetter trfSetter = TransformSetter.Create())
{
IList <GeometryObject> geometryList = new List <GeometryObject>();
geometryList.Add(geometry);
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, extrusionCreationData);
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
string elementName = NamingUtil.GetIFCName(element);
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementId = NamingUtil.CreateIFCElementId(element);
string roofType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementId, roofType);
IList <IFCAnyHandle> elementHandles = new List <IFCAnyHandle>();
elementHandles.Add(roofHandle);
//only thing supported right now.
XYZ extrusionDir = new XYZ(0, 0, 1);
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IList <CurveLoop> roofCurveloops = roofComponents.GetCurveLoops();
IList <XYZ> planeDirs = roofComponents.GetPlaneDirections();
IList <XYZ> planeOrigins = roofComponents.GetPlaneOrigins();
IList <Face> loopFaces = roofComponents.GetLoopFaces();
double scaledDepth = roofComponents.ScaledDepth;
IList <double> areas = roofComponents.GetAreasOfCurveLoops();
IList <IFCAnyHandle> slabHandles = new List <IFCAnyHandle>();
using (IFCExtrusionCreationData slabExtrusionCreationData = new IFCExtrusionCreationData())
{
slabExtrusionCreationData.SetLocalPlacement(extrusionCreationData.GetLocalPlacement());
slabExtrusionCreationData.ReuseLocalPlacement = false;
slabExtrusionCreationData.ForceOffset = true;
for (int numLoop = 0; numLoop < roofCurveloops.Count; numLoop++)
{
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, slabExtrusionCreationData);
Plane plane = new Plane(planeDirs[numLoop], planeOrigins[numLoop]);
IList <CurveLoop> curveLoops = new List <CurveLoop>();
curveLoops.Add(roofCurveloops[numLoop]);
double slope = Math.Abs(planeDirs[numLoop].Z);
double scaledExtrusionDepth = scaledDepth * slope;
IFCAnyHandle shapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, plane, extrusionDir, scaledExtrusionDepth);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
{
return(null);
}
ElementId matId = HostObjectExporter.GetFirstLayerMaterialId(element as HostObject);
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, element.Document, shapeRep, matId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(shapeRep);
shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, catId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle repHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
// Allow support for up to 256 named IfcSlab components, as defined in IFCSubElementEnums.cs.
string slabGUID = (numLoop < 256) ? GUIDUtil.CreateSubElementGUID(element, (int)IFCRoofSubElements.RoofSlabStart + numLoop) : GUIDUtil.CreateGUID();
IFCAnyHandle slabPlacement = ExporterUtil.CreateLocalPlacement(file, slabExtrusionCreationData.GetLocalPlacement(), null);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, elementName,
elementDescription, elementObjectType, slabPlacement, repHnd, elementId, "ROOF");
//slab quantities
slabExtrusionCreationData.ScaledLength = scaledExtrusionDepth;
slabExtrusionCreationData.ScaledArea = UnitUtil.ScaleArea(areas[numLoop]);
slabExtrusionCreationData.ScaledOuterPerimeter = UnitUtil.ScaleLength(curveLoops[0].GetExactLength());
slabExtrusionCreationData.Slope = UnitUtil.ScaleAngle(Math.Acos(Math.Abs(planeDirs[numLoop].Z)));
productWrapper.AddElement(null, slabHnd, setter, slabExtrusionCreationData, false);
elementHandles.Add(slabHnd);
slabHandles.Add(slabHnd);
}
}
productWrapper.AddElement(element, roofHandle, setter, extrusionCreationData, true);
ExporterUtil.RelateObjects(exporterIFC, null, roofHandle, slabHandles);
OpeningUtil.AddOpeningsToElement(exporterIFC, elementHandles, roofCurveloops, element, null, roofComponents.ScaledDepth,
null, setter, localPlacement, productWrapper);
transaction.Commit();
return(roofHandle);
}
}
}
finally
{
exporterIFC.ClearFaceWithElementHandleMap();
}
}
}
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, ProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ecData.ReuseLocalPlacement = false;
GeometryElement rampGeom = GeometryUtil.GetOneLevelGeometryElement(geometryElement, numFlights);
BodyData bodyData;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
ramp, categoryId, rampGeom, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = GUIDUtil.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string rampName = NamingUtil.GetNameOverride(ramp, NamingUtil.GetIFCName(ramp));
string rampDescription = NamingUtil.GetDescriptionOverride(ramp, null);
string rampObjectType = NamingUtil.GetObjectTypeOverride(ramp, NamingUtil.CreateIFCObjectName(exporterIFC, ramp));
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CreateLocalPlacement(file, ecData.GetLocalPlacement(), null);
string elementTag = NamingUtil.GetTagOverride(ramp, NamingUtil.CreateIFCElementId(ramp));
string rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IList <IFCExtrusionCreationData> componentExtrusionData = new List <IFCExtrusionCreationData>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, containedRampGuid, ownerHistory, rampName,
rampDescription, rampObjectType, containedRampLocalPlacement, representation, elementTag, rampType);
components.Add(containedRampHnd);
componentExtrusionData.Add(ecData);
//productWrapper.AddElement(containedRampHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociations(exporterIFC, containedRampHnd, bodyData.MaterialIds);
string guid = GUIDUtil.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, rampName,
rampDescription, rampObjectType, localPlacement, null, elementTag, rampType);
productWrapper.AddElement(ramp, rampHnd, placementSetter.LevelInfo, ecData, true);
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, localPlacement);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights, rampHnd, components, componentExtrusionData, placementSetter,
productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// 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 a Rebar to IFC ReinforcingMesh.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportRebar(ExporterIFC exporterIFC,
Element element, Autodesk.Revit.DB.View filterView, ProductWrapper productWrapper)
{
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
if (element is Rebar)
{
GeometryElement rebarGeometry = ExporterIFCUtils.GetRebarGeometry(element as Rebar, filterView);
// only options are: Not Export, BuildingElementProxy, or ReinforcingBar/Mesh, depending on layout.
// Not Export is handled previously, and ReinforcingBar vs Mesh will be determined below.
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportType == IFCExportType.ExportBuildingElementProxy)
{
if (rebarGeometry != null)
{
ProxyElementExporter.ExportBuildingElementProxy(exporterIFC, element, rebarGeometry, productWrapper);
transaction.Commit();
}
return;
}
}
IFCAnyHandle prodRep = null;
double scale = exporterIFC.LinearScale;
double totalBarLengthUnscale = GetRebarTotalLength(element);
double volumeUnscale = GetRebarVolume(element);
double totalBarLength = totalBarLengthUnscale * scale;
if (MathUtil.IsAlmostZero(totalBarLength))
return;
ElementId typeId = element.GetTypeId();
RebarBarType elementType = element.Document.GetElement(element.GetTypeId()) as RebarBarType;
double diameter = (elementType == null ? 1.0 / 12.0 : elementType.BarDiameter) * scale;
double radius = diameter / 2.0;
double longitudinalBarNominalDiameter = diameter;
double longitudinalBarCrossSectionArea = (volumeUnscale / totalBarLengthUnscale) * scale * scale;
double barLength = totalBarLength / GetRebarQuantity(element);
IList<Curve> baseCurves = GetRebarCenterlineCurves(element, true, false, false);
int numberOfBarPositions = GetNumberOfBarPositions(element);
for (int i = 0; i < numberOfBarPositions; i++)
{
if (!DoesBarExistAtPosition(element, i))
continue;
Transform barTrf = GetBarPositionTransform(element, i);
IList<Curve> curves = new List<Curve>();
foreach (Curve baseCurve in baseCurves)
{
curves.Add(baseCurve.get_Transformed(barTrf));
}
IFCAnyHandle compositeCurve = GeometryUtil.CreateCompositeCurve(exporterIFC, curves);
IFCAnyHandle sweptDiskSolid = IFCInstanceExporter.CreateSweptDiskSolid(file, compositeCurve, radius, null, 0, 1);
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(sweptDiskSolid);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(shapeRep);
prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
string steelGradeOpt = null;
IFCAnyHandle elemHnd = null;
string rebarGUID = GUIDUtil.CreateGUID(element);
string rebarName = NamingUtil.GetIFCName(element);
string rebarDescription = NamingUtil.GetDescriptionOverride(element, null);
string rebarObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string rebarElemId = NamingUtil.CreateIFCElementId(element);
IFCReinforcingBarRole role = IFCReinforcingBarRole.NotDefined;
elemHnd = IFCInstanceExporter.CreateReinforcingBar(file, rebarGUID, exporterIFC.GetOwnerHistoryHandle(),
rebarName, rebarDescription, rebarObjectType, setter.GetPlacement(),
prodRep, rebarElemId, steelGradeOpt, longitudinalBarNominalDiameter, longitudinalBarCrossSectionArea,
barLength, role, null);
productWrapper.AddElement(elemHnd, setter.GetLevelInfo(), null, true);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
transaction.Commit();
}
}
catch (Exception)
{
// It will throw exception at GetBarPositionTransform when exporting rebars with Revit 2013 UR1 and before versions, so we skip the export.
// It should not come here and will export the rebars properly at Revit later versions.
}
}
/// <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 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>
/// Base implementation to export IFC site object.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="document">The Revit document. It may be null if element isn't.</param>
/// <param name="element">The element. It may be null if document isn't.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
IFCAnyHandle siteHandle = ExporterCacheManager.SiteHandle;
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;
bool exportAsFacetation = !ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2;
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, exportAsFacetation, ref bodyRep, ref boundaryRep);
if (representations.Count == 1 && !IFCAnyHandleUtil.IsNullOrHasNoValue(boundaryRep))
{
// If the first site has no boundaryRep,
// we will add the boundaryRep from second site to it.
representations.Clear();
representations.Add(boundaryRep);
IFCAnyHandleUtil.AddProductRepresentations(siteHandle, representations);
}
appendedToSite = true;
}
}
if (!appendedToSite)
{
siteRepresentation = RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC, element, geometryElement, true, exportAsFacetation);
}
}
List <int> latitude = new List <int>();
List <int> longitude = new List <int>();
ProjectLocation projLocation = doc.ActiveProjectLocation;
IFCAnyHandle relativePlacement = null;
double unscaledElevation = 0.0;
if (projLocation != null)
{
const double scaleToDegrees = 180 / Math.PI;
double latitudeInDeg = projLocation.SiteLocation.Latitude * scaleToDegrees;
double longitudeInDeg = projLocation.SiteLocation.Longitude * scaleToDegrees;
ExporterUtil.GetSafeProjectPositionElevation(doc, out unscaledElevation);
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 (!ExporterCacheManager.ExportOptionsCache.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 (!ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
{
longitude.Add(longFracSec);
}
Transform siteSharedCoordinatesTrf = projLocation.GetTransform().Inverse;
if (!siteSharedCoordinatesTrf.IsIdentity)
{
double unscaledSiteElevation = ExporterCacheManager.ExportOptionsCache.IncludeSiteElevation ? 0.0 : unscaledElevation;
XYZ orig = UnitUtil.ScaleLength(siteSharedCoordinatesTrf.Origin - new XYZ(0, 0, unscaledSiteElevation));
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, orig, siteSharedCoordinatesTrf.BasisZ, siteSharedCoordinatesTrf.BasisX);
}
}
// Get elevation for site.
double elevation = UnitUtil.ScaleLength(unscaledElevation);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
{
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file);
}
IFCAnyHandle localPlacement = IFCInstanceExporter.CreateLocalPlacement(file, null, relativePlacement);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string siteObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
ProjectInfo projectInfo = doc.ProjectInformation;
Element mainSiteElement = (element != null) ? element : projectInfo;
bool exportSite = false;
string siteGUID = null;
string siteName = null;
string siteLongName = null;
string siteLandTitleNumber = null;
string siteDescription = null;
if (element != null)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle))
{
exportSite = true;
// We will use the Project Information site name as the primary name, if it exists.
siteGUID = GUIDUtil.CreateSiteGUID(doc, element);
siteName = NamingUtil.GetOverrideStringValue(projectInfo, "SiteName", NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element)));
siteDescription = NamingUtil.GetDescriptionOverride(element, null);
siteObjectType = NamingUtil.GetObjectTypeOverride(element, siteObjectType);
// Look in site element for "IfcLongName" or project information for either "IfcLongName" or "SiteLongName".
siteLongName = NamingUtil.GetLongNameOverride(projectInfo, NamingUtil.GetLongNameOverride(element, null));
if (string.IsNullOrWhiteSpace(siteLongName))
{
siteLongName = NamingUtil.GetOverrideStringValue(projectInfo, "SiteLongName", null);
}
// Look in site element for "IfcLandTitleNumber" or project information for "SiteLandTitleNumber".
siteLandTitleNumber = NamingUtil.GetOverrideStringValue(element, "IfcLandTitleNumber", null);
if (string.IsNullOrWhiteSpace(siteLandTitleNumber))
{
siteLandTitleNumber = NamingUtil.GetOverrideStringValue(projectInfo, "SiteLandTitleNumber", null);
}
}
}
else
{
exportSite = true;
siteGUID = GUIDUtil.CreateProjectLevelGUID(doc, IFCProjectLevelGUIDType.Site);
siteName = NamingUtil.GetOverrideStringValue(projectInfo, "SiteName", "Default");
siteLongName = NamingUtil.GetLongNameOverride(projectInfo, NamingUtil.GetOverrideStringValue(projectInfo, "SiteLongName", null));
siteLandTitleNumber = NamingUtil.GetOverrideStringValue(projectInfo, "SiteLandTitleNumber", null);
// don't bother if we have nothing in the site whatsoever.
if ((latitude.Count == 0 || longitude.Count == 0) && IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement) &&
string.IsNullOrWhiteSpace(siteLongName) && string.IsNullOrWhiteSpace(siteLandTitleNumber))
{
return;
}
}
if (exportSite)
{
siteHandle = IFCInstanceExporter.CreateSite(file, siteGUID, ownerHistory, siteName, siteDescription, siteObjectType, localPlacement,
siteRepresentation, siteLongName, Toolkit.IFCElementComposition.Element, latitude, longitude, elevation, siteLandTitleNumber, null);
productWrapper.AddSite(mainSiteElement, siteHandle);
ExporterCacheManager.SiteHandle = siteHandle;
}
tr.Commit();
}
}
/// <summary>
/// Creates an opening from a solid.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host object handle.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The insert element.</param>
/// <param name="openingGUID">The GUID for the opening, depending on how the opening is created.</param>
/// <param name="solid">The solid.</param>
/// <param name="scaledHostWidth">The scaled host width.</param>
/// <param name="isRecess">True if it is recess.</param>
/// <param name="extrusionCreationData">The extrusion creation data.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localWrapper">The product wrapper.</param>
/// <returns>The created opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, Element hostElement, Element insertElement, string openingGUID,
Solid solid, double scaledHostWidth, bool isRecess, IFCExtrusionCreationData extrusionCreationData, PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
XYZ prepToWall;
bool isLinearWall = GetOpeningDirection(hostElement, out prepToWall);
if (isLinearWall)
{
extrusionCreationData.CustomAxis = prepToWall;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
BodyData bodyData = BodyExporter.ExportBody(exporterIFC, insertElement, catId, ElementId.InvalidElementId,
solid, bodyExporterOptions, extrusionCreationData);
IFCAnyHandle openingRepHnd = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(openingRepHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(openingRepHnd);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = extrusionCreationData.GetLocalPlacement();
IFCAnyHandle hostObjPlacementHnd = IFCAnyHandleUtil.GetObjectPlacement(hostObjHnd);
Transform relTransform = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(openingPlacement, hostObjPlacementHnd);
openingPlacement = ExporterUtil.CreateLocalPlacement(file, hostObjPlacementHnd,
relTransform.Origin, relTransform.BasisZ, relTransform.BasisX);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
double scaledOpeningLength = extrusionCreationData.ScaledLength;
string openingObjectType = "Opening";
if (!MathUtil.IsAlmostZero(scaledHostWidth) && !MathUtil.IsAlmostZero(scaledOpeningLength))
{
openingObjectType = scaledOpeningLength < (scaledHostWidth - MathUtil.Eps()) ? "Recess" : "Opening";
}
else
{
openingObjectType = isRecess ? "Recess" : "Opening";
}
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjHnd))
{
openingName = IFCAnyHandleUtil.GetStringAttribute(hostObjHnd, "Name");
}
else
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(file, openingGUID, ownerHistory, openingName, null,
openingObjectType, openingPlacement, prodRep, null);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, extrusionCreationData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(insertElement, openingHnd, setter, extrusionCreationData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
/// <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>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
Document document = element.Document;
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
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 = GUIDUtil.CreateGUID();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
string elementId = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(file, guid, ownerHistory,
openingName, null, openingObjectType, openingPlacement, openingRep, elementId);
wrapper.AddElement(null, openingElement, setter, extraParams, true);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, roof))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// If the roof is an in-place family, we will allow any arbitrary orientation. While this may result in some
// in-place "cubes" exporting with the wrong direction, it is unlikely that an in-place family would be
// used for this reason in the first place.
ecData.PossibleExtrusionAxes = (roof is FamilyInstance) ? IFCExtrusionAxes.TryXYZ : IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
BodyData bodyData;
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = GUIDUtil.CreateGUID(roof);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string roofName = NamingUtil.GetNameOverride(roof, NamingUtil.GetIFCName(roof));
string roofDescription = NamingUtil.GetDescriptionOverride(roof, null);
string roofObjectType = NamingUtil.GetObjectTypeOverride(roof, NamingUtil.CreateIFCObjectName(exporterIFC, roof));
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(roof, NamingUtil.CreateIFCElementId(roof));
string roofType = GetIFCRoofType(ifcEnumType);
roofType = IFCValidateEntry.GetValidIFCType(roof, ifcEnumType);
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, roofName, roofDescription,
roofObjectType, localPlacement, exportSlab ? null : representation, elementTag, roofType);
productWrapper.AddElement(roof, roofHnd, placementSetter.LevelInfo, ecData, true);
// will export its host object materials later if it is a roof
if (!(roof is RoofBase))
{
CategoryUtil.CreateMaterialAssociations(exporterIFC, roofHnd, bodyData.MaterialIds);
}
if (exportSlab)
{
string slabGUID = GUIDUtil.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, "ROOF");
Transform offsetTransform = (bodyData != null) ? bodyData.OffsetTransform : Transform.Identity;
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, offsetTransform,
exporterIFC, slabLocalPlacementHnd, placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(null, slabHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociations(exporterIFC, slabHnd, bodyData.MaterialIds);
}
}
tr.Commit();
}
}
}