/// <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 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 a Rebar to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="rebarItem">The rebar to be exported. This might be an element or a sub-element.</param>
/// <param name="rebarElement">The element that contains the rebar to be exported. This may be the same as rebarItem.</param>
/// <param name="itemIndex">If greater than 0, the index of the first rebar in the rebarItem in the rebarElement, used for naming and GUID creation.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
/// <returns>The set of handles created, to add to the ProductWrapper in the calling function.</returns>
private static ISet <DelayedProductWrapper> ExportRebar(ExporterIFC exporterIFC, object rebarItem, Element rebarElement, int itemIndex, ProductWrapper productWrapper)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcReinforcingBar", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
}
IFCFile file = exporterIFC.GetFile();
HashSet <DelayedProductWrapper> createdRebars = new HashSet <DelayedProductWrapper>();
int rebarQuantity = GetRebarQuantity(rebarItem);
if (rebarQuantity == 0)
{
return(null);
}
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, rebarElement))
{
bool cannotExportRebar = false;
IFCAnyHandle rebarHandle = ExportRebarAsProxyElementInView(exporterIFC, rebarElement, productWrapper, out cannotExportRebar);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(rebarHandle) || cannotExportRebar)
{
if (!cannotExportRebar)
{
transaction.Commit();
}
return(null); // Rebar doesn't create a group.
}
IFCAnyHandle prodRep = null;
double totalBarLengthUnscale = GetRebarTotalLength(rebarItem);
double volumeUnscale = GetRebarVolume(rebarItem);
double totalBarLength = UnitUtil.ScaleLength(totalBarLengthUnscale);
if (MathUtil.IsAlmostZero(totalBarLength))
{
return(null);
}
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(rebarElement, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
double diameter = GetBarDiameter(rebarItem);
double radius = diameter / 2.0;
double longitudinalBarNominalDiameter = diameter;
double longitudinalBarCrossSectionArea = UnitUtil.ScaleArea(volumeUnscale / totalBarLengthUnscale);
int numberOfBarPositions = GetNumberOfBarPositions(rebarItem);
string steelGrade = NamingUtil.GetOverrideStringValue(rebarElement, "SteelGrade", null);
// Allow use of IFC2x3 or IFC4 naming.
string predefinedType = NamingUtil.GetOverrideStringValue(rebarElement, "BarRole", null);
if (string.IsNullOrWhiteSpace(predefinedType))
{
predefinedType = NamingUtil.GetOverrideStringValue(rebarElement, "PredefinedType", null);
}
IFCReinforcingBarRole role = GetReinforcingBarRole(predefinedType);
string origRebarName = NamingUtil.GetNameOverride(rebarElement, NamingUtil.GetIFCName(rebarElement));
string rebarDescription = NamingUtil.GetDescriptionOverride(rebarElement, null);
string rebarObjectType = NamingUtil.GetObjectTypeOverride(rebarElement, NamingUtil.CreateIFCObjectName(exporterIFC, rebarElement));
string rebarTag = NamingUtil.GetTagOverride(rebarElement, NamingUtil.CreateIFCElementId(rebarElement));
const int maxBarGUIDS = IFCReinforcingBarSubElements.BarEnd - IFCReinforcingBarSubElements.BarStart + 1;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(rebarElement);
IFCAnyHandle originalPlacement = setter.LocalPlacement;
// Potential issue : totalBarLength has a rounded value but individual lengths (from centerlines) do not have rounded values.
// Also dividing a rounded totalBarLength does not result in barLength rounded by the same round value.
double barLength = totalBarLength / rebarQuantity;
IList <Curve> baseCurves = GetRebarCenterlineCurves(rebarItem, true, false, false);
ElementId barLengthParamId = new ElementId(BuiltInParameter.REBAR_ELEM_LENGTH);
ParameterSet rebarElementParams = rebarElement.Parameters;
for (int ii = 0; ii < numberOfBarPositions; ii++)
{
if (!DoesBarExistAtPosition(rebarItem, ii))
{
continue;
}
Rebar rebar = rebarElement as Rebar;
if ((rebar != null) && (rebar.DistributionType == DistributionType.VaryingLength || rebar.IsRebarFreeForm()))
{
baseCurves = GetRebarCenterlineCurves(rebar, true, false, false, MultiplanarOption.IncludeOnlyPlanarCurves, ii);
DoubleParameterValue barLengthParamVal = rebar.GetParameterValueAtIndex(barLengthParamId, ii) as DoubleParameterValue;
if (barLengthParamVal != null)
{
barLength = barLengthParamVal.Value;
}
}
int indexForNamingAndGUID = (itemIndex > 0) ? ii + itemIndex : ii + 1;
string rebarName = NamingUtil.GetNameOverride(rebarElement, origRebarName + ": " + indexForNamingAndGUID);
Transform barTrf = GetBarPositionTransform(rebarItem, ii);
IList <Curve> curves = new List <Curve>();
double endParam = 0.0;
foreach (Curve baseCurve in baseCurves)
{
if (baseCurve is Arc || baseCurve is Ellipse)
{
if (baseCurve.IsBound)
{
endParam += UnitUtil.ScaleAngle(baseCurve.GetEndParameter(1) - baseCurve.GetEndParameter(0));
}
else
{
endParam += UnitUtil.ScaleAngle(2 * Math.PI);
}
}
else
{
endParam += 1.0;
}
curves.Add(baseCurve.CreateTransformed(barTrf));
}
IFCAnyHandle compositeCurve = GeometryUtil.CreateCompositeCurve(exporterIFC, curves);
IFCAnyHandle sweptDiskSolid = IFCInstanceExporter.CreateSweptDiskSolid(file, compositeCurve, radius, null, 0, endParam);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(sweptDiskSolid);
IFCAnyHandle shapeRep = RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, rebarElement, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle copyLevelPlacement = (ii == 0) ? originalPlacement : ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string rebarGUID = (indexForNamingAndGUID < maxBarGUIDS) ?
GUIDUtil.CreateSubElementGUID(rebarElement, indexForNamingAndGUID + (int)IFCReinforcingBarSubElements.BarStart - 1) :
GUIDUtil.CreateGUID();
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateReinforcingBar(file, rebarGUID, ExporterCacheManager.OwnerHistoryHandle,
rebarName, rebarDescription, rebarObjectType, copyLevelPlacement,
prodRep, rebarTag, steelGrade, longitudinalBarNominalDiameter, longitudinalBarCrossSectionArea,
barLength, role, null);
// We will not add the element ot the productWrapper here, but instead in the function that calls
// ExportRebar. The reason for this is that we don't currently know if the handles such be associated
// to the level or not, depending on whether they will or won't be grouped.
createdRebars.Add(new DelayedProductWrapper(rebarElement, elemHnd, setter.LevelInfo));
CacheSubelementParameterValues(rebarElement, rebarElementParams, ii, elemHnd);
ExporterCacheManager.HandleToElementCache.Register(elemHnd, rebarElement.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, elemHnd, materialId);
}
}
transaction.Commit();
}
return(createdRebars);
}
/// <summary>
/// Exports a CeilingAndFloor element to IFC.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="floor">The floor element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCeilingAndFloorElement(ExporterIFC exporterIFC, CeilingAndFloor floorElement, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
// export parts or not
bool exportParts = PartExporter.CanExportParts(floorElement);
if (exportParts && !PartExporter.CanExportElementInPartExport(floorElement, floorElement.LevelId, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, floorElement, out ifcEnumType);
using (IFCTransaction tr = new IFCTransaction(file))
{
bool canExportAsContainerOrWithExtrusionAnalyzer = (!exportParts && (floorElement is Floor));
if (canExportAsContainerOrWithExtrusionAnalyzer)
{
// Try to export the Floor slab as a container. If that succeeds, we are done.
// If we do export the floor as a container, it will take care of the local placement and transform there, so we need to leave
// this out of the IFCTransformSetter and PlacementSetter scopes below, or else we'll get double transforms.
IFCAnyHandle floorHnd = RoofExporter.ExportRoofOrFloorAsContainer(exporterIFC, ifcEnumType, floorElement, geometryElement, productWrapper);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(floorHnd))
{
tr.Commit();
return;
}
}
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
// The routine ExportExtrudedSlabOpenings is called if exportedAsInternalExtrusion is true, and it requires having a valid level association.
// Disable calling ExportSlabAsExtrusion if we can't handle potential openings.
bool canExportAsInternalExtrusion = placementSetter.LevelInfo != null;
bool exportedAsInternalExtrusion = false;
ElementId catId = CategoryUtil.GetSafeCategoryId(floorElement);
IList <IFCAnyHandle> prodReps = new List <IFCAnyHandle>();
IList <ShapeRepresentationType> repTypes = new List <ShapeRepresentationType>();
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 (canExportAsContainerOrWithExtrusionAnalyzer)
{
Floor floor = floorElement as Floor;
// Next, 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.
//
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
bool completelyClipped;
// floorExtrusionDirection is set to (0, 0, -1) because extrusionAnalyzerFloorPlane is computed from the top face of the floor
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 through the Revit model origin. We'll try the midpoint of the bounding box instead.
BoundingBoxXYZ boundingBox = floorElement.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);
GenerateAdditionalInfo additionalInfo = ExporterCacheManager.ExportOptionsCache.ExportAs4 ? GenerateAdditionalInfo.GenerateFootprint : GenerateAdditionalInfo.None;
HandleAndData floorAndProperties =
ExtrusionExporter.CreateExtrusionWithClippingAndProperties(exporterIFC, floorElement,
catId, solids[0], extrusionAnalyzerFloorPlane, floorExtrusionDirection, null, out completelyClipped,
addInfo: additionalInfo);
if (completelyClipped)
{
return;
}
if (floorAndProperties.Handle != null)
{
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(floorAndProperties.Handle);
// Footprint representation will only be exported in export to IFC4
if (((additionalInfo & GenerateAdditionalInfo.GenerateFootprint) != 0) && (floorAndProperties.FootprintRepHandle != null))
{
representations.Add(floorAndProperties.FootprintRepHandle);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
prodReps.Add(prodRep);
repTypes.Add(ShapeRepresentationType.SweptSolid);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (prodReps.Count == 0 && canExportAsInternalExtrusion)
{
//IList<IFCAnyHandle> prodRepsTmp = new List<IFCAnyHandle>();
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out prodReps,
out extrusionLoops, out loopExtraParams, floorPlane);
for (int ii = 0; ii < prodReps.Count; ii++)
{
// all are extrusions
repTypes.Add(ShapeRepresentationType.SweptSolid);
// Footprint representation will only be exported in export to IFC4
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// Get back the representations, we need to add the Footprint to it
//IList<IFCAnyHandle> representations = IFCAnyHandleUtil.GetRepresentations(prodRepsTmp[ii]);
if (extrusionLoops.Count > ii)
{
if (extrusionLoops[ii].Count > 0)
{
// Get the extrusion footprint using the first Curveloop. Transform needs to be obtained from the returned local placement
Transform lcs = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, localPlacements[ii]);
Plane plane = new Plane(lcs.BasisX, lcs.BasisY, lcs.Origin);
IFCAnyHandle footprintGeomRepItem = GeometryUtil.CreateIFCCurveFromCurveLoop(exporterIFC, extrusionLoops[ii][0], plane, floorPlane.Normal);
IFCAnyHandle contextOfItemsFootprint = exporterIFC.Get3DContextHandle("FootPrint");
ISet <IFCAnyHandle> repItem = new HashSet <IFCAnyHandle>();
repItem.Add(footprintGeomRepItem);
IFCAnyHandle footprintShapeRepresentation = RepresentationUtil.CreateBaseShapeRepresentation(exporterIFC, contextOfItemsFootprint, "FootPrint", "Curve2D", repItem);
//representations.Add(footprintShapeRepresentation);
IList <IFCAnyHandle> reps = new List <IFCAnyHandle>();
reps.Add(footprintShapeRepresentation);
IFCAnyHandleUtil.AddRepresentations(prodReps[ii], reps);
}
}
//IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
//prodReps.Add(prodRep);
}
else
{
//prodReps.Add(prodRepsTmp[ii]);
}
// We do not need the prodRepsTmp anymore, delete the handle:
//prodRepsTmp[ii].Delete();
}
}
if (prodReps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// Brep representation using tesellation after ExportSlabAsExtrusion does not return prodReps
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
prodReps.Add(prodDefHnd);
repTypes.Add(bodyData.ShapeRepresentationType);
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(floorElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = null;
switch (exportType)
{
case IFCExportType.IfcFooting:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCFootingType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCFootingType>(floorElement, ifcEnumType, null);
}
break;
case IFCExportType.IfcCovering:
entityType = IFCValidateEntry.GetValidIFCType <IFCCoveringType>(floorElement, ifcEnumType, "FLOORING");
break;
case IFCExportType.IfcRamp:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCRampType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCRampType>(floorElement, ifcEnumType, null);
}
break;
default:
bool isBaseSlab = false;
AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
if (analyticalModel != null)
{
AnalyzeAs slabFoundationType = analyticalModel.GetAnalyzeAs();
isBaseSlab = (slabFoundationType == AnalyzeAs.SlabOnGrade) || (slabFoundationType == AnalyzeAs.Mat);
}
entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(floorElement, ifcEnumType, isBaseSlab ? "BASESLAB" : "FLOOR");
break;
}
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.GetIFCNamePlusIndex(floorElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(floorElement, NamingUtil.CreateIFCElementId(floorElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = null;
// TODO: replace with CreateGenericBuildingElement.
switch (exportType)
{
case IFCExportType.IfcFooting:
slabHnd = IFCInstanceExporter.CreateFooting(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcCovering:
slabHnd = IFCInstanceExporter.CreateCovering(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcRamp:
slabHnd = IFCInstanceExporter.CreateRamp(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
default:
//if ((canExportAsInternalExtrusion || exportedAsInternalExtrusion) && ExporterCacheManager.ExportOptionsCache.ExportAs4)
//{
// slabHnd = IFCInstanceExporter.CreateSlabStandardCase(file, currentGUID, ownerHistory, ifcName,
// ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
// ifcTag, entityType);
//}
//else
slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(floorElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
// This call to the native function appears to create Brep opening also when appropriate. But the creation of the IFC instances is not
// controllable from the managed code. Therefore in some cases BRep geometry for Opening will still be exported even in the Reference View
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
//// For now we have to be content without IfcOpeningStandardCase from the openings created by this native call because it is too much to
//// "reverse engineer" the IFChandle
//foreach (IFCAnyHandle slabHandle in slabHnds)
//{
// updateOpeningProfileRep(exporterIFC, slabHandle);
//}
}
if (!exportParts)
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports a roof or floor as a container of multiple roof slabs. Returns the handle, if successful.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="element">The roof or floor element.</param>
/// <param name="geometry">The geometry of the element.</param>
/// <param name="productWrapper">The product wrapper.</param>
/// <returns>The roof handle.</returns>
/// <remarks>For floors, if there is only one component, return null, as we do not want to create a container.</remarks>
public static IFCAnyHandle ExportRoofOrFloorAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Element element, GeometryElement geometry, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
// We support ExtrusionRoofs, FootPrintRoofs, and Floors only.
bool elementIsRoof = (element is ExtrusionRoof) || (element is FootPrintRoof);
bool elementIsFloor = (element is Floor);
if (!elementIsRoof && !elementIsFloor)
{
return(null);
}
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcRoof;
if (elementIsFloor)
{
elementClassTypeEnum = Common.Enums.IFCEntityType.IfcSlab;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
IList <HostObjectSubcomponentInfo> hostObjectSubcomponents = null;
try
{
hostObjectSubcomponents = ExporterIFCUtils.ComputeSubcomponents(element as HostObject);
}
catch
{
return(null);
}
if (hostObjectSubcomponents == null)
{
return(null);
}
int numSubcomponents = hostObjectSubcomponents.Count;
if (numSubcomponents == 0 || (elementIsFloor && numSubcomponents == 1))
{
return(null);
}
try
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
extrusionCreationData.SetLocalPlacement(localPlacement);
extrusionCreationData.ReuseLocalPlacement = true;
using (TransformSetter trfSetter = TransformSetter.Create())
{
IList <GeometryObject> geometryList = new List <GeometryObject>();
geometryList.Add(geometry);
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, extrusionCreationData);
IFCAnyHandle prodRepHnd = null;
string elementGUID = GUIDUtil.CreateGUID(element);
string elementName = NamingUtil.GetIFCName(element);
string elementDescription = NamingUtil.GetDescriptionOverride(element, null);
string elementObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string elementId = NamingUtil.CreateIFCElementId(element);
string hostObjectType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle hostObjectHandle = null;
if (elementIsRoof)
{
hostObjectHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementId, hostObjectType);
}
else
{
hostObjectHandle = IFCInstanceExporter.CreateSlab(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementId, hostObjectType);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjectHandle))
{
return(null);
}
IList <IFCAnyHandle> elementHandles = new List <IFCAnyHandle>();
elementHandles.Add(hostObjectHandle);
// If element is floor, then the profile curve loop of hostObjectSubComponent is computed from the top face of the floor
// else if element is roof, then the profile curve loop is taken from the bottom face of the roof instead
XYZ extrusionDir = elementIsFloor ? new XYZ(0, 0, -1) : new XYZ(0, 0, 1);
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IList <IFCAnyHandle> slabHandles = new List <IFCAnyHandle>();
IList <CurveLoop> hostObjectOpeningLoops = new List <CurveLoop>();
double maximumScaledDepth = 0.0;
using (IFCExtrusionCreationData slabExtrusionCreationData = new IFCExtrusionCreationData())
{
slabExtrusionCreationData.SetLocalPlacement(extrusionCreationData.GetLocalPlacement());
slabExtrusionCreationData.ReuseLocalPlacement = false;
slabExtrusionCreationData.ForceOffset = true;
int loopNum = 0;
int subElementStart = elementIsRoof ? (int)IFCRoofSubElements.RoofSlabStart : (int)IFCSlabSubElements.SubSlabStart;
string subSlabType = elementIsRoof ? "ROOF" : hostObjectType;
foreach (HostObjectSubcomponentInfo hostObjectSubcomponent in hostObjectSubcomponents)
{
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, slabExtrusionCreationData);
Plane plane = hostObjectSubcomponent.GetPlane();
Transform lcs = GeometryUtil.CreateTransformFromPlane(plane);
IList <CurveLoop> curveLoops = new List <CurveLoop>();
CurveLoop slabCurveLoop = hostObjectSubcomponent.GetCurveLoop();
curveLoops.Add(slabCurveLoop);
double slope = Math.Abs(plane.Normal.Z);
double scaledDepth = UnitUtil.ScaleLength(hostObjectSubcomponent.Depth);
double scaledExtrusionDepth = scaledDepth * slope;
IFCAnyHandle shapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, lcs, extrusionDir, scaledExtrusionDepth, false);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
{
return(null);
}
ElementId matId = HostObjectExporter.GetFirstLayerMaterialId(element as HostObject);
BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, element.Document, shapeRep, matId);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(shapeRep);
shapeRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, catId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
IFCAnyHandle repHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
// Allow support for up to 256 named IfcSlab components, as defined in IFCSubElementEnums.cs.
string slabGUID = (loopNum < 256) ? GUIDUtil.CreateSubElementGUID(element, subElementStart + loopNum) : GUIDUtil.CreateGUID();
IFCAnyHandle slabPlacement = ExporterUtil.CreateLocalPlacement(file, slabExtrusionCreationData.GetLocalPlacement(), null);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, elementName,
elementDescription, elementObjectType, slabPlacement, repHnd, elementId, subSlabType);
//slab quantities
slabExtrusionCreationData.ScaledLength = scaledExtrusionDepth;
slabExtrusionCreationData.ScaledArea = UnitUtil.ScaleArea(UnitUtil.ScaleArea(hostObjectSubcomponent.AreaOfCurveLoop));
slabExtrusionCreationData.ScaledOuterPerimeter = UnitUtil.ScaleLength(curveLoops[0].GetExactLength());
slabExtrusionCreationData.Slope = UnitUtil.ScaleAngle(MathUtil.SafeAcos(Math.Abs(slope)));
productWrapper.AddElement(null, slabHnd, setter, slabExtrusionCreationData, false);
elementHandles.Add(slabHnd);
slabHandles.Add(slabHnd);
hostObjectOpeningLoops.Add(slabCurveLoop);
maximumScaledDepth = Math.Max(maximumScaledDepth, scaledDepth);
loopNum++;
}
}
productWrapper.AddElement(element, hostObjectHandle, setter, extrusionCreationData, true);
ExporterUtil.RelateObjects(exporterIFC, null, hostObjectHandle, slabHandles);
OpeningUtil.AddOpeningsToElement(exporterIFC, elementHandles, hostObjectOpeningLoops, element, null, maximumScaledDepth,
null, setter, localPlacement, productWrapper);
transaction.Commit();
return(hostObjectHandle);
}
}
}
finally
{
exporterIFC.ClearFaceWithElementHandleMap();
}
}
}
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(null);
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(null);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, null);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <summary>
/// Exports an element as 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 ProductWrapper.
/// </param>
public static void ExportRailing(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, ProductWrapper 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 (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
StairRampContainerInfo stairRampInfo = null;
ElementId hostId = GetStairOrRampHostId(exporterIFC, element as Railing);
if (hostId != ElementId.InvalidElementId)
{
stairRampInfo = ExporterCacheManager.StairRampContainerInfoCache.GetStairRampContainerInfo(hostId);
IFCAnyHandle stairRampLocalPlacement = stairRampInfo.LocalPlacements[0];
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(stairRampLocalPlacement, localPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle railingLocalPlacement = ExporterUtil.CreateLocalPlacement(file, stairRampLocalPlacement,
inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
localPlacement = railingLocalPlacement;
}
ecData.SetLocalPlacement(localPlacement);
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geomElem);
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), 0);
SolidMeshGeometryInfo subElementSolidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(subElementGeom);
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.TessellationLevel = BodyExporter.GetTessellationLevel();
//bodyExporterOptions.UseGroupsIfPossible = true;
//bodyExporterOptions.UseMappedGeometriesIfPossible = true;
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId, solids, meshes, bodyExporterOptions, ecData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geomElem);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId, 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);
IList <GeometryObject> geomObjects = new List <GeometryObject>();
foreach (Solid solid in solids)
{
geomObjects.Add(solid);
}
foreach (Mesh mesh in meshes)
{
geomObjects.Add(mesh);
}
Transform boundingBoxTrf = (bodyData.OffsetTransform != null) ? bodyData.OffsetTransform.Inverse : Transform.Identity;
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geomObjects, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string railingType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle railing = IFCInstanceExporter.CreateRailing(file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(),
prodRep, instanceTag, railingType);
bool associateToLevel = (hostId == ElementId.InvalidElementId);
productWrapper.AddElement(element, railing, setter, ecData, associateToLevel);
OpeningUtil.CreateOpeningsIfNecessary(railing, element, ecData, bodyData.OffsetTransform,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
CategoryUtil.CreateMaterialAssociations(exporterIFC, railing, bodyData.MaterialIds);
// Create multi-story duplicates of this railing.
if (stairRampInfo != null)
{
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(element, railingHndCopy, (IFCLevelInfo)null, ecData, false);
CategoryUtil.CreateMaterialAssociations(exporterIFC, railingHndCopy, bodyData.MaterialIds);
}
}
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(hostId, stairRampInfo);
}
}
transaction.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>
/// Export the individual part (IfcBuildingElementPart).
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="partElement">The part element to export.</param>
/// <param name="geometryElement">The geometry of part.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
public static void ExportPart(ExporterIFC exporterIFC, Element partElement, ProductWrapper productWrapper,
PlacementSetter placementSetter, IFCAnyHandle originalPlacement, IFCRange range, IFCExtrusionAxes ifcExtrusionAxes,
Element hostElement, ElementId overrideLevelId, bool asBuildingElement)
{
if (!ElementFilteringUtil.IsElementVisible(partElement))
{
return;
}
Part part = partElement as Part;
if (part == null)
{
return;
}
PlacementSetter standalonePlacementSetter = null;
bool standaloneExport = hostElement == null && !asBuildingElement;
ElementId partExportLevel = null;
if (standaloneExport || asBuildingElement)
{
partExportLevel = partElement.LevelId;
}
else
{
if (part.OriginalCategoryId != hostElement.Category.Id)
{
return;
}
partExportLevel = hostElement.LevelId;
}
if (overrideLevelId != null)
{
partExportLevel = overrideLevelId;
}
if (ExporterCacheManager.PartExportedCache.HasExported(partElement.Id, partExportLevel))
{
return;
}
Options options = GeometryUtil.GetIFCExportGeometryOptions();
View ownerView = partElement.Document.GetElement(partElement.OwnerViewId) as View;
if (ownerView != null)
{
options.View = ownerView;
}
GeometryElement geometryElement = partElement.get_Geometry(options);
if (geometryElement == null)
{
return;
}
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
IFCAnyHandle partPlacement = null;
if (standaloneExport || asBuildingElement)
{
Transform orientationTrf = Transform.Identity;
standalonePlacementSetter = PlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevel);
partPlacement = standalonePlacementSetter.LocalPlacement;
}
else
{
partPlacement = ExporterUtil.CreateLocalPlacement(file, originalPlacement, null);
}
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
SolidMeshGeometryInfo solidMeshInfo;
if (validRange)
{
solidMeshInfo = GeometryUtil.GetSplitClippedSolidMeshGeometry(geometryElement, range);
if (solidMeshInfo.GetSolids().Count == 0 && solidMeshInfo.GetMeshes().Count == 0)
{
return;
}
}
else
{
solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
}
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(partPlacement);
extrusionCreationData.ReuseLocalPlacement = false;
extrusionCreationData.PossibleExtrusionAxes = ifcExtrusionAxes;
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(partElement);
ElementId hostCatId = CategoryUtil.GetSafeCategoryId(hostElement);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, solids, meshes,
bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, partElement, catId, ElementId.InvalidElementId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string partGUID = GUIDUtil.CreateGUID(partElement);
string partName = NamingUtil.GetNameOverride(partElement, NamingUtil.GetIFCName(partElement));
string partDescription = NamingUtil.GetDescriptionOverride(partElement, null);
string partObjectType = NamingUtil.GetObjectTypeOverride(partElement, NamingUtil.CreateIFCObjectName(exporterIFC, partElement));
string partTag = NamingUtil.GetTagOverride(partElement, NamingUtil.CreateIFCElementId(partElement));
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag);
}
else
{
string ifcEnumType = null;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
string defaultValue = null;
// This replicates old functionality before IFC4 addition, where the default for slab was "FLOOR".
// Really the export layer table should be fixed for this case.
if (string.IsNullOrWhiteSpace(ifcEnumType) && hostCatId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOOR";
}
ifcEnumType = IFCValidateEntry.GetValidIFCType(hostElement, ifcEnumType, defaultValue);
switch (exportType)
{
case IFCExportType.IfcColumnType:
ifcPart = IFCInstanceExporter.CreateColumn(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcCovering:
ifcPart = IFCInstanceExporter.CreateCovering(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcFooting:
ifcPart = IFCInstanceExporter.CreateFooting(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcPile:
ifcPart = IFCInstanceExporter.CreatePile(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType, null);
break;
case IFCExportType.IfcRoof:
ifcPart = IFCInstanceExporter.CreateRoof(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcSlab:
ifcPart = IFCInstanceExporter.CreateSlab(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
case IFCExportType.IfcWall:
ifcPart = IFCInstanceExporter.CreateWall(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partTag, ifcEnumType);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partTag, null);
break;
}
}
bool containedInLevel = (standaloneExport || asBuildingElement);
PlacementSetter whichPlacementSetter = containedInLevel ? standalonePlacementSetter : placementSetter;
productWrapper.AddElement(partElement, ifcPart, whichPlacementSetter, extrusionCreationData, containedInLevel);
OpeningUtil.CreateOpeningsIfNecessary(ifcPart, partElement, extrusionCreationData, bodyData.OffsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), whichPlacementSetter, productWrapper);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevel, standaloneExport || asBuildingElement ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociations(exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
/// <summary>
/// Exports an element as a covering of type insulation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(false);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle ductLining = IFCInstanceExporter.CreateCovering(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, "Wrapping");
ExporterCacheManager.ElementToHandleCache.Register(element.Id, ductLining);
productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports 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 a beam to IFC beam if it has an axis representation and only one Solid as its geometry, ideally as an extrusion, potentially with clippings and openings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <param name="dontExport">An output value that says that the element shouldn't be exported at all.</param>
/// <returns>The created handle.</returns>
/// <remarks>In the original implementation, the ExportBeam function would export each beam as its own individual geometry (that is, not use representation maps).
/// For non-standard beams, this could result in massive IFC files. Now, we use the ExportBeamAsStandardElement function and limit its scope, and instead
/// resort to the standard FamilyInstanceExporter.ExportFamilyInstanceAsMappedItem for more complicated objects categorized as beams. This has the following pros and cons:
/// Pro: possiblity for massively reduced file sizes for files containing repeated complex beam families
/// Con: some beams that may have had an "Axis" representation before will no longer have them, although this possibility is minimized.
/// Con: some beams that have 1 Solid and an axis, but that Solid will be heavily faceted, won't be helped by this improvement.
/// It is intended that we phase out this routine entirely and instead teach ExportFamilyInstanceAsMappedItem how to sometimes export the Axis representation for beams.</remarks>
public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
Element element, GeometryElement geometryElement, ProductWrapper productWrapper, out bool dontExport)
{
dontExport = true;
IList <GeometryObject> geomObjects = BeamGeometryToExport(exporterIFC, element, geometryElement, out dontExport);
if (dontExport)
{
return(null);
}
IFCAnyHandle beam = null;
IFCFile file = exporterIFC.GetFile();
MaterialAndProfile materialAndProfile = null;
IFCAnyHandle materialProfileSet = null;
using (IFCTransaction transaction = new IFCTransaction(file))
{
BeamAxisInfo axisInfo = GetBeamAxisTransform(element);
bool canExportAxis = (axisInfo != null);
Curve curve = canExportAxis ? axisInfo.Axis : null;
XYZ beamDirection = canExportAxis ? axisInfo.AxisDirection : null;
Transform orientTrf = canExportAxis ? axisInfo.LCSAsTransform : null;
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, orientTrf))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(localPlacement);
if (canExportAxis && (orientTrf.BasisX != null))
{
extrusionCreationData.CustomAxis = beamDirection;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
}
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
// There may be an offset to make the local coordinate system
// be near the origin. This offset will be used to move the axis to the new LCS.
Transform offsetTransform = null;
// The list of materials in the solids or meshes.
ICollection <ElementId> materialIds = null;
// The representation handle generated from one of the methods below.
BeamBodyAsExtrusionInfo extrusionInfo = CreateBeamGeometryAsExtrusion(exporterIFC, element, catId, geomObjects, axisInfo);
if (extrusionInfo != null && extrusionInfo.DontExport)
{
dontExport = true;
return(null);
}
IFCAnyHandle repHnd = (extrusionInfo != null) ? extrusionInfo.RepresentationHandle : null;
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
materialIds = extrusionInfo.Materials;
extrusionCreationData.Slope = extrusionInfo.Slope;
}
else
{
// Here is where we limit the scope of how complex a case we will still try to export as a standard element.
// This is explicitly added so that many curved beams that can be represented by a reasonable facetation because of the
// SweptSolidExporter can still have an Axis representation.
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyExporterOptions.CollectMaterialAndProfile = true;
if (geomObjects != null && geomObjects.Count == 1 && geomObjects[0] is Solid)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
geomObjects[0], bodyExporterOptions, extrusionCreationData);
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
if (!bodyData.OffsetTransform.IsIdentity)
{
offsetTransform = bodyData.OffsetTransform;
}
materialAndProfile = bodyData.materialAndProfile;
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
IFCAnyHandle axisRep = CreateBeamAxis(exporterIFC, element, catId, axisInfo, offsetTransform);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(axisRep))
{
representations.Add(axisRep);
}
representations.Add(repHnd);
Transform boundingBoxTrf = (offsetTransform == null) ? Transform.Identity : offsetTransform.Inverse;
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string preDefinedType = "BEAM"; // Default predefined type for Beam
preDefinedType = IFCValidateEntry.GetValidIFCType(element, preDefinedType);
beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceTag, preDefinedType);
IFCAnyHandle mpSetUsage;
if (materialProfileSet != null)
{
mpSetUsage = IFCInstanceExporter.CreateMaterialProfileSetUsage(file, materialProfileSet, null, null);
}
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
ExportBeamType(exporterIFC, productWrapper, beam, element, preDefinedType);
OpeningUtil.CreateOpeningsIfNecessary(beam, element, extrusionCreationData, offsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
typeInfo.ScaledDepth = extrusionCreationData.ScaledLength;
typeInfo.ScaledArea = extrusionCreationData.ScaledArea;
typeInfo.ScaledInnerPerimeter = extrusionCreationData.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extrusionCreationData.ScaledOuterPerimeter;
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, beam, element, typeInfo, null);
if (materialIds.Count != 0)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, beam, materialIds);
}
// Register the beam's IFC handle for later use by truss and beam system export.
ExporterCacheManager.ElementToHandleCache.Register(element.Id, beam);
}
}
transaction.Commit();
return(beam);
}
}
/// <summary>
/// Exports a gutter element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, element, null, null, ExporterUtil.GetBaseLevelIdForElement(element)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.GetPlacement());
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions();
IFCAnyHandle bodyRep = BodyExporter.ExportBody(exporterIFC, element, categoryId, ElementId.InvalidElementId,
geometryElement, bodyExporterOptions, ecData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRep);
List <IFCAnyHandle> repMapList = new List <IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
string elementTypeName = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, GUIDUtil.CreateGUID(element), exporterIFC.GetOwnerHistoryHandle(),
elementTypeName, null, null, null, repMapList, NamingUtil.CreateIFCElementId(element), elementTypeName, IFCPipeSegmentType.Gutter);
List <IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(mappedItem);
IFCAnyHandle bodyMappedItemRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyMappedItemRep))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyMappedItemRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
shapeReps.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
if (roomId == ElementId.InvalidElementId)
{
localPlacementToUse = ecData.GetLocalPlacement();
}
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, elementTypeName);
string tag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(file, GUIDUtil.CreateGUID(element),
exporterIFC.GetOwnerHistoryHandle(), name, description, objectType, localPlacementToUse, prodRep,
tag);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.GetLevelInfo(), ecData, !containedInSpace);
if (containedInSpace)
{
exporterIFC.RelateSpatialElement(roomId, elemHnd);
}
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports mullion.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="mullion">
/// The mullion object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <param name="setter">
/// The PlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, PlacementSetter setter, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (PlacementSetter mullionSetter = PlacementSetter.Create(exporterIFC, mullion))
{
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
IFCAnyHandle mullionPlacement = mullionSetter.LocalPlacement;
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(localPlacement, mullionPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle mullionLocalPlacement = ExporterUtil.CreateLocalPlacement(file, localPlacement,
inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
extraParams.SetLocalPlacement(mullionLocalPlacement);
Transform extrusionLCS = null;
// Add a custom direction for trying to create an extrusion based on the base curve of the mullion, if it is a line and not an arc.
Curve baseCurve = mullion.LocationCurve;
if ((baseCurve != null) && (baseCurve is Line))
{
// We won't use curveBounds and origin yet; just need the axis for now.
IFCRange curveBounds;
XYZ origin, mullionDirection;
GeometryUtil.GetAxisAndRangeFromCurve(baseCurve, out curveBounds, out mullionDirection, out origin);
// approx 1.0/sqrt(2.0)
XYZ planeY = (Math.Abs(mullionDirection.Z) < 0.707) ? XYZ.BasisZ.CrossProduct(mullionDirection) : XYZ.BasisX.CrossProduct(mullionDirection);
planeY.Normalize();
XYZ projDir = mullionDirection.CrossProduct(planeY);
extrusionLCS = Transform.Identity;
extrusionLCS.BasisX = mullionDirection; extrusionLCS.BasisY = planeY; extrusionLCS.BasisZ = projDir; extrusionLCS.Origin = origin;
}
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyExporterOptions.ExtrusionLocalCoordinateSystem = extrusionLCS;
IFCAnyHandle repHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = GUIDUtil.CreateGUID(mullion);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string name = NamingUtil.GetNameOverride(mullion, elemObjectType);
string description = NamingUtil.GetDescriptionOverride(mullion, null);
string objectType = NamingUtil.GetObjectTypeOverride(mullion, elemObjectType);
string elemTag = NamingUtil.GetTagOverride(mullion, NamingUtil.CreateIFCElementId(mullion));
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, name, description, objectType,
mullionLocalPlacement, repHnd, elemTag, "MULLION");
ExporterCacheManager.HandleToElementCache.Register(mullionHnd, mullion.Id);
productWrapper.AddElement(mullion, mullionHnd, mullionSetter, extraParams, false);
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, mullion);
CategoryUtil.CreateMaterialAssociation(exporterIFC, mullionHnd, matId);
}
}
}
/// <summary>
/// Exports an element to IfcPile.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="ifcEnumType">The string value represents the IFC type.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportPile(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
string ifcEnumType, ProductWrapper productWrapper)
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
IFCAnyHandle prodRep = null;
ElementId matId = ElementId.InvalidElementId;
if (!exportParts)
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string pileType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle pile = IFCInstanceExporter.CreatePile(file, instanceGUID, ExporterCacheManager.OwnerHistoryHandle,
instanceName, instanceDescription, instanceObjectType, ecData.GetLocalPlacement(), prodRep, instanceTag, pileType, null);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, pile, productWrapper, setter, setter.LocalPlacement, null);
}
else
{
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, pile, matId);
}
}
productWrapper.AddElement(element, pile, setter, ecData, true);
OpeningUtil.CreateOpeningsIfNecessary(pile, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
tr.Commit();
}
}
/// <summary>
/// Exports a Rebar to IFC ReinforcingBar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The list of IfcReinforcingBar handles created.</returns>
public static ISet <IFCAnyHandle> ExportRebar(ExporterIFC exporterIFC, Element element, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
HashSet <IFCAnyHandle> createdRebars = new HashSet <IFCAnyHandle>();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
if (element is Rebar)
{
GeometryElement rebarGeometry = ExporterIFCUtils.GetRebarGeometry(element as Rebar, ExporterCacheManager.ExportOptionsCache.FilterViewForExport);
// 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.IfcBuildingElementProxy ||
exportType == IFCExportType.IfcBuildingElementProxyType)
{
if (rebarGeometry != null)
{
ProxyElementExporter.ExportBuildingElementProxy(exporterIFC, element, rebarGeometry, productWrapper);
transaction.Commit();
}
return(null);
}
}
IFCAnyHandle prodRep = null;
double totalBarLengthUnscale = GetRebarTotalLength(element);
double volumeUnscale = GetRebarVolume(element);
double totalBarLength = UnitUtil.ScaleLength(totalBarLengthUnscale);
if (MathUtil.IsAlmostZero(totalBarLength))
{
return(null);
}
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(element, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
Document doc = element.Document;
ElementId typeId = element.GetTypeId();
RebarBarType elementType = doc.GetElement(element.GetTypeId()) as RebarBarType;
double diameter = UnitUtil.ScaleLength(elementType == null ? 1.0 / 12.0 : elementType.BarDiameter);
double radius = diameter / 2.0;
double longitudinalBarNominalDiameter = diameter;
double longitudinalBarCrossSectionArea = UnitUtil.ScaleArea(volumeUnscale / totalBarLengthUnscale);
double barLength = totalBarLength / GetRebarQuantity(element);
IList <Curve> baseCurves = GetRebarCenterlineCurves(element, true, false, false);
int numberOfBarPositions = GetNumberOfBarPositions(element);
string steelGrade = NamingUtil.GetOverrideStringValue(element, "SteelGrade", null);
// Allow use of IFC2x3 or IFC4 naming.
string predefinedType = NamingUtil.GetOverrideStringValue(element, "BarRole", null);
if (string.IsNullOrWhiteSpace(predefinedType))
{
predefinedType = NamingUtil.GetOverrideStringValue(element, "PredefinedType", null);
}
IFCReinforcingBarRole role = GetReinforcingBarRole(predefinedType);
string origRebarName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string rebarDescription = NamingUtil.GetDescriptionOverride(element, null);
string rebarObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string rebarTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
const int maxBarGUIDS = IFCReinforcingBarSubElements.BarEnd - IFCReinforcingBarSubElements.BarStart + 1;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle originalPlacement = setter.LocalPlacement;
for (int i = 0; i < numberOfBarPositions; i++)
{
if (!DoesBarExistAtPosition(element, i))
{
continue;
}
string rebarName = NamingUtil.GetNameOverride(element, origRebarName + ": " + i);
Transform barTrf = GetBarPositionTransform(element, i);
IList <Curve> curves = new List <Curve>();
double endParam = 0.0;
foreach (Curve baseCurve in baseCurves)
{
if (baseCurve is Arc || baseCurve is Ellipse)
{
if (baseCurve.IsBound)
{
endParam += UnitUtil.ScaleAngle(baseCurve.GetEndParameter(1) - baseCurve.GetEndParameter(0));
}
else
{
endParam += UnitUtil.ScaleAngle(2 * Math.PI);
}
}
else
{
endParam += 1.0;
}
curves.Add(baseCurve.CreateTransformed(barTrf));
}
IFCAnyHandle compositeCurve = GeometryUtil.CreateCompositeCurve(exporterIFC, curves);
IFCAnyHandle sweptDiskSolid = IFCInstanceExporter.CreateSweptDiskSolid(file, compositeCurve, radius, null, 0, endParam);
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(sweptDiskSolid);
IFCAnyHandle shapeRep = RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, element, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null);
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle copyLevelPlacement = (i == 0) ? originalPlacement : ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string rebarGUID = (i < maxBarGUIDS) ?
GUIDUtil.CreateSubElementGUID(element, i + (int)IFCReinforcingBarSubElements.BarStart) :
GUIDUtil.CreateGUID();
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateReinforcingBar(file, rebarGUID, exporterIFC.GetOwnerHistoryHandle(),
rebarName, rebarDescription, rebarObjectType, copyLevelPlacement,
prodRep, rebarTag, steelGrade, longitudinalBarNominalDiameter, longitudinalBarCrossSectionArea,
barLength, role, null);
createdRebars.Add(elemHnd);
productWrapper.AddElement(element, elemHnd, setter.LevelInfo, null, true);
ExporterCacheManager.HandleToElementCache.Register(elemHnd, element.Id);
CategoryUtil.CreateMaterialAssociation(exporterIFC, elemHnd, materialId);
}
}
transaction.Commit();
}
return(createdRebars);
}
/// <summary>
/// Exports a beam to IFC beam.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportBeam(ExporterIFC exporterIFC,
Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
LocationCurve locCurve = element.Location as LocationCurve;
Transform orientTrf = Transform.Identity;
bool canExportAxis = (locCurve != null);
IFCAnyHandle axisRep = null;
XYZ beamDirection = null;
XYZ projDir = null;
Curve curve = null;
Plane plane = null;
if (canExportAxis)
{
curve = locCurve.Curve;
if (curve is Line)
{
Line line = curve as Line;
XYZ planeY, planeOrig;
planeOrig = line.GetEndPoint(0);
beamDirection = line.Direction;
if (Math.Abs(beamDirection.Z) < 0.707) // approx 1.0/sqrt(2.0)
{
planeY = XYZ.BasisZ.CrossProduct(beamDirection);
}
else
{
planeY = XYZ.BasisX.CrossProduct(beamDirection);
}
planeY = planeY.Normalize();
projDir = beamDirection.CrossProduct(planeY);
plane = new Plane(beamDirection, planeY, planeOrig);
orientTrf.BasisX = beamDirection; orientTrf.BasisY = planeY; orientTrf.BasisZ = projDir; orientTrf.Origin = planeOrig;
}
else if (curve is Arc)
{
XYZ yDir, center;
Arc arc = curve as Arc;
beamDirection = arc.XDirection; yDir = arc.YDirection; projDir = arc.Normal; center = arc.Center;
plane = new Plane(beamDirection, yDir, center);
orientTrf.BasisX = beamDirection; orientTrf.BasisY = yDir; orientTrf.BasisZ = projDir; orientTrf.Origin = center;
}
else
{
canExportAxis = false;
}
}
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, canExportAxis ? orientTrf : null))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
extrusionCreationData.SetLocalPlacement(localPlacement);
if (canExportAxis && (orientTrf.BasisX != null))
{
extrusionCreationData.CustomAxis = beamDirection;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
else
{
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryXY;
}
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
// The representation handle generated from one of the methods below.
IFCAnyHandle repHnd = null;
// The list of materials in the solids or meshes.
ICollection <ElementId> materialIds = new HashSet <ElementId>();
// There may be an offset to make the local coordinate system
// be near the origin. This offset will be used to move the axis to the new LCS.
Transform offsetTransform = null;
// If we have a beam with a Linear location line that only has one solid geometry,
// we will try to use the ExtrusionAnalyzer to generate an extrusion with 0 or more clippings.
// This code is currently limited in that it will not process beams with openings, so we
// use other methods below if this one fails.
if (solids.Count == 1 && meshes.Count == 0 && (canExportAxis && (curve is Line)))
{
bool completelyClipped;
beamDirection = orientTrf.BasisX;
Plane beamExtrusionPlane = new Plane(orientTrf.BasisY, orientTrf.BasisZ, orientTrf.Origin);
repHnd = ExtrusionExporter.CreateExtrusionWithClipping(exporterIFC, element,
catId, solids[0], beamExtrusionPlane, beamDirection, null, out completelyClipped);
if (completelyClipped)
{
return;
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
// This is used by the BeamSlopeCalculator. This should probably be generated automatically by
// CreateExtrusionWithClipping.
IFCExtrusionBasis bestAxis = (Math.Abs(beamDirection[0]) > Math.Abs(beamDirection[1])) ?
IFCExtrusionBasis.BasisX : IFCExtrusionBasis.BasisY;
extrusionCreationData.Slope = GeometryUtil.GetSimpleExtrusionSlope(beamDirection, bestAxis);
ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solids[0], exporterIFC, element);
if (materialId != ElementId.InvalidElementId)
{
materialIds.Add(materialId);
}
}
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
solids, meshes, bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId, ElementId.InvalidElementId,
geomlist, bodyExporterOptions, extrusionCreationData);
}
repHnd = bodyData.RepresentationHnd;
materialIds = bodyData.MaterialIds;
offsetTransform = bodyData.OffsetTransform;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
if (canExportAxis)
{
XYZ curveOffset = new XYZ(0, 0, 0);
if (offsetTransform != null)
{
curveOffset = -UnitUtil.UnscaleLength(offsetTransform.Origin);
}
else
{
// Note that we do not have to have any scaling adjustment here, since the curve origin is in the
// same internal coordinate system as the curve.
curveOffset = -plane.Origin;
}
Plane offsetPlane = new Plane(plane.XVec, plane.YVec, XYZ.Zero);
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, offsetPlane, projDir, false);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, curve, curveOffset, true);
IList <IFCAnyHandle> axis_items = info.GetCurves();
if (axis_items.Count > 0)
{
string identifierOpt = "Axis"; // this is by IFC2x2 convention, not temporary
string representationTypeOpt = "Curve2D"; // this is by IFC2x2 convention, not temporary
axisRep = RepresentationUtil.CreateShapeRepresentation(exporterIFC, element, catId, exporterIFC.Get3DContextHandle(identifierOpt),
identifierOpt, representationTypeOpt, axis_items);
representations.Add(axisRep);
}
}
representations.Add(repHnd);
Transform boundingBoxTrf = (offsetTransform == null) ? Transform.Identity : offsetTransform.Inverse;
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, boundingBoxTrf);
if (boundingBoxRep != null)
{
representations.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, NamingUtil.CreateIFCObjectName(exporterIFC, element));
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
string preDefinedType = "BEAM"; // Default predefined type for Beam
preDefinedType = IFCValidateEntry.GetValidIFCType(element, preDefinedType);
IFCAnyHandle beam = IFCInstanceExporter.CreateBeam(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, instanceTag, preDefinedType);
productWrapper.AddElement(element, beam, setter, extrusionCreationData, true);
OpeningUtil.CreateOpeningsIfNecessary(beam, element, extrusionCreationData, offsetTransform, exporterIFC,
extrusionCreationData.GetLocalPlacement(), setter, productWrapper);
FamilyTypeInfo typeInfo = new FamilyTypeInfo();
typeInfo.ScaledDepth = extrusionCreationData.ScaledLength;
typeInfo.ScaledArea = extrusionCreationData.ScaledArea;
typeInfo.ScaledInnerPerimeter = extrusionCreationData.ScaledInnerPerimeter;
typeInfo.ScaledOuterPerimeter = extrusionCreationData.ScaledOuterPerimeter;
PropertyUtil.CreateBeamColumnBaseQuantities(exporterIFC, beam, element, typeInfo, null);
if (materialIds.Count != 0)
{
CategoryUtil.CreateMaterialAssociations(exporterIFC, beam, materialIds);
}
// Register the beam's IFC handle for later use by truss and beam system export.
ExporterCacheManager.ElementToHandleCache.Register(element.Id, beam);
}
}
transaction.Commit();
}
}
private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element, IFCFile file, IFCExportType exportType, string ifcEnumType, IFCExtrusionCreationData extraParams,
PlacementSetter setter, IFCAnyHandle localPlacementToUse, IFCAnyHandle productRepresentation, ProductWrapper productWrapper)
{
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
ElementId typeId = element.GetTypeId();
ElementType type = element.Document.GetElement(typeId) as ElementType;
IFCAnyHandle styleHandle = null;
if (type != null)
{
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(typeId, false, exportType);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeGUID = GUIDUtil.CreateGUID(type);
string typeName = NamingUtil.GetIFCName(type);
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>();
styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType, typeGUID, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMapListOpt, typeElemId, typeName, element, type);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.TypeObjectsCache.Register(typeId, false, exportType, currentTypeInfo);
}
}
else
{
styleHandle = currentTypeInfo.Style;
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetIFCName(element);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, objectType);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceElemId = NamingUtil.CreateIFCElementId(element);
string instanceTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
bool roomRelated = !FamilyExporterUtil.IsDistributionFlowElementSubType(exportType);
ElementId roomId = ElementId.InvalidElementId;
if (roomRelated)
{
roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
}
IFCAnyHandle instanceHandle = null;
// For MEP objects
string exportEntityStr = exportType.ToString();
Common.Enums.IFCEntityType exportEntity;
if (String.Compare(exportEntityStr.Substring(exportEntityStr.Length - 4), "Type", true) == 0)
{
exportEntityStr = exportEntityStr.Substring(0, (exportEntityStr.Length - 4));
}
if (Enum.TryParse(exportEntityStr, out exportEntity))
{
// For MEP object creation
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(exportEntity, file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, localPlacementToUse, productRepresentation, instanceTag);
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
return;
}
if (roomId != ElementId.InvalidElementId)
{
//exporterIFC.RelateSpatialElement(roomId, instanceHandle);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
productWrapper.AddElement(element, instanceHandle, setter, extraParams, false);
}
else
{
productWrapper.AddElement(element, instanceHandle, setter, extraParams, true);
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, null, exporterIFC, localPlacementToUse, setter, productWrapper);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
ExporterCacheManager.TypeRelationsCache.Add(styleHandle, instanceHandle);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, element, productWrapper.GetAllObjects());
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
// add to system export cache
// SystemExporter.ExportSystem(exporterIFC, element, instanceHandle);
}
/// <summary>
/// Exports an element as building element proxy.
/// </summary>
/// <remarks>
/// This function is called from the Export function, but can also be called directly if you do not
/// want CreateInternalPropertySets to be called.
/// </remarks>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>The handle if created, null otherwise.</returns>
public static IFCAnyHandle ExportBuildingElementProxy(ExporterIFC exporterIFC, Element element,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (element == null || geometryElement == null)
{
return(null);
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcBuildingElementProxy", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return(null);
}
}
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle buildingElementProxy = null;
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geometryElement, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return(null);
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(element, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
buildingElementProxy = IFCInstanceExporter.CreateBuildingElementProxy(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag, null);
productWrapper.AddElement(element, buildingElementProxy, placementSetter.LevelInfo, ecData, true);
}
tr.Commit();
}
}
return(buildingElementProxy);
}
/// <summary>
/// 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 ProductWrapper.</param>
private static void ExportBase(ExporterIFC exporterIFC, ICollection <ElementId> allSubElements, Element element, ProductWrapper wrapper)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
PlacementSetter setter = null;
using (ProductWrapper curtainWallSubWrapper = ProductWrapper.Create(wrapper, false))
{
try
{
Transform orientationTrf = Transform.Identity;
IFCAnyHandle localPlacement = null;
setter = PlacementSetter.Create(exporterIFC, element, null, orientationTrf);
localPlacement = setter.LocalPlacement;
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, element);
IFCAnyHandle prodRepHnd = null;
IFCAnyHandle elemHnd = null;
string elemGUID = GUIDUtil.CreateGUID(element);
string elemName = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string elemDesc = NamingUtil.GetDescriptionOverride(element, null);
string elemType = NamingUtil.GetObjectTypeOverride(element, objectType);
string elemTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
if (element is Wall || element is CurtainSystem || IsLegacyCurtainElement(element))
{
elemHnd = IFCInstanceExporter.CreateCurtainWall(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement, prodRepHnd, elemTag);
}
else if (element is RoofBase)
{
//need to convert the string to enum
string ifcEnumType = ExporterUtil.GetIFCTypeFromExportTable(exporterIFC, element);
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
elemHnd = IFCInstanceExporter.CreateRoof(file, elemGUID, ownerHistory, elemName, elemDesc, elemType, localPlacement,
prodRepHnd, elemTag, ifcEnumType);
}
else
{
return;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
return;
}
wrapper.AddElement(element, elemHnd, setter, null, true);
bool canExportCurtainWallAsContainer = CanExportCurtainWallAsContainer(allSubElements, element.Document);
IFCAnyHandle rep = null;
if (!canExportCurtainWallAsContainer)
{
rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
{
return;
}
}
else
{
ExportCurtainObjectCommonAsContainer(allSubElements, element, exporterIFC, curtainWallSubWrapper, setter);
}
ICollection <IFCAnyHandle> relatedElementIds = curtainWallSubWrapper.GetAllObjects();
if (relatedElementIds.Count > 0)
{
string guid = GUIDUtil.CreateSubElementGUID(element, (int)IFCCurtainWallSubElements.RelAggregates);
HashSet <IFCAnyHandle> relatedElementIdSet = new HashSet <IFCAnyHandle>(relatedElementIds);
IFCInstanceExporter.CreateRelAggregates(file, guid, ownerHistory, null, null, elemHnd, relatedElementIdSet);
}
ExportCurtainWallType(exporterIFC, wrapper, elemHnd, element);
SpaceBoundingElementUtil.RegisterSpaceBoundingElementHandle(exporterIFC, elemHnd, element.Id, ElementId.InvalidElementId);
}
finally
{
if (setter != null)
{
setter.Dispose();
}
}
}
}
/// <summary>
/// Exports an element as IFC covering.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element to be exported.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="productWrapper">
/// The ProductWrapper.
/// </param>
public static void ExportCovering(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, ProductWrapper productWrapper)
{
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.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, null, null, ExporterUtil.GetBaseLevelIdForElement(element)))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ecData.SetLocalPlacement(setter.GetPlacement());
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geomElem, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
// We will use the category of the element to set a default value for the covering.
if (string.IsNullOrEmpty(ifcEnumType))
{
if (categoryId == new ElementId(BuiltInCategory.OST_Ceilings))
{
ifcEnumType = "CEILING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Floors))
{
ifcEnumType = "FLOORING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Roofs))
{
ifcEnumType = "ROOFING";
}
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string instanceName = NamingUtil.GetIFCName(element);
string instanceDescription = NamingUtil.GetDescriptionOverride(element, null);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
string instanceElemId = NamingUtil.GetTagOverride(element, 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);
}
bool containInSpace = false;
IFCAnyHandle localPlacementToUse = setter.GetPlacement();
// Ceiling containment in Space is generally required and not specific to any view
if (ExporterCacheManager.CeilingSpaceRelCache.ContainsKey(element.Id))
{
IList <ElementId> roomlist = ExporterCacheManager.CeilingSpaceRelCache[element.Id];
// Process Ceiling to be contained in a Space only when it is exactly bounding one Space
if (roomlist.Count == 1)
{
productWrapper.AddElement(element, covering, setter, null, false);
// Modify the Ceiling placement to be relative to the Space that it bounds
IFCAnyHandle roomPlacement = IFCAnyHandleUtil.GetObjectPlacement(ExporterCacheManager.SpatialElementHandleCache.Find(roomlist[0]));
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(roomPlacement, localPlacementToUse);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandleUtil.SetAttribute(localPlacementToUse, "PlacementRelTo", roomPlacement);
GeometryUtil.SetRelativePlacement(localPlacementToUse, relLocalPlacement);
exporterIFC.RelateSpatialElement(roomlist[0], covering);
containInSpace = true;
}
}
// if not contained in Space, assign it to default containment in Level
if (!containInSpace)
{
productWrapper.AddElement(element, covering, setter, null, true);
}
if (!exportParts)
{
Ceiling ceiling = element as Ceiling;
if (ceiling != null)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, null);
}
else
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geomElem, exporterIFC, element);
CategoryUtil.CreateMaterialAssociation(exporterIFC, covering, matId);
}
}
OpeningUtil.CreateOpeningsIfNecessary(covering, element, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), setter, productWrapper);
}
}
transaction.Commit();
}
}
/// <summary>
/// Exports a Rebar Coupler,
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="coupler">The RebarCoupler element.</param>
/// <param name="productWrapper">The product wrapper.</param>
public static void ExportCoupler(ExporterIFC exporterIFC, RebarCoupler coupler, ProductWrapper productWrapper)
{
if (coupler == null)
{
return;
}
FamilySymbol familySymbol = ExporterCacheManager.Document.GetElement(coupler.GetTypeId()) as FamilySymbol;
if (familySymbol == null)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcMechanicalFastener", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
ElementId categoryId = CategoryUtil.GetSafeCategoryId(coupler);
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
Options options = GeometryUtil.GetIFCExportGeometryOptions();;
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, coupler, out ifcEnumType);
using (IFCTransaction tr = new IFCTransaction(file))
{
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.TypeObjectsCache.Find(coupler.GetTypeId(), false, exportType);
bool found = currentTypeInfo.IsValid();
if (!found)
{
string typeGUID = GUIDUtil.CreateGUID(familySymbol);
string typeName = NamingUtil.GetIFCName(familySymbol);
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, familySymbol);
string applicableOccurance = NamingUtil.GetObjectTypeOverride(familySymbol, typeObjectType);
string typeDescription = NamingUtil.GetDescriptionOverride(familySymbol, null);
string typeElemId = NamingUtil.CreateIFCElementId(familySymbol);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
GeometryElement exportGeometry = familySymbol.get_Geometry(options);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyData = BodyExporter.ExportBody(exporterIFC, coupler, categoryId, ElementId.InvalidElementId, exportGeometry, bodyExporterOptions, null);
List <IFCAnyHandle> repMap = new List <IFCAnyHandle>();
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);;
repMap.Add(IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyData.RepresentationHnd));
IFCAnyHandle styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType, typeGUID, typeName,
typeDescription, applicableOccurance, propertySetsOpt, repMap, typeElemId, typeName, coupler, familySymbol);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.TypeObjectsCache.Register(coupler.GetTypeId(), false, exportType, currentTypeInfo);
}
}
int nCouplerQuantity = coupler.GetCouplerQuantity();
if (nCouplerQuantity <= 0)
{
return;
}
ISet <IFCAnyHandle> createdRebarCouplerHandles = new HashSet <IFCAnyHandle>();
string origInstanceName = NamingUtil.GetNameOverride(coupler, NamingUtil.GetIFCName(coupler));
for (int idx = 0; idx < nCouplerQuantity; idx++)
{
string instanceGUID = GUIDUtil.CreateSubElementGUID(coupler, idx);
string instanceName = NamingUtil.GetNameOverride(coupler, origInstanceName + ": " + idx);
string objectType = NamingUtil.CreateIFCObjectName(exporterIFC, coupler);
string instanceObjectType = NamingUtil.GetObjectTypeOverride(coupler, objectType);
string instanceDescription = NamingUtil.GetDescriptionOverride(coupler, null);
string instanceElemId = NamingUtil.CreateIFCElementId(coupler);
string instanceTag = NamingUtil.GetTagOverride(coupler, NamingUtil.CreateIFCElementId(coupler));
IFCAnyHandle style = currentTypeInfo.Style;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(style))
{
return;
}
IList <IFCAnyHandle> repMapList = GeometryUtil.GetRepresentationMaps(style);
if (repMapList == null)
{
return;
}
if (repMapList.Count == 0)
{
return;
}
IList <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
IFCAnyHandle contextOfItems3d = exporterIFC.Get3DContextHandle("Body");
ISet <IFCAnyHandle> representations = new HashSet <IFCAnyHandle>();
representations.Add(ExporterUtil.CreateDefaultMappedItem(file, repMapList[0], XYZ.Zero));
IFCAnyHandle shapeRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC, coupler, categoryId, contextOfItems3d, representations);
shapeReps.Add(shapeRep);
IFCAnyHandle productRepresentation = IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null, null, shapeReps);
Transform trf = coupler.GetCouplerPositionTransform(idx);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, coupler, trf, null))
{
IFCAnyHandle instanceHandle = null;
instanceHandle = IFCInstanceExporter.CreateGenericIFCEntity(Common.Enums.IFCEntityType.IfcMechanicalFastener, file, instanceGUID, ownerHistory,
instanceName, instanceDescription, instanceObjectType, setter.LocalPlacement, productRepresentation, instanceTag);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// In IFC4 NominalDiameter and NominalLength attributes have been deprecated. PredefinedType attribute was added.
IFCAnyHandleUtil.SetAttribute(instanceHandle, "PredefinedType", Revit.IFC.Export.Toolkit.IFC4.IFCMechanicalFastenerType.USERDEFINED);
}
else
{
IFCAnyHandleUtil.SetAttribute(instanceHandle, "NominalDiameter", familySymbol.get_Parameter(BuiltInParameter.COUPLER_WIDTH).AsDouble());
IFCAnyHandleUtil.SetAttribute(instanceHandle, "NominalLength", familySymbol.get_Parameter(BuiltInParameter.COUPLER_LENGTH).AsDouble());
}
createdRebarCouplerHandles.Add(instanceHandle);
productWrapper.AddElement(coupler, instanceHandle, setter, null, true);
}
}
string couplerGUID = GUIDUtil.CreateGUID(coupler);
if (nCouplerQuantity > 1)
{
// Create a group to hold all of the created IFC entities, if the coupler aren't already in an assembly.
// We want to avoid nested groups of groups of couplers.
if (coupler.AssemblyInstanceId == ElementId.InvalidElementId)
{
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(coupler, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(coupler, null);
string objectType = NamingUtil.GetObjectTypeOverride(coupler, revitObjectType);
IFCAnyHandle rebarGroup = IFCInstanceExporter.CreateGroup(file, couplerGUID,
ownerHistory, name, description, objectType);
productWrapper.AddElement(coupler, rebarGroup);
IFCInstanceExporter.CreateRelAssignsToGroup(file, GUIDUtil.CreateGUID(), ownerHistory,
null, null, createdRebarCouplerHandles, null, rebarGroup);
}
}
else
{
// We will update the GUID of the one created element to be the element GUID.
// This will allow the IfcGUID parameter to be use/set if appropriate.
ExporterUtil.SetGlobalId(createdRebarCouplerHandles.ElementAt(0), couplerGUID);
}
tr.Commit();
}
}
/// <summary>
/// Exports a generic element as an IfcSlab.</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 ProductWrapper.</param>
/// <returns>True if the floor is exported successfully, false otherwise.</returns>
public static void ExportGenericSlab(ExporterIFC exporterIFC, Element slabElement, GeometryElement geometryElement, string ifcEnumType,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, slabElement))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
bool exportParts = PartExporter.CanExportParts(slabElement);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle prodDefHnd = null;
bool isBRepSlabHnd = false;
if (!exportParts)
{
ecData.SetLocalPlacement(localPlacement);
ElementId catId = CategoryUtil.GetSafeCategoryId(slabElement);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
BodyData bodyData;
prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
slabElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
isBRepSlabHnd = (bodyData.ShapeRepresentationType == ShapeRepresentationType.Brep);
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(slabElement);
string entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(slabElement, ifcEnumType, "FLOOR");
string ifcName = NamingUtil.GetNameOverride(slabElement, NamingUtil.GetIFCName(slabElement));
string ifcDescription = NamingUtil.GetDescriptionOverride(slabElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(slabElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(slabElement, NamingUtil.CreateIFCElementId(slabElement));
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, ifcGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacement, exportParts ? null : prodDefHnd,
ifcTag, entityType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, slabElement, slabHnd, productWrapper, placementSetter, localPlacement, null);
}
productWrapper.AddElement(slabElement, slabHnd, placementSetter, ecData, true);
if (!exportParts)
{
if (slabElement is HostObject)
{
HostObject hostObject = slabElement as HostObject;
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, slabHnd,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, isBRepSlabHnd);
}
else if (slabElement is FamilyInstance)
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
Document doc = slabElement.Document;
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
}
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, slabElement, ecData, null,
exporterIFC, ecData.GetLocalPlacement(), placementSetter, productWrapper);
}
}
}
tr.Commit();
return;
}
}
}
/// <summary>
/// Exports an element as an IfcReinforcingMesh.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportFabricSheet(ExporterIFC exporterIFC, FabricSheet sheet,
GeometryElement geometryElement, ProductWrapper productWrapper)
{
if (sheet == null || geometryElement == null)
{
return(false);
}
Document doc = sheet.Document;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, sheet))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(sheet);
ElementId materialId = ElementId.InvalidElementId;
ParameterUtil.GetElementIdValueFromElementOrSymbol(sheet, BuiltInParameter.MATERIAL_ID_PARAM, out materialId);
string guid = GUIDUtil.CreateGUID(sheet);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string revitObjectType = exporterIFC.GetFamilyName();
string name = NamingUtil.GetNameOverride(sheet, revitObjectType);
string description = NamingUtil.GetDescriptionOverride(sheet, null);
string objectType = NamingUtil.GetObjectTypeOverride(sheet, revitObjectType);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.CreateIFCElementId(sheet);
string steelGrade = NamingUtil.GetOverrideStringValue(sheet, "SteelGrade", null);
double?meshLength = sheet.CutOverallLength;
double?meshWidth = sheet.CutOverallWidth;
Element fabricSheetTypeElem = doc.GetElement(sheet.GetTypeId());
FabricSheetType fabricSheetType = (fabricSheetTypeElem == null) ? null : (fabricSheetTypeElem as FabricSheetType);
double longitudinalBarNominalDiameter = 0.0;
double transverseBarNominalDiameter = 0.0;
double longitudinalBarCrossSectionArea = 0.0;
double transverseBarCrossSectionArea = 0.0;
double longitudinalBarSpacing = 0.0;
double transverseBarSpacing = 0.0;
if (fabricSheetType != null)
{
Element majorFabricWireTypeElem = doc.GetElement(fabricSheetType.MajorDirectionWireType);
FabricWireType majorFabricWireType = (majorFabricWireTypeElem == null) ? null : (majorFabricWireTypeElem as FabricWireType);
if (majorFabricWireType != null)
{
longitudinalBarNominalDiameter = UnitUtil.ScaleLength(majorFabricWireType.WireDiameter);
double localRadius = longitudinalBarNominalDiameter / 2.0;
longitudinalBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
Element minorFabricWireTypeElem = doc.GetElement(fabricSheetType.MinorDirectionWireType);
FabricWireType minorFabricWireType = (minorFabricWireTypeElem == null) ? null : (minorFabricWireTypeElem as FabricWireType);
if (minorFabricWireType != null)
{
transverseBarNominalDiameter = UnitUtil.ScaleLength(minorFabricWireType.WireDiameter);
double localRadius = transverseBarNominalDiameter / 2.0;
transverseBarCrossSectionArea = localRadius * localRadius * Math.PI;
}
longitudinalBarSpacing = UnitUtil.ScaleLength(fabricSheetType.MajorSpacing);
transverseBarSpacing = UnitUtil.ScaleLength(fabricSheetType.MinorSpacing);
}
ISet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
IList <Curve> wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Major);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, longitudinalBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
wireCenterlines = sheet.GetWireCenterlines(WireDistributionDirection.Minor);
foreach (Curve wireCenterline in wireCenterlines)
{
IFCAnyHandle bodyItem = CreateSweptDiskSolid(exporterIFC, file, wireCenterline, transverseBarNominalDiameter);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(bodyItem))
{
bodyItems.Add(bodyItem);
}
}
IFCAnyHandle shapeRep = (bodyItems.Count > 0) ?
RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, sheet, categoryId, exporterIFC.Get3DContextHandle("Body"), bodyItems, null) :
null;
IList <IFCAnyHandle> shapeReps = null;
if (shapeRep != null)
{
shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(shapeRep);
}
IFCAnyHandle prodRep = (shapeReps != null) ? IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps) : null;
IFCAnyHandle fabricSheet = IFCInstanceExporter.CreateReinforcingMesh(file, guid,
ownerHistory, name, description, objectType, localPlacement, prodRep, elementTag,
steelGrade, meshLength, meshWidth, longitudinalBarNominalDiameter, transverseBarNominalDiameter,
longitudinalBarCrossSectionArea, transverseBarCrossSectionArea,
longitudinalBarSpacing, transverseBarSpacing);
ElementId fabricAreaId = sheet.FabricAreaOwnerId;
if (fabricAreaId != ElementId.InvalidElementId)
{
HashSet <IFCAnyHandle> fabricSheets = null;
if (!ExporterCacheManager.FabricAreaHandleCache.TryGetValue(fabricAreaId, out fabricSheets))
{
fabricSheets = new HashSet <IFCAnyHandle>();
ExporterCacheManager.FabricAreaHandleCache[fabricAreaId] = fabricSheets;
}
fabricSheets.Add(fabricSheet);
}
productWrapper.AddElement(sheet, fabricSheet, placementSetter.LevelInfo, ecData, true);
CategoryUtil.CreateMaterialAssociation(exporterIFC, fabricSheet, materialId);
}
}
tr.Commit();
return(true);
}
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The roof type.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRoof(ExporterIFC exporterIFC, string ifcEnumType, Element roof, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (roof == null || geometryElement == null)
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, roof))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
// If the roof is an in-place family, we will allow any arbitrary orientation. While this may result in some
// in-place "cubes" exporting with the wrong direction, it is unlikely that an in-place family would be
// used for this reason in the first place.
ecData.PossibleExtrusionAxes = (roof is FamilyInstance) ? IFCExtrusionAxes.TryXYZ : IFCExtrusionAxes.TryZ;
ecData.AreInnerRegionsOpenings = true;
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(roof);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
BodyData bodyData;
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, roof,
categoryId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
bool exportSlab = ecData.ScaledLength > MathUtil.Eps();
string guid = GUIDUtil.CreateGUID(roof);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string roofName = NamingUtil.GetNameOverride(roof, NamingUtil.GetIFCName(roof));
string roofDescription = NamingUtil.GetDescriptionOverride(roof, null);
string roofObjectType = NamingUtil.GetObjectTypeOverride(roof, NamingUtil.CreateIFCObjectName(exporterIFC, roof));
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
string elementTag = NamingUtil.GetTagOverride(roof, NamingUtil.CreateIFCElementId(roof));
string roofType = GetIFCRoofType(ifcEnumType);
roofType = IFCValidateEntry.GetValidIFCType(roof, ifcEnumType);
IFCAnyHandle roofHnd = IFCInstanceExporter.CreateRoof(file, guid, ownerHistory, roofName, roofDescription,
roofObjectType, localPlacement, exportSlab ? null : representation, elementTag, roofType);
productWrapper.AddElement(roof, roofHnd, placementSetter.LevelInfo, ecData, true);
// will export its host object materials later if it is a roof
if (!(roof is RoofBase))
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, roofHnd, bodyData.MaterialIds);
}
if (exportSlab)
{
string slabGUID = GUIDUtil.CreateSubElementGUID(roof, (int)IFCRoofSubElements.RoofSlabStart);
string slabName = roofName + ":1";
IFCAnyHandle slabLocalPlacementHnd = ExporterUtil.CopyLocalPlacement(file, localPlacement);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, slabName,
roofDescription, roofObjectType, slabLocalPlacementHnd, representation, elementTag, "ROOF");
Transform offsetTransform = (bodyData != null) ? bodyData.OffsetTransform : Transform.Identity;
OpeningUtil.CreateOpeningsIfNecessary(slabHnd, roof, ecData, offsetTransform,
exporterIFC, slabLocalPlacementHnd, placementSetter, productWrapper);
ExporterUtil.RelateObject(exporterIFC, roofHnd, slabHnd);
productWrapper.AddElement(null, slabHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, bodyData.MaterialIds);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a CeilingAndFloor element to IFC.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="floor">The floor element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCeilingAndFloorElement(ExporterIFC exporterIFC, CeilingAndFloor floorElement, GeometryElement geometryElement,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
// export parts or not
bool exportParts = PartExporter.CanExportParts(floorElement);
if (exportParts && !PartExporter.CanExportElementInPartExport(floorElement, floorElement.LevelId, false))
{
return;
}
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, floorElement, out ifcEnumType);
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, floorElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool exportedAsInternalExtrusion = false;
ElementId catId = CategoryUtil.GetSafeCategoryId(floorElement);
IList <IFCAnyHandle> prodReps = new List <IFCAnyHandle>();
IList <ShapeRepresentationType> repTypes = new List <ShapeRepresentationType>();
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 && (floorElement is Floor))
{
Floor floor = floorElement as Floor;
// 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.
//
SolidMeshGeometryInfo solidMeshInfo = GeometryUtil.GetSplitSolidMeshGeometry(geometryElement);
IList <Solid> solids = solidMeshInfo.GetSolids();
IList <Mesh> meshes = solidMeshInfo.GetMeshes();
if (solids.Count == 1 && meshes.Count == 0)
{
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 = floorElement.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, floorElement,
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);
prodReps.Add(prodRep);
repTypes.Add(ShapeRepresentationType.SweptSolid);
if (floorAndProperties.Data != null)
{
loopExtraParams.Add(floorAndProperties.Data);
}
}
}
}
}
// Use internal routine as backup that handles openings.
if (prodReps.Count == 0)
{
exportedAsInternalExtrusion = ExporterIFCUtils.ExportSlabAsExtrusion(exporterIFC, floorElement,
geometryElement, transformSetter, localPlacement, out localPlacements, out prodReps,
out extrusionLoops, out loopExtraParams, floorPlane);
for (int ii = 0; ii < prodReps.Count; ii++)
{
// all are extrusions
repTypes.Add(ShapeRepresentationType.SweptSolid);
}
}
if (prodReps.Count == 0)
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporter.GetTessellationLevel();
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
floorElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
prodReps.Add(prodDefHnd);
repTypes.Add(bodyData.ShapeRepresentationType);
}
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(floorElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = null;
switch (exportType)
{
case IFCExportType.IfcFooting:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCFootingType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCFootingType>(floorElement, ifcEnumType, null);
}
break;
case IFCExportType.IfcCovering:
entityType = IFCValidateEntry.GetValidIFCType <IFCCoveringType>(floorElement, ifcEnumType, "FLOORING");
break;
case IFCExportType.IfcRamp:
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
entityType = IFCValidateEntry.GetValidIFCType <Revit.IFC.Export.Toolkit.IFC4.IFCRampType>(floorElement, ifcEnumType, null);
}
else
{
entityType = IFCValidateEntry.GetValidIFCType <IFCRampType>(floorElement, ifcEnumType, null);
}
break;
default:
bool isBaseSlab = false;
AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
if (analyticalModel != null)
{
AnalyzeAs slabFoundationType = analyticalModel.GetAnalyzeAs();
isBaseSlab = (slabFoundationType == AnalyzeAs.SlabOnGrade) || (slabFoundationType == AnalyzeAs.Mat);
}
entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(floorElement, ifcEnumType, isBaseSlab ? "BASESLAB" : "FLOOR");
break;
}
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(floorElement, NamingUtil.GetIFCNamePlusIndex(floorElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(floorElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(floorElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(floorElement, NamingUtil.CreateIFCElementId(floorElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = null;
// TODO: replace with CreateGenericBuildingElement.
switch (exportType)
{
case IFCExportType.IfcFooting:
slabHnd = IFCInstanceExporter.CreateFooting(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcCovering:
slabHnd = IFCInstanceExporter.CreateCovering(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
case IFCExportType.IfcRamp:
slabHnd = IFCInstanceExporter.CreateRamp(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
default:
slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
break;
}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, floorElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(floorElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, floorElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
}
if (!exportParts)
{
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, floorElement, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports a gutter element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportGutter(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement, ProductWrapper productWrapper)
{
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum = Common.Enums.IFCEntityType.IfcPipeSegmentType;
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle bodyRep = BodyExporter.ExportBody(exporterIFC, element, categoryId, ElementId.InvalidElementId,
geometryElement, bodyExporterOptions, ecData).RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
if (ecData != null)
{
ecData.ClearOpenings();
}
return;
}
string originalTag = NamingUtil.CreateIFCElementId(element);
// In Revit, we don't have a corresponding type, so we create one for every gutter.
IFCAnyHandle origin = ExporterUtil.CreateAxis2Placement3D(file);
IFCAnyHandle repMap3dHnd = IFCInstanceExporter.CreateRepresentationMap(file, origin, bodyRep);
List <IFCAnyHandle> repMapList = new List <IFCAnyHandle>();
repMapList.Add(repMap3dHnd);
string elementTypeName = NamingUtil.CreateIFCObjectName(exporterIFC, element);
string typeGuid = GUIDUtil.CreateSubElementGUID(element, (int)IFCHostedSweepSubElements.PipeSegmentType);
IFCAnyHandle style = IFCInstanceExporter.CreatePipeSegmentType(file, null, null, repMapList, IFCPipeSegmentType.Gutter);
IFCAnyHandleUtil.OverrideNameAttribute(style, elementTypeName);
IFCAnyHandleUtil.SetAttribute(style, "Tag", originalTag);
ExporterUtil.SetGlobalId(style, typeGuid);
IFCAnyHandleUtil.SetAttribute(style, "ElementType", elementTypeName);
List <IFCAnyHandle> representationMaps = GeometryUtil.GetRepresentationMaps(style);
IFCAnyHandle mappedItem = ExporterUtil.CreateDefaultMappedItem(file, representationMaps[0]);
ISet <IFCAnyHandle> representations = new HashSet <IFCAnyHandle>();
representations.Add(mappedItem);
IFCAnyHandle bodyMappedItemRep = RepresentationUtil.CreateBodyMappedItemRep(exporterIFC,
element, categoryId, exporterIFC.Get3DContextHandle("Body"), representations);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyMappedItemRep))
{
return;
}
List <IFCAnyHandle> shapeReps = new List <IFCAnyHandle>();
shapeReps.Add(bodyMappedItemRep);
IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, Transform.Identity);
if (boundingBoxRep != null)
{
shapeReps.Add(boundingBoxRep);
}
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
IFCAnyHandle localPlacementToUse;
ElementId roomId = setter.UpdateRoomRelativeCoordinates(element, out localPlacementToUse);
if (roomId == ElementId.InvalidElementId)
{
localPlacementToUse = ecData.GetLocalPlacement();
}
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle elemHnd = IFCInstanceExporter.CreateFlowSegment(exporterIFC, element, guid,
ExporterCacheManager.OwnerHistoryHandle, localPlacementToUse, prodRep);
bool containedInSpace = (roomId != ElementId.InvalidElementId);
productWrapper.AddElement(element, elemHnd, setter.LevelInfo, ecData, !containedInSpace);
if (containedInSpace)
{
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, elemHnd);
}
// Associate segment with type.
ExporterCacheManager.TypeRelationsCache.Add(style, elemHnd);
OpeningUtil.CreateOpeningsIfNecessary(elemHnd, element, ecData, null,
exporterIFC, localPlacementToUse, setter, productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a generic element as an IfcSlab.</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 ProductWrapper.</param>
/// <returns>True if the floor is exported successfully, false otherwise.</returns>
public static void ExportGenericSlab(ExporterIFC exporterIFC, Element slabElement, GeometryElement geometryElement, string ifcEnumType,
ProductWrapper productWrapper)
{
if (geometryElement == null)
{
return;
}
bool exportParts = PartExporter.CanExportParts(slabElement);
IFCFile file = exporterIFC.GetFile();
IList <IFCAnyHandle> slabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> brepSlabHnds = new List <IFCAnyHandle>();
IList <IFCAnyHandle> nonBrepSlabHnds = new List <IFCAnyHandle>();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (IFCTransformSetter transformSetter = IFCTransformSetter.Create())
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, slabElement))
{
IFCAnyHandle localPlacement = placementSetter.LocalPlacement;
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
bool exportedAsInternalExtrusion = false;
ElementId catId = CategoryUtil.GetSafeCategoryId(slabElement);
IList <IFCAnyHandle> prodReps = new List <IFCAnyHandle>();
IList <ShapeRepresentationType> repTypes = new List <ShapeRepresentationType>();
IList <IList <CurveLoop> > extrusionLoops = new List <IList <CurveLoop> >();
IList <IFCExtrusionCreationData> loopExtraParams = new List <IFCExtrusionCreationData>();
Plane floorPlane = GeometryUtil.CreateDefaultPlane();
IList <IFCAnyHandle> localPlacements = new List <IFCAnyHandle>();
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
bodyExporterOptions.TessellationLevel = BodyExporter.GetTessellationLevel();
BodyData bodyData;
IFCAnyHandle prodDefHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
slabElement, catId, geometryElement, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodDefHnd))
{
ecData.ClearOpenings();
return;
}
prodReps.Add(prodDefHnd);
repTypes.Add(bodyData.ShapeRepresentationType);
}
// Create the slab from either the extrusion or the BRep information.
string ifcGUID = GUIDUtil.CreateGUID(slabElement);
int numReps = exportParts ? 1 : prodReps.Count;
string entityType = IFCValidateEntry.GetValidIFCType <IFCSlabType>(slabElement, ifcEnumType, "FLOOR");
for (int ii = 0; ii < numReps; ii++)
{
string ifcName = NamingUtil.GetNameOverride(slabElement, NamingUtil.GetIFCNamePlusIndex(slabElement, ii == 0 ? -1 : ii + 1));
string ifcDescription = NamingUtil.GetDescriptionOverride(slabElement, null);
string ifcObjectType = NamingUtil.GetObjectTypeOverride(slabElement, exporterIFC.GetFamilyName());
string ifcTag = NamingUtil.GetTagOverride(slabElement, NamingUtil.CreateIFCElementId(slabElement));
string currentGUID = (ii == 0) ? ifcGUID : GUIDUtil.CreateGUID();
IFCAnyHandle localPlacementHnd = exportedAsInternalExtrusion ? localPlacements[ii] : localPlacement;
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, currentGUID, ownerHistory, ifcName,
ifcDescription, ifcObjectType, localPlacementHnd, exportParts ? null : prodReps[ii],
ifcTag, entityType);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(slabHnd))
{
return;
}
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, slabElement, slabHnd, productWrapper, placementSetter, localPlacementHnd, null);
}
slabHnds.Add(slabHnd);
if (!exportParts)
{
if (repTypes[ii] == ShapeRepresentationType.Brep)
{
brepSlabHnds.Add(slabHnd);
}
else
{
nonBrepSlabHnds.Add(slabHnd);
}
}
}
for (int ii = 0; ii < numReps; ii++)
{
IFCExtrusionCreationData loopExtraParam = ii < loopExtraParams.Count ? loopExtraParams[ii] : null;
productWrapper.AddElement(slabElement, slabHnds[ii], placementSetter, loopExtraParam, true);
}
if (exportedAsInternalExtrusion)
{
ExporterIFCUtils.ExportExtrudedSlabOpenings(exporterIFC, slabElement, placementSetter.LevelInfo,
localPlacements[0], slabHnds, extrusionLoops, floorPlane, productWrapper.ToNative());
}
}
if (!exportParts)
{
if (slabElement is HostObject)
{
HostObject hostObject = slabElement as HostObject;
if (nonBrepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, nonBrepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, false);
}
if (brepSlabHnds.Count > 0)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, hostObject, brepSlabHnds,
geometryElement, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, true);
}
}
else if (slabElement is FamilyInstance && slabHnds.Count > 0)
{
ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
Document doc = slabElement.Document;
foreach (IFCAnyHandle slabHnd in slabHnds)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, slabHnd, matId);
}
}
}
}
tr.Commit();
return;
}
}
/// <summary>
/// Exports a ramp to IfcRamp, without decomposing into separate runs and landings.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="ifcEnumType">The ramp type.</param>
/// <param name="ramp">The ramp element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="numFlights">The number of flights for a multistory ramp.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportRamp(ExporterIFC exporterIFC, string ifcEnumType, Element ramp, GeometryElement geometryElement,
int numFlights, ProductWrapper productWrapper)
{
if (ramp == null || geometryElement == null)
{
return;
}
// Check the intended IFC entity or type name is in the exclude list specified in the UI
Common.Enums.IFCEntityType elementClassTypeEnum;
if (Enum.TryParse <Common.Enums.IFCEntityType>("IfcRamp", out elementClassTypeEnum))
{
if (ExporterCacheManager.ExportOptionsCache.IsElementInExcludeList(elementClassTypeEnum))
{
return;
}
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
using (PlacementSetter placementSetter = PlacementSetter.Create(exporterIFC, ramp))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ecData.SetLocalPlacement(placementSetter.LocalPlacement);
ecData.ReuseLocalPlacement = false;
GeometryElement rampGeom = GeometryUtil.GetOneLevelGeometryElement(geometryElement, numFlights);
BodyData bodyData;
ElementId categoryId = CategoryUtil.GetSafeCategoryId(ramp);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
IFCAnyHandle representation = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
ramp, categoryId, rampGeom, bodyExporterOptions, null, ecData, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(representation))
{
ecData.ClearOpenings();
return;
}
string containedRampGuid = GUIDUtil.CreateSubElementGUID(ramp, (int)IFCRampSubElements.ContainedRamp);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string rampName = NamingUtil.GetNameOverride(ramp, NamingUtil.GetIFCName(ramp));
string rampDescription = NamingUtil.GetDescriptionOverride(ramp, null);
string rampObjectType = NamingUtil.GetObjectTypeOverride(ramp, NamingUtil.CreateIFCObjectName(exporterIFC, ramp));
IFCAnyHandle containedRampLocalPlacement = ExporterUtil.CreateLocalPlacement(file, ecData.GetLocalPlacement(), null);
string elementTag = NamingUtil.GetTagOverride(ramp, NamingUtil.CreateIFCElementId(ramp));
string rampType = GetIFCRampType(ifcEnumType);
List <IFCAnyHandle> components = new List <IFCAnyHandle>();
IList <IFCExtrusionCreationData> componentExtrusionData = new List <IFCExtrusionCreationData>();
IFCAnyHandle containedRampHnd = IFCInstanceExporter.CreateRamp(file, containedRampGuid, ownerHistory, rampName,
rampDescription, rampObjectType, containedRampLocalPlacement, representation, elementTag, rampType);
components.Add(containedRampHnd);
componentExtrusionData.Add(ecData);
//productWrapper.AddElement(containedRampHnd, placementSetter.LevelInfo, ecData, false);
CategoryUtil.CreateMaterialAssociation(exporterIFC, containedRampHnd, bodyData.MaterialIds);
string guid = GUIDUtil.CreateGUID(ramp);
IFCAnyHandle localPlacement = ecData.GetLocalPlacement();
IFCAnyHandle rampHnd = IFCInstanceExporter.CreateRamp(file, guid, ownerHistory, rampName,
rampDescription, rampObjectType, localPlacement, null, elementTag, rampType);
productWrapper.AddElement(ramp, rampHnd, placementSetter.LevelInfo, ecData, true);
StairRampContainerInfo stairRampInfo = new StairRampContainerInfo(rampHnd, components, localPlacement);
ExporterCacheManager.StairRampContainerInfoCache.AddStairRampContainerInfo(ramp.Id, stairRampInfo);
ExportMultistoryRamp(exporterIFC, ramp, numFlights, rampHnd, components, componentExtrusionData, placementSetter,
productWrapper);
}
tr.Commit();
}
}
}
/// <summary>
/// Exports an element as an IFC assembly.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportAssemblyInstanceElement(ExporterIFC exporterIFC, AssemblyInstance element,
ProductWrapper productWrapper)
{
if (element == null)
{
return(false);
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
IFCAnyHandle assemblyInstanceHnd = null;
string guid = GUIDUtil.CreateGUID(element);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string name = NamingUtil.GetNameOverride(element, NamingUtil.GetIFCName(element));
string description = NamingUtil.GetDescriptionOverride(element, null);
string objectType = NamingUtil.GetObjectTypeOverride(element, exporterIFC.GetFamilyName());
IFCAnyHandle localPlacement = null;
PlacementSetter placementSetter = null;
IFCLevelInfo levelInfo = null;
bool relateToLevel = true;
string ifcEnumType;
IFCExportType exportAs = ExporterUtil.GetExportType(exporterIFC, element, out ifcEnumType);
if (exportAs == IFCExportType.IfcSystem)
{
assemblyInstanceHnd = IFCInstanceExporter.CreateSystem(file, guid,
ownerHistory, name, description, objectType);
// Create classification reference when System has classification filed name assigned to it
ClassificationUtil.CreateClassification(exporterIFC, file, element, assemblyInstanceHnd);
HashSet <IFCAnyHandle> relatedBuildings = new HashSet <IFCAnyHandle>();
relatedBuildings.Add(ExporterCacheManager.BuildingHandle);
IFCAnyHandle relServicesBuildings = IFCInstanceExporter.CreateRelServicesBuildings(file, GUIDUtil.CreateGUID(),
ExporterCacheManager.OwnerHistoryHandle, null, null, assemblyInstanceHnd, relatedBuildings);
relateToLevel = false; // Already related to the building via IfcRelServicesBuildings.
}
else
{
using (placementSetter = PlacementSetter.Create(exporterIFC, element))
{
string elementTag = NamingUtil.GetTagOverride(element, NamingUtil.CreateIFCElementId(element));
IFCAnyHandle representation = null;
// We have limited support for exporting assemblies as other container types.
localPlacement = placementSetter.LocalPlacement;
levelInfo = placementSetter.LevelInfo;
ifcEnumType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
switch (exportAs)
{
case IFCExportType.IfcCurtainWall:
case IFCExportType.IfcCurtainWallType:
assemblyInstanceHnd = IFCInstanceExporter.CreateCurtainWall(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag);
break;
case IFCExportType.IfcRamp:
string rampPredefinedType = RampExporter.GetIFCRampType(ifcEnumType);
assemblyInstanceHnd = IFCInstanceExporter.CreateRamp(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
rampPredefinedType);
break;
case IFCExportType.IfcRoof:
assemblyInstanceHnd = IFCInstanceExporter.CreateRoof(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
ifcEnumType);
break;
case IFCExportType.IfcStair:
string stairPredefinedType = StairsExporter.GetIFCStairType(ifcEnumType);
assemblyInstanceHnd = IFCInstanceExporter.CreateStair(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
stairPredefinedType);
break;
case IFCExportType.IfcWall:
assemblyInstanceHnd = IFCInstanceExporter.CreateWall(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
ifcEnumType);
break;
default:
IFCElementAssemblyType assemblyPredefinedType = GetPredefinedTypeFromObjectType(objectType);
assemblyInstanceHnd = IFCInstanceExporter.CreateElementAssembly(file, guid,
ownerHistory, name, description, objectType, localPlacement, representation, elementTag,
IFCAssemblyPlace.NotDefined, assemblyPredefinedType);
break;
}
}
}
if (assemblyInstanceHnd == null)
{
return(false);
}
// relateToLevel depends on how the AssemblyInstance is being mapped to IFC, above.
productWrapper.AddElement(element, assemblyInstanceHnd, levelInfo, null, relateToLevel);
ExporterCacheManager.AssemblyInstanceCache.RegisterAssemblyInstance(element.Id, assemblyInstanceHnd);
tr.Commit();
return(true);
}
}