/// <summary>
/// Exports a MEP family instance.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="exportType">The export type of the element.
/// <param name="ifcEnumType">The sub-type of the element.</param></param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <returns>True if an entity was created, false otherwise.</returns>
public static bool Export(ExporterIFC exporterIFC, Element element, GeometryElement geometryElement,
IFCExportInfoPair exportType, string ifcEnumType, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// CQ_TODO: Clean up this code by at least factoring it out.
// If we are exporting a duct segment, we may need to split it into parts by level. Create a list of ranges.
IList <ElementId> levels = new List <ElementId>();
IList <IFCRange> ranges = new List <IFCRange>();
// We will not split duct segments if the assemblyId is set, as we would like to keep the original duct segment
// associated with the assembly, on the level of the assembly.
if ((exportType.ExportType == IFCEntityType.IfcDuctSegmentType) &&
(ExporterCacheManager.ExportOptionsCache.WallAndColumnSplitting) &&
(element.AssemblyInstanceId == ElementId.InvalidElementId))
{
LevelUtil.CreateSplitLevelRangesForElement(exporterIFC, exportType, element, out levels,
out ranges);
}
int numPartsToExport = ranges.Count;
{
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
if (0 == numPartsToExport)
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, overrideContainerId, overrideContainerHnd))
{
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
BodyData bodyData = null;
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
extraParams.SetLocalPlacement(localPlacementToUse);
IFCAnyHandle productRepresentation =
RepresentationUtil.CreateAppropriateProductDefinitionShape(
exporterIFC, element, catId, geometryElement, bodyExporterOptions, null, extraParams, out bodyData);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return(false);
}
ExportAsMappedItem(exporterIFC, element, exportType, ifcEnumType, extraParams,
setter, localPlacementToUse, productRepresentation,
productWrapper);
}
}
}
else
{
for (int ii = 0; ii < numPartsToExport; ii++)
{
// Check for containment override
IFCAnyHandle overrideContainerHnd = null;
ParameterUtil.OverrideContainmentParameter(exporterIFC, element, out overrideContainerHnd);
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element, null, null, levels[ii], overrideContainerHnd))
{
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
{
SolidMeshGeometryInfo solidMeshCapsule =
GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, ranges[ii]);
IList <Solid> solids = solidMeshCapsule.GetSolids();
IList <Mesh> polyMeshes = solidMeshCapsule.GetMeshes();
IList <GeometryObject> geomObjects =
FamilyExporterUtil.RemoveInvisibleSolidsAndMeshes(element.Document,
exporterIFC, ref solids, ref polyMeshes);
if (geomObjects.Count == 0 && (solids.Count > 0 || polyMeshes.Count > 0))
{
return(false);
}
bool tryToExportAsExtrusion = (!exporterIFC.ExportAs2x2 ||
(exportType.ExportInstance == IFCEntityType.IfcColumn));
if (exportType.ExportInstance == IFCEntityType.IfcColumn)
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
}
else
{
extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryXYZ;
}
BodyData bodyData = null;
if (geomObjects.Count > 0)
{
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId,
ElementId.InvalidElementId, geomObjects,
bodyExporterOptions, extraParams);
}
else
{
IList <GeometryObject> exportedGeometries = new List <GeometryObject>();
exportedGeometries.Add(geometryElement);
bodyData = BodyExporter.ExportBody(exporterIFC, element, catId,
ElementId.InvalidElementId,
exportedGeometries, bodyExporterOptions,
extraParams);
}
List <IFCAnyHandle> bodyReps = new List <IFCAnyHandle>();
bodyReps.Add(bodyData.RepresentationHnd);
IFCAnyHandle productRepresentation =
IFCInstanceExporter.CreateProductDefinitionShape(exporterIFC.GetFile(), null,
null, bodyReps);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(productRepresentation))
{
extraParams.ClearOpenings();
return(false);
}
ExportAsMappedItem(exporterIFC, element, exportType, ifcEnumType,
extraParams, setter, localPlacementToUse,
productRepresentation, productWrapper);
}
}
}
}
}
tr.Commit();
}
return(true);
}
protected override void Process(IFCAnyHandle ifcMaterialProfileWithOffsets)
{
base.Process(ifcMaterialProfileWithOffsets);
OffsetValues = IFCAnyHandleUtil.GetAggregateDoubleAttribute <List <double> >(ifcMaterialProfileWithOffsets, "OffsetValues");
}
/// <summary>
/// Exports materials for host object.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="hostObject">The host object.</param>
/// <param name="elemHnds">The host IFC handles.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
/// <param name="levelId">The level id.</param>
/// <param name="direction">The IFCLayerSetDirection.</param>
/// <param name="containsBRepGeometry">True if the geometry contains BRep geoemtry. If so, we will export an IfcMaterialList</param>
/// <returns>True if exported successfully, false otherwise.</returns>
public static bool ExportHostObjectMaterials(ExporterIFC exporterIFC, HostObject hostObject,
IList <IFCAnyHandle> elemHnds, GeometryElement geometryElement, ProductWrapper productWrapper,
ElementId levelId, Toolkit.IFCLayerSetDirection direction, bool containsBRepGeometry)
{
if (hostObject == null)
{
return(true); //nothing to do
}
if (elemHnds == null || (elemHnds.Count == 0))
{
return(true); //nothing to do
}
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
if (productWrapper != null)
{
productWrapper.ClearFinishMaterials();
}
double scaledOffset = 0.0, scaledWallWidth = 0.0, wallHeight = 0.0;
Wall wall = hostObject as Wall;
if (wall != null)
{
scaledWallWidth = UnitUtil.ScaleLength(wall.Width);
scaledOffset = -scaledWallWidth / 2.0;
BoundingBoxXYZ boundingBox = wall.get_BoundingBox(null);
if (boundingBox != null)
{
wallHeight = boundingBox.Max.Z - boundingBox.Min.Z;
}
}
ElementId typeElemId = hostObject.GetTypeId();
IFCAnyHandle materialLayerSet = ExporterCacheManager.MaterialLayerSetCache.Find(typeElemId);
// Roofs with no components are only allowed one material. We will arbitrarily choose the thickest material.
IFCAnyHandle primaryMaterialHnd = ExporterCacheManager.MaterialLayerSetCache.FindPrimaryMaterialHnd(typeElemId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(materialLayerSet))
{
HostObjAttributes hostObjAttr = hostObject.Document.GetElement(typeElemId) as HostObjAttributes;
if (hostObjAttr == null)
{
return(true); //nothing to do
}
List <ElementId> matIds = new List <ElementId>();
List <double> widths = new List <double>();
List <MaterialFunctionAssignment> functions = new List <MaterialFunctionAssignment>();
ElementId baseMatId = CategoryUtil.GetBaseMaterialIdForElement(hostObject);
CompoundStructure cs = hostObjAttr.GetCompoundStructure();
if (cs != null)
{
//TODO: Vertically compound structures are not yet supported by export.
if (!cs.IsVerticallyHomogeneous() && !MathUtil.IsAlmostZero(wallHeight))
{
cs = cs.GetSimpleCompoundStructure(wallHeight, wallHeight / 2.0);
}
for (int i = 0; i < cs.LayerCount; ++i)
{
ElementId matId = cs.GetMaterialId(i);
if (matId != ElementId.InvalidElementId)
{
matIds.Add(matId);
}
else
{
matIds.Add(baseMatId);
}
widths.Add(cs.GetLayerWidth(i));
// save layer function into ProductWrapper,
// it's used while exporting "Function" of Pset_CoveringCommon
functions.Add(cs.GetLayerFunction(i));
}
}
if (matIds.Count == 0)
{
matIds.Add(baseMatId);
widths.Add(cs != null ? cs.GetWidth() : 0);
functions.Add(MaterialFunctionAssignment.None);
}
// We can't create IfcMaterialLayers without creating an IfcMaterialLayerSet. So we will simply collate here.
IList <IFCAnyHandle> materialHnds = new List <IFCAnyHandle>();
IList <int> widthIndices = new List <int>();
double thickestLayer = 0.0;
for (int ii = 0; ii < matIds.Count; ++ii)
{
// Require positive width for IFC2x3 and before, and non-negative width for IFC4.
if (widths[ii] < -MathUtil.Eps())
{
continue;
}
bool almostZeroWidth = MathUtil.IsAlmostZero(widths[ii]);
if (ExporterCacheManager.ExportOptionsCache.FileVersion != IFCVersion.IFC4 && almostZeroWidth)
{
continue;
}
if (almostZeroWidth)
{
widths[ii] = 0.0;
}
IFCAnyHandle materialHnd = CategoryUtil.GetOrCreateMaterialHandle(exporterIFC, matIds[ii]);
if (primaryMaterialHnd == null || (widths[ii] > thickestLayer))
{
primaryMaterialHnd = materialHnd;
thickestLayer = widths[ii];
}
widthIndices.Add(ii);
materialHnds.Add(materialHnd);
if ((productWrapper != null) && (functions[ii] == MaterialFunctionAssignment.Finish1 || functions[ii] == MaterialFunctionAssignment.Finish2))
{
productWrapper.AddFinishMaterial(materialHnd);
}
}
int numLayersToCreate = widthIndices.Count;
if (numLayersToCreate == 0)
{
return(false);
}
if (!containsBRepGeometry)
{
IList <IFCAnyHandle> layers = new List <IFCAnyHandle>(numLayersToCreate);
for (int ii = 0; ii < numLayersToCreate; ii++)
{
int widthIndex = widthIndices[ii];
double scaledWidth = UnitUtil.ScaleLength(widths[widthIndex]);
IFCAnyHandle materialLayer = IFCInstanceExporter.CreateMaterialLayer(file, materialHnds[ii], scaledWidth, null);
layers.Add(materialLayer);
}
string layerSetName = exporterIFC.GetFamilyName();
materialLayerSet = IFCInstanceExporter.CreateMaterialLayerSet(file, layers, layerSetName);
ExporterCacheManager.MaterialLayerSetCache.Register(typeElemId, materialLayerSet);
ExporterCacheManager.MaterialLayerSetCache.RegisterPrimaryMaterialHnd(typeElemId, primaryMaterialHnd);
}
else
{
foreach (IFCAnyHandle elemHnd in elemHnds)
{
CategoryUtil.CreateMaterialAssociations(exporterIFC, elemHnd, matIds);
}
}
}
// IfcMaterialLayerSetUsage is not supported for IfcWall, only IfcWallStandardCase.
IFCAnyHandle layerSetUsage = null;
for (int ii = 0; ii < elemHnds.Count; ii++)
{
IFCAnyHandle elemHnd = elemHnds[ii];
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elemHnd))
{
continue;
}
SpaceBoundingElementUtil.RegisterSpaceBoundingElementHandle(exporterIFC, elemHnd, hostObject.Id, levelId);
if (containsBRepGeometry)
{
continue;
}
HashSet <IFCAnyHandle> relDecomposesSet = IFCAnyHandleUtil.GetRelDecomposes(elemHnd);
IList <IFCAnyHandle> subElemHnds = null;
if (relDecomposesSet != null && relDecomposesSet.Count == 1)
{
IFCAnyHandle relAggregates = relDecomposesSet.First();
if (IFCAnyHandleUtil.IsTypeOf(relAggregates, IFCEntityType.IfcRelAggregates))
{
subElemHnds = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(relAggregates, "RelatedObjects");
}
}
bool hasSubElems = (subElemHnds != null && subElemHnds.Count != 0);
bool isRoof = IFCAnyHandleUtil.IsTypeOf(elemHnd, IFCEntityType.IfcRoof);
if (!hasSubElems && !isRoof && !IFCAnyHandleUtil.IsTypeOf(elemHnd, IFCEntityType.IfcWall))
{
if (layerSetUsage == null)
{
bool flipDirSense = true;
if (wall != null)
{
// if we have flipped the center curve on export, we need to take that into account here.
// We flip the center curve on export if it is an arc and it has a negative Z direction.
LocationCurve locCurve = wall.Location as LocationCurve;
if (locCurve != null)
{
Curve curve = locCurve.Curve;
Plane defPlane = new Plane(XYZ.BasisX, XYZ.BasisY, XYZ.Zero);
bool curveFlipped = GeometryUtil.MustFlipCurve(defPlane, curve);
flipDirSense = !(wall.Flipped ^ curveFlipped);
}
}
else if (hostObject is Floor)
{
flipDirSense = false;
}
double offsetFromReferenceLine = flipDirSense ? -scaledOffset : scaledOffset;
IFCDirectionSense sense = flipDirSense ? IFCDirectionSense.Negative : IFCDirectionSense.Positive;
layerSetUsage = IFCInstanceExporter.CreateMaterialLayerSetUsage(file, materialLayerSet, direction, sense, offsetFromReferenceLine);
}
ExporterCacheManager.MaterialLayerRelationsCache.Add(layerSetUsage, elemHnd);
}
else
{
if (hasSubElems)
{
foreach (IFCAnyHandle subElemHnd in subElemHnds)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(subElemHnd))
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(materialLayerSet, subElemHnd);
}
}
}
else if (!isRoof)
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(materialLayerSet, elemHnd);
}
else if (primaryMaterialHnd != null)
{
ExporterCacheManager.MaterialLayerRelationsCache.Add(primaryMaterialHnd, elemHnd);
}
}
}
tr.Commit();
return(true);
}
}
private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element,
IFCExportInfoPair 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;
ElementId matId = ElementId.InvalidElementId;
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
bool hasMaterialAssociatedToType = false;
if (type != null)
{
FamilyTypeInfo currentTypeInfo = ExporterCacheManager.FamilySymbolToTypeInfoCache.Find(typeId, false, exportType);
if (!currentTypeInfo.IsValid())
{
string typeObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, type);
HashSet <IFCAnyHandle> propertySetsOpt = new HashSet <IFCAnyHandle>();
IList <IFCAnyHandle> repMapListOpt = new List <IFCAnyHandle>();
string typeGuid = FamilyExporterUtil.GetGUIDForFamilySymbol(element as FamilyInstance, type);
styleHandle = FamilyExporterUtil.ExportGenericType(exporterIFC, exportType, ifcEnumType,
propertySetsOpt, repMapListOpt, element, type, typeGuid);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
productWrapper.RegisterHandleWithElementType(type, exportType, styleHandle, null);
currentTypeInfo.Style = styleHandle;
ExporterCacheManager.FamilySymbolToTypeInfoCache.Register(typeId, false, exportType, currentTypeInfo);
Element elementType = element.Document.GetElement(element.GetTypeId());
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), elementType, element);
if (matId != ElementId.InvalidElementId)
{
currentTypeInfo.MaterialIdList = new List <ElementId>()
{
matId
};
hasMaterialAssociatedToType = true;
CategoryUtil.CreateMaterialAssociation(exporterIFC, styleHandle, matId);
}
}
}
else
{
styleHandle = currentTypeInfo.Style;
if (currentTypeInfo.MaterialIdList != null && currentTypeInfo.MaterialIdList.Count > 0)
{
hasMaterialAssociatedToType = true;
}
}
}
string instanceGUID = GUIDUtil.CreateGUID(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(exportType, exporterIFC, element, instanceGUID, ownerHistory,
localPlacementToUse, productRepresentation);
//}
if (IFCAnyHandleUtil.IsNullOrHasNoValue(instanceHandle))
{
return;
}
if (matId == ElementId.InvalidElementId && !hasMaterialAssociatedToType)
{
matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), element);
if (matId != ElementId.InvalidElementId)
{
CategoryUtil.CreateMaterialAssociation(exporterIFC, instanceHandle, matId);
}
}
if (roomId != ElementId.InvalidElementId)
{
//exporterIFC.RelateSpatialElement(roomId, instanceHandle);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
productWrapper.AddElement(element, instanceHandle, setter, extraParams, false, exportType);
}
else
{
productWrapper.AddElement(element, instanceHandle, setter, extraParams, true, exportType);
}
OpeningUtil.CreateOpeningsIfNecessary(instanceHandle, element, extraParams, null, exporterIFC, localPlacementToUse, setter, productWrapper);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(styleHandle))
{
ExporterCacheManager.TypeRelationsCache.Add(styleHandle, instanceHandle);
}
ExporterCacheManager.MEPCache.Register(element, instanceHandle);
// add to system export cache
// SystemExporter.ExportSystem(exporterIFC, element, instanceHandle);
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
// We are going to attempt minor repairs for small but reasonable gaps between Line/Line and Line/Arc pairs. As such, we want to collect the
// curves before we create the curve loop.
IList <IFCAnyHandle> segments = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(ifcCurve, "Segments");
if (segments == null)
{
Importer.TheLog.LogError(Id, "Invalid IfcCompositeCurve with no segments.", true);
}
// need List<> so that we can AddRange later.
List <Curve> curveSegments = new List <Curve>();
Segments.Clear();
foreach (IFCAnyHandle segment in segments)
{
IFCCurve currCurve = ProcessIFCCompositeCurveSegment(segment);
if (currCurve != null)
{
Segments.Add(currCurve);
if (currCurve.Curve != null)
{
curveSegments.Add(currCurve.Curve);
}
else if (currCurve.CurveLoop != null)
{
foreach (Curve subCurve in currCurve.CurveLoop)
{
if (subCurve != null)
{
curveSegments.Add(subCurve);
}
}
}
}
}
int numSegments = curveSegments.Count;
if (numSegments == 0)
{
Importer.TheLog.LogError(Id, "Invalid IfcCompositeCurve with no segments.", true);
}
try
{
// We are going to try to reverse or tweak segments as necessary to make the CurveLoop.
// For each curve, it is acceptable if it can be appended to the end of the existing loop, or prepended to its start,
// possibly after reversing the curve, and possibly with some tweaking.
// NOTE: we do not do any checks yet to repair the endpoints of the curveloop to make them closed.
// NOTE: this is not expected to be perfect with dirty data, but is expected to not change already valid data.
// curveLoopStartPoint and curveLoopEndPoint will change over time as we add new curves to the start or end of the CurveLoop.
XYZ curveLoopStartPoint = curveSegments[0].GetEndPoint(0);
XYZ curveLoopEndPoint = curveSegments[0].GetEndPoint(1);
double vertexEps = IFCImportFile.TheFile.Document.Application.VertexTolerance;
// This is intended to be "relatively large". The idea here is that the user would rather have the information presented
// than thrown away because of a gap that is architecturally insignificant.
double gapVertexEps = Math.Max(vertexEps, 0.01); // 1/100th of a foot, or 3.048 mm.
double shortCurveTol = IFCImportFile.TheFile.Document.Application.ShortCurveTolerance;
// canRepairFirst may change over time, as we may potentially add curves to the start of the CurveLoop.
bool canRepairFirst = (curveSegments[0] is Line);
for (int ii = 1; ii < numSegments; ii++)
{
XYZ nextStartPoint = curveSegments[ii].GetEndPoint(0);
XYZ nextEndPoint = curveSegments[ii].GetEndPoint(1);
// These will be set below.
bool attachNextSegmentToEnd = false;
bool reverseNextSegment = false;
double minGap = 0.0;
// Scoped to prevent distLoopEndPtToNextStartPt and others from being used later on.
{
// Find the minimum gap between the current curve segment and the existing curve loop. If it is too large, we will give up.
double distLoopEndPtToNextStartPt = curveLoopEndPoint.DistanceTo(nextStartPoint);
double distLoopEndPtToNextEndPt = curveLoopEndPoint.DistanceTo(nextEndPoint);
double distLoopStartPtToNextEndPt = curveLoopStartPoint.DistanceTo(nextEndPoint);
double distLoopStartPtToNextStartPt = curveLoopStartPoint.DistanceTo(nextStartPoint);
// Determine the minimum gap between the two curves. If it is too large, we'll give up before trying anything.
double minStartGap = Math.Min(distLoopStartPtToNextEndPt, distLoopStartPtToNextStartPt);
double minEndGap = Math.Min(distLoopEndPtToNextStartPt, distLoopEndPtToNextEndPt);
minGap = Math.Min(minStartGap, minEndGap);
// If the minimum distance between the two curves is greater than gapVertexEps (which is the larger of our two tolerances),
// we can't fix the issue.
if (minGap > gapVertexEps)
{
string lengthAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, minGap, true, false);
string maxGapAsString = UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), UnitType.UT_Length, gapVertexEps, true, false);
throw new InvalidOperationException("IfcCompositeCurve contains a gap of " + lengthAsString +
" that is greater than the maximum gap size of " + maxGapAsString +
" and cannot be repaired.");
}
// We have a possibility to add the segment. What we do depends on the gap distance.
// If the current curve loop's closest end to the next segment is its end (vs. start) point, set attachNextSegmentToEnd to true.
attachNextSegmentToEnd = (MathUtil.IsAlmostEqual(distLoopEndPtToNextStartPt, minGap)) ||
(MathUtil.IsAlmostEqual(distLoopEndPtToNextEndPt, minGap));
// We need to reverse the next segment if:
// 1. We are attaching the next segment to the end of the curve loop, and the next segment's closest end to the current curve loop is its end (vs. start) point.
// 2. We are attaching the next segment to the start of the curve loop, and the next segment's closest end to the current curve loop is its start (vs. end) point.
reverseNextSegment = (MathUtil.IsAlmostEqual(distLoopEndPtToNextEndPt, minGap)) ||
(MathUtil.IsAlmostEqual(distLoopStartPtToNextStartPt, minGap));
}
if (reverseNextSegment)
{
curveSegments[ii] = curveSegments[ii].CreateReversed();
MathUtil.Swap <XYZ>(ref nextStartPoint, ref nextEndPoint);
}
// If minGap is less than vertexEps, we won't need to do any repairing - just fix the orientation if necessary.
if (minGap < vertexEps)
{
if (attachNextSegmentToEnd)
{
// Update the curve loop end point to be the end point of the next segment after potentially being reversed.
curveLoopEndPoint = nextEndPoint;
}
else
{
canRepairFirst = curveSegments[ii] is Line;
curveLoopStartPoint = nextStartPoint;
// Update the curve loop start point to be the start point of the next segment, now at the beginning of the loop,
// after potentially being reversed.
Curve tmpCurve = curveSegments[ii];
curveSegments.RemoveAt(ii);
curveSegments.Insert(0, tmpCurve);
}
continue;
}
// The gap is too big for CurveLoop, but smaller than our maximum tolerance - we will try to fix the gap by extending
// one of the line segments around the gap. If the gap is between two Arcs, we will try to introduce a short
// segment between them, as long as the gap is larger than the short curve tolerance.
bool canRepairNext = curveSegments[ii] is Line;
bool createdRepairLine = false;
if (attachNextSegmentToEnd)
{
// Update the curve loop end point to be the end point of the next segment after potentially being reversed.
XYZ originalCurveLoopEndPoint = curveLoopEndPoint;
curveLoopEndPoint = nextEndPoint;
if (canRepairNext)
{
curveSegments[ii] = RepairLineAndReport(Id, originalCurveLoopEndPoint, curveLoopEndPoint, minGap);
}
else if (curveSegments[ii - 1] is Line) // = canRepairCurrent, only used here.
{
curveSegments[ii - 1] = RepairLineAndReport(Id, curveSegments[ii - 1].GetEndPoint(0), curveSegments[ii].GetEndPoint(0), minGap);
}
else
{
// Can't add a line to fix a gap that is smaller than the short curve tolerance.
// In the future, we may fix this gap by intersecting the two curves and extending one of them.
if (minGap < shortCurveTol + MathUtil.Eps())
{
Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that is too short to be repaired by a connecting segment.", true);
}
try
{
Line repairLine = Line.CreateBound(originalCurveLoopEndPoint, curveSegments[ii].GetEndPoint(0));
curveSegments.Insert(ii, repairLine);
ii++; // Skip the repair line as we've already "added" it and the non-linear segment to our growing loop.
numSegments++;
createdRepairLine = true;
}
catch
{
Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that can't be fixed.", true);
}
}
}
else
{
XYZ originalCurveLoopStartPoint = curveLoopStartPoint;
curveLoopStartPoint = nextStartPoint;
if (canRepairNext)
{
curveSegments[ii] = RepairLineAndReport(Id, curveLoopStartPoint, originalCurveLoopStartPoint, minGap);
}
else if (canRepairFirst)
{
curveSegments[0] = RepairLineAndReport(Id, curveSegments[ii].GetEndPoint(1), curveSegments[0].GetEndPoint(1), minGap);
}
else
{
// Can't add a line to fix a gap that is smaller than the short curve tolerance.
// In the future, we may fix this gap by intersecting the two curves and extending one of them.
if (minGap < shortCurveTol + MathUtil.Eps())
{
Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that is too short to be repaired by a connecting segment.", true);
}
Line repairLine = Line.CreateBound(curveSegments[ii].GetEndPoint(1), originalCurveLoopStartPoint);
curveSegments.Insert(0, repairLine);
ii++; // Skip the repair line as we've already "added" it and the non-linear curve to our growing loop.
numSegments++;
}
// Either canRepairFirst was already true, or canRepairNext was true and we added it to the front of the loop,
// or we added a short repair line to the front of the loop. In any of these cases, the front curve segement of the
// loop is now a line segment.
if (!canRepairFirst && !canRepairNext && !createdRepairLine)
{
Importer.TheLog.LogError(Id, "IfcCompositeCurve contains a gap between two non-linear segments that can't be fixed.", true);
}
canRepairFirst = true;
// Move the curve to the front of the loop.
Curve tmpCurve = curveSegments[ii];
curveSegments.RemoveAt(ii);
curveSegments.Insert(0, tmpCurve);
}
}
if (CurveLoop == null)
{
CurveLoop = new CurveLoop();
}
foreach (Curve curveSegment in curveSegments)
{
if (curveSegment != null)
{
CurveLoop.Append(curveSegment);
}
}
}
catch (Exception ex)
{
Importer.TheLog.LogError(Id, ex.Message, true);
}
// Try to create the curve representation of this IfcCompositeCurve
Curve = ConvertCurveLoopIntoSingleCurve(CurveLoop);
}
/// <summary>
/// Gets material handle from material id or creates one if there is none.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="materialId">The material id.</param>
/// <returns>The handle.</returns>
public static IFCAnyHandle GetOrCreateMaterialHandle(ExporterIFC exporterIFC, ElementId materialId)
{
Document document = ExporterCacheManager.Document;
IFCAnyHandle materialNameHandle = ExporterCacheManager.MaterialHandleCache.Find(materialId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(materialNameHandle))
{
string materialName = " <Unnamed>";
string description = null;
string category = null;
if (materialId != ElementId.InvalidElementId)
{
Material material = document.GetElement(materialId) as Material;
if (material != null)
{
materialName = NamingUtil.GetNameOverride(material, material.Name);
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
category = NamingUtil.GetOverrideStringValue(material, "IfcCategory",
NamingUtil.GetOverrideStringValue(material, "Category", material.MaterialCategory));
description = NamingUtil.GetOverrideStringValue(material, "IfcDescription", null);
}
}
}
materialNameHandle = IFCInstanceExporter.CreateMaterial(exporterIFC.GetFile(), materialName, description: description, category: category);
ExporterCacheManager.MaterialHandleCache.Register(materialId, materialNameHandle);
// associate Material with SurfaceStyle if necessary.
IFCFile file = exporterIFC.GetFile();
if (materialId != ElementId.InvalidElementId && !ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && materialNameHandle.HasValue)
{
HashSet <IFCAnyHandle> matRepHandles = IFCAnyHandleUtil.GetHasRepresentation(materialNameHandle);
if (matRepHandles.Count == 0)
{
Material matElem = document.GetElement(materialId) as Material;
// TODO_DOUBLE_PATTERN - deal with background pattern
ElementId fillPatternId = (matElem != null) ? matElem.CutForegroundPatternId : ElementId.InvalidElementId;
Autodesk.Revit.DB.Color color = (matElem != null) ? GetSafeColor(matElem.CutForegroundPatternColor) : new Color(0, 0, 0);
double planScale = 100.0;
HashSet <IFCAnyHandle> styles = new HashSet <IFCAnyHandle>();
bool hasFill = false;
IFCAnyHandle styledRepItem = null;
IFCAnyHandle matStyleHnd = CategoryUtil.GetOrCreateMaterialStyle(document, exporterIFC, materialId);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(matStyleHnd) && !ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
styles.Add(matStyleHnd);
bool supportCutStyles = !ExporterCacheManager.ExportOptionsCache.ExportAsCoordinationView2;
if (fillPatternId != ElementId.InvalidElementId && supportCutStyles)
{
IFCAnyHandle cutStyleHnd = exporterIFC.GetOrCreateFillPattern(fillPatternId, color, planScale);
if (cutStyleHnd.HasValue)
{
styles.Add(cutStyleHnd);
hasFill = true;
}
}
IFCAnyHandle presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, styles);
HashSet <IFCAnyHandle> presStyleSet = new HashSet <IFCAnyHandle>();
presStyleSet.Add(presStyleHnd);
IFCAnyHandle styledItemHnd = IFCInstanceExporter.CreateStyledItem(file, styledRepItem, presStyleSet, null);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("");
string repId = "Style";
string repType = (hasFill) ? "Material and Cut Pattern" : "Material";
HashSet <IFCAnyHandle> repItems = new HashSet <IFCAnyHandle>();
repItems.Add(styledItemHnd);
IFCAnyHandle styleRepHnd = IFCInstanceExporter.CreateStyledRepresentation(file, contextOfItems, repId, repType, repItems);
List <IFCAnyHandle> repList = new List <IFCAnyHandle>();
repList.Add(styleRepHnd);
IFCAnyHandle matDefRepHnd = IFCInstanceExporter.CreateMaterialDefinitionRepresentation(file, null, null, repList, materialNameHandle);
}
}
}
}
return(materialNameHandle);
}
/// <summary>
/// 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 IFCProductWrapper object.</param>
public static void ExportPart(ExporterIFC exporterIFC, Element partElement, IFCProductWrapper productWrapper,
IFCPlacementSetter placementSetter, IFCAnyHandle originalPlacement, IFCRange range, IFCExtrusionAxes ifcExtrusionAxes,
Element hostElement, ElementId overrideLevelId, bool asBuildingElement)
{
if (!ElementFilteringUtil.IsElementVisible(ExporterCacheManager.ExportOptionsCache.FilterViewForExport, partElement))
{
return;
}
Part part = partElement as Part;
if (part == null)
{
return;
}
IFCPlacementSetter standalonePlacementSetter = null;
bool standaloneExport = hostElement == null && !asBuildingElement;
ElementId partExportLevel = null;
if (standaloneExport || asBuildingElement)
{
if (partElement.Level != null)
{
partExportLevel = partElement.Level.Id;
}
}
else
{
if (part.OriginalCategoryId != hostElement.Category.Id)
{
return;
}
partExportLevel = hostElement.Level.Id;
}
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 = IFCPlacementSetter.Create(exporterIFC, partElement, null, orientationTrf, partExportLevel);
partPlacement = standalonePlacementSetter.GetPlacement();
}
else
{
partPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
}
bool validRange = (range != null && !MathUtil.IsAlmostZero(range.Start - range.End));
SolidMeshGeometryInfo solidMeshInfo;
if (validRange)
{
solidMeshInfo = GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, range);
if (solidMeshInfo.GetSolids().Count == 0 && solidMeshInfo.GetMeshes().Count == 0)
{
return;
}
}
else
{
solidMeshInfo = GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity);
}
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);
BodyData bodyData = null;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
if (solids.Count > 0 || meshes.Count > 0)
{
bodyData = BodyExporter.ExportBody(partElement.Document.Application, exporterIFC, partElement, catId, solids, meshes,
bodyExporterOptions, extrusionCreationData);
}
else
{
IList <GeometryObject> geomlist = new List <GeometryObject>();
geomlist.Add(geometryElement);
bodyData = BodyExporter.ExportBody(partElement.Document.Application, exporterIFC, partElement, catId, geomlist,
bodyExporterOptions, extrusionCreationData);
}
IFCAnyHandle bodyRep = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(bodyRep))
{
extrusionCreationData.ClearOpenings();
return;
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string partGUID = ExporterIFCUtils.CreateGUID(partElement);
string origPartName = NamingUtil.CreateIFCName(exporterIFC, -1);
string partName = NamingUtil.GetNameOverride(partElement, origPartName);
string partDescription = NamingUtil.GetDescriptionOverride(partElement, null);
string partObjectType = NamingUtil.GetObjectTypeOverride(partElement, NamingUtil.CreateIFCObjectName(exporterIFC, partElement));
string partElemId = NamingUtil.CreateIFCElementId(partElement);
IFCAnyHandle ifcPart = null;
if (!asBuildingElement)
{
ifcPart = IFCInstanceExporter.CreateBuildingElementPart(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partElemId);
}
else
{
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, hostElement, out ifcEnumType);
switch (exportType)
{
case IFCExportType.ExportColumnType:
ifcPart = IFCInstanceExporter.CreateColumn(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partElemId);
break;
case IFCExportType.ExportCovering:
IFCCoveringType coveringType = CeilingExporter.GetIFCCoveringType(hostElement, ifcEnumType);
ifcPart = IFCInstanceExporter.CreateCovering(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partElemId, coveringType);
break;
case IFCExportType.ExportFooting:
IFCFootingType footingType = FootingExporter.GetIFCFootingType(hostElement, ifcEnumType);
ifcPart = IFCInstanceExporter.CreateFooting(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partElemId, footingType);
break;
case IFCExportType.ExportRoof:
IFCRoofType roofType = RoofExporter.GetIFCRoofType(ifcEnumType);
ifcPart = IFCInstanceExporter.CreateRoof(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partElemId, roofType);
break;
case IFCExportType.ExportSlab:
IFCSlabType slabType = FloorExporter.GetIFCSlabType(ifcEnumType);
ifcPart = IFCInstanceExporter.CreateSlab(file, partGUID, ownerHistory, partName, partDescription, partObjectType,
extrusionCreationData.GetLocalPlacement(), prodRep, partElemId, slabType);
break;
case IFCExportType.ExportWall:
ifcPart = IFCInstanceExporter.CreateWallStandardCase(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partElemId);
break;
default:
ifcPart = IFCInstanceExporter.CreateBuildingElementProxy(file, partGUID, ownerHistory, partName, partDescription,
partObjectType, extrusionCreationData.GetLocalPlacement(), prodRep, partElemId, IFCElementComposition.Element);
break;
}
}
productWrapper.AddElement(ifcPart, standaloneExport || asBuildingElement ? standalonePlacementSetter : placementSetter, extrusionCreationData, standaloneExport || asBuildingElement);
//Add the exported part to exported cache.
TraceExportedParts(partElement, partExportLevel, standaloneExport || asBuildingElement ? ElementId.InvalidElementId : hostElement.Id);
CategoryUtil.CreateMaterialAssociations(partElement.Document, exporterIFC, ifcPart, bodyData.MaterialIds);
transaction.Commit();
}
}
}
finally
{
if (standalonePlacementSetter != null)
{
standalonePlacementSetter.Dispose();
}
}
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
IFCAnyHandle localOrigin = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "LocalOrigin", false);
XYZ origin = null;
if (localOrigin != null)
{
origin = IFCPoint.ProcessScaledLengthIFCCartesianPoint(localOrigin);
}
else
{
origin = XYZ.Zero;
}
IFCAnyHandle axis1 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis1");
XYZ xAxis = null;
if (axis1 != null)
{
xAxis = IFCPoint.ProcessNormalizedIFCDirection(axis1);
}
IFCAnyHandle axis2 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis2");
XYZ yAxis = null;
if (axis2 != null)
{
yAxis = IFCPoint.ProcessNormalizedIFCDirection(axis2);
}
Scale = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale", 1.0);
XYZ zAxis = null;
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator2DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
}
else if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3D))
{
IFCAnyHandle axis3 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis3");
if (axis3 != null)
{
zAxis = IFCPoint.ProcessNormalizedIFCDirection(axis3);
}
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
ScaleZ = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale3", Scale);
}
}
// Set the axes based on what is specified.
// If all three axes are set, ensure they are truly orthogonal.
// If two axes are set, ensure they are orthogonal and set the 3rd axis to be the cross product.
// If one axis is set, arbitrarily set the next axis to be the basis vector which
// If no axes are set, use identity transform.
if (xAxis == null)
{
if (yAxis == null)
{
if (zAxis == null)
{
xAxis = XYZ.BasisX;
yAxis = XYZ.BasisY;
zAxis = XYZ.BasisZ;
}
}
else if (zAxis == null)
{
// Special case - Y axis is in XY plane.
if (MathUtil.IsAlmostZero(yAxis[2]))
{
xAxis = new XYZ(yAxis[1], -yAxis[0], 0.0);
zAxis = XYZ.BasisZ;
}
else
{
throw new InvalidOperationException("#" + item.StepId + ": IfcCartesianTransformOperator has only y axis defined, ignoring.");
}
}
else
{
xAxis = yAxis.CrossProduct(zAxis);
}
}
else if (yAxis == null)
{
if (zAxis == null)
{
// Special case - X axis is in XY plane.
if (MathUtil.IsAlmostZero(xAxis[2]))
{
yAxis = new XYZ(xAxis[1], -xAxis[0], 0.0);
zAxis = XYZ.BasisZ;
}
else
{
throw new InvalidOperationException("#" + item.StepId + ": IfcCartesianTransformOperator has only x axis defined, ignoring.");
}
}
else
{
yAxis = zAxis.CrossProduct(xAxis);
}
}
else if (zAxis == null)
{
zAxis = xAxis.CrossProduct(yAxis);
}
// Make sure that the axes are really orthogonal.
if (!MathUtil.IsAlmostZero(xAxis.DotProduct(zAxis)))
{
zAxis = xAxis.CrossProduct(yAxis);
}
if (!MathUtil.IsAlmostZero(xAxis.DotProduct(yAxis)))
{
yAxis = zAxis.CrossProduct(xAxis);
}
Transform = Transform.CreateTranslation(origin);
Transform.set_Basis(0, xAxis);
Transform.set_Basis(1, yAxis);
Transform.set_Basis(2, zAxis);
}
/// <summary>
/// Exports an element as IFC covering.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="element">The element to be exported.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The ProductWrapper.</param>
public static void ExportCovering(ExporterIFC exporterIFC, Element element, GeometryElement geomElem, string ifcEnumType, ProductWrapper productWrapper)
{
bool exportParts = PartExporter.CanExportParts(element);
if (exportParts && !PartExporter.CanExportElementInPartExport(element, element.LevelId, false))
{
return;
}
ElementType elemType = element.Document.GetElement(element.GetTypeId()) as ElementType;
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
using (IFCExtrusionCreationData ecData = new IFCExtrusionCreationData())
{
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
IFCAnyHandle prodRep = null;
if (!exportParts)
{
ecData.SetLocalPlacement(setter.LocalPlacement);
ecData.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, element,
categoryId, geomElem, bodyExporterOptions, null, ecData, true);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRep))
{
ecData.ClearOpenings();
return;
}
}
// We will use the category of the element to set a default value for the covering.
string defaultCoveringEnumType = null;
if (categoryId == new ElementId(BuiltInCategory.OST_Ceilings))
{
defaultCoveringEnumType = "CEILING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Floors))
{
defaultCoveringEnumType = "FLOORING";
}
else if (categoryId == new ElementId(BuiltInCategory.OST_Roofs))
{
defaultCoveringEnumType = "ROOFING";
}
string instanceGUID = GUIDUtil.CreateGUID(element);
string 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 coveringType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType, defaultCoveringEnumType);
IFCAnyHandle covering = IFCInstanceExporter.CreateCovering(file, instanceGUID, exporterIFC.GetOwnerHistoryHandle(),
instanceName, instanceDescription, instanceObjectType, setter.LocalPlacement, prodRep, instanceTag, coveringType);
if (exportParts)
{
PartExporter.ExportHostPart(exporterIFC, element, covering, productWrapper, setter, setter.LocalPlacement, null);
}
bool containInSpace = false;
IFCAnyHandle localPlacementToUse = setter.LocalPlacement;
// Ceiling containment in Space is generally required and not specific to any view
if (ExporterCacheManager.CeilingSpaceRelCache.ContainsKey(element.Id))
{
IList <ElementId> roomlist = ExporterCacheManager.CeilingSpaceRelCache[element.Id];
// Process Ceiling to be contained in a Space only when it is exactly bounding one Space
if (roomlist.Count == 1)
{
productWrapper.AddElement(element, covering, setter, null, false);
// Modify the Ceiling placement to be relative to the Space that it bounds
IFCAnyHandle roomPlacement = IFCAnyHandleUtil.GetObjectPlacement(ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(roomlist[0]));
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(roomPlacement, localPlacementToUse);
Transform inverseTrf = relTrf.Inverse;
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
IFCAnyHandleUtil.SetAttribute(localPlacementToUse, "PlacementRelTo", roomPlacement);
GeometryUtil.SetRelativePlacement(localPlacementToUse, relLocalPlacement);
ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomlist[0], covering);
containInSpace = true;
}
}
// if not contained in Space, assign it to default containment in Level
if (!containInSpace)
{
productWrapper.AddElement(element, covering, setter, null, true);
}
if (!exportParts)
{
Ceiling ceiling = element as Ceiling;
if (ceiling != null)
{
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, ceiling, covering,
geomElem, productWrapper, ElementId.InvalidElementId, Toolkit.IFCLayerSetDirection.Axis3, null);
}
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 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);
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 = exporterIFC.GetOwnerHistoryHandle();
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.CreateMaterialAssociations(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.CreateMaterialAssociations(exporterIFC, slabHnd, bodyData.MaterialIds);
}
}
tr.Commit();
}
}
}
/// <summary>
/// Exports a roof 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 element.</param>
/// <param name="geometry">The geometry of the element.</param>
/// <param name="productWrapper">The product wrapper.</param>
/// <returns>The roof handle.</returns>
public static IFCAnyHandle ExportRoofAsContainer(ExporterIFC exporterIFC, string ifcEnumType, Element element, GeometryElement geometry, ProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
if (!(element is ExtrusionRoof) && !(element is FootPrintRoof))
{
return(null);
}
using (IFCTransaction transaction = new IFCTransaction(file))
{
using (PlacementSetter setter = PlacementSetter.Create(exporterIFC, element))
{
IFCAnyHandle localPlacement = setter.LocalPlacement;
RoofComponents roofComponents = null;
try
{
roofComponents = ExporterIFCUtils.GetRoofComponents(exporterIFC, element as RoofBase);
}
catch
{
return(null);
}
if (roofComponents == null)
{
return(null);
}
try
{
using (IFCExtrusionCreationData extrusionCreationData = new IFCExtrusionCreationData())
{
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
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 roofType = IFCValidateEntry.GetValidIFCType(element, ifcEnumType);
IFCAnyHandle roofHandle = IFCInstanceExporter.CreateRoof(file, elementGUID, ownerHistory, elementName, elementDescription,
elementObjectType, localPlacement, prodRepHnd, elementId, roofType);
IList <IFCAnyHandle> elementHandles = new List <IFCAnyHandle>();
elementHandles.Add(roofHandle);
//only thing supported right now.
XYZ extrusionDir = new XYZ(0, 0, 1);
ElementId catId = CategoryUtil.GetSafeCategoryId(element);
IList <CurveLoop> roofCurveloops = roofComponents.GetCurveLoops();
IList <XYZ> planeDirs = roofComponents.GetPlaneDirections();
IList <XYZ> planeOrigins = roofComponents.GetPlaneOrigins();
IList <Face> loopFaces = roofComponents.GetLoopFaces();
double scaledDepth = roofComponents.ScaledDepth;
IList <double> areas = roofComponents.GetAreasOfCurveLoops();
IList <IFCAnyHandle> slabHandles = new List <IFCAnyHandle>();
using (IFCExtrusionCreationData slabExtrusionCreationData = new IFCExtrusionCreationData())
{
slabExtrusionCreationData.SetLocalPlacement(extrusionCreationData.GetLocalPlacement());
slabExtrusionCreationData.ReuseLocalPlacement = false;
slabExtrusionCreationData.ForceOffset = true;
for (int numLoop = 0; numLoop < roofCurveloops.Count; numLoop++)
{
trfSetter.InitializeFromBoundingBox(exporterIFC, geometryList, slabExtrusionCreationData);
Plane plane = new Plane(planeDirs[numLoop], planeOrigins[numLoop]);
IList <CurveLoop> curveLoops = new List <CurveLoop>();
curveLoops.Add(roofCurveloops[numLoop]);
double slope = Math.Abs(planeDirs[numLoop].Z);
double scaledExtrusionDepth = scaledDepth * slope;
IFCAnyHandle shapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, plane, extrusionDir, scaledExtrusionDepth);
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 = (numLoop < 256) ? GUIDUtil.CreateSubElementGUID(element, (int)IFCRoofSubElements.RoofSlabStart + numLoop) : GUIDUtil.CreateGUID();
IFCAnyHandle slabPlacement = ExporterUtil.CreateLocalPlacement(file, slabExtrusionCreationData.GetLocalPlacement(), null);
IFCAnyHandle slabHnd = IFCInstanceExporter.CreateSlab(file, slabGUID, ownerHistory, elementName,
elementDescription, elementObjectType, slabPlacement, repHnd, elementId, "ROOF");
//slab quantities
slabExtrusionCreationData.ScaledLength = scaledExtrusionDepth;
slabExtrusionCreationData.ScaledArea = UnitUtil.ScaleArea(areas[numLoop]);
slabExtrusionCreationData.ScaledOuterPerimeter = UnitUtil.ScaleLength(curveLoops[0].GetExactLength());
slabExtrusionCreationData.Slope = UnitUtil.ScaleAngle(Math.Acos(Math.Abs(planeDirs[numLoop].Z)));
productWrapper.AddElement(null, slabHnd, setter, slabExtrusionCreationData, false);
elementHandles.Add(slabHnd);
slabHandles.Add(slabHnd);
}
}
productWrapper.AddElement(element, roofHandle, setter, extrusionCreationData, true);
ExporterUtil.RelateObjects(exporterIFC, null, roofHandle, slabHandles);
OpeningUtil.AddOpeningsToElement(exporterIFC, elementHandles, roofCurveloops, element, null, roofComponents.ScaledDepth,
null, setter, localPlacement, productWrapper);
transaction.Commit();
return(roofHandle);
}
}
}
finally
{
exporterIFC.ClearFaceWithElementHandleMap();
}
}
}
}
/// <summary>
/// Creates openings if there is necessary.
/// </summary>
/// <param name="elementHandle">The element handle to create openings.</param>
/// <param name="element">The element to create openings.</param>
/// <param name="info">The extrusion data.</param>
/// <param name="extraParams">The extrusion creation data.</param>
/// <param name="offsetTransform">The offset transform from ExportBody, or the identity transform.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="originalPlacement">The original placement handle.</param>
/// <param name="setter">The PlacementSetter.</param>
/// <param name="wrapper">The ProductWrapper.</param>
private static void CreateOpeningsIfNecessaryBase(IFCAnyHandle elementHandle, Element element, IList <IFCExtrusionData> info,
IFCExtrusionCreationData extraParams, Transform offsetTransform, ExporterIFC exporterIFC,
IFCAnyHandle originalPlacement, PlacementSetter setter, ProductWrapper wrapper)
{
if (IFCAnyHandleUtil.IsNullOrHasNoValue(elementHandle))
{
return;
}
int sz = info.Count;
if (sz == 0)
{
return;
}
using (TransformSetter transformSetter = TransformSetter.Create())
{
if (offsetTransform != null)
{
transformSetter.Initialize(exporterIFC, offsetTransform.Inverse);
}
IFCFile file = exporterIFC.GetFile();
ElementId categoryId = CategoryUtil.GetSafeCategoryId(element);
Document document = element.Document;
string openingObjectType = "Opening";
int openingNumber = 1;
for (int curr = info.Count - 1; curr >= 0; curr--)
{
Transform extrusionTrf = Transform.Identity;
IFCAnyHandle extrusionHandle =
ExtrusionExporter.CreateExtrudedSolidFromExtrusionData(exporterIFC, element, info[curr], out extrusionTrf);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(extrusionHandle))
{
continue;
}
// Openings shouldn't have surface styles for their geometry.
HashSet <IFCAnyHandle> bodyItems = new HashSet <IFCAnyHandle>();
bodyItems.Add(extrusionHandle);
IFCAnyHandle contextOfItems = exporterIFC.Get3DContextHandle("Body");
IFCAnyHandle bodyRep = RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItems, null);
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(bodyRep);
IFCAnyHandle openingRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = ExporterUtil.CopyLocalPlacement(file, originalPlacement);
string guid = GUIDUtil.CreateGUID();
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
string openingName = NamingUtil.GetIFCNamePlusIndex(element, openingNumber++);
string openingDescription = NamingUtil.GetDescriptionOverride(element, null);
string openingTag = NamingUtil.GetTagOverride(element);
IFCAnyHandle openingElement = IFCInstanceExporter.CreateOpeningElement(exporterIFC,
guid, ownerHistory, openingName, openingDescription, openingObjectType,
openingPlacement, openingRep, openingTag);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcOpeningElement);
wrapper.AddElement(null, openingElement, setter, extraParams, true, exportInfo);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && (extraParams != null))
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingElement, extraParams);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, elementHandle, openingElement);
}
}
}
/// <summary>
/// Creates an opening from a solid.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="hostObjHnd">The host object handle.</param>
/// <param name="hostElement">The host element.</param>
/// <param name="insertElement">The insert element.</param>
/// <param name="openingGUID">The GUID for the opening, depending on how the opening is created.</param>
/// <param name="solid">The solid.</param>
/// <param name="scaledHostWidth">The scaled host width.</param>
/// <param name="isRecess">True if it is recess.</param>
/// <param name="extrusionCreationData">The extrusion creation data.</param>
/// <param name="setter">The placement setter.</param>
/// <param name="localWrapper">The product wrapper.</param>
/// <returns>The created opening handle.</returns>
static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle hostObjHnd, Element hostElement, Element insertElement, string openingGUID,
Solid solid, double scaledHostWidth, bool isRecess, IFCExtrusionCreationData extrusionCreationData, PlacementSetter setter, ProductWrapper localWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
XYZ prepToWall;
bool isLinearWall = GetOpeningDirection(hostElement, out prepToWall);
if (isLinearWall)
{
extrusionCreationData.CustomAxis = prepToWall;
extrusionCreationData.PossibleExtrusionAxes = IFCExtrusionAxes.TryCustom;
}
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
bodyExporterOptions.CreatingVoid = true;
BodyData bodyData = BodyExporter.ExportBody(exporterIFC, insertElement, catId, ElementId.InvalidElementId,
solid, bodyExporterOptions, extrusionCreationData);
IFCAnyHandle openingRepHnd = bodyData.RepresentationHnd;
if (IFCAnyHandleUtil.IsNullOrHasNoValue(openingRepHnd))
{
extrusionCreationData.ClearOpenings();
return(null);
}
IList <IFCAnyHandle> representations = new List <IFCAnyHandle>();
representations.Add(openingRepHnd);
IFCAnyHandle prodRep = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, representations);
IFCAnyHandle openingPlacement = extrusionCreationData.GetLocalPlacement();
IFCAnyHandle hostObjPlacementHnd = IFCAnyHandleUtil.GetObjectPlacement(hostObjHnd);
Transform relTransform = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(openingPlacement, hostObjPlacementHnd);
openingPlacement = ExporterUtil.CreateLocalPlacement(file, hostObjPlacementHnd,
relTransform.Origin, relTransform.BasisZ, relTransform.BasisX);
IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
double scaledOpeningLength = extrusionCreationData.ScaledLength;
string openingObjectType = "Opening";
if (!MathUtil.IsAlmostZero(scaledHostWidth) && !MathUtil.IsAlmostZero(scaledOpeningLength))
{
openingObjectType = scaledOpeningLength < (scaledHostWidth - MathUtil.Eps()) ? "Recess" : "Opening";
}
else
{
openingObjectType = isRecess ? "Recess" : "Opening";
}
string openingName = NamingUtil.GetNameOverride(insertElement, null);
if (string.IsNullOrEmpty(openingName))
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(hostObjHnd))
{
openingName = IFCAnyHandleUtil.GetStringAttribute(hostObjHnd, "Name");
}
else
{
openingName = NamingUtil.GetNameOverride(hostElement, NamingUtil.CreateIFCObjectName(exporterIFC, hostElement));
}
}
string openingDescription = NamingUtil.GetDescriptionOverride(insertElement, null);
string openingTag = NamingUtil.GetTagOverride(insertElement);
IFCAnyHandle openingHnd = IFCInstanceExporter.CreateOpeningElement(exporterIFC,
openingGUID, ownerHistory, openingName, openingDescription, openingObjectType,
openingPlacement, prodRep, openingTag);
IFCExportInfoPair exportInfo = new IFCExportInfoPair(IFCEntityType.IfcOpeningElement, openingObjectType);
if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
{
PropertyUtil.CreateOpeningQuantities(exporterIFC, openingHnd, extrusionCreationData);
}
if (localWrapper != null)
{
Element elementForProperties = null;
if (GUIDUtil.IsGUIDFor(insertElement, openingGUID))
{
elementForProperties = insertElement;
}
localWrapper.AddElement(insertElement, openingHnd, setter, extrusionCreationData, false, exportInfo);
}
string voidGuid = GUIDUtil.CreateGUID();
IFCInstanceExporter.CreateRelVoidsElement(file, voidGuid, ownerHistory, null, null, hostObjHnd, openingHnd);
return(openingHnd);
}