/// <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>
/// Calculates the end hook angle for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
RebarBendData bendData = null;
if (element is Rebar)
bendData = (element as Rebar).GetBendData();
else if (element is RebarInSystem)
bendData = (element as RebarInSystem).GetBendData();
if (bendData != null)
{
if (bendData.HookLength1 > MathUtil.Eps())
{
ElementId hookAtEndTypeId;
if (ParameterUtil.GetElementIdValueFromElement(element, BuiltInParameter.REBAR_ELEM_HOOK_END_TYPE, out hookAtEndTypeId) != null)
{
RebarHookType rebarHookType = element.Document.GetElement(hookAtEndTypeId) as RebarHookType;
if (rebarHookType != null)
{
//HookAngle is measured in radians, so scale directly.
m_Angle = rebarHookType.HookAngle *180 / Math.PI;
return true;
}
}
}
}
return false;
}
/// <summary>
/// Calculates slope value for a beam.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
return false;
m_Slope = extrusionCreationData.Slope;
return true;
}
/// <summary>
/// Exports mullion.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="mullion">
/// The mullion object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <param name="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCExtrusionCreationData extraParams, IFCPlacementSetter setter, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle repHnd = RepresentationUtil.CreateBRepProductDefinitionShape(mullion.Document.Application, exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = ExporterIFCUtils.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string elemId = NamingUtil.CreateIFCElementId(mullion);
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, elemObjectType, null, elemObjectType,
localPlacement, repHnd, elemId);
productWrapper.AddElement(mullionHnd, setter, extraParams, LevelUtil.AssociateElementToLevel(mullion));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, mullion, productWrapper);
}
/// <summary>
/// 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>
/// Calculates temperature value for a space.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (!string.IsNullOrEmpty(m_Name))
{
string temperatureName, temperatureNameMax, temperatureNameMin;
if (string.Compare(m_Name, "SpaceTemperatureSummer") == 0)
{
temperatureName = "SpaceTemperatureSummer";
temperatureNameMax = "SpaceTemperatureSummerMax";
temperatureNameMin = "SpaceTemperatureSummerMin";
}
else if (string.Compare(m_Name, "SpaceTemperatureWinter") == 0)
{
temperatureName = "SpaceTemperatureWinter";
temperatureNameMax = "SpaceTemperatureWinterMax";
temperatureNameMin = "SpaceTemperatureWinterMin";
}
else
return false;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, temperatureName, out m_Temperature) != null)
return true;
double maxValue = 0, minValue = 0;
if ((ParameterUtil.GetDoubleValueFromElementOrSymbol(element, temperatureNameMax, out maxValue) != null) &&
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, temperatureNameMin, out minValue) != null))
{
m_Temperature = (maxValue + minValue) / 2.0;
return true;
}
}
return false;
}
/// <summary>
/// Exports a ceiling to IFC covering.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="ceiling">
/// The ceiling element to be exported.
/// </param>
/// <param name="geomElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportCeilingElement(ExporterIFC exporterIFC, Ceiling ceiling, GeometryElement geomElement, ProductWrapper productWrapper)
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, ceiling);
if (String.IsNullOrEmpty(ifcEnumType))
ifcEnumType = "CEILING";
ExportCovering(exporterIFC, ceiling, geomElement, ifcEnumType, productWrapper);
}
/// <summary>
/// Sets best material id for current export state.
/// </summary>
/// <param name="geometryObject">The geometry object to get the best material id.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
public static void SetBestMaterialIdInExporter(GeometryObject geometryObject, ExporterIFC exporterIFC)
{
ElementId materialId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC);
if (materialId != ElementId.InvalidElementId)
exporterIFC.SetMaterialIdForCurrentExportState(materialId);
}
/// <summary>
/// Creates a shape representation and register it to shape representation layer.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="contextOfItems">The context for which the different subtypes of representation are valid.</param>
/// <param name="identifier">The identifier for the representation.</param>
/// <param name="representationType">The type handle for the representation.</param>
/// <param name="items">Collection of geometric representation items that are defined for this representation.</param>
/// <returns>The handle.</returns>
public static IFCAnyHandle CreateBaseShapeRepresentation(ExporterIFC exporterIFC, IFCAnyHandle contextOfItems,
string identifier, string representationType, ISet<IFCAnyHandle> items)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle newShapeRepresentation = IFCInstanceExporter.CreateShapeRepresentation(file, contextOfItems, identifier, representationType, items);
return newShapeRepresentation;
}
/// <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="filterView">The view.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void Export(ExporterIFC exporterIFC,
Element element, Autodesk.Revit.DB.View filterView, ProductWrapper productWrapper)
{
if (element is Rebar)
{
ExportRebar(exporterIFC, element, filterView, 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);
ExportRebar(exporterIFC, rebarInSystem, filterView, 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);
ExportRebar(exporterIFC, rebarInSystem, filterView, productWrapper);
}
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, IFCProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.CreateIFCElementId(element);
Toolkit.IFCFootingType footingType = GetIFCFootingType(element, ifcEnumType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceElemId, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(footing, setter, ecData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// 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 not set.
string uniformatKeyString = "Uniformat";
string uniformatCode = "";
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_CODE, false, out uniformatCode) == null)
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Code", out uniformatCode);
string uniformatDescription = "";
if (!String.IsNullOrWhiteSpace(uniformatCode))
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, BuiltInParameter.UNIFORMAT_DESCRIPTION, false, out uniformatDescription) == null)
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Assembly Description", out uniformatDescription);
}
IFCAnyHandle classification;
if (!ExporterCacheManager.ClassificationCache.ClassificationHandles.TryGetValue(uniformatKeyString, out classification))
{
classification = IFCInstanceExporter.CreateClassification(file, "http://www.csiorg.net/uniformat", "1998", null, uniformatKeyString);
ExporterCacheManager.ClassificationCache.ClassificationHandles.Add(uniformatKeyString, classification);
}
InsertClassificationReference(exporterIFC, file, element, elemHnd, uniformatKeyString, uniformatCode, uniformatDescription, "http://www.csiorg.net/uniformat" );
}
/// <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>
/// Calculates shape parameter A for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
bool ret = (ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameterGroup.PG_GEOMETRY, "A", out m_ShapeParameterA) != null);
if (ret)
m_ShapeParameterA = UnitUtil.ScaleLength(m_ShapeParameterA);
return ret;
}
/// <summary>
/// Calculates perimeter for a slab.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
return false;
m_Perimeter = extrusionCreationData.ScaledOuterPerimeter;
return m_Perimeter > MathUtil.Eps();
}
/// <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>
/// Calculates shape parameter B for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
bool ret = (ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameterGroup.PG_GEOMETRY, "B", out m_ShapeParameterB) != null);
if (ret)
m_ShapeParameterB = m_ShapeParameterB * exporterIFC.LinearScale;
return ret;
}
/// <summary>
/// Calculates span value for a beam.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null || MathUtil.IsAlmostZero(extrusionCreationData.ScaledLength))
return false;
m_Span = extrusionCreationData.ScaledLength;
return true;
}
/// <summary>
/// Calculates width for a slab.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
return false;
m_Width = extrusionCreationData.ScaledLength;
return m_Width > MathUtil.Eps();
}
/// <summary>
/// Exports a hosted weep.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostedSweep">The hosted sweep element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, HostedSweep hostedSweep, GeometryElement geometryElement, ProductWrapper productWrapper)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(hostedSweep);
if (catId == new ElementId(BuiltInCategory.OST_Gutter))
ExportGutter(exporterIFC, hostedSweep, geometryElement, productWrapper);
else
ProxyElementExporter.Export(exporterIFC, hostedSweep, geometryElement, productWrapper);
}
/// <summary>
/// Create a Frequency measure property from the element's parameter.
/// </summary>
/// <param name="file">The IFC file.</param>
/// <param name="exporterIFC">The ExporterIFC.</param>
/// <param name="elem">The Element.</param>
/// <param name="revitParameterName">The name of the parameter.</param>
/// <param name="ifcPropertyName">The name of the property.</param>
/// <param name="valueType">The value type of the property.</param>
/// <returns>The created property handle.</returns>
public static IFCAnyHandle CreateFrequencyPropertyFromElement(IFCFile file, ExporterIFC exporterIFC, Element elem,
string revitParameterName, string ifcPropertyName, PropertyValueType valueType)
{
double propertyValue;
if (ParameterUtil.GetDoubleValueFromElement(elem, null, revitParameterName, out propertyValue) != null)
return CreateFrequencyProperty(file, ifcPropertyName, propertyValue, valueType);
return null;
}
/// <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>
/// Calculates the shape for a provision for void.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
return false;
IFCAnyHandle provisionForVoidHnd = ExporterCacheManager.ElementToHandleCache.Find(element.Id);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(provisionForVoidHnd))
return false;
IFCAnyHandle prodRepHnd = IFCAnyHandleUtil.GetInstanceAttribute(provisionForVoidHnd, "Representation");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRepHnd))
return false;
IList<IFCAnyHandle> repHnds = IFCAnyHandleUtil.GetRepresentations(prodRepHnd);
foreach (IFCAnyHandle repHnd in repHnds)
{
string repId = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationIdentifier");
if (String.Compare(repId, "Body", true) != 0)
continue;
string repType = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationType");
if (String.Compare(repType, "SweptSolid", true) != 0)
return false;
HashSet<IFCAnyHandle> repItemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(repHnd, "Items");
int numRepItems = repItemSet.Count;
if (numRepItems == 0)
return false;
if (numRepItems == 1)
{
IFCAnyHandle repItemHnd = repItemSet.ElementAt(0);
if (!IFCAnyHandleUtil.IsSubTypeOf(repItemHnd, IFCEntityType.IfcExtrudedAreaSolid))
return false;
IFCAnyHandle sweptAreaHnd = IFCAnyHandleUtil.GetInstanceAttribute(repItemHnd, "SweptArea");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(sweptAreaHnd))
return false;
m_CurrentProfileHandle = sweptAreaHnd;
if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcRectangleProfileDef))
m_Shape = IFCProvisionForVoidShapeType.Rectangle.ToString();
else if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcCircleProfileDef))
m_Shape = IFCProvisionForVoidShapeType.Round.ToString();
}
if (m_Shape == null)
{
m_Shape = IFCProvisionForVoidShapeType.Undefined.ToString();
m_CurrentProfileHandle = null;
}
m_CurrentElement = element;
return true;
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="exporterIFC"></param>
/// <param name="file"></param>
/// <param name="element"></param>
/// <param name="elemHnd"></param>
/// <param name="location"></param>
public static void CreateClassification(ExporterIFC exporterIFC, IFCFile file, Element element, IFCAnyHandle elemHnd, string location)
{
string paramClassificationCode = "";
string classificationName = null;
string classificationCode = null;
string classificationDescription = null;
// For now the support is fixed to 10 predefined classification code parameter names (to support limitation of schedule key that supports only one category per schedule key and needs one parameter for each)
int noClassCodeParam = 10;
string [] classCodeParamName = {"ClassificationCode", "ClassificationCode(2)", "ClassificationCode(3)", "ClassificationCode(4)", "ClassificationCode(5)",
"ClassificationCode(6)", "ClassificationCode(7)", "ClassificationCode(8)", "ClassificationCode(9)", "ClassificationCode(10)"};
int ret = 0;
for (int n = 0; n < noClassCodeParam; n++)
{
// Create A classification, if it is not set.
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, classCodeParamName[n], out paramClassificationCode))
{
ret = parseClassificationCode(paramClassificationCode, out classificationName, out classificationCode, out classificationDescription);
if (string.IsNullOrEmpty(classificationName))
classificationName = "Default Classification";
IFCAnyHandle classification;
if (!ExporterCacheManager.ClassificationCache.TryGetValue(classificationName, out classification))
{
IFCClassificationMgr savedClassificationFromUI = new IFCClassificationMgr();
IFCClassification savedClassification = new IFCClassification();
if (savedClassificationFromUI.GetSavedClassificationByName(element.Document, classificationName, out savedClassification))
{
if (savedClassification.ClassificationEditionDate == null)
{
IFCAnyHandle editionDate = IFCInstanceExporter.CreateCalendarDate(file, savedClassification.ClassificationEditionDate.Day, savedClassification.ClassificationEditionDate.Month, savedClassification.ClassificationEditionDate.Year);
classification = IFCInstanceExporter.CreateClassification(file, savedClassification.ClassificationSource, savedClassification.ClassificationEdition,
editionDate, savedClassification.ClassificationName);
}
else
classification = IFCInstanceExporter.CreateClassification(file, savedClassification.ClassificationSource, savedClassification.ClassificationEdition,
null, savedClassification.ClassificationName);
}
else
classification = IFCInstanceExporter.CreateClassification(file, "", "", null, classificationName);
ExporterCacheManager.ClassificationCache.Add(classificationName, classification);
if (!String.IsNullOrEmpty(savedClassification.ClassificationLocation))
ExporterCacheManager.ClassificationLocationCache.Add(classificationName, savedClassification.ClassificationLocation);
}
if (String.IsNullOrEmpty(location))
{
ExporterCacheManager.ClassificationLocationCache.TryGetValue(classificationName, out location);
}
InsertClassificationReference(exporterIFC, file, element, elemHnd, classificationName, classificationCode, classificationDescription, location);
}
}
}
/// <summary>
/// Calculates load bearing value for a wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="calcValues">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
Wall wall = element as Wall;
if (wall != null)
{
m_LoadBearing = wall.StructuralUsage == StructuralWallUsage.Bearing;
}
return 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>
/// Calculates extend to structure value for a wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element,">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
Wall wall = element as Wall;
if (wall != null)
{
m_ExtendToStructure = ExporterIFCUtils.IsWallJoinedToTop(wall);
}
return true;
}
/// <summary>
/// Exports a connector instance. Almost verbatim exmaple from Revit 2012 API for Connector Class
/// Works only for HVAC and Piping for now
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
public static void Export(ExporterIFC exporterIFC)
{
foreach (ConnectorSet connectorSet in ExporterCacheManager.MEPCache.MEPConnectors)
{
Export(exporterIFC, connectorSet);
}
// clear local cache
ConnectorExporter.ClearConnections();
}
private static Transform GetLocalTransform(ExporterIFC exporterIFC, double scale)
{
// We want to transform the geometry into the current local coordinate system.
Transform geomTrf = Transform.Identity;
geomTrf.BasisX = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, XYZ.BasisX);
geomTrf.BasisY = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, XYZ.BasisY);
geomTrf.BasisZ = geomTrf.BasisX.CrossProduct(geomTrf.BasisY);
geomTrf.Origin = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, XYZ.Zero) / scale;
return geomTrf;
}
/// <summary>
/// Sets best material id for current export state.
/// </summary>
/// <param name="geometryObject">The geometry object to get the best material id.</param>
/// <param name="element">The element to get its structual material if no material found in its geometry.</param>
/// <param name="overrideMaterialId">The material id to override the one gets from geometry object.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The material id.</returns>
public static ElementId SetBestMaterialIdInExporter(GeometryObject geometryObject, Element element, ElementId overrideMaterialId, ExporterIFC exporterIFC)
{
ElementId materialId = overrideMaterialId != ElementId.InvalidElementId ? overrideMaterialId :
GetBestMaterialIdFromGeometryOrParameter(geometryObject, exporterIFC, element);
if (materialId != ElementId.InvalidElementId)
exporterIFC.SetMaterialIdForCurrentExportState(materialId);
return materialId;
}
/// <summary>
/// Gets spatial element filter.
/// </summary>
/// <param name="document">The Revit document.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The element filter.</returns>
public static ElementFilter GetSpatialElementFilter(Document document, ExporterIFC exporterIFC)
{
return GetExportFilter(document, exporterIFC, true);
}
/// <summary>
/// Adds openings to an element.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="elementHandles">The parent handles.</param>
/// <param name="curveLoops">The parent CurveLoops.</param>
/// <param name="element">The element.</param>
/// <param name="lcs">The local coordinate system.</param>
/// <param name="scaledWidth">The width.</param>
/// <param name="range">The range.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="localWrapper">The wrapper.</param>
public static void AddOpeningsToElement(ExporterIFC exporterIFC, IList <IFCAnyHandle> elementHandles,
IList <CurveLoop> curveLoops, Element element, Transform lcs, double scaledWidth,
IFCRange range, PlacementSetter setter, IFCAnyHandle localPlacement, ProductWrapper localWrapper)
{
IList <IFCOpeningData> openingDataList = ExporterIFCUtils.GetOpeningData(exporterIFC, element, lcs, range);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
foreach (IFCOpeningData openingData in openingDataList)
{
Element openingElem = element.Document.GetElement(openingData.OpeningElementId);
if (openingElem == null)
{
openingElem = element;
}
// Don't export the opening if WallSweep category has been turned off.
// This is currently restricted to WallSweeps because the element responsible for the opening could be a variety of things,
// including a line as part of the elevation profile of the wall.
// As such, we will restrict which element types we check for CanExportElement.
if ((openingElem is WallSweep) && (!ElementFilteringUtil.CanExportElement(exporterIFC, openingElem, true)))
{
continue;
}
IList <IFCExtrusionData> extrusionDataList = openingData.GetExtrusionData();
IFCAnyHandle parentHandle = null;
if (elementHandles.Count > 1 && extrusionDataList.Count > 0)
{
parentHandle = FindParentHandle(elementHandles, curveLoops, extrusionDataList[0].GetLoops()[0]);
}
if (parentHandle == null)
{
parentHandle = elementHandles[0];
}
bool isDoorOrWindowOpening = IsDoorOrWindowOpening(exporterIFC, openingElem, element);
if (isDoorOrWindowOpening)
{
DoorWindowDelayedOpeningCreator delayedCreator =
DoorWindowDelayedOpeningCreator.Create(exporterIFC, openingData, scaledWidth, element.Id, parentHandle, setter.LevelId);
if (delayedCreator != null)
{
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
continue;
}
}
// If the opening is "filled" by another element (either a door or window as determined above,
// or an embedded wall, then we can't use the element GUID for the opening.
bool canUseElementGUID = !isDoorOrWindowOpening && !(openingElem is Wall);
IList <Solid> solids = openingData.GetOpeningSolids();
foreach (Solid solid in solids)
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
extrusionCreationData.ReuseLocalPlacement = true;
string openingGUID = CreateOpeningGUID(openingElem, canUseElementGUID);
canUseElementGUID = false; // Either it was used above, and therefore is now false, or it was already false.
CreateOpening(exporterIFC, parentHandle, element, openingElem, openingGUID, solid, scaledWidth, openingData.IsRecess, extrusionCreationData,
setter, localWrapper);
}
}
foreach (IFCExtrusionData extrusionData in extrusionDataList)
{
if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
{
extrusionData.ScaledExtrusionLength = scaledWidth;
}
string openingGUID = CreateOpeningGUID(openingElem, canUseElementGUID);
canUseElementGUID = false; // Either it was used above, and therefore is now false, or it was already false.
CreateOpening(exporterIFC, parentHandle, localPlacement, element, openingElem, openingGUID, extrusionData, lcs, openingData.IsRecess,
setter, localWrapper);
}
}
}
/// <summary>
/// Creates an opening from a solid.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host object handle.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The insert element.</param>
/// <param name="openingGUID">The GUID for the opening, depending on how the opening is created.</param>
/// <param name="solid">The solid.</param>
/// <param name="scaledHostWidth">The scaled host width.</param>
/// <param name="isRecess">True if it is recess.</param>
/// <param name="extrusionCreationData">The extrusion creation data.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localWrapper">The product wrapper.</param>
/// <returns>The created opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, Element hostElement, Element insertElement, string openingGUID,
Solid solid, double scaledHostWidth, bool isRecess, IFCExtrusionCreationData extrusionCreationData, PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
XYZ prepToWall;
bool isLinearWall = GetOpeningDirection(hostElement, out prepToWall);
if (isLinearWall)
{
extrusionCreationData.CustomAxis = prepToWall;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData = BodyExporter.ExportBody(exporterIFC, insertElement, catId, ElementId.InvalidElementId,
solid, bodyExporterOptions, extrusionCreationData);
IFCAnyHandle openingRepHnd = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(openingRepHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(openingRepHnd);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = extrusionCreationData.GetLocalPlacement();
IFCAnyHandle hostObjPlacementHnd = IFCAnyHandleUtil.GetObjectPlacement(hostObjHnd);
Transform relTransform = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(openingPlacement, hostObjPlacementHnd);
openingPlacement = ExporterUtil.CreateLocalPlacement(file, hostObjPlacementHnd,
relTransform.Origin, relTransform.BasisZ, relTransform.BasisX);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
double scaledOpeningLength = extrusionCreationData.ScaledLength;
string openingObjectType = "Opening";
if (!MathUtil.IsAlmostZero(scaledHostWidth) && !MathUtil.IsAlmostZero(scaledOpeningLength))
{
openingObjectType = scaledOpeningLength < (scaledHostWidth - MathUtil.Eps()) ? "Recess" : "Opening";
}
else
{
openingObjectType = isRecess ? "Recess" : "Opening";
}
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjHnd))
{
openingName = IFCAnyHandleUtil.GetStringAttribute(hostObjHnd, "Name");
}
else
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(exporterIFC, hostElement, openingGUID, ownerHistory,
openingPlacement, prodRep, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingHnd, openingName);
IFCAnyHandleUtil.SetAttribute(openingHnd, "ObjectType", openingObjectType);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, extrusionCreationData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(insertElement, openingHnd, setter, extrusionCreationData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
/// <summary>
/// Initializes the transformation in the transform setter.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="geometryList">The set of geometry used to determine the bounding box.</param>
/// <param name="ecData">The extrusion creation data which contains the local placement.</param>
/// <returns>The transform corresponding to the movement, if any.</returns>
/// <remarks>This method will eventually be obsoleted by the InitializeFromBoundingBox/CreateLocalPlacementFromOffset pair below, which delays creating or updating the local placement
/// until we are certain we will use it, saving time and reducing wasted line numbers.</remarks>
public Transform InitializeFromBoundingBox(ExporterIFC exporterIFC, IList <GeometryObject> geometryList, IFCExtrusionCreationData ecData)
{
if (ecData == null)
{
return(null);
}
Transform trf = Transform.Identity;
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(localPlacement))
{
IFCFile file = exporterIFC.GetFile();
BoundingBoxXYZ bbox = GeometryUtil.GetBBoxOfGeometries(geometryList);
// If the BBox passes through (0,0, 0), or no bbox, do nothing.
if (bbox == null ||
((bbox.Min.X < MathUtil.Eps() && bbox.Max.X > -MathUtil.Eps()) &&
(bbox.Min.Y < MathUtil.Eps() && bbox.Max.Y > -MathUtil.Eps()) &&
(bbox.Min.Z < MathUtil.Eps() && bbox.Max.Z > -MathUtil.Eps())))
{
if (!ecData.ReuseLocalPlacement)
{
ecData.SetLocalPlacement(ExporterUtil.CopyLocalPlacement(file, localPlacement));
}
return(trf);
}
XYZ bboxMin = bbox.Min;
XYZ scaledOrig = UnitUtil.ScaleLength(bboxMin);
Transform scaledTrf = GeometryUtil.GetScaledTransform(exporterIFC);
XYZ lpOrig = scaledTrf.OfPoint(scaledOrig);
if (!ecData.AllowVerticalOffsetOfBReps)
{
lpOrig = new XYZ(lpOrig.X, lpOrig.Y, 0.0);
}
Transform scaledTrfInv = scaledTrf.Inverse;
XYZ scaledInvOrig = scaledTrfInv.OfPoint(XYZ.Zero);
XYZ unscaledInvOrig = UnitUtil.UnscaleLength(scaledInvOrig);
XYZ trfOrig = unscaledInvOrig - bboxMin;
if (!ecData.AllowVerticalOffsetOfBReps)
{
trfOrig = new XYZ(trfOrig.X, trfOrig.Y, 0.0);
}
if (!MathUtil.IsAlmostZero(trfOrig.DotProduct(trfOrig)))
{
Initialize(exporterIFC, trfOrig, XYZ.BasisX, XYZ.BasisY);
if (!ecData.ReuseLocalPlacement)
{
ecData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, lpOrig, null, null));
}
else
{
IFCAnyHandle relativePlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
{
IFCAnyHandle newRelativePlacement = ExporterUtil.CreateAxis(file, lpOrig, null, null);
GeometryUtil.SetRelativePlacement(localPlacement, newRelativePlacement);
}
else
{
IFCAnyHandle oldOriginHnd, zDirHnd, xDirHnd;
xDirHnd = IFCAnyHandleUtil.GetInstanceAttribute(relativePlacement, "RefDirection");
zDirHnd = IFCAnyHandleUtil.GetInstanceAttribute(relativePlacement, "Axis");
oldOriginHnd = IFCAnyHandleUtil.GetInstanceAttribute(relativePlacement, "Location");
bool trfSet = false;
XYZ xDir = XYZ.BasisX; XYZ zDir = XYZ.BasisZ; XYZ oldCoords = XYZ.Zero;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(xDirHnd))
{
xDir = GeometryUtil.GetDirectionRatios(xDirHnd);
trfSet = true;
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(zDirHnd))
{
zDir = GeometryUtil.GetDirectionRatios(zDirHnd);
trfSet = true;
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(oldOriginHnd))
{
oldCoords = GeometryUtil.GetCoordinates(oldOriginHnd);
}
if (trfSet)
{
XYZ yDir = zDir.CrossProduct(xDir);
Transform relPlacementTrf = Transform.Identity;
relPlacementTrf.Origin = oldCoords; relPlacementTrf.BasisX = xDir;
relPlacementTrf.BasisY = yDir; relPlacementTrf.BasisZ = zDir;
lpOrig = relPlacementTrf.OfPoint(lpOrig);
}
else
{
lpOrig = oldCoords + lpOrig;
}
IFCAnyHandle newOriginHnd = ExporterUtil.CreateCartesianPoint(file, lpOrig);
IFCAnyHandleUtil.SetAttribute(relativePlacement, "Location", newOriginHnd);
}
}
trf.Origin = lpOrig;
}
else if (ecData.ForceOffset)
{
ecData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
}
else if (!ecData.ReuseLocalPlacement)
{
ecData.SetLocalPlacement(ExporterUtil.CopyLocalPlacement(file, localPlacement));
}
}
return(trf);
}
/// <summary>
/// Get all the grids and add to the map with its level.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The map with sorted grids by level.</returns>
private static IDictionary <Tuple <ElementId, string>, List <Grid> > GetAllGrids(Document document, ExporterIFC exporterIFC)
{
View currentView = ExporterCacheManager.ExportOptionsCache.FilterViewForExport;
Level currentLevel = null;
if (currentView != null)
{
currentLevel = currentView.GenLevel;
}
SortedDictionary <double, ElementId> levelIds = new SortedDictionary <double, ElementId>();
if (currentLevel != null)
{
levelIds.Add(currentLevel.Elevation, currentLevel.Id);
}
else
{
foreach (ElementId levelId in ExporterCacheManager.LevelInfoCache.BuildingStoreysByElevation)
{
Level level = document.GetElement(levelId) as Level;
if (!levelIds.ContainsKey(level.Elevation))
{
levelIds.Add(level.Elevation, levelId);
}
}
}
double eps = MathUtil.Eps();
// The Dictionary key is a tuple of the containing level id, and the elevation of the Grid
IDictionary <Tuple <ElementId, string>, List <Grid> > levelGrids = new Dictionary <Tuple <ElementId, string>, List <Grid> >(new TupleGridAndNameComparer());
// Group grids based on their elevation (the same elevation will be the same IfcGrid)
foreach (Element element in ExporterCacheManager.GridCache)
{
Grid grid = element as Grid;
XYZ minPoint = grid.GetExtents().MinimumPoint;
XYZ maxPoint = grid.GetExtents().MaximumPoint;
// Find level where the Grid min point is at higher elevation but lower than the next level
KeyValuePair <double, ElementId> levelGrid = levelIds.First();
foreach (KeyValuePair <double, ElementId> levelInfo in levelIds)
{
//if (levelInfo.Key + eps >= minPoint.Z)
// break;
if (minPoint.Z <= levelInfo.Key + eps && levelInfo.Key - eps <= maxPoint.Z)
{
levelGrid = levelInfo;
break;
}
}
string gridName = NamingUtil.GetNameOverride(element, "Default Grid");
Tuple <ElementId, string> gridGroupKey = new Tuple <ElementId, string>(levelGrid.Value, gridName);
if (!levelGrids.ContainsKey(gridGroupKey))
{
levelGrids.Add(gridGroupKey, new List <Grid>());
}
levelGrids[gridGroupKey].Add(grid);
}
return(levelGrids);
}
// return null if parent should be completely clipped.
// TODO: determine whether or not to use face boundary.
private static IFCAnyHandle ProcessClippingFace(ExporterIFC exporterIFC, CurveLoop outerBoundary, Plane boundaryPlane,
Plane extrusionBasePlane, XYZ extrusionDirection, IFCRange range, bool useFaceBoundary, IFCAnyHandle bodyItemHnd)
{
if (outerBoundary == null || boundaryPlane == null)
{
throw new Exception("Invalid face boundary.");
}
double clippingSlant = boundaryPlane.Normal.DotProduct(extrusionDirection);
if (useFaceBoundary)
{
if (MathUtil.IsAlmostZero(clippingSlant))
{
return(bodyItemHnd);
}
}
bool clipCompletely;
if (!IsInRange(range, outerBoundary, boundaryPlane, extrusionDirection, out clipCompletely))
{
return(clipCompletely ? null : bodyItemHnd);
}
if (MathUtil.IsAlmostZero(clippingSlant))
{
throw new Exception("Can't create clipping perpendicular to extrusion.");
}
IFCFile file = exporterIFC.GetFile();
XYZ scaledOrig = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, boundaryPlane.Origin);
XYZ scaledNorm = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, boundaryPlane.Normal);
XYZ scaledXDir = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, boundaryPlane.XVec);
IFCAnyHandle planeAxisHnd = ExporterUtil.CreateAxis(file, scaledOrig, scaledNorm, scaledXDir);
IFCAnyHandle surfHnd = IFCInstanceExporter.CreatePlane(file, planeAxisHnd);
IFCAnyHandle clippedBodyItemHnd = null;
IFCAnyHandle halfSpaceHnd = null;
if (useFaceBoundary)
{
IFCAnyHandle boundedCurveHnd;
if (boundaryPlane != null)
{
XYZ projScaledOrigin = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, extrusionBasePlane.Origin);
XYZ projScaledX = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, extrusionBasePlane.XVec);
XYZ projScaledY = ExporterIFCUtils.TransformAndScaleVector(exporterIFC, extrusionBasePlane.YVec);
XYZ projScaledNorm = projScaledX.CrossProduct(projScaledY);
Plane projScaledPlane = new Plane(projScaledX, projScaledY, projScaledOrigin);
IList <UV> polylinePts = TransformAndProjectCurveLoopToPlane(exporterIFC, outerBoundary, projScaledPlane);
polylinePts.Add(polylinePts[0]);
boundedCurveHnd = ExporterUtil.CreatePolyline(file, polylinePts);
IFCAnyHandle boundedAxisHnd = ExporterUtil.CreateAxis(file, projScaledOrigin, projScaledNorm, projScaledX);
halfSpaceHnd = IFCInstanceExporter.CreatePolygonalBoundedHalfSpace(file, boundedAxisHnd, boundedCurveHnd, surfHnd, false);
}
else
{
throw new Exception("Can't create non-polygonal face boundary.");
}
}
else
{
halfSpaceHnd = IFCInstanceExporter.CreateHalfSpaceSolid(file, surfHnd, false);
}
if (halfSpaceHnd == null)
{
throw new Exception("Can't create clipping.");
}
clippedBodyItemHnd = IFCInstanceExporter.CreateBooleanClippingResult(file, IFCBooleanOperator.Difference,
bodyItemHnd, halfSpaceHnd);
return(clippedBodyItemHnd);
}
/// <summary>
/// Create the "Body" IfcRepresentation for a beam if it is representable by an extrusion, possibly with clippings and openings.
/// </summary>
/// <param name="exporterIFC">The exporterIFC class.</param>
/// <param name="element">The beam element.T</param>
/// <param name="catId">The category id.</param>
/// <param name="geomObjects">The list of solids and meshes representing the beam's geometry.
/// <param name="axisInfo">The beam axis information.</param>
/// <returns>The BeamBodyAsExtrusionInfo class which contains the created handle (if any) and other information, or null.</returns>
private static BeamBodyAsExtrusionInfo CreateBeamGeometryAsExtrusion(ExporterIFC exporterIFC, Element element, ElementId catId,
IList <GeometryObject> geomObjects, BeamAxisInfo axisInfo)
{
// If we have a beam with a Linear location line that only has one solid geometry,
// we will try to use the ExtrusionAnalyzer to generate an extrusion with 0 or more clippings.
// This code is currently limited in that it will not process beams with openings, so we
// use other methods below if this one fails.
if (geomObjects == null || geomObjects.Count != 1 || (!(geomObjects[0] is Solid)) || axisInfo == null || !(axisInfo.Axis is Line))
{
return(null);
}
BeamBodyAsExtrusionInfo info = new BeamBodyAsExtrusionInfo();
info.DontExport = false;
info.Materials = new HashSet <ElementId>();
info.Slope = 0.0;
Transform orientTrf = axisInfo.LCSAsTransform;
Solid solid = geomObjects[0] as Solid;
bool completelyClipped;
XYZ beamDirection = orientTrf.BasisX;
XYZ planeXVec = orientTrf.BasisY.Normalize();
XYZ planeYVec = orientTrf.BasisZ.Normalize();
MaterialAndProfile materialAndProfile = null;
FootPrintInfo footPrintInfo = null;
Plane beamExtrusionBasePlane = GeometryUtil.CreatePlaneByXYVectorsAtOrigin(planeXVec, planeYVec);
info.RepresentationHandle = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, element,
catId, solid, beamExtrusionBasePlane, orientTrf.Origin, beamDirection, null, out completelyClipped,
out footPrintInfo, out materialAndProfile, addInfo: GenerateAdditionalInfo.GenerateProfileDef);
if (completelyClipped)
{
info.DontExport = true;
return(null);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(info.RepresentationHandle))
{
// This is used by the BeamSlopeCalculator. This should probably be generated automatically by
// CreateExtrusionWithClipping.
IFCExtrusionBasis bestAxis = (Math.Abs(beamDirection[0]) > Math.Abs(beamDirection[1])) ?
IFCExtrusionBasis.BasisX : IFCExtrusionBasis.BasisY;
info.Slope = GeometryUtil.GetSimpleExtrusionSlope(beamDirection, bestAxis);
ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, exporterIFC, element);
if (materialId != ElementId.InvalidElementId)
{
info.Materials.Add(materialId);
}
}
if (materialAndProfile != null)
{
info.materialAndProfile = materialAndProfile;
}
return(info);
}
/// <summary>
/// Exports a beam to IFC beam.
/// </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 IFCProductWrapper.
/// </param>
public static void ExportBeam(ExporterIFC exporterIFC,
Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
double scale = exporterIFC.LinearScale;
using (IFCTransaction transaction = new IFCTransaction(file))
{
LocationCurve locCurve = element.Location as LocationCurve;
Transform orientTrf = Transform.Identity;
bool canExportAxis = (locCurve != null);
IFCAnyHandle axisRep = null;
XYZ beamDirection = null;
XYZ projDir = null;
Curve curve = null;
Plane plane = null;
if (canExportAxis)
{
curve = locCurve.Curve;
if (curve is Line)
{
Line line = curve as Line;
XYZ planeY, planeOrig;
planeOrig = line.get_EndPoint(0);
beamDirection = line.Direction;
if (Math.Abs(beamDirection.Z) < 0.707) // approx 1.0/sqrt(2.0)
{
planeY = XYZ.BasisZ.CrossProduct(beamDirection);
}
else
{
planeY = XYZ.BasisX.CrossProduct(beamDirection);
}
planeY = planeY.Normalize();
projDir = beamDirection.CrossProduct(planeY);
plane = new Plane(beamDirection, planeY, planeOrig);
orientTrf.BasisX = beamDirection; orientTrf.BasisY = planeY; orientTrf.BasisZ = projDir; orientTrf.Origin = planeOrig;
}
else if (curve is Arc)
{
XYZ yDir, center;
Arc arc = curve as Arc;
beamDirection = arc.XDirection; yDir = arc.YDirection; projDir = arc.Normal; center = arc.Center;
plane = new Plane(beamDirection, yDir, center);
orientTrf.BasisX = beamDirection; orientTrf.BasisY = yDir; orientTrf.BasisZ = projDir; orientTrf.Origin = center;
}
else
{
canExportAxis = false;
}
}
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element, null, canExportAxis ? orientTrf : null, ElementId.InvalidElementId))
{
IFCAnyHandle localPlacement = setter.GetPlacement();
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity);
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(localPlacement);
if (canExportAxis && (orientTrf.BasisX != null))
{
extrusionCreationData.CustomAxis = beamDirection;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
}
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
// The representation handle generated from one of the methods below.
IFCAnyHandle repHnd = null;
// The list of materials in the solids or meshes.
ICollection <ElementId> materialIds = new HashSet <ElementId>();
// If we can only export as a BRep, there may be an offset to make the BRep local coordinate system
// be near the origin. This offset will be used to move the axis to the new LCS.
Transform brepOffsetTransform = null;
// If we have a beam with a Linear location line that only has one solid geometry,
// we will try to use the ExtrusionAnalyzer to generate an extrusion with 0 or more clippings.
// This code is currently limited in that it will not process beams with openings, so we
// use other methods below if this one fails.
if (solids.Count == 1 && meshes.Count == 0 && (canExportAxis && (curve is Line)))
{
IList <Solid> splitVolumes = SolidUtils.SplitVolumes(solids[0]);
if (splitVolumes.Count == 1)
{
bool completelyClipped;
beamDirection = orientTrf.BasisX;
Plane beamExtrusionPlane = new Plane(orientTrf.BasisY, orientTrf.BasisZ, orientTrf.Origin);
repHnd = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, element,
catId, solids[0], beamExtrusionPlane, beamDirection, null, out completelyClipped);
if (completelyClipped)
{
return;
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
ElementId materialId = BodyExporter.GetBestMaterialIdForGeometry(solids[0], exporterIFC);
if (materialId != ElementId.InvalidElementId)
{
materialIds.Add(materialId);
}
}
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId,
solids, meshes, bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
brepOffsetTransform = bodyData.BrepOffsetTransform;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
if (canExportAxis)
{
XYZ curveOffset = new XYZ(0, 0, 0);
if (brepOffsetTransform != null)
{
curveOffset = -brepOffsetTransform.Origin / scale;
}
else
{
// Note that we do not have to have any scaling adjustment here, since the curve origin is in the
// same internal coordinate system as the curve.
curveOffset = -plane.Origin;
}
Plane offsetPlane = new Plane(plane.XVec, plane.YVec, XYZ.Zero);
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, offsetPlane, projDir, false);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, curve, curveOffset, true);
IList <IFCAnyHandle> axis_items = info.GetCurves();
if (axis_items.Count > 0)
{
string identifierOpt = "Axis"; // this is by IFC2x2 convention, not temporary
string representationTypeOpt = "Curve2D"; // this is by IFC2x2 convention, not temporary
axisRep = RepresentationUtil.CreateShapeRepresentation(exporterIFC, element, catId, exporterIFC.Get3DContextHandle(identifierOpt),
identifierOpt, representationTypeOpt, axis_items);
representations.Add(axisRep);
}
}
representations.Add(repHnd);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
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, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string instanceElemId = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceElemId);
productWrapper.AddElement(beam, setter, extrusionCreationData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(beam, element, extrusionCreationData, exporterIFC, extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
typeInfo.ScaledDepth = extrusionCreationData.ScaledLength;
typeInfo.ScaledArea = extrusionCreationData.ScaledArea;
typeInfo.ScaledInnerPerimeter = extrusionCreationData.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extrusionCreationData.ScaledOuterPerimeter;
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, beam, element, typeInfo);
if (materialIds.Count != 0)
{
CategoryUtil.CreateMaterialAssociations(element.Document, exporterIFC, beam, materialIds);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports text note elements.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="textNote">
/// The text note element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, TextNote textNote, ProductWrapper productWrapper)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse<Common.Enums.IFCEntityType>("IfcAnnotation", out elementClassTypeEnum))
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
return;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string textString = textNote.Text;
if (String.IsNullOrEmpty(textString))
throw new Exception("TextNote does not have test string.");
ElementId symId = textNote.GetTypeId();
if (symId == ElementId.InvalidElementId)
throw new Exception("TextNote does not have valid type id.");
PresentationStyleAssignmentCache cache = ExporterCacheManager.PresentationStyleAssignmentCache;
IFCAnyHandle presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
{
TextElementType textElemType = textNote.Symbol;
CreatePresentationStyleAssignmentForTextElementType(exporterIFC, textElemType, cache);
presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
throw new Exception("Failed to create presentation style assignment for TextElementType.");
}
HashSet<IFCAnyHandle> presHndSet = new HashSet<IFCAnyHandle>();
presHndSet.Add(presHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, textNote))
{
const double planScale = 100.0; // currently hardwired.
XYZ orig = UnitUtil.ScaleLength(textNote.Coord);
XYZ yDir = textNote.UpDirection;
XYZ xDir = textNote.BaseDirection;
XYZ zDir = xDir.CrossProduct(yDir);
double sizeX = UnitUtil.ScaleLength(textNote.Width * planScale);
double sizeY = UnitUtil.ScaleLength(textNote.Height * planScale);
// When we display text on screen, we "flip" it if the xDir is negative with relation to
// the X-axis. So if it is, we'll flip x and y.
bool flipOrig = false;
if (xDir.X < 0)
{
xDir = xDir.Multiply(-1.0);
yDir = yDir.Multiply(-1.0);
flipOrig = true;
}
// xFactor, yFactor only used if flipOrig.
double xFactor = 0.0, yFactor = 0.0;
string boxAlignment = ConvertTextNoteAlignToBoxAlign(textNote, out xFactor, out yFactor);
// modify the origin to match the alignment. In Revit, the origin is at the top-left (unless flipped,
// then bottom-right).
if (flipOrig)
{
orig = orig.Add(xDir.Multiply(sizeX * xFactor));
orig = orig.Add(yDir.Multiply(sizeY * yFactor));
}
IFCAnyHandle origin = ExporterUtil.CreateAxis(file, orig, zDir, xDir);
IFCAnyHandle extent = IFCInstanceExporter.CreatePlanarExtent(file, sizeX, sizeY);
IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateTextLiteralWithExtent(file, textString, origin, Toolkit.IFCTextPath.Left, extent, boxAlignment);
IFCAnyHandle annoTextOccHnd = IFCInstanceExporter.CreateStyledItem(file, repItemHnd, presHndSet, null);
ElementId catId = textNote.Category != null ? textNote.Category.Id : ElementId.InvalidElementId;
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, textNote, catId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
throw new Exception("Failed to create shape representation.");
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle annoHnd = IFCInstanceExporter.CreateAnnotation(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle,
null, null, null, setter.LocalPlacement, prodShapeHnd);
productWrapper.AddAnnotation(annoHnd, setter.LevelInfo, true);
}
tr.Commit();
}
}
/// <summary>
/// Gets material handle from material id or creates one if there is none.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="materialId">The material id.</param>
/// <returns>The handle.</returns>
public static IFCAnyHandle GetOrCreateMaterialHandle(ExporterIFC exporterIFC, ElementId materialId)
{
Document document = ExporterCacheManager.Document;
IFCAnyHandle materialNameHandle = ExporterCacheManager.MaterialHandleCache.Find(materialId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(materialNameHandle))
{
string materialName = " <Unnamed>";
if (materialId != ElementId.InvalidElementId)
{
Material material = document.GetElement(materialId) as Material;
if (material != null)
{
materialName = NamingUtil.GetNameOverride(material, material.Name);
}
}
materialNameHandle = IFCInstanceExporter.CreateMaterial(exporterIFC.GetFile(), materialName);
ExporterCacheManager.MaterialHandleCache.Register(materialId, materialNameHandle);
// associate Material with SurfaceStyle if necessary.
IFCFile file = exporterIFC.GetFile();
if (materialId != ElementId.InvalidElementId && !ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && materialNameHandle.HasValue)
{
HashSet <IFCAnyHandle> matRepHandles = IFCAnyHandleUtil.GetHasRepresentation(materialNameHandle);
if (matRepHandles.Count == 0)
{
Material matElem = document.GetElement(materialId) as Material;
ElementId fillPatternId = (matElem != null) ? matElem.CutPatternId : ElementId.InvalidElementId;
Autodesk.Revit.DB.Color color = (matElem != null) ? GetSafeColor(matElem.CutPatternColor) : new Color(0, 0, 0);
double planScale = 100.0;
HashSet <IFCAnyHandle> styles = new HashSet <IFCAnyHandle>();
bool hasFill = false;
IFCAnyHandle styledRepItem = null;
IFCAnyHandle matStyleHnd = CategoryUtil.GetOrCreateMaterialStyle(document, exporterIFC, materialId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(matStyleHnd))
{
styles.Add(matStyleHnd);
bool supportCutStyles = !ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2;
if (fillPatternId != ElementId.InvalidElementId && supportCutStyles)
{
IFCAnyHandle cutStyleHnd = exporterIFC.GetOrCreateFillPattern(fillPatternId, color, planScale);
if (cutStyleHnd.HasValue)
{
styles.Add(cutStyleHnd);
hasFill = true;
}
}
IFCAnyHandle presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, styles);
HashSet <IFCAnyHandle> presStyleSet = new HashSet <IFCAnyHandle>();
presStyleSet.Add(presStyleHnd);
IFCAnyHandle styledItemHnd = IFCInstanceExporter.CreateStyledItem(file, styledRepItem, presStyleSet, null);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("");
string repId = "Style";
string repType = (hasFill) ? "Material and Cut Pattern" : "Material";
HashSet <IFCAnyHandle> repItems = new HashSet <IFCAnyHandle>();
repItems.Add(styledItemHnd);
IFCAnyHandle styleRepHnd = IFCInstanceExporter.CreateStyledRepresentation(file, contextOfItems, repId, repType, repItems);
List <IFCAnyHandle> repList = new List <IFCAnyHandle>();
repList.Add(styleRepHnd);
IFCAnyHandle matDefRepHnd = IFCInstanceExporter.CreateMaterialDefinitionRepresentation(file, null, null, repList, materialNameHandle);
}
}
}
}
return(materialNameHandle);
}
/// <summary>
/// Initializes the transformation in the transform setter.
/// </summary>
/// <param name="exporterIFC">
/// The exporter.
/// </param>
/// <param name="transform">
/// The transform.
/// </param>
public void Initialize(ExporterIFC exporterIFC, Transform trf)
{
Initialize(exporterIFC, trf.Origin, trf.BasisX, trf.BasisY);
}
/// <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 (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element, null, null, ExporterUtil.GetBaseLevelIdForElement(element)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
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 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);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, GUIDUtil.CreateGUID(element), exporterIFC.GetOwnerHistoryHandle(),
elementTypeName, null, null, null, repMapList, NamingUtil.CreateIFCElementId(element), elementTypeName, IFCPipeSegmentType.Gutter);
List <IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
IList <IFCAnyHandle> representations = new List <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 name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, elementTypeName);
string tag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(file, GUIDUtil.CreateGUID(element),
exporterIFC.GetOwnerHistoryHandle(), name, description, objectType, localPlacementToUse, prodRep,
tag);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.GetLevelInfo(), ecData, !containedInSpace);
if (containedInSpace)
{
exporterIFC.RelateSpatialElement(roomId, elemHnd);
}
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports curtain object as container.
/// </summary>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="wallElement">
/// The curtain wall element.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportCurtainObjectCommonAsContainer(ICollection <ElementId> allSubElements, Element wallElement,
ExporterIFC exporterIFC, IFCProductWrapper origWrapper)
{
if (wallElement == null)
{
return;
}
HashSet <ElementId> alreadyVisited = new HashSet <ElementId>(); // just in case.
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
{
foreach (ElementId subElemId in allSubElements)
{
using (IFCProductWrapper productWrapper = IFCProductWrapper.Create(origWrapper))
{
Element subElem = wallElement.Document.GetElement(subElemId);
if (subElem == null)
{
continue;
}
GeometryElement geomElem = subElem.get_Geometry(geomOptions);
if (geomElem == null)
{
continue;
}
if (alreadyVisited.Contains(subElem.Id))
{
continue;
}
alreadyVisited.Add(subElem.Id);
try
{
if (subElem is FamilyInstance)
{
if (subElem is Mullion)
{
if (exporterIFC.ExportAs2x2)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
else
{
using (IFCPlacementSetter currSetter = IFCPlacementSetter.Create(exporterIFC, wallElement))
{
IFCAnyHandle currLocalPlacement = currSetter.GetPlacement();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
MullionExporter.Export(exporterIFC, subElem as Mullion, geomElem, currLocalPlacement, extraParams, currSetter,
productWrapper);
}
}
}
}
else
{
FamilyInstance subFamInst = subElem as FamilyInstance;
string ifcEnumType;
ElementId catId = CategoryUtil.GetSafeCategoryId(subElem);
IFCExportType exportType = ElementFilteringUtil.GetExportTypeFromCategoryId(catId, out ifcEnumType);
if (exporterIFC.ExportAs2x2)
{
if ((exportType == IFCExportType.DontExport) || (exportType == IFCExportType.ExportPlateType) ||
(exportType == IFCExportType.ExportMemberType))
{
exportType = IFCExportType.ExportBuildingElementProxy;
}
}
else
{
if (exportType == IFCExportType.DontExport)
{
ifcEnumType = "CURTAIN_PANEL";
exportType = IFCExportType.ExportPlateType;
}
}
FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem(exporterIFC, subFamInst, exportType, ifcEnumType, productWrapper,
ElementId.InvalidElementId, null);
}
}
else if (subElem is CurtainGridLine)
{
ProxyElementExporter.Export(exporterIFC, subElem, geomElem, productWrapper);
}
}
catch (Exception ex)
{
if (ExporterUtil.IsFatalException(wallElement.Document, ex))
{
throw ex;
}
continue;
}
}
}
}
}
/// <summary>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
Document document = element.Document;
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
Transform extrusionTrf = Transform.Identity;
IFCAnyHandle extrusionHandle = ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element, info[curr]);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, document, extrusionHandle, ElementId.InvalidElementId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(extrusionHandle);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCAnyHandle bodyRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItems, null);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = GUIDUtil.CreateGUID();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(exporterIFC, element, guid, ownerHistory,
openingPlacement, openingRep, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingElement, openingName);
IFCAnyHandleUtil.SetAttribute(openingElement, "ObjectType", openingObjectType);
wrapper.AddElement(null, openingElement, setter, extraParams, true);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
}
/// <summary>
/// Exports a beam to IFC beam if it has an axis representation and only one Solid as its geometry, ideally as an extrusion, potentially with clippings and openings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <param name="dontExport">An output value that says that the element shouldn't be exported at all.</param>
/// <returns>The created handle.</returns>
/// <remarks>In the original implementation, the ExportBeam function would export each beam as its own individual geometry (that is, not use representation maps).
/// For non-standard beams, this could result in massive IFC files. Now, we use the ExportBeamAsStandardElement function and limit its scope, and instead
/// resort to the standard FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem for more complicated objects categorized as beams. This has the following pros and cons:
/// Pro: possiblity for massively reduced file sizes for files containing repeated complex beam families
/// Con: some beams that may have had an "Axis" representation before will no longer have them, although this possibility is minimized.
/// Con: some beams that have 1 Solid and an axis, but that Solid will be heavily faceted, won't be helped by this improvement.
/// It is intended that we phase out this routine entirely and instead teach ExportFamilyInstanceAsMappedItem how to sometimes export the Axis representation for beams.</remarks>
public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
Element element, GeometryElement geometryElement, ProductWrapper productWrapper, out bool dontExport)
{
dontExport = true;
IList <GeometryObject> geomObjects = BeamGeometryToExport(exporterIFC, element, geometryElement, out dontExport);
if (dontExport)
{
return(null);
}
IFCAnyHandle beam = null;
IFCFile file = exporterIFC.GetFile();
MaterialAndProfile materialAndProfile = null;
IFCAnyHandle materialProfileSet = null;
using (IFCTransaction transaction = new IFCTransaction(file))
{
BeamAxisInfo axisInfo = GetBeamAxisTransform(element);
bool canExportAxis = (axisInfo != null);
Curve curve = canExportAxis ? axisInfo.Axis : null;
XYZ beamDirection = canExportAxis ? axisInfo.AxisDirection : null;
Transform orientTrf = canExportAxis ? axisInfo.LCSAsTransform : null;
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, orientTrf))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(localPlacement);
if (canExportAxis && (orientTrf.BasisX != null))
{
extrusionCreationData.CustomAxis = beamDirection;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
}
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
// There may be an offset to make the local coordinate system
// be near the origin. This offset will be used to move the axis to the new LCS.
Transform offsetTransform = null;
// The list of materials in the solids or meshes.
ICollection <ElementId> materialIds = null;
// The representation handle generated from one of the methods below.
BeamBodyAsExtrusionInfo extrusionInfo = CreateBeamGeometryAsExtrusion(exporterIFC, element, catId, geomObjects, axisInfo);
if (extrusionInfo != null && extrusionInfo.DontExport)
{
dontExport = true;
return(null);
}
IFCAnyHandle repHnd = (extrusionInfo != null) ? extrusionInfo.RepresentationHandle : null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
materialIds = extrusionInfo.Materials;
extrusionCreationData.Slope = extrusionInfo.Slope;
}
else
{
// Here is where we limit the scope of how complex a case we will still try to export as a standard element.
// This is explicitly added so that many curved beams that can be represented by a reasonable facetation because of the
// SweptSolidExporter can still have an Axis representation.
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyExporterOptions.CollectMaterialAndProfile = true;
if (geomObjects != null && geomObjects.Count == 1 && geomObjects[0] is Solid)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
geomObjects[0], bodyExporterOptions, extrusionCreationData);
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
if (!bodyData.OffsetTransform.IsIdentity)
{
offsetTransform = bodyData.OffsetTransform;
}
materialAndProfile = bodyData.materialAndProfile;
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
IFCAnyHandle axisRep = CreateBeamAxis(exporterIFC, element, catId, axisInfo, offsetTransform);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(axisRep))
{
representations.Add(axisRep);
}
representations.Add(repHnd);
Transform boundingBoxTrf = (offsetTransform == null) ? Transform.Identity : offsetTransform.Inverse;
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string preDefinedType = "BEAM"; // Default predefined type for Beam
preDefinedType = IFCValidateEntry.GetValidIFCType(element, preDefinedType);
beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceTag, preDefinedType);
IFCAnyHandle mpSetUsage;
if (materialProfileSet != null)
{
mpSetUsage = IFCInstanceExporter.CreateMaterialProfileSetUsage(file, materialProfileSet, null, null);
}
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
ExportBeamType(exporterIFC, productWrapper, beam, element, preDefinedType);
OpeningUtil.CreateOpeningsIfNecessary(beam, element, extrusionCreationData, offsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
typeInfo.ScaledDepth = extrusionCreationData.ScaledLength;
typeInfo.ScaledArea = extrusionCreationData.ScaledArea;
typeInfo.ScaledInnerPerimeter = extrusionCreationData.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extrusionCreationData.ScaledOuterPerimeter;
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, beam, element, typeInfo, null);
if (materialIds.Count != 0)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, beam, materialIds);
}
// Register the beam's IFC handle for later use by truss and beam system export.
ExporterCacheManager.ElementToHandleCache.Register(element.Id, beam);
}
}
transaction.Commit();
return(beam);
}
}
/// <summary>
/// Split associated parts when host element is split by level.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostElement">The host element havign associtaed parts.</param>
/// <param name="associatedPartsList">The list of associtated parts.</param>
private static void SplitParts(ExporterIFC exporterIFC, Element hostElement, List <ElementId> associatedPartsList)
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
// Split the host to find the orphan parts.
IList <ElementId> orphanLevels = new List <ElementId>();
IList <ElementId> hostLevels = new List <ElementId>();
IList <IFCRange> hostRanges = new List <IFCRange>();
LevelUtil.CreateSplitLevelRangesForElement(exporterIFC, exportType, hostElement, out hostLevels, out hostRanges);
orphanLevels = hostLevels;
// Split each Parts
IList <ElementId> levels = new List <ElementId>();
IList <IFCRange> ranges = new List <IFCRange>();
// Dictionary to storage the level and its parts.
Dictionary <ElementId, List <KeyValuePair <Part, IFCRange> > > levelParts = new Dictionary <ElementId, List <KeyValuePair <Part, IFCRange> > >();
foreach (ElementId partId in associatedPartsList)
{
Part part = hostElement.Document.GetElement(partId) as Part;
LevelUtil.CreateSplitLevelRangesForElement(exporterIFC, exportType, part, out levels, out ranges);
// if the parts are above top level, associate them with nearest bottom level.
if (ranges.Count == 0)
{
ElementId bottomLevelId = FindPartSplitLevel(exporterIFC, part);
if (bottomLevelId == ElementId.InvalidElementId)
{
bottomLevelId = part.LevelId;
}
if (!levelParts.ContainsKey(bottomLevelId))
{
levelParts.Add(bottomLevelId, new List <KeyValuePair <Part, IFCRange> >());
}
KeyValuePair <Part, IFCRange> splitPartRange = new KeyValuePair <Part, IFCRange>(part, null);
levelParts[bottomLevelId].Add(splitPartRange);
continue;
}
// The parts split by levels are stored in dictionary.
for (int ii = 0; ii < ranges.Count; ii++)
{
if (!levelParts.ContainsKey(levels[ii]))
{
levelParts.Add(levels[ii], new List <KeyValuePair <Part, IFCRange> >());
}
KeyValuePair <Part, IFCRange> splitPartRange = new KeyValuePair <Part, IFCRange>(part, ranges[ii]);
levelParts[levels[ii]].Add(splitPartRange);
}
if (levels.Count > hostLevels.Count)
{
orphanLevels = orphanLevels.Union <ElementId>(levels).ToList();
}
}
ExporterCacheManager.HostPartsCache.Register(hostElement.Id, levelParts);
// The levels of orphan part.
orphanLevels = orphanLevels.Where(number => !hostLevels.Contains(number)).ToList();
List <KeyValuePair <ElementId, IFCRange> > levelRangePairList = new List <KeyValuePair <ElementId, IFCRange> >();
foreach (ElementId orphanLevelId in orphanLevels)
{
IFCLevelInfo levelInfo = ExporterCacheManager.LevelInfoCache.GetLevelInfo(exporterIFC, orphanLevelId);
if (levelInfo == null)
{
continue;
}
double levelHeight = ExporterCacheManager.LevelInfoCache.FindHeight(orphanLevelId);
IFCRange levelRange = new IFCRange(levelInfo.Elevation, levelInfo.Elevation + levelHeight);
List <KeyValuePair <Part, IFCRange> > splitPartRangeList = new List <KeyValuePair <Part, IFCRange> >();
splitPartRangeList = ExporterCacheManager.HostPartsCache.Find(hostElement.Id, orphanLevelId);
IFCRange highestRange = levelRange;
foreach (KeyValuePair <Part, IFCRange> partRange in splitPartRangeList)
{
if (partRange.Value.End > highestRange.End)
{
highestRange = partRange.Value;
}
}
levelRangePairList.Add(new KeyValuePair <ElementId, IFCRange>(orphanLevelId, highestRange));
}
if (levelRangePairList.Count > 0)
{
ExporterCacheManager.DummyHostCache.Register(hostElement.Id, levelRangePairList);
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
IFCProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, roof))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(roof.Document.Application, exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = ExporterIFCUtils.CreateGUID(roof);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origRoofName = exporterIFC.GetName();
string roofName = NamingUtil.GetNameOverride(roof, origRoofName);
string roofDescription = NamingUtil.GetDescriptionOverride(roof, null);
string roofObjectType = NamingUtil.GetObjectTypeOverride(roof, NamingUtil.CreateIFCObjectName(exporterIFC, roof));
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(roof);
IFCRoofType roofType = GetIFCRoofType(ifcEnumType);
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, roofName, roofDescription,
roofObjectType, localPlacement, exportSlab ? null : representation, elementTag, roofType);
productWrapper.AddElement(roofHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(roof));
if (exportSlab)
{
string slabGUID = ExporterIFCUtils.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = roofName + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, slabName,
roofDescription, roofObjectType, slabLocalPlacementHnd, representation, elementTag, IFCSlabType.Roof);
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, exporterIFC, slabLocalPlacementHnd,
placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(slabHnd, placementSetter.GetLevelInfo(), ecData, false);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Export the individual part (IfcBuildingElementPart).
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="partElement">The part element to export.</param>
/// <param name="geometryElement">The geometry of part.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
public static void ExportPart(ExporterIFC exporterIFC, Element partElement, ProductWrapper productWrapper,
PlacementSetter placementSetter, IFCAnyHandle originalPlacement, IFCRange range, IFCExtrusionAxes ifcExtrusionAxes,
Element hostElement, ElementId overrideLevelId, bool asBuildingElement)
{
if (!ElementFilteringUtil.IsElementVisible(partElement))
{
return;
}
Part part = partElement as Part;
if (part == null)
{
return;
}
PlacementSetter standalonePlacementSetter = null;
bool standaloneExport = hostElement == null && !asBuildingElement;
ElementId partExportLevel = null;
if (standaloneExport || asBuildingElement)
{
partExportLevel = partElement.LevelId;
}
else
{
if (part.OriginalCategoryId != hostElement.Category.Id)
{
return;
}
partExportLevel = hostElement.LevelId;
}
if (overrideLevelId != null)
{
partExportLevel = overrideLevelId;
}
if (ExporterCacheManager.PartExportedCache.HasExported(partElement.Id, partExportLevel))
{
return;
}
Options options = GeometryUtil.GetIFCExportGeometryOptions();
View ownerView = partElement.Document.GetElement(partElement.OwnerViewId) as View;
if (ownerView != null)
{
options.View = ownerView;
}
GeometryElement geometryElement = partElement.get_Geometry(options);
if (geometryElement == null)
{
return;
}
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IFCAnyHandle partPlacement = null;
if (standaloneExport || asBuildingElement)
{
Transform orientationTrf = Transform.Identity;
standalonePlacementSetter = PlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevel);
partPlacement = standalonePlacementSetter.LocalPlacement;
}
else
{
partPlacement = ExporterUtil.CreateLocalPlacement(file, originalPlacement, null);
}
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
SolidMeshGeometryInfo solidMeshInfo;
if (validRange)
{
solidMeshInfo = GeometryUtil.GetSplitClippedSolidMeshGeometry(geometryElement, range);
if (solidMeshInfo.GetSolids().Count == 0 && solidMeshInfo.GetMeshes().Count == 0)
{
return;
}
}
else
{
solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
}
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(partPlacement);
extrusionCreationData.ReuseLocalPlacement = false;
extrusionCreationData.PossibleExtrusionAxes = ifcExtrusionAxes;
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(partElement);
ElementId hostCatId = CategoryUtil.GetSafeCategoryId(hostElement);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, solids, meshes,
bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string partGUID = GUIDUtil.CreateGUID(partElement);
string partName = NamingUtil.GetNameOverride(partElement, NamingUtil.GetIFCName(partElement));
string partDescription = NamingUtil.GetDescriptionOverride(partElement, null);
string partObjectType = NamingUtil.GetObjectTypeOverride(partElement, NamingUtil.CreateIFCObjectName(exporterIFC, partElement));
string partTag = NamingUtil.GetTagOverride(partElement, NamingUtil.CreateIFCElementId(partElement));
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag);
}
else
{
string ifcEnumType = null;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
string defaultValue = null;
// This replicates old functionality before IFC4 addition, where the default for slab was "FLOOR".
// Really the export layer table should be fixed for this case.
if (string.IsNullOrWhiteSpace(ifcEnumType) && hostCatId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOOR";
}
ifcEnumType = IFCValidateEntry.GetValidIFCType(hostElement, ifcEnumType, defaultValue);
switch (exportType)
{
case IFCExportType.IfcColumnType:
ifcPart = IFCInstanceExporter.CreateColumn(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcCovering:
ifcPart = IFCInstanceExporter.CreateCovering(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcFooting:
ifcPart = IFCInstanceExporter.CreateFooting(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcPile:
ifcPart = IFCInstanceExporter.CreatePile(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType, null);
break;
case IFCExportType.IfcRoof:
ifcPart = IFCInstanceExporter.CreateRoof(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcSlab:
ifcPart = IFCInstanceExporter.CreateSlab(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcWall:
ifcPart = IFCInstanceExporter.CreateWall(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag, null);
break;
}
}
bool containedInLevel = (standaloneExport || asBuildingElement);
PlacementSetter whichPlacementSetter = containedInLevel ? standalonePlacementSetter : placementSetter;
productWrapper.AddElement(partElement, ifcPart, whichPlacementSetter, extrusionCreationData, containedInLevel);
OpeningUtil.CreateOpeningsIfNecessary(ifcPart, partElement, extrusionCreationData, bodyData.OffsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), whichPlacementSetter, productWrapper);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevel, standaloneExport || asBuildingElement ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
/// <summary>
/// Attempts to create a clipping, recess, or opening from a collection of faces.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="cuttingElement">The cutting element. This will help determine whether to use a clipping or opening in boundary cases.</param>
/// <param name="extrusionBasePlane">The plane of the extrusion base.</param>
/// <param name="extrusionDirection">The extrusion direction.</param>
/// <param name="faces">The collection of faces.</param>
/// <param name="range">The valid range of the extrusion.</param>
/// <param name="origBodyRepHnd">The original body representation.</param>
/// <returns>The new body representation. If the clipping completely clips the extrusion, this will be null. Otherwise, this
/// will be the clipped representation if a clipping was done, or the original representation if not.</returns>
public static IFCAnyHandle ProcessFaceCollection(ExporterIFC exporterIFC, Element cuttingElement, Plane extrusionBasePlane,
XYZ extrusionDirection, ICollection <Face> faces, IFCRange range, IFCAnyHandle origBodyRepHnd)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(origBodyRepHnd))
{
return(null);
}
bool polygonalOnly = ExporterCacheManager.ExportOptionsCache.ExportAs2x2;
IList <CurveLoop> outerCurveLoops = new List <CurveLoop>();
IList <Plane> outerCurveLoopPlanes = new List <Plane>();
IList <bool> boundaryIsPolygonal = new List <bool>();
bool allPlanes = true;
UV faceOriginUV = new UV(0, 0);
foreach (Face face in faces)
{
FaceBoundaryType faceBoundaryType;
CurveLoop curveLoop = GetOuterFaceBoundary(face, null, polygonalOnly, out faceBoundaryType);
outerCurveLoops.Add(curveLoop);
boundaryIsPolygonal.Add(faceBoundaryType == FaceBoundaryType.Polygonal);
if (face is PlanarFace)
{
PlanarFace planarFace = face as PlanarFace;
XYZ faceOrigin = planarFace.Origin;
XYZ faceNormal = planarFace.ComputeNormal(faceOriginUV);
Plane plane = new Plane(faceNormal, faceOrigin);
outerCurveLoopPlanes.Add(plane);
if (!curveLoop.IsCounterclockwise(faceNormal))
{
curveLoop.Flip();
}
}
else
{
outerCurveLoopPlanes.Add(null);
allPlanes = false;
}
}
if (allPlanes)
{
int numFaces = faces.Count;
// Special case: one face is a clip plane.
if (numFaces == 1)
{
return(ProcessClippingFace(exporterIFC, outerCurveLoops[0], outerCurveLoopPlanes[0], extrusionBasePlane,
extrusionDirection, range, false, origBodyRepHnd));
}
KeyValuePair <bool, bool> clipsExtrusionEnds = CollectionClipsExtrusionEnds(outerCurveLoops, extrusionDirection, range);
if (clipsExtrusionEnds.Key == true || clipsExtrusionEnds.Value == true)
{
// Don't clip for a door, window or opening.
if (CreateOpeningForCategory(cuttingElement))
{
throw new Exception("Unhandled opening.");
}
ICollection <int> facesToSkip = new HashSet <int>();
bool clipStart = (clipsExtrusionEnds.Key == true);
bool clipBoth = (clipsExtrusionEnds.Key == true && clipsExtrusionEnds.Value == true);
if (!clipBoth)
{
for (int ii = 0; ii < numFaces; ii++)
{
double slant = outerCurveLoopPlanes[ii].Normal.DotProduct(extrusionDirection);
if (!MathUtil.IsAlmostZero(slant))
{
if (clipStart && (slant > 0.0))
{
throw new Exception("Unhandled clip plane direction.");
}
if (!clipStart && (slant < 0.0))
{
throw new Exception("Unhandled clip plane direction.");
}
}
else
{
facesToSkip.Add(ii);
}
}
}
else
{
// If we are clipping both the start and end of the extrusion, we have to make sure all of the clipping
// planes have the same a non-negative dot product relative to one another.
int clipOrientation = 0;
for (int ii = 0; ii < numFaces; ii++)
{
double slant = outerCurveLoopPlanes[ii].Normal.DotProduct(extrusionDirection);
if (!MathUtil.IsAlmostZero(slant))
{
if (slant > 0.0)
{
if (clipOrientation < 0)
{
throw new Exception("Unhandled clipping orientations.");
}
clipOrientation = 1;
}
else
{
if (clipOrientation > 0)
{
throw new Exception("Unhandled clipping orientations.");
}
clipOrientation = -1;
}
}
else
{
facesToSkip.Add(ii);
}
}
}
IFCAnyHandle newBodyRepHnd = origBodyRepHnd;
for (int ii = 0; ii < numFaces; ii++)
{
if (facesToSkip.Contains(ii))
{
continue;
}
newBodyRepHnd = ProcessClippingFace(exporterIFC, outerCurveLoops[ii], outerCurveLoopPlanes[ii],
extrusionBasePlane, extrusionDirection, range, true, newBodyRepHnd);
if (newBodyRepHnd == null)
{
return(null);
}
}
return(newBodyRepHnd);
}
}
bool unhandledCases = true;
if (unhandledCases)
{
throw new Exception("Unhandled opening or clipping.");
}
// We will attempt to "sew" the faces, and see what we have left over. Depending on what we have, we have an opening, recess, or clipping.
IList <Edge> boundaryEdges = new List <Edge>();
foreach (Face face in faces)
{
EdgeArrayArray faceBoundaries = face.EdgeLoops;
// We only know how to deal with the outer loop; we'll throw if we have multiple boundaries.
if (faceBoundaries.Size != 1)
{
throw new Exception("Can't process faces with inner boundaries.");
}
EdgeArray faceBoundary = faceBoundaries.get_Item(0);
foreach (Edge edge in faceBoundary)
{
if (edge.get_Face(0) == null || edge.get_Face(1) == null)
{
boundaryEdges.Add(edge);
}
}
}
return(origBodyRepHnd);
}
/// <summary>
/// Export Curtain Walls and Roofs.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportBase(ExporterIFC exporterIFC, ICollection <ElementId> allSubElements,
Element element, IFCProductWrapper wrapper)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCPlacementSetter setter = null;
using (IFCProductWrapper curtainWallSubWrapper = IFCProductWrapper.Create(wrapper, false))
{
try
{
IFCAnyHandle localPlacement = null;
bool canExportCurtainWallAsContainer = CanExportCurtainWallAsContainer(allSubElements, element.Document);
IFCAnyHandle rep = null;
if (!canExportCurtainWallAsContainer)
{
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
{
return;
}
}
else
{
ExportCurtainObjectCommonAsContainer(allSubElements, element, exporterIFC, curtainWallSubWrapper);
// This has to go LAST. Why? Because otherwise we apply the level transform twice -- once in the familyTrf, once here.
// This will be used just to put the CurtainWall on the right level.
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
}
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
{
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = ExporterIFCUtils.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, exporterIFC.GetName());
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemId = NamingUtil.CreateIFCElementId(element);
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement, prodRepHnd, elemId);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
elemHnd = IFCInstanceExporter.CreateRoof(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement,
prodRepHnd, elemId, RoofExporter.GetIFCRoofType(ifcEnumType));
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(elemHnd, setter, null, true);
ExporterIFCUtils.CreateCurtainWallPropertySet(exporterIFC, element, wrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, wrapper);
ICollection <IFCAnyHandle> relatedElementIds = curtainWallSubWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateSubElementGUID(element, (int)IFCCurtainWallSubElements.RelAggregates);
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(file, guid, ownerHistory, null, null, elemHnd, relatedElementIdSet);
}
exporterIFC.RegisterSpaceBoundingElementHandle(elemHnd, element.Id, ElementId.InvalidElementId);
}
}
finally
{
if (setter != null)
{
setter.Dispose();
}
}
}
}
/// <summary>
/// Calculates the shape for a provision for void.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (extrusionCreationData == null)
{
return(false);
}
IFCAnyHandle provisionForVoidHnd = ExporterCacheManager.ElementToHandleCache.Find(element.Id);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(provisionForVoidHnd))
{
return(false);
}
IFCAnyHandle prodRepHnd = IFCAnyHandleUtil.GetInstanceAttribute(provisionForVoidHnd, "Representation");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRepHnd))
{
return(false);
}
IList <IFCAnyHandle> repHnds = IFCAnyHandleUtil.GetRepresentations(prodRepHnd);
foreach (IFCAnyHandle repHnd in repHnds)
{
string repId = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationIdentifier");
if (String.Compare(repId, "Body", true) != 0)
{
continue;
}
string repType = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationType");
if (String.Compare(repType, "SweptSolid", true) != 0)
{
return(false);
}
HashSet <IFCAnyHandle> repItemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(repHnd, "Items");
int numRepItems = repItemSet.Count;
if (numRepItems == 0)
{
return(false);
}
if (numRepItems == 1)
{
IFCAnyHandle repItemHnd = repItemSet.ElementAt(0);
if (!IFCAnyHandleUtil.IsSubTypeOf(repItemHnd, IFCEntityType.IfcExtrudedAreaSolid))
{
return(false);
}
IFCAnyHandle sweptAreaHnd = IFCAnyHandleUtil.GetInstanceAttribute(repItemHnd, "SweptArea");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(sweptAreaHnd))
{
return(false);
}
m_CurrentProfileHandle = sweptAreaHnd;
if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcRectangleProfileDef))
{
m_Shape = IFCProvisionForVoidShapeType.Rectangle.ToString();
}
else if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcCircleProfileDef))
{
m_Shape = IFCProvisionForVoidShapeType.Round.ToString();
}
}
if (m_Shape == null)
{
m_Shape = IFCProvisionForVoidShapeType.Undefined.ToString();
m_CurrentProfileHandle = null;
}
m_CurrentElement = element;
return(true);
}
return(false);
}
/// <summary>
/// Creates a SweptSolidExporter.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="solid">The solid.</param>
/// <param name="normal">The normal of the plane that the path lies on.</param>
/// <returns>The SweptSolidExporter.</returns>
public static SweptSolidExporter Create(ExporterIFC exporterIFC, Element element, SimpleSweptSolidAnalyzer sweptAnalyzer, GeometryObject geomObject, GenerateAdditionalInfo addInfo = GenerateAdditionalInfo.None)
{
try
{
if (sweptAnalyzer == null)
{
return(null);
}
SweptSolidExporter sweptSolidExporter = null;
IList <Revit.IFC.Export.Utility.GeometryUtil.FaceBoundaryType> faceBoundaryTypes;
IList <CurveLoop> faceBoundaries = GeometryUtil.GetFaceBoundaries(sweptAnalyzer.ProfileFace, null, out faceBoundaryTypes);
string profileName = null;
if (element != null)
{
ElementType type = element.Document.GetElement(element.GetTypeId()) as ElementType;
if (type != null)
{
profileName = type.Name;
}
}
// Is it really an extrusion?
if (sweptAnalyzer.PathCurve is Line)
{
Line line = sweptAnalyzer.PathCurve as Line;
// invalid case
if (MathUtil.VectorsAreOrthogonal(line.Direction, sweptAnalyzer.ProfileFace.FaceNormal))
{
return(null);
}
sweptSolidExporter = new SweptSolidExporter();
sweptSolidExporter.RepresentationType = ShapeRepresentationType.SweptSolid;
Transform lcs = GeometryUtil.CreateTransformFromPlanarFace(sweptAnalyzer.ProfileFace);
sweptSolidExporter.RepresentationItem = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, profileName, faceBoundaries, lcs,
line.Direction, UnitUtil.ScaleLength(line.Length), false);
if ((addInfo & GenerateAdditionalInfo.GenerateFootprint) != 0)
{
FootPrintInfo fInfo = new FootPrintInfo();
fInfo.LCSTransformUsed = lcs;
fInfo.FootPrintHandle = GeometryUtil.CreateIFCCurveFromCurveLoop(exporterIFC, faceBoundaries[0], lcs, line.Direction);
sweptSolidExporter.FootprintInfo = fInfo;
}
}
else
{
sweptSolidExporter = new SweptSolidExporter();
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// Use tessellated geometry in IFC Reference View
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView || ExporterCacheManager.ExportOptionsCache.ExportAs4General)
{
// TODO: Create CreateSimpleSweptSolidAsTessellation routine that takes advantage of the superior tessellation of this class.
BodyExporterOptions options = new BodyExporterOptions(false, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
sweptSolidExporter.RepresentationItem = BodyExporter.ExportBodyAsTessellatedFaceSet(exporterIFC, element, options, geomObject)[0];
sweptSolidExporter.RepresentationType = ShapeRepresentationType.Tessellation;
}
else
{
sweptSolidExporter.RepresentationItem = CreateSimpleSweptSolid(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve);
sweptSolidExporter.RepresentationType = ShapeRepresentationType.AdvancedSweptSolid;
if ((addInfo & GenerateAdditionalInfo.GenerateFootprint) != 0)
{
FootPrintInfo fInfo = new FootPrintInfo();
Transform lcs = GeometryUtil.CreateTransformFromPlanarFace(sweptAnalyzer.ProfileFace);
fInfo.LCSTransformUsed = lcs;
fInfo.FootPrintHandle = GeometryUtil.CreateIFCCurveFromCurveLoop(exporterIFC, faceBoundaries[0], lcs, sweptAnalyzer.ReferencePlaneNormal);
sweptSolidExporter.FootprintInfo = fInfo;
}
}
}
else
{
sweptSolidExporter.Facets = CreateSimpleSweptSolidAsBRep(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve);
sweptSolidExporter.RepresentationType = ShapeRepresentationType.Brep;
}
}
return(sweptSolidExporter);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Get the handles of Grid Axes.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="sameDirectionAxes">The grid axes in the same direction of one level.</param>
/// <param name="representations">The representation of grid axis.</param>
/// <returns>The list of handles of grid axes.</returns>
private static List <IFCAnyHandle> CreateIFCGridAxisAndRepresentations(ExporterIFC exporterIFC, ProductWrapper productWrapper, IList <Grid> sameDirectionAxes,
IList <IFCAnyHandle> representations, GridRepresentationData gridRepresentationData)
{
if (sameDirectionAxes.Count == 0)
{
return(null);
}
IDictionary <ElementId, List <IFCAnyHandle> > gridAxisMap = new Dictionary <ElementId, List <IFCAnyHandle> >();
IDictionary <ElementId, List <IFCAnyHandle> > gridRepMap = new Dictionary <ElementId, List <IFCAnyHandle> >();
IFCFile ifcFile = exporterIFC.GetFile();
Grid baseGrid = sameDirectionAxes[0];
Transform lcs = Transform.Identity;
List <IFCAnyHandle> ifcGridAxes = new List <IFCAnyHandle>();
foreach (Grid grid in sameDirectionAxes)
{
// Because the IfcGrid is a collection of Revit Grids, any one of them can override the IFC CAD Layer.
// We will take the first name, and not do too much checking.
if (string.IsNullOrWhiteSpace(gridRepresentationData.m_IFCCADLayer))
{
ParameterUtil.GetStringValueFromElementOrSymbol(grid, "IFCCadLayer", out gridRepresentationData.m_IFCCADLayer);
}
// Get the handle of curve.
XYZ projectionDirection = lcs.BasisZ;
IFCAnyHandle axisCurve;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
axisCurve = GeometryUtil.CreatePolyCurveFromCurve(exporterIFC, grid.Curve, lcs, projectionDirection);
}
else
{
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, lcs, projectionDirection, false);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, grid.Curve, XYZ.Zero, false);
IList <IFCAnyHandle> curves = info.GetCurves();
if (curves.Count != 1)
{
throw new Exception("IFC: expected 1 curve when export curve element.");
}
axisCurve = curves[0];
}
bool sameSense = true;
if (baseGrid.Curve is Line)
{
Line baseLine = baseGrid.Curve as Line;
Line axisLine = grid.Curve as Line;
sameSense = (axisLine.Direction.IsAlmostEqualTo(baseLine.Direction));
}
IFCAnyHandle ifcGridAxis = IFCInstanceExporter.CreateGridAxis(ifcFile, grid.Name, axisCurve, sameSense);
ifcGridAxes.Add(ifcGridAxis);
HashSet <IFCAnyHandle> AxisCurves = new HashSet <IFCAnyHandle>();
AxisCurves.Add(axisCurve);
IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateGeometricCurveSet(ifcFile, AxisCurves);
// get the weight and color from the GridType to create the curve style.
GridType gridType = grid.Document.GetElement(grid.GetTypeId()) as GridType;
IFCData curveWidth = null;
if (ExporterCacheManager.ExportOptionsCache.ExportAnnotations)
{
int outWidth;
double width =
(ParameterUtil.GetIntValueFromElement(gridType, BuiltInParameter.GRID_END_SEGMENT_WEIGHT, out outWidth) != null) ? outWidth : 1;
curveWidth = IFCDataUtil.CreateAsPositiveLengthMeasure(width);
}
if (!ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
int outColor;
int color =
(ParameterUtil.GetIntValueFromElement(gridType, BuiltInParameter.GRID_END_SEGMENT_COLOR, out outColor) != null) ? outColor : 0;
double blueVal = 0.0;
double greenVal = 0.0;
double redVal = 0.0;
GeometryUtil.GetRGBFromIntValue(color, out blueVal, out greenVal, out redVal);
IFCAnyHandle colorHnd = IFCInstanceExporter.CreateColourRgb(ifcFile, null, redVal, greenVal, blueVal);
BodyExporter.CreateCurveStyleForRepItem(exporterIFC, repItemHnd, curveWidth, colorHnd);
}
HashSet <IFCAnyHandle> curveSet = new HashSet <IFCAnyHandle>();
curveSet.Add(repItemHnd);
gridRepresentationData.m_Grids.Add(grid);
gridRepresentationData.m_curveSets.Add(curveSet);
}
return(ifcGridAxes);
}
/// <summary>
/// Export one IFCGrid in one level.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="levelId">The level ID.</param>
/// <param name="sameDirectionAxesU">The U axes of grids.</param>
/// <param name="sameDirectionAxesV">The V axes of grids.</param>
/// <param name="sameDirectionAxesW">The W axes of grids.</param>
public static void ExportGrid(ExporterIFC exporterIFC, ElementId levelId, string gridName, List <Grid> sameDirectionAxesU, List <Grid> sameDirectionAxesV, List <Grid> sameDirectionAxesW)
{
List <IFCAnyHandle> axesU = null;
List <IFCAnyHandle> axesV = null;
List <IFCAnyHandle> axesW = null;
List <IFCAnyHandle> representations = new List <IFCAnyHandle>();
using (ProductWrapper productWrapper = ProductWrapper.Create(exporterIFC, true))
{
IFCFile ifcFile = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(ifcFile))
{
GridRepresentationData gridRepresentationData = new GridRepresentationData();
axesU = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesU, representations, gridRepresentationData);
axesV = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesV, representations, gridRepresentationData);
if (sameDirectionAxesW != null)
{
axesW = CreateIFCGridAxisAndRepresentations(exporterIFC, productWrapper, sameDirectionAxesW, representations, gridRepresentationData);
}
IFCAnyHandle contextOfItemsFootPrint = exporterIFC.Get3DContextHandle("FootPrint");
string identifierOpt = "FootPrint";
string representationTypeOpt = "GeometricCurveSet";
int numGridsToExport = gridRepresentationData.m_Grids.Count;
if (numGridsToExport == 0)
{
return;
}
bool useIFCCADLayer = !string.IsNullOrWhiteSpace(gridRepresentationData.m_IFCCADLayer);
IFCAnyHandle shapeRepresentation = null;
HashSet <IFCAnyHandle> allCurves = new HashSet <IFCAnyHandle>();
for (int ii = 0; ii < numGridsToExport; ii++)
{
allCurves.UnionWith(gridRepresentationData.m_curveSets[ii]);
}
if (useIFCCADLayer)
{
shapeRepresentation = RepresentationUtil.CreateShapeRepresentation(exporterIFC, contextOfItemsFootPrint,
identifierOpt, representationTypeOpt, allCurves, gridRepresentationData.m_IFCCADLayer);
}
else
{
ElementId catId = CategoryUtil.GetSafeCategoryId(gridRepresentationData.m_Grids[0]);
shapeRepresentation = RepresentationUtil.CreateShapeRepresentation(exporterIFC, gridRepresentationData.m_Grids[0], catId,
contextOfItemsFootPrint, identifierOpt, representationTypeOpt, allCurves);
}
representations.Add(shapeRepresentation);
IFCAnyHandle productRep = IFCInstanceExporter.CreateProductDefinitionShape(ifcFile, null, null, representations);
// We will associate the grid with its level, unless there are no levels in the file, in which case we'll associate it with the building.
IFCLevelInfo levelInfo = ExporterCacheManager.LevelInfoCache.GetLevelInfo(exporterIFC, levelId);
bool useLevelInfo = (levelInfo != null);
string gridGUID = GUIDUtil.CreateGUID();
//// Get the first grid's override name, if cannot find it, use null.
//string gridName = GetGridName(sameDirectionAxesU, sameDirectionAxesV, sameDirectionAxesW);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle gridLevelHandle = useLevelInfo ? levelInfo.GetBuildingStorey() : ExporterCacheManager.BuildingHandle;
IFCAnyHandle levelObjectPlacement = IFCAnyHandleUtil.GetObjectPlacement(gridLevelHandle);
double elev = useLevelInfo ? levelInfo.Elevation : 0.0;
double elevation = UnitUtil.ScaleLength(elev);
XYZ orig = new XYZ(0.0, 0.0, elevation);
IFCAnyHandle copyLevelPlacement = ExporterUtil.CopyLocalPlacement(ifcFile, levelObjectPlacement);
IFCAnyHandle ifcGrid = IFCInstanceExporter.CreateGrid(exporterIFC, gridGUID, ownerHistory, gridName, copyLevelPlacement, productRep, axesU, axesV, axesW);
productWrapper.AddElement(null, ifcGrid, levelInfo, null, true);
transaction.Commit();
}
}
}
/// <summary>
/// Creates an opening from extrusion data.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host handle.</param>
/// <param name="hostPlacement">The host placement.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The opening element.</param>
/// <param name="openingGUID">The opening GUID.</param>
/// <param name="extrusionData">The extrusion data.</param>
/// <param name="lcs">The local coordinate system of the base of the extrusion.</param>
/// <param name="isRecess">True if it is a recess.</param>
/// <returns>The opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, IFCAnyHandle hostPlacement, Element hostElement,
Element insertElement, string openingGUID, IFCExtrusionData extrusionData, Transform lcs, bool isRecess,
PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
IList <CurveLoop> curveLoops = extrusionData.GetLoops();
if (curveLoops.Count == 0)
{
return(null);
}
if (lcs == null)
{
// assumption: first curve loop defines the plane.
if (!curveLoops[0].HasPlane())
{
return(null);
}
lcs = GeometryUtil.CreateTransformFromPlane(curveLoops[0].GetPlane());
}
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
IFCAnyHandle openingProdRepHnd = RepresentationUtil.CreateExtrudedProductDefShape(exporterIFC, insertElement, catId,
curveLoops, lcs, extrusionData.ExtrusionDirection, extrusionData.ScaledExtrusionLength);
string openingObjectType = isRecess ? "Recess" : "Opening";
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(exporterIFC, null, openingGUID, ownerHistory,
ExporterUtil.CreateLocalPlacement(file, hostPlacement, null), openingProdRepHnd, allowTag: false);
IFCAnyHandleUtil.OverrideNameAttribute(openingHnd, openingName);
IFCAnyHandleUtil.SetAttribute(openingHnd, "ObjectType", openingObjectType);
IFCExtrusionCreationData ecData = null;
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
double height, width;
ecData = new IFCExtrusionCreationData();
if (GeometryUtil.ComputeHeightWidthOfCurveLoop(curveLoops[0], lcs, out height, out width))
{
ecData.ScaledHeight = UnitUtil.ScaleLength(height);
ecData.ScaledWidth = UnitUtil.ScaleLength(width);
}
else
{
double area = ExporterIFCUtils.ComputeAreaOfCurveLoops(curveLoops);
ecData.ScaledArea = UnitUtil.ScaleArea(area);
}
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, ecData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(elementForProperties, openingHnd, setter, ecData, true);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}
/// <summary>
/// Exports curtain object as one Brep.
/// </summary>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="wallElement">
/// The curtain wall element.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter object.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <returns>
/// The handle.
/// </returns>
public static IFCAnyHandle ExportCurtainObjectCommonAsOneBRep(ICollection <ElementId> allSubElements, Element wallElement,
ExporterIFC exporterIFC, IFCPlacementSetter setter, IFCAnyHandle localPlacement)
{
IFCAnyHandle prodDefRep = null;
Document document = wallElement.Document;
double eps = document.Application.VertexTolerance * exporterIFC.LinearScale;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCGeometryInfo info = IFCGeometryInfo.CreateFaceGeometryInfo(eps);
IList <IFCAnyHandle> bodyItems = new List <IFCAnyHandle>();
// Want to make sure we don't accidentally add a mullion or curtain line more than once.
HashSet <ElementId> alreadyVisited = new HashSet <ElementId>();
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
foreach (ElementId subElemId in allSubElements)
{
Element subElem = wallElement.Document.GetElement(subElemId);
GeometryElement geomElem = subElem.get_Geometry(geomOptions);
if (geomElem == null)
{
continue;
}
if (alreadyVisited.Contains(subElem.Id))
{
continue;
}
alreadyVisited.Add(subElem.Id);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, geomElem, XYZ.Zero, false);
HashSet <IFCAnyHandle> faces = new HashSet <IFCAnyHandle>(info.GetSurfaces());
IFCAnyHandle outer = IFCInstanceExporter.CreateClosedShell(file, faces);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(outer))
{
bodyItems.Add(RepresentationUtil.CreateFacetedBRep(exporterIFC, document, outer, ElementId.InvalidElementId));
}
}
if (bodyItems.Count == 0)
{
return(prodDefRep);
}
ElementId catId = CategoryUtil.GetSafeCategoryId(wallElement);
IFCAnyHandle shapeRep = RepresentationUtil.CreateBRepRep(exporterIFC, wallElement, catId, contextOfItems, bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
{
return(prodDefRep);
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
prodDefRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
return(prodDefRep);
}
/// <summary>
/// Adds openings to an element.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="elementHandles">The parent handles.</param>
/// <param name="curveLoops">The parent CurveLoops.</param>
/// <param name="element">The element.</param>
/// <param name="lcs">The local coordinate system.</param>
/// <param name="scaledWidth">The width.</param>
/// <param name="range">The range.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="localWrapper">The wrapper.</param>
public static void AddOpeningsToElement(ExporterIFC exporterIFC,
IList <IFCAnyHandle> elementHandles, IList <CurveLoop> curveLoops, Element element,
Transform lcs, double scaledWidth, IFCRange range, PlacementSetter setter,
IFCAnyHandle localPlacement, ProductWrapper localWrapper)
{
if (lcs == null && ((curveLoops?.Count ?? 0) > 0))
{
// assumption: first curve loop defines the plane.
Plane hostObjPlane = curveLoops[0].HasPlane() ? curveLoops[0].GetPlane(): null;
if (hostObjPlane != null)
{
lcs = GeometryUtil.CreateTransformFromPlane(hostObjPlane);
}
}
IList <IFCOpeningData> openingDataList = ExporterIFCUtils.GetOpeningData(exporterIFC,
element, lcs, range);
IFCFile file = exporterIFC.GetFile();
int openingIndex = 0;
foreach (IFCOpeningData openingData in openingDataList)
{
openingIndex++;
Element openingElem = element.Document.GetElement(openingData.OpeningElementId);
if (openingElem == null)
{
openingElem = element;
}
bool currentWallIsHost = false;
FamilyInstance openingFInst = openingElem as FamilyInstance;
if (openingFInst != null && openingFInst.Host != null)
{
if (openingFInst.Host.Id == element.Id)
{
currentWallIsHost = true;
}
}
// Don't export the opening if WallSweep category has been turned off.
// This is currently restricted to WallSweeps because the element responsible for the opening could be a variety of things,
// including a line as part of the elevation profile of the wall.
// As such, we will restrict which element types we check for CanExportElement.
if ((openingElem is WallSweep) &&
(!ElementFilteringUtil.CanExportElement(exporterIFC, openingElem, true)))
{
continue;
}
IList <IFCExtrusionData> extrusionDataList = openingData.GetExtrusionData();
IFCAnyHandle parentHandle = FindParentHandle(elementHandles, curveLoops, extrusionDataList);
string predefinedType;
IFCExportInfoPair exportType = ExporterUtil.GetProductExportType(exporterIFC,
openingElem, out predefinedType);
bool exportingDoorOrWindow = (exportType.ExportInstance == IFCEntityType.IfcDoor ||
exportType.ExportType == IFCEntityType.IfcDoorType ||
exportType.ExportInstance == IFCEntityType.IfcWindow ||
exportType.ExportType == IFCEntityType.IfcWindowType);
bool isDoorOrWindowOpening = IsDoorOrWindowOpening(openingElem, element,
exportingDoorOrWindow);
if (isDoorOrWindowOpening && currentWallIsHost)
{
DoorWindowDelayedOpeningCreator delayedCreator =
DoorWindowDelayedOpeningCreator.Create(exporterIFC, openingData, scaledWidth,
element.Id, parentHandle, setter.LevelId);
if (delayedCreator != null)
{
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
continue;
}
}
IList <Solid> solids = openingData.GetOpeningSolids();
int solidIndex = 0;
foreach (Solid solid in solids)
{
solidIndex++;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(ExporterUtil.CreateLocalPlacement(file, localPlacement, null));
extrusionCreationData.ReuseLocalPlacement = true;
string openingGUID = CreateOpeningGUID(openingElem, range, openingIndex, solidIndex);
CreateOpening(exporterIFC, parentHandle, element, openingElem, openingGUID, solid, scaledWidth, openingData.IsRecess, extrusionCreationData,
setter, localWrapper);
}
}
foreach (IFCExtrusionData extrusionData in extrusionDataList)
{
solidIndex++;
if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
{
extrusionData.ScaledExtrusionLength = scaledWidth;
}
string openingGUID = CreateOpeningGUID(openingElem, range, openingIndex, solidIndex);
CreateOpening(exporterIFC, parentHandle, localPlacement, element, openingElem,
openingGUID, extrusionData, lcs, openingData.IsRecess, setter, localWrapper);
}
}
}
/// <summary>
/// Gets filter for non spatial elements.
/// </summary>
/// <param name="document">The Revit document.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The Element filter.</returns>
public static ElementFilter GetNonSpatialElementFilter(Document document, ExporterIFC exporterIFC)
{
return(GetExportFilter(document, exporterIFC, false));
}
private void CalculateDoorWindowInformation(ExporterIFC exporterIFC, FamilyInstance famInst,
ElementId overrideLevelId, Transform trf)
{
IFCFile file = exporterIFC.GetFile();
if (ExportingDoor)
{
string doorOperationType = null;
Element doorType = famInst.Document.GetElement(famInst.GetTypeId());
if (doorType != null)
{
// Look at the "Operation" override first, then the built-in parameter.
ParameterUtil.GetStringValueFromElementOrSymbol(doorType, "Operation", out doorOperationType);
if (string.IsNullOrWhiteSpace(doorOperationType))
{
ParameterUtil.GetStringValueFromElement(doorType, BuiltInParameter.DOOR_OPERATION_TYPE, out doorOperationType);
}
}
DoorOperationTypeString = "NOTDEFINED";
if (!string.IsNullOrWhiteSpace(doorOperationType))
{
Type enumType = null;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
enumType = typeof(Toolkit.IFC4.IFCDoorStyleOperation);
}
else
{
enumType = typeof(Toolkit.IFCDoorStyleOperation);
}
foreach (Enum ifcDoorStyleOperation in Enum.GetValues(enumType))
{
string enumAsString = ifcDoorStyleOperation.ToString();
if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(enumAsString, doorOperationType))
{
DoorOperationTypeString = enumAsString;
break;
}
}
}
if (DoorOperationTypeString == "NOTDEFINED")
{
// We are going to try to guess the hinge placement.
DoorOperationTypeString = CalculateDoorOperationStyle(famInst, trf);
}
else
{
if (FlippedX ^ FlippedY)
{
DoorOperationTypeString = ReverseDoorStyleOperation(DoorOperationTypeString);
}
}
if (String.Compare(DoorOperationTypeString, "USERDEFINED", true) == 0)
{
string userDefinedOperationType;
ParameterUtil.GetStringValueFromElementOrSymbol(doorType, "UserDefinedOperationType", out userDefinedOperationType);
if (!string.IsNullOrEmpty(userDefinedOperationType))
{
UserDefinedOperationType = userDefinedOperationType;
}
else
{
DoorOperationTypeString = "NOTDEFINED"; //re-set to NotDefined if operation type is set to UserDefined but the userDefinedOperationType parameter is empty!
}
}
}
if (HasRealWallHost)
{
// do hingeside calculation
Wall wall = HostObject as Wall;
PosHingeSide = true;
BoundingBoxXYZ famBBox = null;
Options options = GeometryUtil.GetIFCExportGeometryOptions();
GeometryElement geomElement = famInst.GetOriginalGeometry(options);
if (geomElement != null)
{
famBBox = geomElement.GetBoundingBox();
}
if (famBBox != null)
{
XYZ bboxCtr = trf.OfPoint((famBBox.Min + famBBox.Max) / 2.0);
Curve curve = WallExporter.GetWallAxis(wall);
XYZ wallZDir = WallExporter.GetWallHeightDirection(wall);
// famInst.HostParameter will fail if FamilyPlacementType is WorkPlaneBased, regardless of whether or not the reported host is a Wall.
// In this case, just use the start parameter of the curve.
bool hasHostParameter = famInst.Symbol.Family.FamilyPlacementType != FamilyPlacementType.WorkPlaneBased;
double param = hasHostParameter ? famInst.HostParameter : curve.GetEndParameter(0);
Transform wallTrf = curve.ComputeDerivatives(param, false);
XYZ wallOrig = wallTrf.Origin;
XYZ wallXDir = wallTrf.BasisX;
XYZ wallYDir = wallZDir.CrossProduct(wallXDir);
double eps = MathUtil.Eps();
bboxCtr -= wallOrig;
PosHingeSide = (bboxCtr.DotProduct(wallYDir) > -eps);
XYZ famInstYDir = trf.BasisY;
FlippedSymbol = (PosHingeSide != (wallYDir.DotProduct(famInstYDir) > -eps));
}
}
}
/// <summary>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
IFCAnyHandle extrusionHandle =
ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element,
info[curr], out _);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
// Openings shouldn't have surface styles for their geometry.
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>()
{
extrusionHandle
};
IFCAnyHandle representationHnd = RepresentationUtil.CreateSweptSolidRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> representations = IFCAnyHandleUtil.IsNullOrHasNoValue(representationHnd) ?
null : new List <IFCAnyHandle>()
{
representationHnd
};
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null,
null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = GUIDUtil.GenerateIFCGuidFrom(IFCEntityType.IfcOpeningElement,
openingNumber.ToString(), elementHandle);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
string openingDescription = NamingUtil.GetDescriptionOverride(element, null);
string openingTag = NamingUtil.GetTagOverride(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(exporterIFC,
guid, ownerHistory, openingName, openingDescription, openingObjectType,
openingPlacement, openingRep, openingTag);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcOpeningElement);
wrapper.AddElement(null, openingElement, setter, extraParams, true, exportInfo);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.GenerateIFCGuidFrom(IFCEntityType.IfcRelVoidsElement,
elementHandle, openingElement);
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null,
elementHandle, openingElement);
}
}
}
