/// <summary>
/// Initialize the class with the entity and the type
/// </summary>
/// <param name="instance">the entity</param>
/// <param name="type">the type</param>
public IFCExportInfoPair(IFCEntityType instance, IFCEntityType type, string predefinedType)
{
instance = ElementFilteringUtil.GetValidIFCEntityType(instance);
ExportInstance = instance;
type = ElementFilteringUtil.GetValidIFCEntityType(type);
ExportType = type;
if (!string.IsNullOrEmpty(predefinedType))
{
ValidatedPredefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(predefinedType, null, ExportInstance.ToString());
if (string.IsNullOrEmpty(ValidatedPredefinedType))
{
ValidatedPredefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(predefinedType, "NOTDEFINED", ExportType.ToString());
}
}
}
/// <summary>
/// Initialize the class with the entity and the type
/// </summary>
/// <param name="instance">the entity</param>
/// <param name="type">the type</param>
public IFCExportInfoPair(IFCEntityType instance, IFCEntityType type, string predefinedType)
{
instance = ElementFilteringUtil.GetValidIFCEntityType(instance);
ExportInstance = instance;
type = ElementFilteringUtil.GetValidIFCEntityType(type);
ExportType = type;
if (!string.IsNullOrEmpty(predefinedType))
{
string newValidatedPredefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(predefinedType, ValidatedPredefinedType, ExportInstance.ToString());
if (ExporterUtil.IsNotDefined(newValidatedPredefinedType))
{
newValidatedPredefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(predefinedType, ValidatedPredefinedType, ExportType.ToString());
}
ValidatedPredefinedType = newValidatedPredefinedType;
}
}
/// <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, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData;
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = GUIDUtil.CreateGUID(roof);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
//string predefinedType = GetIFCRoofType(ifcEnumType);
string predefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType(ifcEnumType, "NOTDEFINED", IFCEntityType.IfcRoofType.ToString());
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(exporterIFC, roof, guid, ownerHistory,
localPlacement, exportSlab ? null : representation, predefinedType);
// Export IfcRoofType
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcRoof, IFCEntityType.IfcRoofType, predefinedType);
if (exportInfo.ExportType != IFCEntityType.UnKnown)
{
string overridePDefType;
if (ParameterUtil.GetStringValueFromElementOrSymbol(roof, "IfcExportType", out overridePDefType) == null) // change IFCType to consistent parameter of IfcExportType
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(roof, "IfcType", out overridePDefType) == null) // support IFCType for legacy support
{
if (string.IsNullOrEmpty(predefinedType))
{
predefinedType = "NOTDEFINED";
}
}
}
if (!string.IsNullOrEmpty(overridePDefType))
{
exportInfo.ValidatedPredefinedType = overridePDefType;
}
else
{
exportInfo.ValidatedPredefinedType = predefinedType;
}
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(roof, exportInfo, file, ownerHistory, predefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, roofHnd);
}
productWrapper.AddElement(roof, roofHnd, placementSetter.LevelInfo, ecData, true);
// will export its host object materials later if it is a roof
if (!(roof is RoofBase))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, bodyData.MaterialIds);
}
if (exportSlab)
{
string slabGUID = GUIDUtil.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = IFCAnyHandleUtil.GetStringAttribute(roofHnd, "Name") + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(exporterIFC, roof, slabGUID, ownerHistory,
slabLocalPlacementHnd, representation, slabRoofPredefinedType);
IFCAnyHandleUtil.OverrideNameAttribute(slabHnd, slabName);
Transform offsetTransform = (bodyData != null) ? bodyData.OffsetTransform : Transform.Identity;
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, offsetTransform,
exporterIFC, slabLocalPlacementHnd, placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(null, slabHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, bodyData.MaterialIds);
// Create type
IFCExportInfoPair slabRoofExportType = new IFCExportInfoPair();
slabRoofExportType.SetValueWithPair(IFCEntityType.IfcSlab);
IFCAnyHandle slabRoofTypeHnd = ExporterUtil.CreateGenericTypeFromElement(roof, slabRoofExportType, exporterIFC.GetFile(), ownerHistory, slabRoofPredefinedType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(slabRoofTypeHnd, slabHnd);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Exports an element as IFC covering.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCovering(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, ProductWrapper productWrapper)
{
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcCovering;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geomElem, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
// We will use the category of the element to set a default value for the covering.
string defaultCoveringEnumType = null;
if (categoryId == new ElementId(BuiltInCategory.OST_Ceilings))
{
defaultCoveringEnumType = "CEILING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Floors))
{
defaultCoveringEnumType = "FLOORING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Roofs))
{
defaultCoveringEnumType = "ROOFING";
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string coveringType = IFCValidateEntry.GetValidIFCPredefinedTypeType(/*element,*/ ifcEnumType, defaultCoveringEnumType, "IfcCoveringType");
IFCAnyHandle covering = IFCInstanceExporter.CreateCovering(exporterIFC, element, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
setter.LocalPlacement, prodRep, coveringType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.LocalPlacement, null);
}
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcCovering, IFCEntityType.IfcCoveringType, coveringType);
IFCAnyHandle typeHnd = ExporterUtil.CreateGenericTypeFromElement(element, exportInfo, file, ExporterCacheManager.OwnerHistoryHandle, coveringType, productWrapper);
ExporterCacheManager.TypeRelationsCache.Add(typeHnd, covering);
bool containInSpace = false;
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
// Ceiling containment in Space is generally required and not specific to any view
if (ExporterCacheManager.CeilingSpaceRelCache.ContainsKey(element.Id))
{
IList <ElementId> roomlist = ExporterCacheManager.CeilingSpaceRelCache[element.Id];
// Process Ceiling to be contained in a Space only when it is exactly bounding one Space
if (roomlist.Count == 1)
{
productWrapper.AddElement(element, covering, setter, null, false);
// Modify the Ceiling placement to be relative to the Space that it bounds
IFCAnyHandle roomPlacement = IFCAnyHandleUtil.GetObjectPlacement(ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(roomlist[0]));
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(roomPlacement, localPlacementToUse);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandleUtil.SetAttribute(localPlacementToUse, "PlacementRelTo", roomPlacement);
GeometryUtil.SetRelativePlacement(localPlacementToUse, relLocalPlacement);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomlist[0], covering);
containInSpace = true;
}
}
// if not contained in Space, assign it to default containment in Level
if (!containInSpace)
{
productWrapper.AddElement(element, covering, setter, null, true);
}
if (!exportParts)
{
Ceiling ceiling = element as Ceiling;
if (ceiling != null)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, null, null);
}
else
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geomElem, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, covering, matId);
}
}
OpeningUtil.CreateOpeningsIfNecessary(covering, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
transaction.Commit();
}
}
/// <summary>
/// Set the pair information using only either the entity or the type
/// </summary>
/// <param name="entityType">the entity or type</param>
public void SetValueWithPair(IFCEntityType entityType)
{
string entityTypeStr = entityType.ToString();
bool isType = entityTypeStr.Substring(entityTypeStr.Length - 4, 4).Equals("Type", StringComparison.CurrentCultureIgnoreCase);
if (isType)
{
// Get the instance
string instName = entityTypeStr.Substring(0, entityTypeStr.Length - 4);
IfcSchemaEntityNode node = IfcSchemaEntityTree.Find(instName);
if (node != null && !node.isAbstract)
{
IFCEntityType instType = IFCEntityType.UnKnown;
if (IFCEntityType.TryParse(instName, out instType))
{
ExportInstance = instType;
}
}
// If not found, try non-abstract supertype derived from the type
node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(instName);
if (node != null)
{
IFCEntityType instType = IFCEntityType.UnKnown;
if (IFCEntityType.TryParse(node.Name, out instType))
{
ExportInstance = instType;
}
}
// set the type
entityType = ElementFilteringUtil.GetValidIFCEntityType(entityType);
if (entityType != IFCEntityType.UnKnown)
{
ExportType = entityType;
}
else
{
node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
if (node != null)
{
IFCEntityType instType = IFCEntityType.UnKnown;
if (IFCEntityType.TryParse(node.Name, out instType))
{
ExportType = instType;
}
}
}
}
else
{
// set the instance
entityType = ElementFilteringUtil.GetValidIFCEntityType(entityType);
if (entityType != IFCEntityType.UnKnown)
{
ExportInstance = entityType;
}
else
{
// If not found, try non-abstract supertype derived from the type
IfcSchemaEntityNode node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
if (node != null)
{
IFCEntityType instType = IFCEntityType.UnKnown;
if (IFCEntityType.TryParse(node.Name, out instType))
{
ExportInstance = instType;
}
}
}
// set the type pair
string typeName = entityType.ToString() + "Type";
entityType = ElementFilteringUtil.GetValidIFCEntityType(typeName);
if (entityType != IFCEntityType.UnKnown)
{
ExportType = entityType;
}
else
{
IfcSchemaEntityNode node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(typeName);
if (node != null)
{
IFCEntityType instType = IFCEntityType.UnKnown;
if (IFCEntityType.TryParse(node.Name, out instType))
{
ExportType = instType;
}
}
}
}
ValidatedPredefinedType = IFCValidateEntry.GetValidIFCPredefinedTypeType("NOTDEFINED", ValidatedPredefinedType, ExportType.ToString());
}