/// <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 ProductWrapper.
/// </param>
public static void ExportBeam(ExporterIFC exporterIFC,
Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (geometryElement == null)
return;
IFCFile file = exporterIFC.GetFile();
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.GetEndPoint(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 (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, canExportAxis ? orientTrf : null))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
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>();
// 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;
// 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)))
{
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))
{
// 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;
extrusionCreationData.Slope = GeometryUtil.GetSimpleExtrusionSlope(beamDirection, bestAxis);
ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solids[0], exporterIFC, element);
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(exporterIFC, element, catId, ElementId.InvalidElementId,
solids, meshes, bodyExporterOptions, extrusionCreationData);
}
else
{
IList<GeometryObject> geomlist = new List<GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
geomlist, bodyExporterOptions, extrusionCreationData);
}
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
offsetTransform = bodyData.OffsetTransform;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return;
}
IList<IFCAnyHandle> representations = new List<IFCAnyHandle>();
if (canExportAxis)
{
XYZ curveOffset = new XYZ(0, 0, 0);
if (offsetTransform != null)
curveOffset = -UnitUtil.UnscaleLength(offsetTransform.Origin);
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);
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);
IFCAnyHandle beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceTag, preDefinedType);
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
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.CreateMaterialAssociations(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();
}
}
private static IFCAnyHandle CreateFamilyTypeHandle(ExporterIFC exporterIFC, FamilyTypeInfo typeInfo, DoorWindowInfo doorWindowInfo,
IFCAnyHandle bodyRepresentation, IFCAnyHandle planRepresentation,
Element familyInstance, ElementType familySymbol, ElementType originalFamilySymbol,
bool useInstanceGeometry, bool exportParts,
IFCExportType exportType, string revitObjectType, string ifcEnumType,
out HashSet<IFCAnyHandle> propertySets)
{
// for many
propertySets = new HashSet<IFCAnyHandle>();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle repMap2dHnd = null;
IFCAnyHandle repMap3dHnd = null;
IList<IFCAnyHandle> repMapList = new List<IFCAnyHandle>();
{
IFCAnyHandle origin = null;
if (bodyRepresentation != null)
{
if (origin == null)
origin = ExporterUtil.CreateAxis2Placement3D(file);
repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRepresentation);
repMapList.Add(repMap3dHnd);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(planRepresentation))
{
if (origin == null)
origin = ExporterUtil.CreateAxis2Placement3D(file);
repMap2dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, planRepresentation);
repMapList.Add(repMap2dHnd);
}
}
// We won't allow creating a type if we aren't creating an instance.
// We won't create the instance if: we are exporting to CV2.0, we have no 2D, 3D, or bounding box geometry, and we aren't exporting parts.
bool willCreateInstance = !(repMapList.Count == 0 && ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2 &&
!ExporterCacheManager.ExportOptionsCache.ExportBoundingBox && !exportParts);
if (!willCreateInstance)
return null;
IFCAnyHandle typeStyle = null;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
// for Door, Window
bool paramTakesPrecedence = false; // For Revit, this is currently always false.
bool sizeable = false;
string guid = null;
if (useInstanceGeometry)
{
int subElementIndex = ExporterStateManager.GetCurrentRangeIndex();
if (subElementIndex == 0)
guid = GUIDUtil.CreateSubElementGUID(familyInstance, (int)IFCFamilyInstanceSubElements.InstanceAsType);
else if (subElementIndex <= ExporterStateManager.RangeIndexSetter.GetMaxStableGUIDs())
guid = GUIDUtil.CreateSubElementGUID(familyInstance, (int)IFCGenericSubElements.SplitTypeStart + subElementIndex - 1);
else
guid = GUIDUtil.CreateGUID();
}
else
guid = GUIDUtil.CreateGUID(originalFamilySymbol);
string symId = NamingUtil.CreateIFCElementId(originalFamilySymbol);
string gentypeName = NamingUtil.GetNameOverride(familySymbol, revitObjectType);
string gentypeDescription = NamingUtil.GetDescriptionOverride(familySymbol, null);
string gentypeApplicableOccurrence = NamingUtil.GetOverrideStringValue(familySymbol, "IfcApplicableOccurrence", null);
string gentypeTag = NamingUtil.GetTagOverride(familySymbol, symId);
string gentypeElementType = NamingUtil.GetOverrideStringValue(familySymbol, "IfcElementType", revitObjectType);
// This covers many generic types. If we can't find it in the list here, do custom exports.
typeStyle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType, guid,
gentypeName, gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, gentypeTag, gentypeElementType,
familyInstance, familySymbol);
// Cover special cases not covered above.
if (IFCAnyHandleUtil.IsNullOrHasNoValue(typeStyle))
{
string symbolTag = NamingUtil.GetTagOverride(familySymbol, NamingUtil.CreateIFCElementId(familySymbol));
switch (exportType)
{
case IFCExportType.IfcColumnType:
{
string columnType = "Column";
typeStyle = IFCInstanceExporter.CreateColumnType(file, guid, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
gentypeElementType, GetColumnType(familyInstance, columnType));
break;
}
case IFCExportType.IfcDoorType:
{
IFCAnyHandle doorLining = DoorWindowUtil.CreateDoorLiningProperties(exporterIFC, familyInstance);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(doorLining))
propertySets.Add(doorLining);
IList<IFCAnyHandle> doorPanels = DoorWindowUtil.CreateDoorPanelProperties(exporterIFC, doorWindowInfo,
familyInstance);
propertySets.UnionWith(doorPanels);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
string doorTypeGUID = GUIDUtil.CreateSubElementGUID(originalFamilySymbol, (int)IFCDoorSubElements.DoorType);
typeStyle = IFCInstanceExporter.CreateDoorType(file, doorTypeGUID, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
doorWindowInfo.PreDefinedType, doorWindowInfo.DoorOperationTypeString,
paramTakesPrecedence, doorWindowInfo.UserDefinedOperationType);
}
else
{
string doorStyleGUID = GUIDUtil.CreateSubElementGUID(originalFamilySymbol, (int)IFCDoorSubElements.DoorStyle);
typeStyle = IFCInstanceExporter.CreateDoorStyle(file, doorStyleGUID, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
doorWindowInfo.DoorOperationTypeString, DoorWindowUtil.GetDoorStyleConstruction(familyInstance),
paramTakesPrecedence, sizeable);
}
break;
}
case IFCExportType.IfcSpace:
{
typeStyle = IFCInstanceExporter.CreateSpaceType(file, guid, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
gentypeElementType);
break;
}
case IFCExportType.IfcSystemFurnitureElementType:
{
typeStyle = IFCInstanceExporter.CreateSystemFurnitureElementType(file, guid, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
gentypeElementType);
break;
}
case IFCExportType.IfcWindowType:
{
Toolkit.IFCWindowStyleOperation operationType = DoorWindowUtil.GetIFCWindowStyleOperation(originalFamilySymbol);
IFCWindowStyleConstruction constructionType = DoorWindowUtil.GetIFCWindowStyleConstruction(familyInstance);
IFCAnyHandle windowLining = DoorWindowUtil.CreateWindowLiningProperties(exporterIFC, familyInstance, null);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(windowLining))
propertySets.Add(windowLining);
IList<IFCAnyHandle> windowPanels =
DoorWindowUtil.CreateWindowPanelProperties(exporterIFC, familyInstance, null);
propertySets.UnionWith(windowPanels);
string windowStyleGUID = GUIDUtil.CreateSubElementGUID(originalFamilySymbol, (int)IFCWindowSubElements.WindowStyle);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
typeStyle = IFCInstanceExporter.CreateWindowType(file, windowStyleGUID, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
doorWindowInfo.PreDefinedType, DoorWindowUtil.GetIFCWindowPartitioningType(originalFamilySymbol),
paramTakesPrecedence, doorWindowInfo.UserDefinedOperationType);
}
else
{
typeStyle = IFCInstanceExporter.CreateWindowStyle(file, windowStyleGUID, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
constructionType, operationType, paramTakesPrecedence, sizeable);
}
break;
}
case IFCExportType.IfcBuildingElementProxyType:
{
Revit.IFC.Common.Enums.IFCEntityType IFCTypeEntity;
if (!Enum.TryParse(ifcEnumType, out IFCTypeEntity))
break; // The export type is unknown IFC type entity
typeStyle = IFCInstanceExporter.CreateGenericIFCType(IFCTypeEntity, file, guid, ownerHistory, gentypeName,
gentypeDescription, gentypeApplicableOccurrence, propertySets, repMapList, symbolTag,
gentypeElementType, FamilyExporterUtil.GetPreDefinedType<Toolkit.IFCBuildingElementProxyType>(familyInstance, ifcEnumType).ToString());
break;
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(typeStyle))
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd))
typeInfo.Map2DHandle = repMap2dHnd;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd))
typeInfo.Map3DHandle = repMap3dHnd;
}
}
return typeStyle;
}
/// <summary>
/// Exports a family instance as a mapped item.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="familyInstance">The family instance to be exported.</param>
/// <param name="exportType">The export type.</param>
/// <param name="ifcEnumType">The string value represents the IFC type.</param>
/// <param name="wrapper">The ProductWrapper.</param>
/// <param name="overrideLevelId">The level id.</param>
/// <param name="range">The range of this family instance to be exported.</param>
public static void ExportFamilyInstanceAsMappedItem(ExporterIFC exporterIFC,
FamilyInstance familyInstance, IFCExportType exportType, string ifcEnumType,
ProductWrapper wrapper, ElementId overrideLevelId, IFCRange range, IFCAnyHandle parentLocalPlacement)
{
bool exportParts = PartExporter.CanExportParts(familyInstance);
bool isSplit = range != null;
if (exportParts && !PartExporter.CanExportElementInPartExport(familyInstance, isSplit ? overrideLevelId : familyInstance.LevelId, isSplit))
return;
Document doc = familyInstance.Document;
IFCFile file = exporterIFC.GetFile();
// The "originalFamilySymbol" has the right geometry, but should be used as little as possible.
FamilySymbol originalFamilySymbol = ExporterIFCUtils.GetOriginalSymbol(familyInstance);
FamilySymbol familySymbol = familyInstance.Symbol;
if (originalFamilySymbol == null || familySymbol == null)
return;
ProductWrapper familyProductWrapper = ProductWrapper.Create(wrapper);
Options options = GeometryUtil.GetIFCExportGeometryOptions();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
HostObject hostElement = familyInstance.Host as HostObject; //hostElement could be null
ElementId categoryId = CategoryUtil.GetSafeCategoryId(familySymbol);
//string emptyString = "";
string familyName = familySymbol.Name;
string revitObjectType = familyName;
// A Family Instance can have its own copy of geometry, or use the symbol's copy with a transform.
// The routine below tells us whether to use the Instance's copy or the Symbol's copy.
bool useInstanceGeometry = ExporterIFCUtils.UsesInstanceGeometry(familyInstance);
Transform trf = familyInstance.GetTransform();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
// Extra information if we are exporting a door or a window.
DoorWindowInfo doorWindowInfo = null;
if (exportType == IFCExportType.IfcDoorType)
doorWindowInfo = DoorWindowExporter.CreateDoor(exporterIFC, familyInstance, hostElement, overrideLevelId, trf);
else if (exportType == IFCExportType.IfcWindowType)
doorWindowInfo = DoorWindowExporter.CreateWindow(exporterIFC, familyInstance, hostElement, overrideLevelId, trf);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
bool flipped = doorWindowInfo != null ? doorWindowInfo.FlippedSymbol : false;
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(originalFamilySymbol.Id, flipped);
bool found = currentTypeInfo.IsValid();
Family family = familySymbol.Family;
IList<GeometryObject> geomObjects = new List<GeometryObject>();
Transform offsetTransform = null;
Transform doorWindowTrf = Transform.Identity;
// We will create a new mapped type if:
// 1. We are exporting part of a column or in-place wall (range != null), OR
// 2. We are using the instance's copy of the geometry (that it, it has unique geometry), OR
// 3. We haven't already created the type.
bool creatingType = ((range != null) || useInstanceGeometry || !found);
if (creatingType)
{
IFCAnyHandle bodyRepresentation = null;
IFCAnyHandle planRepresentation = null;
IFCAnyHandle dummyPlacement = null;
if (doorWindowInfo != null)
{
doorWindowTrf = ExporterIFCUtils.GetTransformForDoorOrWindow(familyInstance, originalFamilySymbol,
doorWindowInfo.FlippedX, doorWindowInfo.FlippedY);
}
else
{
dummyPlacement = ExporterUtil.CreateLocalPlacement(file, null, null);
extraParams.SetLocalPlacement(dummyPlacement);
}
bool needToCreate2d = ExporterCacheManager.ExportOptionsCache.ExportAnnotations;
GeometryElement exportGeometry =
useInstanceGeometry ? familyInstance.get_Geometry(options) : originalFamilySymbol.get_Geometry(options);
if (!exportParts)
{
using (TransformSetter trfSetter = TransformSetter.Create())
{
if (doorWindowInfo != null)
{
trfSetter.Initialize(exporterIFC, doorWindowTrf);
}
if (exportGeometry == null)
return;
SolidMeshGeometryInfo solidMeshCapsule = null;
if (range == null)
{
solidMeshCapsule = GeometryUtil.GetSplitSolidMeshGeometry(exportGeometry);
}
else
{
solidMeshCapsule = GeometryUtil.GetSplitClippedSolidMeshGeometry(exportGeometry, range);
}
IList<Solid> solids = solidMeshCapsule.GetSolids();
IList<Mesh> polyMeshes = solidMeshCapsule.GetMeshes();
// If we are exporting parts, it is OK to have no geometry here - it will be added by the host Part.
bool hasSolidsOrMeshesInSymbol = (solids.Count > 0 || polyMeshes.Count > 0);
if (range != null && !hasSolidsOrMeshesInSymbol)
return; // no proper split geometry to export.
if (hasSolidsOrMeshesInSymbol)
{
geomObjects = FamilyExporterUtil.RemoveSolidsAndMeshesSetToDontExport(doc, exporterIFC, solids, polyMeshes);
if ((geomObjects.Count == 0))
return; // no proper visible split geometry to export.
}
else
geomObjects.Add(exportGeometry);
bool tryToExportAsExtrusion = (!ExporterCacheManager.ExportOptionsCache.ExportAs2x2 || (exportType == IFCExportType.IfcColumnType));
if (exportType == IFCExportType.IfcColumnType)
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
if (ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2 && solids.Count > 0)
{
LocationPoint point = familyInstance.Location as LocationPoint;
XYZ orig = XYZ.Zero;
if (point != null)
orig = point.Point;
Plane plane = new Plane(XYZ.BasisX, XYZ.BasisY, orig);
bool completelyClipped = false;
HashSet<ElementId> materialIds = null;
bodyRepresentation = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, familyInstance,
categoryId, solids, plane, XYZ.BasisZ, null, out completelyClipped, out materialIds);
typeInfo.MaterialIds = materialIds;
}
}
else
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryXYZ;
}
BodyData bodyData = null;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation))
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(tryToExportAsExtrusion);
bodyData = BodyExporter.ExportBody(exporterIFC, familyInstance, categoryId, ElementId.InvalidElementId,
geomObjects, bodyExporterOptions, extraParams);
typeInfo.MaterialIds = bodyData.MaterialIds;
bodyRepresentation = bodyData.RepresentationHnd;
offsetTransform = bodyData.OffsetTransform;
}
// We will allow a door or window to be exported without any geometry, or an element with parts.
// Anything else doesn't really make sense.
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepresentation) && (doorWindowInfo == null))
{
extraParams.ClearOpenings();
return;
}
}
// By default: if exporting IFC2x3 or later, export 2D plan rep of family, if it exists, unless we are exporting Coordination View V2.
// This default can be overridden in the export options.
if (needToCreate2d)
{
XYZ curveOffset = new XYZ(0, 0, 0);
if (offsetTransform != null)
curveOffset = -UnitUtil.UnscaleLength(offsetTransform.Origin);
HashSet<IFCAnyHandle> curveSet = new HashSet<IFCAnyHandle>();
{
Transform planeTrf = doorWindowTrf.Inverse;
Plane plane = new Plane(planeTrf.get_Basis(0), planeTrf.get_Basis(1), planeTrf.Origin);
XYZ projDir = new XYZ(0, 0, 1);
IFCGeometryInfo IFCGeometryInfo = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, plane, projDir, true);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, IFCGeometryInfo, exportGeometry, curveOffset, false);
IList<IFCAnyHandle> curves = IFCGeometryInfo.GetCurves();
foreach (IFCAnyHandle curve in curves)
curveSet.Add(curve);
if (curveSet.Count > 0)
{
IFCAnyHandle contextOfItems2d = exporterIFC.Get2DContextHandle();
IFCAnyHandle curveRepresentationItem = IFCInstanceExporter.CreateGeometricSet(file, curveSet);
HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
bodyItems.Add(curveRepresentationItem);
planRepresentation = RepresentationUtil.CreateGeometricSetRep(exporterIFC, familyInstance, categoryId, "FootPrint",
contextOfItems2d, bodyItems);
}
}
}
}
if (doorWindowInfo != null)
typeInfo.StyleTransform = doorWindowTrf.Inverse;
else
typeInfo.StyleTransform = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, extraParams.GetLocalPlacement());
// for many
HashSet<IFCAnyHandle> propertySets = null;
IFCAnyHandle typeStyle = CreateFamilyTypeHandle(exporterIFC, typeInfo, doorWindowInfo, bodyRepresentation, planRepresentation,
familyInstance, familySymbol, originalFamilySymbol, useInstanceGeometry, exportParts,
exportType, revitObjectType, ifcEnumType, out propertySets);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(typeStyle))
{
wrapper.RegisterHandleWithElementType(familySymbol, typeStyle, propertySets);
CategoryUtil.CreateMaterialAssociations(exporterIFC, typeStyle, typeInfo.MaterialIds);
typeInfo.Style = typeStyle;
if ((exportType == IFCExportType.IfcColumnType) || (exportType == IFCExportType.IfcMemberType))
{
typeInfo.ScaledArea = extraParams.ScaledArea;
typeInfo.ScaledDepth = extraParams.ScaledLength;
typeInfo.ScaledInnerPerimeter = extraParams.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extraParams.ScaledOuterPerimeter;
}
ClassificationUtil.CreateClassification(exporterIFC, file, familySymbol, typeStyle); // Create other generic classification from ClassificationCode(s)
ClassificationUtil.CreateUniformatClassification(exporterIFC, file, originalFamilySymbol, typeStyle);
}
}
if (found && !typeInfo.IsValid())
typeInfo = currentTypeInfo;
// we'll pretend we succeeded, but we'll do nothing.
if (!typeInfo.IsValid())
return;
// add to the map, as long as we are not using range, not using instance geometry, and don't have extra openings.
if ((range == null) && !useInstanceGeometry && (extraParams.GetOpenings().Count == 0))
ExporterCacheManager.TypeObjectsCache.Register(originalFamilySymbol.Id, flipped, typeInfo);
// If we are using the instance geometry, ignore the transformation.
if (useInstanceGeometry)
trf = Transform.Identity;
if ((range != null) && exportParts)
{
XYZ rangeOffset = trf.Origin;
rangeOffset += new XYZ(0, 0, range.Start);
trf.Origin = rangeOffset;
}
Transform originalTrf = new Transform(trf);
XYZ scaledMapOrigin = XYZ.Zero;
trf = trf.Multiply(typeInfo.StyleTransform);
// create instance.
IList<IFCAnyHandle> shapeReps = new List<IFCAnyHandle>();
{
IFCAnyHandle contextOfItems2d = exporterIFC.Get2DContextHandle();
IFCAnyHandle contextOfItems3d = exporterIFC.Get3DContextHandle("Body");
// for proxies, we store the IfcRepresentationMap directly since there is no style.
IFCAnyHandle style = typeInfo.Style;
IList<IFCAnyHandle> repMapList = !IFCAnyHandleUtil.IsNullOrHasNoValue(style) ?
GeometryUtil.GetRepresentationMaps(style) : null;
int numReps = repMapList != null ? repMapList.Count : 0;
IFCAnyHandle repMap2dHnd = typeInfo.Map2DHandle;
IFCAnyHandle repMap3dHnd = typeInfo.Map3DHandle;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd) && (numReps > 0))
repMap3dHnd = repMapList[0];
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd) && (numReps > 1))
repMap2dHnd = repMapList[1];
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap3dHnd))
{
ISet<IFCAnyHandle> representations = new HashSet<IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMap3dHnd, scaledMapOrigin));
IFCAnyHandle shapeRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC, familyInstance, categoryId, contextOfItems3d,
representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
return;
shapeReps.Add(shapeRep);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repMap2dHnd))
{
HashSet<IFCAnyHandle> representations = new HashSet<IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMap2dHnd, scaledMapOrigin));
IFCAnyHandle shapeRep = RepresentationUtil.CreatePlanMappedItemRep(exporterIFC, familyInstance, categoryId, contextOfItems2d,
representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
return;
shapeReps.Add(shapeRep);
}
}
IFCAnyHandle boundingBoxRep = null;
Transform boundingBoxTrf = (offsetTransform != null) ? offsetTransform.Inverse : Transform.Identity;
if (geomObjects.Count > 0)
boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geomObjects, boundingBoxTrf);
else
{
boundingBoxTrf = boundingBoxTrf.Multiply(trf.Inverse);
boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, familyInstance.get_Geometry(options), boundingBoxTrf);
}
if (boundingBoxRep != null)
shapeReps.Add(boundingBoxRep);
IFCAnyHandle repHnd = (shapeReps.Count > 0) ? IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps) : null;
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, familyInstance, trf, null, overrideLevelId))
{
IFCAnyHandle instanceHandle = null;
IFCAnyHandle localPlacement = setter.LocalPlacement;
// We won't create the instance if:
// (1) we are exporting to CV2.0, (2) we have no 2D, 3D, or bounding box geometry, and (3) we aren't exporting parts.
if (!(repHnd == null && ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2 && !exportParts))
{
string instanceGUID = null;
int subElementIndex = ExporterStateManager.GetCurrentRangeIndex();
if (subElementIndex == 0)
instanceGUID = GUIDUtil.CreateGUID(familyInstance);
else if (subElementIndex <= ExporterStateManager.RangeIndexSetter.GetMaxStableGUIDs())
instanceGUID = GUIDUtil.CreateSubElementGUID(familyInstance, subElementIndex + (int)IFCGenericSubElements.SplitInstanceStart - 1);
else
instanceGUID = GUIDUtil.CreateGUID();
string instanceName = NamingUtil.GetNameOverride(familyInstance, NamingUtil.GetIFCName(familyInstance));
string instanceDescription = NamingUtil.GetDescriptionOverride(familyInstance, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(familyInstance, revitObjectType);
string instanceTag = NamingUtil.GetTagOverride(familyInstance, NamingUtil.CreateIFCElementId(familyInstance));
IFCAnyHandle overrideLocalPlacement = null;
bool isChildInContainer = familyInstance.AssemblyInstanceId != ElementId.InvalidElementId;
if (parentLocalPlacement != null)
{
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(parentLocalPlacement, localPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle plateLocalPlacement = ExporterUtil.CreateLocalPlacement(file, parentLocalPlacement,
inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
overrideLocalPlacement = plateLocalPlacement;
}
instanceHandle = FamilyExporterUtil.ExportGenericInstance(exportType, exporterIFC, familyInstance,
wrapper, setter, extraParams, instanceGUID, ownerHistory, instanceName, instanceDescription, instanceObjectType,
exportParts ? null : repHnd, instanceTag, overrideLocalPlacement);
if (exportParts)
PartExporter.ExportHostPart(exporterIFC, familyInstance, instanceHandle, familyProductWrapper, setter, setter.LocalPlacement, overrideLevelId);
if (ElementFilteringUtil.IsMEPType(exportType) || ElementFilteringUtil.ProxyForMEPType(familyInstance, exportType))
{
ExporterCacheManager.MEPCache.Register(familyInstance, instanceHandle);
// For ducts and pipes, check later if there is an associated duct or pipe.
if (exportType == IFCExportType.IfcDuctFittingType || exportType == IFCExportType.IfcPipeFittingType ||
exportType == IFCExportType.IfcDuctSegmentType || exportType == IFCExportType.IfcPipeSegmentType)
ExporterCacheManager.MEPCache.CoveredElementsCache.Add(familyInstance.Id);
}
switch (exportType)
{
case IFCExportType.IfcColumnType:
{
IFCAnyHandle placementToUse = localPlacement;
if (!useInstanceGeometry)
{
bool needToCreateOpenings = OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = new Transform(originalTrf);
Transform extraRot = new Transform(originalTrf);
extraRot.Origin = XYZ.Zero;
openingTrf = openingTrf.Multiply(extraRot);
openingTrf = openingTrf.Multiply(typeInfo.StyleTransform);
XYZ scaledOrigin = UnitUtil.ScaleLength(openingTrf.Origin);
IFCAnyHandle openingRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, scaledOrigin,
openingTrf.get_Basis(2), openingTrf.get_Basis(0));
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacement);
GeometryUtil.SetRelativePlacement(openingPlacement, openingRelativePlacement);
placementToUse = openingPlacement;
}
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, offsetTransform,
exporterIFC, placementToUse, setter, wrapper);
//export Base Quantities.
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, instanceHandle, familyInstance, typeInfo, geomObjects);
break;
}
case IFCExportType.IfcDoorType:
case IFCExportType.IfcWindowType:
{
double doorHeight = GetMinSymbolHeight(originalFamilySymbol);
double doorWidth = GetMinSymbolWidth(originalFamilySymbol);
double height = UnitUtil.ScaleLength(doorHeight);
double width = UnitUtil.ScaleLength(doorWidth);
IFCAnyHandle doorWindowLocalPlacement = !IFCAnyHandleUtil.IsNullOrHasNoValue(overrideLocalPlacement) ?
overrideLocalPlacement : localPlacement;
if (exportType == IFCExportType.IfcDoorType)
instanceHandle = IFCInstanceExporter.CreateDoor(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, doorWindowLocalPlacement,
repHnd, instanceTag, height, width, doorWindowInfo.PreDefinedType,doorWindowInfo.DoorOperationTypeString,
doorWindowInfo.UserDefinedOperationType);
else if (exportType == IFCExportType.IfcWindowType)
instanceHandle = IFCInstanceExporter.CreateWindow(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, doorWindowLocalPlacement,
repHnd, instanceTag, height, width, doorWindowInfo.PreDefinedType, DoorWindowUtil.GetIFCWindowPartitioningType(originalFamilySymbol),
doorWindowInfo.UserDefinedPartitioningType);
wrapper.AddElement(familyInstance, instanceHandle, setter, extraParams, true);
SpaceBoundingElementUtil.RegisterSpaceBoundingElementHandle(exporterIFC, instanceHandle, familyInstance.Id,
setter.LevelId);
IFCAnyHandle placementToUse = doorWindowLocalPlacement;
if (!useInstanceGeometry)
{
// correct the placement to the symbol space
bool needToCreateOpenings = OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = Transform.Identity;
openingTrf.Origin = new XYZ(0, 0, setter.Offset);
openingTrf = openingTrf.Multiply(doorWindowTrf);
XYZ scaledOrigin = UnitUtil.ScaleLength(openingTrf.Origin);
IFCAnyHandle openingLocalPlacement = ExporterUtil.CreateLocalPlacement(file, doorWindowLocalPlacement,
scaledOrigin, openingTrf.BasisZ, openingTrf.BasisX);
placementToUse = openingLocalPlacement;
}
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, offsetTransform,
exporterIFC, placementToUse, setter, wrapper);
break;
}
case IFCExportType.IfcMemberType:
{
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, offsetTransform,
exporterIFC, localPlacement, setter, wrapper);
//export Base Quantities.
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, instanceHandle, familyInstance, typeInfo, null);
break;
}
case IFCExportType.IfcPlateType:
{
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, offsetTransform,
exporterIFC, localPlacement, setter, wrapper);
break;
}
case IFCExportType.IfcTransportElementType:
{
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(familyInstance, out localPlacementToUse);
string operationTypeStr;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// It is PreDefinedType attribute in IFC4
Toolkit.IFC4.IFCTransportElementType operationType = FamilyExporterUtil.GetPreDefinedType<Toolkit.IFC4.IFCTransportElementType>(familyInstance, ifcEnumType);
operationTypeStr = operationType.ToString();
}
else
{
Toolkit.IFCTransportElementType operationType = FamilyExporterUtil.GetPreDefinedType<Toolkit.IFCTransportElementType>(familyInstance, ifcEnumType);
operationTypeStr = operationType.ToString();
}
double capacityByWeight = 0.0;
ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "IfcCapacityByWeight", out capacityByWeight);
double capacityByNumber = 0.0;
ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "IfcCapacityByNumber", out capacityByNumber);
instanceHandle = IFCInstanceExporter.CreateTransportElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, repHnd, instanceTag, operationTypeStr, capacityByWeight, capacityByNumber);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
wrapper.AddElement(familyInstance, instanceHandle, setter, extraParams, !containedInSpace);
if (containedInSpace)
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
break;
}
//case IFCExportType.IfcBuildingElementProxy:
//case IFCExportType.IfcBuildingElementProxyType:
default:
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
bool isBuildingElementProxy =
((exportType == IFCExportType.IfcBuildingElementProxy) ||
(exportType == IFCExportType.IfcBuildingElementProxyType));
IFCAnyHandle localPlacementToUse = null;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(familyInstance, out localPlacementToUse);
if (!isBuildingElementProxy && FamilyExporterUtil.IsDistributionControlElementSubType(exportType))
{
string ifcelementType = null;
ParameterUtil.GetStringValueFromElement(familyInstance.Id, "IfcElementType", out ifcelementType);
instanceHandle = IFCInstanceExporter.CreateDistributionControlElement(file, instanceGUID,
ownerHistory, instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, repHnd, instanceTag, ifcelementType);
}
else
{
instanceHandle = IFCInstanceExporter.CreateBuildingElementProxy(file, instanceGUID,
ownerHistory, instanceName, instanceDescription, instanceObjectType,
localPlacementToUse, repHnd, instanceTag, null);
}
bool containedInSpace = (roomId != ElementId.InvalidElementId);
bool associateToLevel = containedInSpace ? false : !isChildInContainer;
wrapper.AddElement(familyInstance, instanceHandle, setter, extraParams, associateToLevel);
if (containedInSpace)
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
}
IFCAnyHandle placementToUse = localPlacement;
if (!useInstanceGeometry)
{
bool needToCreateOpenings = OpeningUtil.NeedToCreateOpenings(instanceHandle, extraParams);
if (needToCreateOpenings)
{
Transform openingTrf = new Transform(originalTrf);
Transform extraRot = new Transform(originalTrf);
extraRot.Origin = XYZ.Zero;
openingTrf = openingTrf.Multiply(extraRot);
openingTrf = openingTrf.Multiply(typeInfo.StyleTransform);
XYZ scaledOrigin = UnitUtil.ScaleLength(openingTrf.Origin);
IFCAnyHandle openingRelativePlacement = ExporterUtil.CreateAxis2Placement3D(file, scaledOrigin,
openingTrf.get_Basis(2), openingTrf.get_Basis(0));
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, localPlacement);
GeometryUtil.SetRelativePlacement(openingPlacement, openingRelativePlacement);
placementToUse = openingPlacement;
}
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, familyInstance, extraParams, offsetTransform,
exporterIFC, placementToUse, setter, wrapper);
break;
}
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
ExporterCacheManager.HandleToElementCache.Register(instanceHandle, familyInstance.Id);
if (!exportParts)
CategoryUtil.CreateMaterialAssociations(exporterIFC, instanceHandle, typeInfo.MaterialIds);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(typeInfo.Style))
ExporterCacheManager.TypeRelationsCache.Add(typeInfo.Style, instanceHandle);
}
}
if (doorWindowInfo != null)
{
DoorWindowDelayedOpeningCreator delayedCreator = DoorWindowDelayedOpeningCreator.Create(exporterIFC, doorWindowInfo, instanceHandle, setter.LevelId);
if (delayedCreator != null)
ExporterCacheManager.DoorWindowDelayedOpeningCreatorCache.Add(delayedCreator);
}
}
}
}
/// <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;
if (geometryElement == null)
return null;
IFCAnyHandle beam = null;
dontExport = false;
IFCFile file = exporterIFC.GetFile();
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;
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
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);
// 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, solids, meshes, 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);
if (solids.Count == 1 && meshes.Count == 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
solids, meshes, bodyExporterOptions, extrusionCreationData);
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
offsetTransform = bodyData.OffsetTransform;
}
}
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);
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
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.CreateMaterialAssociations(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;
}
}