/// <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);
}
private static IFCAnyHandle CopyRailingHandle(ExporterIFC exporterIFC, Element elem, ElementId catId, IFCAnyHandle origLocalPlacement,
IFCAnyHandle origRailing)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle origRailingObjectPlacement = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "ObjectPlacement");
IFCAnyHandle railingRelativePlacement = IFCAnyHandleUtil.GetInstanceAttribute(origRailingObjectPlacement, "RelativePlacement");
IFCAnyHandle parentRelativePlacement = IFCAnyHandleUtil.GetInstanceAttribute(origLocalPlacement, "RelativePlacement");
IFCAnyHandle newRelativePlacement = null;
IFCAnyHandle parentRelativeOrig = IFCAnyHandleUtil.GetInstanceAttribute(parentRelativePlacement, "Location");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(parentRelativeOrig))
{
IList <double> parentVec = IFCAnyHandleUtil.GetCoordinates(parentRelativeOrig);
IFCAnyHandle railingRelativeOrig = IFCAnyHandleUtil.GetInstanceAttribute(railingRelativePlacement, "Location");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(railingRelativeOrig))
{
IList <double> railingVec = IFCAnyHandleUtil.GetCoordinates(railingRelativeOrig);
IList <double> newMeasure = new List <double>();
newMeasure.Add(railingVec[0] - parentVec[0]);
newMeasure.Add(railingVec[1] - parentVec[1]);
newMeasure.Add(railingVec[2]);
IFCAnyHandle locPtHnd = ExporterUtil.CreateCartesianPoint(file, newMeasure);
newRelativePlacement = IFCInstanceExporter.CreateAxis2Placement3D(file, locPtHnd, null, null);
}
else
{
IList <double> railingMeasure = new List <double>();
railingMeasure.Add(-parentVec[0]);
railingMeasure.Add(-parentVec[1]);
railingMeasure.Add(0.0);
IFCAnyHandle locPtHnd = ExporterUtil.CreateCartesianPoint(file, railingMeasure);
newRelativePlacement = IFCInstanceExporter.CreateAxis2Placement3D(file, locPtHnd, null, null);
}
}
IFCAnyHandle newLocalPlacement = IFCInstanceExporter.CreateLocalPlacement(file, origLocalPlacement, newRelativePlacement);
IFCAnyHandle origRailingRep = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "Representation");
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, elem, catId, origRailingRep);
string ifcEnumTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(origRailing, "PredefinedType");
IFCRailingType railingType = GetIFCRailingTypeFromString(ifcEnumTypeAsString);
string copyGUID = ExporterIFCUtils.CreateGUID();
IFCAnyHandle copyOwnerHistory = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "OwnerHistory");
string copyName = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Name");
string copyDescription = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Description");
string copyObjectType = IFCAnyHandleUtil.GetStringAttribute(origRailing, "ObjectType");
string copyElemId = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Tag");
return(IFCInstanceExporter.CreateRailing(file, copyGUID, copyOwnerHistory, copyName, copyDescription, copyObjectType,
newLocalPlacement, newProdRep,
copyElemId, railingType));
}
/// <summary>
/// Returns the GUID for a storey level, depending on whether we are using R2009 GUIDs or current GUIDs.
/// </summary>
/// <param name="level">
/// The level.
/// </param>
/// <returns>
/// The GUID.
/// </returns>
public static string GetLevelGUID(Level level)
{
if (!ExporterCacheManager.ExportOptionsCache.Use2009BuildingStoreyGUIDs)
{
return(ExporterIFCUtils.CreateAlternateGUID(level));
}
else
{
return(ExporterIFCUtils.CreateGUID(level));
}
}
/// <summary>
/// Export all the parts of the host element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostElement">The host element having parts to export.</param>
/// <param name="hostHandle">The host element handle.</param>
/// <param name="originalWrapper">The IFCProductWrapper object.</param>
public static void ExportHostPart(ExporterIFC exporterIFC, Element hostElement, IFCAnyHandle hostHandle,
IFCProductWrapper originalWrapper, IFCPlacementSetter placementSetter, IFCAnyHandle originalPlacement, ElementId overrideLevelId)
{
using (IFCProductWrapper subWrapper = IFCProductWrapper.Create(exporterIFC, true))
{
List <ElementId> associatedPartsList = PartUtils.GetAssociatedParts(hostElement.Document, hostElement.Id, false, true).ToList();
if (associatedPartsList.Count == 0)
{
return;
}
bool isWallOrColumn = IsHostWallOrColumn(exporterIFC, hostElement);
bool hasOverrideLevel = overrideLevelId != null && overrideLevelId != ElementId.InvalidElementId;
IFCExtrusionAxes ifcExtrusionAxes = GetDefaultExtrusionAxesForHost(exporterIFC, hostElement);
// Split parts if wall or column is split by level, and then export; otherwise, export parts normally.
if (isWallOrColumn && hasOverrideLevel && ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting)
{
if (!ExporterCacheManager.HostPartsCache.HasRegistered(hostElement.Id))
{
SplitParts(exporterIFC, hostElement, associatedPartsList); // Split parts and associate them with host.
}
// Find and export the parts that are split by specific level.
List <KeyValuePair <Part, IFCRange> > splitPartRangeList = new List <KeyValuePair <Part, IFCRange> >();
splitPartRangeList = ExporterCacheManager.HostPartsCache.Find(hostElement.Id, overrideLevelId);
foreach (KeyValuePair <Part, IFCRange> partRange in splitPartRangeList)
{
PartExporter.ExportPart(exporterIFC, partRange.Key, subWrapper, placementSetter, originalPlacement, partRange.Value, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
else
{
foreach (ElementId partId in associatedPartsList)
{
Part part = hostElement.Document.GetElement(partId) as Part;
PartExporter.ExportPart(exporterIFC, part, subWrapper, placementSetter, originalPlacement, null, ifcExtrusionAxes, hostElement, overrideLevelId, false);
}
}
// Create the relationship of Host and Parts.
ICollection <IFCAnyHandle> relatedElementIds = subWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateGUID();
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(exporterIFC.GetFile(), guid, exporterIFC.GetOwnerHistoryHandle(), null, null, hostHandle, relatedElementIdSet);
}
}
}
/// <summary>
/// Exports an element as IFC covering.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportCovering(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, IFCProductWrapper productWrapper)
{
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle prodRep = exportParts ? null : RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC,
element, geomElem, false, false);
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.IFCCoveringType coveringType = GetIFCCoveringType(element, ifcEnumType);
IFCAnyHandle covering = IFCInstanceExporter.CreateCovering(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, setter.GetPlacement(), prodRep, instanceElemId, coveringType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(covering, setter, null, LevelUtil.AssociateElementToLevel(element));
Ceiling ceiling = element as Ceiling;
if (ceiling != null && !exportParts)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3);
}
ExporterIFCUtils.CreateCoveringPropertySet(exporterIFC, element, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
transaction.Commit();
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = ExporterIFCUtils.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string objectType = exporterIFC.GetFamilyName();
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, objectType, null, objectType, localPlacement, representation, elementTag, IFCCoveringType.Wrapping);
productWrapper.AddElement(ductLining, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(element));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Export the roof to IfcRoof containing its parts.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRoofAsParts(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle localPlacement = setter.GetPlacement();
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(setter.GetPlacement());
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
IFCAnyHandle prodRepHnd = null;
string elementGUID = ExporterIFCUtils.CreateGUID(element);
string origElementName = exporterIFC.GetName();
string elementName = NamingUtil.GetNameOverride(element, origElementName);
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementId = NamingUtil.CreateIFCElementId(element);
//need to convert the string to enum
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription, elementObjectType, localPlacement, prodRepHnd, elementId, GetIFCRoofType(ifcEnumType));
// Export the parts
PartExporter.ExportHostPart(exporterIFC, element, roofHandle, productWrapper, setter, localPlacement, null);
productWrapper.AddElement(roofHandle, setter, extrusionCreationData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(roofHandle, element, extrusionCreationData, exporterIFC, extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
transaction.Commit();
}
}
}
/// <summary>
/// Creates window panel properties.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="doorWindowInfo">
/// The IFCDoorWindowInfo object.
/// </param>
/// <param name="familyInstance">
/// The family instance of a window.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <returns>
/// The list of handles created.
/// </returns>
public static IList <IFCAnyHandle> CreateWindowPanelProperties(ExporterIFC exporterIFC,
Element familyInstance, string description)
{
IList <IFCAnyHandle> panels = new List <IFCAnyHandle>();
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
const int maxPanels = 1000; // arbitrary large number to prevent infinite loops.
for (int panelNumber = 1; panelNumber < maxPanels; panelNumber++)
{
string frameDepthCurrString = "FrameDepth" + panelNumber.ToString();
string frameThicknessCurrString = "FrameThickness" + panelNumber.ToString();
IFCWindowPanelOperation panelOperation = GetIFCWindowPanelOperation("", familyInstance, panelNumber);
IFCWindowPanelPosition panelPosition = GetIFCWindowPanelPosition("", familyInstance, panelNumber);
if (panelOperation == IFCWindowPanelOperation.NotDefined && panelPosition == IFCWindowPanelPosition.NotDefined)
{
break;
}
double?frameDepth = null;
double?frameThickness = null;
double value1, value2;
if ((ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, frameDepthCurrString, out value1) ||
((panelNumber == 1) && (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FrameDepth", out value1)))) &&
(ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, frameThicknessCurrString, out value2) ||
((panelNumber == 1) && (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FrameThickness", out value2)))))
{
frameDepth = value1;
frameThickness = value2;
}
string panelGUID = ExporterIFCUtils.CreateGUID();
string panelName = NamingUtil.CreateIFCName(exporterIFC, panelNumber);
panels.Add(IFCInstanceExporter.CreateWindowPanelProperties(file, panelGUID, ownerHistory,
panelName, description, panelOperation, panelPosition, frameDepth, frameThickness, null));
}
return(panels);
}
/// <summary>
/// Creates a new IfcAnnotation object.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="curveElement">The curve element.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="sketchPlaneId">The sketch plane id.</param>
/// <param name="refPlane">The reference plane.</param>
/// <param name="curveStyle">The curve style.</param>
/// <param name="placementSetter">The placemenet setter.</param>
/// <param name="localPlacement">The local placement.</param>
/// <param name="repItemHnd">The representation item.</param>
/// <returns>The handle.</returns>
static IFCAnyHandle CreateCurveAnnotation(ExporterIFC exporterIFC, Element curveElement, ElementId categoryId, ElementId sketchPlaneId,
Plane refPlane, IFCAnyHandle curveStyle, IFCPlacementSetter placementSetter, IFCAnyHandle localPlacement, IFCAnyHandle repItemHnd)
{
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, curveElement, categoryId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
throw new Exception("Failed to create shape representation.");
}
List <IFCAnyHandle> shapes = new List <IFCAnyHandle>();
shapes.Add(bodyRepHnd);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapes);
XYZ xDir = refPlane.XVec; XYZ zDir = refPlane.Normal; XYZ origin = refPlane.Origin;
// subtract out level origin if we didn't already before.
IFCLevelInfo levelInfo = placementSetter.GetLevelInfo();
if (levelInfo != null && !MathUtil.IsAlmostEqual(zDir.Z, 1.0))
{
zDir -= new XYZ(0, 0, levelInfo.Elevation);
}
origin = origin * exporterIFC.LinearScale;
IFCAnyHandle relativePlacement = ExporterUtil.CreateAxis(file, origin, zDir, xDir);
GeometryUtil.SetRelativePlacement(localPlacement, relativePlacement);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, localPlacement, prodShapeHnd);
return(annotation);
}
/// <summary>
/// Exports 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>
/// Thin wrapper for the CreateGUID() Revit API function.
/// </summary>
/// <returns>A random GUID.</returns>
static private string CreateGUID()
{
return(ExporterIFCUtils.CreateGUID());
}
/// <summary>
/// Exports an element as an annotation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="filledRegion">The filled region element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, FilledRegion filledRegion,
GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
if (filledRegion == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IList <CurveLoop> boundaries = filledRegion.GetBoundaries();
if (boundaries.Count == 0)
{
return;
}
Plane plane = null;
try
{
plane = boundaries[0].GetPlane();
}
catch
{
return;
}
Transform orientTrf = Transform.Identity;
orientTrf.BasisX = plane.XVec; orientTrf.BasisY = plane.YVec; orientTrf.BasisZ = plane.Normal;
orientTrf.Origin = plane.Origin;
XYZ projectionDirection = plane.Normal;
IList <IList <CurveLoop> > sortedLoops = ExporterIFCUtils.SortCurveLoops(boundaries);
if (sortedLoops.Count == 0)
{
return;
}
FilledRegionType filledRegionType = filledRegion.Document.GetElement(filledRegion.GetTypeId()) as FilledRegionType;
Color color = filledRegionType != null ? filledRegionType.Color : new Color(0, 0, 0);
ElementId fillPatternId = filledRegionType != null ? filledRegionType.FillPatternId : ElementId.InvalidElementId;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(filledRegion);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, filledRegion, null, orientTrf, ElementId.InvalidElementId))
{
foreach (IList <CurveLoop> curveLoopList in sortedLoops)
{
IFCAnyHandle outerCurve = null;
HashSet <IFCAnyHandle> innerCurves = null;
for (int ii = 0; ii < curveLoopList.Count; ii++)
{
IFCAnyHandle ifcCurve = ExporterIFCUtils.CreateCurveFromCurveLoop(exporterIFC, curveLoopList[ii], plane, projectionDirection);
if (ii == 0)
{
outerCurve = ifcCurve;
}
else
{
if (innerCurves == null)
{
innerCurves = new HashSet <IFCAnyHandle>();
}
innerCurves.Add(ifcCurve);
}
}
IFCAnyHandle representItem = IFCInstanceExporter.CreateAnnotationFillArea(file, outerCurve, innerCurves);
file.CreateStyle(exporterIFC, representItem, color, fillPatternId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(representItem);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, filledRegion, categoryId,
exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle productShape = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle annotation = IFCInstanceExporter.CreateAnnotation(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, setter.GetPlacement(), productShape);
productWrapper.AddAnnotation(annotation, setter.GetLevelInfo(), true);
}
}
transaction.Commit();
}
}
/// <summary>
/// Relates one object to a collection of others.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="optionalGUID">
/// A GUID value, or null to generate a random GUID.
/// </param>
/// <param name="relatingObject">
/// The relating object.
/// </param>
/// <param name="relatedObjects">
/// The related objects.
/// </param>
public static void RelateObjects(ExporterIFC exporterIFC, string optionalGUID, IFCAnyHandle relatingObject, ICollection <IFCAnyHandle> relatedObjects)
{
string guid = (optionalGUID != null) ? optionalGUID : ExporterIFCUtils.CreateGUID();
IFCInstanceExporter.CreateRelAggregates(exporterIFC.GetFile(), guid, exporterIFC.GetOwnerHistoryHandle(), null, null, relatingObject, new HashSet <IFCAnyHandle>(relatedObjects));
}
/// <summary>
/// Add IFC Nodes
/// </summary>
/// <param name="ifcFile"></param>
/// <param name="exporterIFC"></param>
/// <param name="inElement"></param>
/// <param name="outElement"></param>
/// <param name="isBiDirectional"></param>
static void AddConnection(IFCFile ifcFile, ExporterIFC exporterIFC, Element inElement, Element outElement, bool isBiDirectional)
{
// Check if the connection already exist
if (connectionExists(inElement.Id, outElement.Id))
{
return;
}
if (isBiDirectional)
{
if (connectionExists(outElement.Id, inElement.Id))
{
return;
}
}
IFCAnyHandle inElementIFCHandle = ExporterCacheManager.MEPCache.Find(inElement.Id);
IFCAnyHandle outElementIFCHandle = ExporterCacheManager.MEPCache.Find(outElement.Id);
if (inElementIFCHandle == null || outElementIFCHandle == null ||
!IFCAnyHandleUtil.IsSubTypeOf(inElementIFCHandle, IFCEntityType.IfcElement) ||
!IFCAnyHandleUtil.IsSubTypeOf(outElementIFCHandle, IFCEntityType.IfcElement))
{
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCAnyHandle portOut = null;
IFCAnyHandle portIn = null;
// ----------------------- In Port ----------------------
{
// Make Source port
IFCAnyHandle productRepresentation = null;
string guid = ExporterIFCUtils.CreateGUID();
string objType = IFCEntityType.IfcDistributionPort.ToString();
IFCFlowDirection flowDir = (isBiDirectional) ? IFCFlowDirection.SourceAndSink : IFCFlowDirection.Sink;
portIn = IFCInstanceExporter.CreateDistributionPort(ifcFile, guid, ownerHistory, null, null, objType, null, productRepresentation, flowDir);
// Attach the port to the element
guid = ExporterIFCUtils.CreateGUID();
IFCAnyHandle connectorIn = IFCInstanceExporter.CreateRelConnectsPortToElement(ifcFile, guid, ownerHistory, null, null, portIn, inElementIFCHandle);
}
// ----------------------- Out Port----------------------
{
IFCAnyHandle productRepresentation = null;
string guid = ExporterIFCUtils.CreateGUID();
string objType = IFCEntityType.IfcDistributionPort.ToString();
IFCFlowDirection flowDir = (isBiDirectional) ? IFCFlowDirection.SourceAndSink : IFCFlowDirection.Source;
portOut = IFCInstanceExporter.CreateDistributionPort(ifcFile, guid, ownerHistory, null, null, objType, null, productRepresentation, flowDir);
// Attach the port to the element
guid = ExporterIFCUtils.CreateGUID();
IFCAnyHandle connectorOut = IFCInstanceExporter.CreateRelConnectsPortToElement(ifcFile, guid, ownerHistory, null, null, portOut, outElementIFCHandle);
}
// ----------------------- Out Port -> In Port ----------------------
if (portOut != null && portIn != null)
{
string guid = ExporterIFCUtils.CreateGUID();
IFCAnyHandle realizingElement = null;
IFCInstanceExporter.CreateRelConnectsPorts(ifcFile, guid, ownerHistory, null, null, portIn, portOut, realizingElement);
addConnection(inElement.Id, outElement.Id);
}
}
/// <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>
/// Base implementation to export IFC site object.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="document">
/// The Revit document.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCAnyHandle siteHandle = exporterIFC.GetSite();
int numSiteElements = (!IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle) ? 1 : 0);
if (element == null && (numSiteElements != 0))
{
return;
}
Document doc = document;
if (doc == null)
{
if (element != null)
{
doc = element.Document;
}
else
{
throw new ArgumentException("Both document and element are null.");
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle siteRepresentation = null;
if (element != null)
{
// It would be possible that they actually represent several different sites with different buildings,
// but until we have a concept of a building in Revit, we have to assume 0-1 sites, 1 building.
bool appendedToSite = false;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle))
{
IList <IFCAnyHandle> representations = IFCAnyHandleUtil.GetProductRepresentations(siteHandle);
if (representations.Count > 0)
{
IFCAnyHandle bodyRep = representations[0];
IFCAnyHandle boundaryRep = null;
if (representations.Count > 1)
{
boundaryRep = representations[1];
}
siteRepresentation = RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC, element, geometryElement, true, true, ref bodyRep, ref boundaryRep);
appendedToSite = true;
}
}
if (!appendedToSite)
{
siteRepresentation = RepresentationUtil.CreateSurfaceProductDefinitionShape(exporterIFC, element, geometryElement, true, true);
}
}
List <int> latitude = new List <int>();
List <int> longitude = new List <int>();
ProjectLocation projLocation = doc.ActiveProjectLocation;
IFCAnyHandle relativePlacement = null;
double elevation = 0.0;
if (projLocation != null)
{
double latitudeInDeg = projLocation.SiteLocation.Latitude * 180 / Math.PI;
double longitudeInDeg = projLocation.SiteLocation.Longitude * 180 / Math.PI;
int latDeg = ((int)latitudeInDeg); latitudeInDeg -= latDeg; latitudeInDeg *= 60;
int latMin = ((int)latitudeInDeg); latitudeInDeg -= latMin; latitudeInDeg *= 60;
int latSec = ((int)latitudeInDeg); latitudeInDeg -= latSec; latitudeInDeg *= 1000000;
int latFracSec = ((int)latitudeInDeg);
latitude.Add(latDeg);
latitude.Add(latMin);
latitude.Add(latSec);
if (!exporterIFC.ExportAs2x2)
{
latitude.Add(latFracSec);
}
int longDeg = ((int)longitudeInDeg); longitudeInDeg -= longDeg; longitudeInDeg *= 60;
int longMin = ((int)longitudeInDeg); longitudeInDeg -= longMin; longitudeInDeg *= 60;
int longSec = ((int)longitudeInDeg); longitudeInDeg -= longSec; longitudeInDeg *= 1000000;
int longFracSec = ((int)longitudeInDeg);
longitude.Add(longDeg);
longitude.Add(longMin);
longitude.Add(longSec);
if (!exporterIFC.ExportAs2x2)
{
longitude.Add(longFracSec);
}
Transform siteSharedCoordinatesTrf = projLocation.GetTransform().Inverse;
if (!siteSharedCoordinatesTrf.IsIdentity)
{
XYZ orig = siteSharedCoordinatesTrf.Origin;
orig = orig.Multiply(exporterIFC.LinearScale);
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, orig, siteSharedCoordinatesTrf.BasisZ, siteSharedCoordinatesTrf.BasisX);
}
}
// Get elevation for site.
elevation = -LevelUtil.GetReferenceHeightForRelativeElevation(doc) * exporterIFC.LinearScale;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
{
relativePlacement = ExporterUtil.CreateAxis2Placement3D(file);
}
IFCAnyHandle localPlacement = IFCInstanceExporter.CreateLocalPlacement(file, null, relativePlacement);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
if (element != null)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(siteHandle))
{
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
siteHandle = IFCInstanceExporter.CreateSite(file, instanceGUID, ownerHistory, instanceName, instanceDescription, instanceObjectType, localPlacement,
siteRepresentation, null, Toolkit.IFCElementComposition.Element, latitude, longitude, elevation, null, null);
}
}
else
{
// don't bother if we have nothing in the site whatsoever.
if ((latitude.Count == 0 || longitude.Count == 0) && IFCAnyHandleUtil.IsNullOrHasNoValue(relativePlacement))
{
return;
}
string defaultSiteName = "Default";
siteHandle = IFCInstanceExporter.CreateSite(file, ExporterIFCUtils.CreateProjectLevelGUID(doc, IFCProjectLevelGUIDType.Site), ownerHistory, defaultSiteName, null, objectType, localPlacement,
null, null, Toolkit.IFCElementComposition.Element, latitude, longitude, elevation, null, null);
}
productWrapper.AddSite(siteHandle);
exporterIFC.SetSite(siteHandle);
tr.Commit();
}
}
/// <summary>
/// Exports an element as IFC railing.
/// </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 ExportRailing(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, IFCProductWrapper productWrapper)
{
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSolidMeshGeometry(geomElem, Transform.Identity);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
Railing railingElem = element as Railing;
IList <ElementId> subElementIds = CollectSubElements(railingElem);
foreach (ElementId subElementId in subElementIds)
{
Element subElement = railingElem.Document.GetElement(subElementId);
if (subElement != null)
{
GeometryElement subElementGeom = GeometryUtil.GetOneLevelGeometryElement(subElement.get_Geometry(geomOptions));
SolidMeshGeometryInfo subElementSolidMeshInfo = GeometryUtil.GetSolidMeshGeometry(subElementGeom, Transform.Identity);
IList <Solid> subElementSolids = subElementSolidMeshInfo.GetSolids();
IList <Mesh> subElementMeshes = subElementSolidMeshInfo.GetMeshes();
foreach (Solid subElementSolid in subElementSolids)
{
solids.Add(subElementSolid);
}
foreach (Mesh subElementMesh in subElementMeshes)
{
meshes.Add(subElementMesh);
}
}
}
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
//bodyExporterOptions.UseGroupsIfPossible = true;
//bodyExporterOptions.UseMappedGeometriesIfPossible = true;
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId, solids, meshes, bodyExporterOptions, ecData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geomElem);
bodyData = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, catId, geomlist, bodyExporterOptions, ecData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
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.IFCRailingType railingType = GetIFCRailingType(element, ifcEnumType);
IFCAnyHandle railing = IFCInstanceExporter.CreateRailing(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(),
prodRep, instanceElemId, railingType);
ElementId hostId = GetStairOrRampHostId(exporterIFC, element as Railing);
bool associateToLevel = (hostId == ElementId.InvalidElementId) && LevelUtil.AssociateElementToLevel(element);
productWrapper.AddElement(railing, setter, ecData, associateToLevel);
OpeningUtil.CreateOpeningsIfNecessary(railing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
CategoryUtil.CreateMaterialAssociations(element.Document, exporterIFC, railing, bodyData.MaterialIds);
// Create multi-story duplicates of this railing.
if (hostId != ElementId.InvalidElementId)
{
StairRampContainerInfo stairRampInfo = ExporterCacheManager.StairRampContainerInfoCache.GetStairRampContainerInfo(hostId);
stairRampInfo.AddComponent(0, railing);
List <IFCAnyHandle> stairHandles = stairRampInfo.StairOrRampHandles;
for (int ii = 1; ii < stairHandles.Count; ii++)
{
IFCAnyHandle railingLocalPlacement = stairRampInfo.LocalPlacements[ii];
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(railingLocalPlacement))
{
IFCAnyHandle railingHndCopy = CopyRailingHandle(exporterIFC, element, catId, railingLocalPlacement, railing);
stairRampInfo.AddComponent(ii, railingHndCopy);
productWrapper.AddElement(railingHndCopy, (IFCLevelInfo)null, ecData, false);
CategoryUtil.CreateMaterialAssociations(element.Document, exporterIFC, railingHndCopy, bodyData.MaterialIds);
}
}
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(hostId, stairRampInfo);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
transaction.Commit();
}
}
}
/// <summary>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">
/// The element handle to create openings.
/// </param>
/// <param name="element">
/// The element to create openings.
/// </param>
/// <param name="info">
/// The extrusion datas.
/// </param>
/// <param name="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="originalPlacement">
/// The original placement handle.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="wrapper">
/// The IFCProductWrapper.
/// </param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, IFCPlacementSetter setter, IFCProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
Document document = element.Document;
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
IFCAnyHandle extrusionHandle = ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element, info[curr]);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
IFCAnyHandle styledItemHnd = BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, document,
extrusionHandle, ElementId.InvalidElementId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(extrusionHandle);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCAnyHandle bodyRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItems, null);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = ExporterIFCUtils.CreateGUID();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string openingName = NamingUtil.GetNameOverride(element, NamingUtil.CreateIFCName(exporterIFC, openingNumber++));
string elementId = NamingUtil.CreateIFCElementId(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(file, guid, ownerHistory,
openingName, null, openingObjectType, openingPlacement, openingRep, elementId);
wrapper.AddElement(openingElement, setter, extraParams, true);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
ExporterIFCUtils.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = ExporterIFCUtils.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
/// <summary>
/// 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 IFCProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
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());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle bodyRep = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, categoryId,
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, ExporterIFCUtils.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 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.CreateIFCName(exporterIFC, -1));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, elementTypeName);
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(file, ExporterIFCUtils.CreateGUID(element),
exporterIFC.GetOwnerHistoryHandle(), name, description, objectType, localPlacementToUse, prodRep,
NamingUtil.CreateIFCElementId(element));
if (roomId == ElementId.InvalidElementId)
{
productWrapper.AddElement(elemHnd, setter.GetLevelInfo(), ecData, true);
}
else
{
exporterIFC.RelateSpatialElement(roomId, elemHnd);
productWrapper.AddElement(elemHnd, setter.GetLevelInfo(), ecData, false);
}
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, exporterIFC,
localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a floor to IFC slab.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="floor">
/// The floor element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
/// <param name="exportParts">
/// Whether to export parts or not.
/// </param>
/// <returns>
/// True if the floor is exported successfully, false otherwise.
/// </returns>
public static void ExportFloor(ExporterIFC exporterIFC, Element floorElement, GeometryElement geometryElement, string ifcEnumType,
IFCProductWrapper productWrapper, bool exportParts)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.GetPlacement();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool exportedAsInternalExtrusion = false;
double scale = exporterIFC.LinearScale;
ElementId catId = CategoryUtil.GetSafeCategoryId(floorElement);
IList <IFCAnyHandle> reps = new List <IFCAnyHandle>();
IList <IList <CurveLoop> > extrusionLoops = new List <IList <CurveLoop> >();
IList <IFCExtrusionCreationData> loopExtraParams = new List <IFCExtrusionCreationData>();
Plane floorPlane = GeometryUtil.CreateDefaultPlane();
IList <IFCAnyHandle> localPlacements = new List <IFCAnyHandle>();
if (!exportParts)
{
// First, try to use the ExtrusionAnalyzer for the limited cases it handles - 1 solid, no openings, end clippings only.
// Also limited to cases with line and arc boundaries.
//
if (floorElement is Floor)
{
Floor floor = floorElement as Floor;
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
IList <Solid> splitVolumes = SolidUtils.SplitVolumes(solids[0]);
if (splitVolumes.Count == 1)
{
bool completelyClipped;
XYZ floorExtrusionDirection = new XYZ(0, 0, -1);
XYZ modelOrigin = XYZ.Zero;
XYZ floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
if (floorOrigin == null)
{
// GetVerticalProjectionPoint may return null if FloorFace.Top is an edited face that doesn't
// go thruough te Revit model orgigin. We'll try the midpoint of the bounding box instead.
BoundingBoxXYZ boundingBox = floor.get_BoundingBox(null);
modelOrigin = (boundingBox.Min + boundingBox.Max) / 2.0;
floorOrigin = floor.GetVerticalProjectionPoint(modelOrigin, FloorFace.Top);
}
if (floorOrigin != null)
{
XYZ floorDir = floor.GetNormalAtVerticalProjectionPoint(floorOrigin, FloorFace.Top);
Plane extrusionAnalyzerFloorPlane = new Plane(floorDir, floorOrigin);
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floor,
catId, solids[0], extrusionAnalyzerFloorPlane, floorExtrusionDirection, null, out completelyClipped);
if (completelyClipped)
{
return;
}
if (floorAndProperties.Handle != null)
{
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(floorAndProperties.Handle);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
reps.Add(prodRep);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (reps.Count == 0)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out reps,
out extrusionLoops, out loopExtraParams, floorPlane);
}
if (reps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporterOptions.BodyTessellationLevel.Coarse;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateBRepProductDefinitionShape(floorElement.Document.Application, exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
reps.Add(prodDefHnd);
}
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = ExporterIFCUtils.CreateGUID(floorElement);
int numReps = exportParts ? 1 : reps.Count;
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.CreateIFCName(exporterIFC, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcElemId = NamingUtil.CreateIFCElementId(floorElement);
string currentGUID = (ii == 0) ? ifcGUID : ExporterIFCUtils.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCSlabType slabType = GetIFCSlabType(ifcEnumType);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : reps[ii], ifcElemId, slabType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
}
bool associateElementToLevel = LevelUtil.AssociateElementToLevel(floorElement);
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(slabHnds[ii], placementSetter, loopExtraParam, associateElementToLevel);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, floorElement, productWrapper);
}
if (!exportParts)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement as HostObject, slabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3);
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports an element to IFC footing.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="ifcEnumType">
/// The string value represents the IFC type.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportFooting(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, IFCProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.Level.Id, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application, exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.CreateIFCElementId(element);
Toolkit.IFCFootingType footingType = GetIFCFootingType(element, ifcEnumType);
IFCAnyHandle footing = IFCInstanceExporter.CreateFooting(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceElemId, footingType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, footing, productWrapper, setter, setter.GetPlacement(), null);
}
productWrapper.AddElement(footing, setter, ecData, LevelUtil.AssociateElementToLevel(element));
OpeningUtil.CreateOpeningsIfNecessary(footing, element, ecData, exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, IFCProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(ramp.Document.Application,
exporterIFC, ramp, categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = ExporterIFCUtils.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origRampName = exporterIFC.GetName();
string rampName = NamingUtil.GetNameOverride(ramp, origRampName);
string rampDescription = NamingUtil.GetDescriptionOverride(ramp, null);
string rampObjectType = NamingUtil.GetObjectTypeOverride(ramp, NamingUtil.CreateIFCObjectName(exporterIFC, ramp));
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CopyLocalPlacement(file, ecData.GetLocalPlacement());
string elementTag = NamingUtil.CreateIFCElementId(ramp);
IFCRampType rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, containedRampGuid, ownerHistory, rampName,
rampDescription, rampObjectType, containedRampLocalPlacement, representation, elementTag, rampType);
components.Add(containedRampHnd);
productWrapper.AddElement(containedRampHnd, placementSetter.GetLevelInfo(), ecData, false);
string guid = ExporterIFCUtils.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, rampName,
rampDescription, rampObjectType, localPlacement, null, elementTag, rampType);
productWrapper.AddElement(rampHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(ramp));
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, null);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights,
ownerHistory, localPlacement, containedRampLocalPlacement, representation,
rampName, rampObjectType, rampDescription, elementTag, rampType,
ecData, placementSetter, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, ramp, productWrapper);
tr.Commit();
}
}
}
/// <summary>
/// Thin wrapper for the CreateGUID Revit API function.
/// </summary>
/// <returns>A random GUID.</returns>
static public string CreateGUID()
{
return(ExporterIFCUtils.CreateGUID());
}
/// <summary>
/// Exports a Rebar to IFC ReinforcingMesh.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportRebar(ExporterIFC exporterIFC,
Rebar element, Autodesk.Revit.DB.View filterView, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
GeometryElement rebarGeometry = ExporterIFCUtils.GetRebarGeometry(element, filterView);
// only options are: Not Export, BuildingElementProxy, or ReinforcingBar/Mesh, depending on layout.
// Not Export is handled previously, and ReinforcingBar vs Mesh will be determined below.
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportType == IFCExportType.ExportBuildingElementProxy)
{
if (rebarGeometry != null)
{
ProxyElementExporter.ExportBuildingElementProxy(exporterIFC, element, rebarGeometry, productWrapper);
transaction.Commit();
}
return;
}
IFCAnyHandle prodRep = null;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(setter.GetPlacement());
if (rebarGeometry != null)
{
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = BodyExporter.ExportBody(element.Document.Application, exporterIFC, element, categoryId, rebarGeometry, bodyExporterOptions,
extrusionCreationData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
extrusionCreationData.ClearOpenings();
}
}
double scale = exporterIFC.LinearScale;
double barLength = element.TotalLength * scale;
if (MathUtil.IsAlmostZero(barLength))
{
return;
}
int quantity = element.Quantity;
if (quantity < 1)
{
return;
}
ElementId typeId = element.GetTypeId();
RebarBarType elementType = element.Document.GetElement(element.GetTypeId()) as RebarBarType;
double diameter = elementType == null ? 1.0 / 12.0 : elementType.BarDiameter;
double longitudinalBarNominalDiameter = diameter * scale;
double longitudinalBarCrossSectionArea = (element.Volume * scale * scale * scale) / barLength;
string steelGradeOpt = null;
IFCAnyHandle elemHnd = null;
string rebarGUID = ExporterIFCUtils.CreateGUID(element);
string origRebarName = exporterIFC.GetName();
string rebarName = NamingUtil.GetNameOverride(element, origRebarName);
string rebarDescription = NamingUtil.GetDescriptionOverride(element, null);
string rebarObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string rebarElemId = NamingUtil.CreateIFCElementId(element);
if (element.LayoutRule == RebarLayoutRule.Single || (quantity == 1))
{
IFCReinforcingBarRole role = IFCReinforcingBarRole.NotDefined;
elemHnd = IFCInstanceExporter.CreateReinforcingBar(file, rebarGUID, exporterIFC.GetOwnerHistoryHandle(),
rebarName, rebarDescription, rebarObjectType, extrusionCreationData.GetLocalPlacement(),
prodRep, rebarElemId, steelGradeOpt, longitudinalBarNominalDiameter, longitudinalBarCrossSectionArea,
barLength, role, null);
}
else
{
double meshLength;
double longitudinalBarSpacing;
double val = element.ArrayLength * scale;
if (element.LayoutRule == RebarLayoutRule.NumberWithSpacing)
{
longitudinalBarSpacing = val;
meshLength = val * (quantity - 1);
}
else
{
meshLength = val;
longitudinalBarSpacing = val / (quantity - 1);
}
double meshWidth = diameter * scale; // array is in one direction only.
double transverseBarNominalDiameter = longitudinalBarNominalDiameter;
double transverseBarCrossSectionArea = longitudinalBarCrossSectionArea;
double transverseBarSpacing = longitudinalBarSpacing;
elemHnd = IFCInstanceExporter.CreateReinforcingMesh(file, rebarGUID,
exporterIFC.GetOwnerHistoryHandle(), rebarName,
rebarDescription, rebarObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, rebarElemId,
steelGradeOpt, meshLength, meshWidth, longitudinalBarNominalDiameter,
transverseBarNominalDiameter, longitudinalBarCrossSectionArea,
transverseBarCrossSectionArea, longitudinalBarSpacing,
transverseBarSpacing);
}
productWrapper.AddElement(elemHnd, setter.GetLevelInfo(), extrusionCreationData, true);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports the top stories of a multistory ramp.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="ownerHistory">The owner history.</param>
/// <param name="localPlacement">The local placement of the IfcRamp container.</param>
/// <param name="containedRampLocalPlacement">The local placement of the IfcRamp containing the ramp geometry.</param>
/// <param name="representation">The ramp geometry representation.</param>
/// <param name="rampName">The ramp name.</param>
/// <param name="rampObjectType">The ramp object type.</param>
/// <param name="rampDescription">The ramp description.</param>
/// <param name="elementTag">The ramp element tag.</param>
/// <param name="rampType">The ramp type.</param>
/// <param name="ecData">The extrusion creation data.</param>
/// <param name="placementSetter">The placement setter.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportMultistoryRamp(ExporterIFC exporterIFC, Element ramp, int numFlights,
IFCAnyHandle ownerHistory, IFCAnyHandle localPlacement, IFCAnyHandle containedRampLocalPlacement, IFCAnyHandle representation,
string rampName, string rampObjectType, string rampDescription, string elementTag, IFCRampType rampType,
IFCExtrusionCreationData ecData, IFCPlacementSetter placementSetter, IFCProductWrapper productWrapper)
{
if (numFlights < 2)
{
return;
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relPlacement = GeometryUtil.GetRelativePlacementFromLocalPlacement(localPlacement);
IFCAnyHandle ptHnd = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> origCoords = IFCAnyHandleUtil.GetCoordinates(ptHnd);
double heightNonScaled = GetRampHeight(exporterIFC, ramp);
double scale = exporterIFC.LinearScale;
for (int ii = 1; ii < numFlights; ii++)
{
double newOffsetScaled = 0.0;
IFCAnyHandle newLevelHnd = null;
IFCLevelInfo currLevelInfo =
placementSetter.GetOffsetLevelInfoAndHandle(heightNonScaled * ii, scale, out newLevelHnd, out newOffsetScaled);
if (currLevelInfo == null)
{
currLevelInfo = placementSetter.GetLevelInfo();
}
XYZ orig = new XYZ(0.0, 0.0, newOffsetScaled);
IFCAnyHandle relativePlacementHnd = ExporterUtil.CreateAxis2Placement3D(file, orig);
IFCAnyHandle containedLocalPlacementCopy = IFCInstanceExporter.CreateLocalPlacement(file, newLevelHnd, relativePlacementHnd);
if (ptHnd.HasValue)
{
IFCAnyHandle relPlacementCopy = GeometryUtil.GetRelativePlacementFromLocalPlacement(containedLocalPlacementCopy);
IFCAnyHandle newPt = IFCAnyHandleUtil.GetLocation(relPlacement);
IList <double> newCoords = new List <double>();
newCoords.Add(origCoords[0]);
newCoords.Add(origCoords[1]);
newCoords.Add(origCoords[2]);
if (newPt.HasValue)
{
IList <double> addToCoords = IFCAnyHandleUtil.GetCoordinates(newPt);
newCoords[0] += addToCoords[0];
newCoords[1] += addToCoords[1];
newCoords[2] = addToCoords[2];
}
IFCAnyHandle locPt = IFCInstanceExporter.CreateCartesianPoint(file, newCoords);
IFCAnyHandleUtil.SetAttribute(relPlacementCopy, "Location", locPt);
}
ElementId catId = CategoryUtil.GetSafeCategoryId(ramp);
IFCAnyHandle representationCopy = ExporterUtil.CopyProductDefinitionShape(exporterIFC, ramp, catId, representation);
string localRampName = rampName + ":" + (ii + 1);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IFCAnyHandle containedRampCopyHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(), ownerHistory,
localRampName, rampDescription, rampObjectType, containedLocalPlacementCopy, representationCopy, elementTag, rampType);
components.Add(containedRampCopyHnd);
productWrapper.AddElement(containedRampCopyHnd, currLevelInfo, ecData, false);
IFCAnyHandle rampLocalPlacementCopy = ExporterUtil.CopyLocalPlacement(file, containedRampLocalPlacement);
IFCAnyHandle rampCopyHnd = IFCInstanceExporter.CreateRamp(file, ExporterIFCUtils.CreateGUID(), ownerHistory, localRampName,
rampDescription, rampObjectType, rampLocalPlacementCopy, null, elementTag, rampType);
productWrapper.AddElement(rampCopyHnd, currLevelInfo, ecData, LevelUtil.AssociateElementToLevel(ramp));
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampCopyHnd, components, rampLocalPlacementCopy);
ExporterCacheManager.StairRampContainerInfoCache.AppendStairRampContainerInfo(ramp.Id, stairRampInfo);
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
IFCProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter placementSetter = IFCPlacementSetter.Create(exporterIFC, roof))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateBRepProductDefinitionShape(roof.Document.Application, exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = ExporterIFCUtils.CreateGUID(roof);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string origRoofName = exporterIFC.GetName();
string roofName = NamingUtil.GetNameOverride(roof, origRoofName);
string roofDescription = NamingUtil.GetDescriptionOverride(roof, null);
string roofObjectType = NamingUtil.GetObjectTypeOverride(roof, NamingUtil.CreateIFCObjectName(exporterIFC, roof));
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(roof);
IFCRoofType roofType = GetIFCRoofType(ifcEnumType);
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, roofName, roofDescription,
roofObjectType, localPlacement, exportSlab ? null : representation, elementTag, roofType);
productWrapper.AddElement(roofHnd, placementSetter.GetLevelInfo(), ecData, LevelUtil.AssociateElementToLevel(roof));
if (exportSlab)
{
string slabGUID = ExporterIFCUtils.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = roofName + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, slabName,
roofDescription, roofObjectType, slabLocalPlacementHnd, representation, elementTag, IFCSlabType.Roof);
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, exporterIFC, slabLocalPlacementHnd,
placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(slabHnd, placementSetter.GetLevelInfo(), ecData, false);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Exports text note elements.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="textNote">
/// The text note element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, TextNote textNote, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string textString = textNote.Text;
if (String.IsNullOrEmpty(textString))
{
throw new Exception("TextNote does not have test string.");
}
ElementId symId = textNote.GetTypeId();
if (symId == ElementId.InvalidElementId)
{
throw new Exception("TextNote does not have valid type id.");
}
PresentationStyleAssignmentCache cache = ExporterCacheManager.PresentationStyleAssignmentCache;
IFCAnyHandle presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
{
TextElementType textElemType = textNote.Symbol;
CreatePresentationStyleAssignmentForTextElementType(exporterIFC, textElemType, cache);
presHnd = cache.Find(symId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(presHnd))
{
throw new Exception("Failed to create presentation style assignment for TextElementType.");
}
}
HashSet <IFCAnyHandle> presHndSet = new HashSet <IFCAnyHandle>();
presHndSet.Add(presHnd);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, textNote))
{
double linScale = exporterIFC.LinearScale;
const double planScale = 100.0; // currently hardwired.
XYZ orig = textNote.Coord;
orig = orig.Multiply(linScale);
XYZ yDir = textNote.UpDirection;
XYZ xDir = textNote.BaseDirection;
XYZ zDir = xDir.CrossProduct(yDir);
double sizeX = textNote.LineWidth * linScale * planScale;
double sizeY = textNote.Height * linScale * planScale;
// When we display text on screen, we "flip" it if the xDir is negative with relation to
// the X-axis. So if it is, we'll flip x and y.
bool flipOrig = false;
if (xDir.X < 0)
{
xDir = xDir.Multiply(-1.0);
yDir = yDir.Multiply(-1.0);
flipOrig = true;
}
// xFactor, yFactor only used if flipOrig.
double xFactor = 0.0, yFactor = 0.0;
string boxAlignment = ConvertTextNoteAlignToBoxAlign(textNote, out xFactor, out yFactor);
// modify the origin to match the alignment. In Revit, the origin is at the top-left (unless flipped,
// then bottom-right).
if (flipOrig)
{
orig = orig.Add(xDir.Multiply(sizeX * xFactor));
orig = orig.Add(yDir.Multiply(sizeY * yFactor));
}
IFCAnyHandle origin = ExporterUtil.CreateAxis(file, orig, zDir, xDir);
IFCAnyHandle extent = IFCInstanceExporter.CreatePlanarExtent(file, sizeX, sizeY);
IFCAnyHandle repItemHnd = IFCInstanceExporter.CreateTextLiteralWithExtent(file, textString, origin, Toolkit.IFCTextPath.Left, extent, boxAlignment);
IFCAnyHandle annoTextOccHnd = IFCInstanceExporter.CreateStyledItem(file, repItemHnd, presHndSet, null);
ElementId catId = textNote.Category != null ? textNote.Category.Id : ElementId.InvalidElementId;
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(repItemHnd);
IFCAnyHandle bodyRepHnd = RepresentationUtil.CreateAnnotationSetRep(exporterIFC, textNote, catId, exporterIFC.Get2DContextHandle(), bodyItems);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRepHnd))
{
throw new Exception("Failed to create shape representation.");
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyRepHnd);
IFCAnyHandle prodShapeHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle annoHnd = IFCInstanceExporter.CreateAnnotation(file, ExporterIFCUtils.CreateGUID(), exporterIFC.GetOwnerHistoryHandle(),
null, null, null, setter.GetPlacement(), prodShapeHnd);
productWrapper.AddAnnotation(annoHnd, setter.GetLevelInfo(), true);
}
tr.Commit();
}
}
/// <summary>
/// Export Curtain Walls and Roofs.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="allSubElements">
/// Collection of elements contained in the host curtain element.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void ExportBase(ExporterIFC exporterIFC, ICollection <ElementId> allSubElements,
Element element, IFCProductWrapper wrapper)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IFCPlacementSetter setter = null;
using (IFCProductWrapper curtainWallSubWrapper = IFCProductWrapper.Create(wrapper, false))
{
try
{
IFCAnyHandle localPlacement = null;
bool canExportCurtainWallAsContainer = CanExportCurtainWallAsContainer(allSubElements, element.Document);
IFCAnyHandle rep = null;
if (!canExportCurtainWallAsContainer)
{
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
{
return;
}
}
else
{
ExportCurtainObjectCommonAsContainer(allSubElements, element, exporterIFC, curtainWallSubWrapper);
// This has to go LAST. Why? Because otherwise we apply the level transform twice -- once in the familyTrf, once here.
// This will be used just to put the CurtainWall on the right level.
setter = IFCPlacementSetter.Create(exporterIFC, element);
localPlacement = setter.GetPlacement();
}
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
{
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = ExporterIFCUtils.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, exporterIFC.GetName());
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemId = NamingUtil.CreateIFCElementId(element);
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement, prodRepHnd, elemId);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, element);
elemHnd = IFCInstanceExporter.CreateRoof(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement,
prodRepHnd, elemId, RoofExporter.GetIFCRoofType(ifcEnumType));
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(elemHnd, setter, null, true);
ExporterIFCUtils.CreateCurtainWallPropertySet(exporterIFC, element, wrapper);
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, wrapper);
ICollection <IFCAnyHandle> relatedElementIds = curtainWallSubWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = ExporterIFCUtils.CreateSubElementGUID(element, (int)IFCCurtainWallSubElements.RelAggregates);
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(file, guid, ownerHistory, null, null, elemHnd, relatedElementIdSet);
}
exporterIFC.RegisterSpaceBoundingElementHandle(elemHnd, element.Id, ElementId.InvalidElementId);
}
}
finally
{
if (setter != null)
{
setter.Dispose();
}
}
}
}
/// <summary>
/// Exports a MEP family instance.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacementToUse = setter.GetPlacement();
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle productRepresentation = RepresentationUtil.CreateBRepProductDefinitionShape(element.Document.Application,
exporterIFC, element, catId, geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return;
}
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.GetElement(typeId) as ElementType;
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(typeId, false);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeGUID = ExporterIFCUtils.CreateGUID(type);
string origTypeName = exporterIFC.GetName();
string typeName = NamingUtil.GetNameOverride(type, origTypeName);
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
string applicableOccurance = NamingUtil.GetObjectTypeOverride(type, typeObjectType);
string typeDescription = NamingUtil.GetDescriptionOverride(type, null);
string typeElemId = NamingUtil.CreateIFCElementId(type);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
IList <IFCAnyHandle> repMapListOpt = new List <IFCAnyHandle>();
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(file, exportType, ifcEnumType, typeGUID, ownerHistory, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMapListOpt, typeElemId, typeName, element, type);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.TypeObjectsCache.Register(typeId, false, currentTypeInfo);
}
}
string instanceGUID = ExporterIFCUtils.CreateGUID(element);
string origInstanceName = exporterIFC.GetName();
string instanceName = NamingUtil.GetNameOverride(element, origInstanceName);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = null;
if (FamilyExporterUtil.IsFurnishingElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFurnishingElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsDistributionFlowElementSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateDistributionFlowElement(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsEnergyConversionDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateEnergyConversionDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowFittingSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowFitting(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowMovingDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowMovingDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowSegmentSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowSegment(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowStorageDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowStorageDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTerminalSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTerminal(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowTreatmentDeviceSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowTreatmentDevice(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
else if (FamilyExporterUtil.IsFlowControllerSubType(exportType))
{
instanceHandle = IFCInstanceExporter.CreateFlowController(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceElemId);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
return;
}
if (roomId != ElementId.InvalidElementId)
{
exporterIFC.RelateSpatialElement(roomId, instanceHandle);
productWrapper.AddElement(instanceHandle, setter, extraParams, false);
}
else
{
productWrapper.AddElement(instanceHandle, setter, extraParams, LevelUtil.AssociateElementToLevel(element));
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, exporterIFC, localPlacementToUse, setter, productWrapper);
if (currentTypeInfo.IsValid())
{
ExporterCacheManager.TypeRelationsCache.Add(currentTypeInfo.Style, instanceHandle);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper);
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
tr.Commit();
}
}
}
}
/// <summary>
/// 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);
}
}
