/// <summary>
/// Exports mullion.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="mullion">
/// The mullion object.
/// </param>
/// <param name="geometryElement">
/// The geometry element.
/// </param>
/// <param name="localPlacement">
/// The local placement handle.
/// </param>
/// <param name="extraParams">
/// The extrusion creation data.
/// </param>
/// <param name="setter">
/// The IFCPlacementSetter.
/// </param>
/// <param name="productWrapper">
/// The IFCProductWrapper.
/// </param>
public static void Export(ExporterIFC exporterIFC, Mullion mullion, GeometryElement geometryElement,
IFCAnyHandle localPlacement, IFCExtrusionCreationData extraParams, IFCPlacementSetter setter, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
ElementId catId = CategoryUtil.GetSafeCategoryId(mullion);
BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true);
IFCAnyHandle repHnd = RepresentationUtil.CreateBRepProductDefinitionShape(mullion.Document.Application, exporterIFC, mullion, catId,
geometryElement, bodyExporterOptions, null, extraParams);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
{
extraParams.ClearOpenings();
return;
}
string elemGUID = ExporterIFCUtils.CreateGUID(mullion);
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
string elemObjectType = NamingUtil.CreateIFCObjectName(exporterIFC, mullion);
string elemId = NamingUtil.CreateIFCElementId(mullion);
IFCAnyHandle mullionHnd = IFCInstanceExporter.CreateMember(file, elemGUID, ownerHistory, elemObjectType, null, elemObjectType,
localPlacement, repHnd, elemId);
productWrapper.AddElement(mullionHnd, setter, extraParams, LevelUtil.AssociateElementToLevel(mullion));
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, mullion, productWrapper);
}
/// <summary>
/// Create the handle corresponding to the "Axis" IfcRepresentation for a beam, if possible.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC class.</param>
/// <param name="element">The beam element.</param>
/// <param name="catId">The beam category id.</param>
/// <param name="axisInfo">The optional beam axis information.</param>
/// <param name="offsetTransform">The optional offset transform applied to the "Body" representation.</param>
/// <param name="elevation">The optional level elevation.</param>
/// <returns>The handle, or null if not created.</returns>
private static IFCAnyHandle CreateBeamAxis(ExporterIFC exporterIFC, Element element, ElementId catId, BeamAxisInfo axisInfo, Transform offsetTransform, double elevation)
{
if (axisInfo == null)
{
return(null);
}
Curve curve = axisInfo.Axis;
XYZ projDir = axisInfo.AxisNormal;
Transform lcs = axisInfo.LCSAsTransform;
string representationTypeOpt = "Curve2D"; // This is by IFC2x2+ convention.
XYZ curveOffset = XYZ.Zero;
if (offsetTransform != null)
{
curveOffset = -(offsetTransform.Origin);
curveOffset -= new XYZ(0, 0, elevation);
}
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 = -lcs.Origin;
}
Transform offsetLCS = new Transform(lcs);
offsetLCS.Origin = XYZ.Zero;
IList <IFCAnyHandle> axis_items = null;
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
IFCAnyHandle axisHnd = GeometryUtil.CreatePolyCurveFromCurve(exporterIFC, curve);
axis_items = new List <IFCAnyHandle>();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(axisHnd))
{
axis_items.Add(axisHnd);
representationTypeOpt = "Curve3D"; // We use Curve3D for IFC4RV Axis
}
}
else
{
IFCGeometryInfo info = IFCGeometryInfo.CreateCurveGeometryInfo(exporterIFC, offsetLCS, projDir, false);
ExporterIFCUtils.CollectGeometryInfo(exporterIFC, info, curve, curveOffset, true);
axis_items = info.GetCurves();
}
if (axis_items.Count > 0)
{
string identifierOpt = "Axis"; // This is by IFC2x2+ convention.
IFCAnyHandle axisRep = RepresentationUtil.CreateShapeRepresentation(exporterIFC, element, catId, exporterIFC.Get3DContextHandle(identifierOpt),
identifierOpt, representationTypeOpt, axis_items);
return(axisRep);
}
return(null);
}
// Check Profile-----------------------------------------------------------
public static bool Check_Profile(Element element, Element element_link, Document doc, Document doc_link)
{
bool Profile_change = false;
try
{
if (element.Category.Name == Source.Category_Check[4].name)
{
if (ExporterIFCUtils.HasElevationProfile(element as Wall) || ExporterIFCUtils.HasElevationProfile(element_link as Wall))
{
if (string.Join(",", Support.Get_Profile(doc, element).Select(x => x.ToString())) != string.Join(",", Support.Get_Profile(doc_link, element_link).Select(x => x.ToString())))
{
Profile_change = true;
}
}
}
else if (element.Category.Name == Source.Category_Check[3].name)
{
if (string.Join(",", Support.Get_Profile(doc, element).Select(x => x.ToString())) != string.Join(",", Support.Get_Profile(doc_link, element_link).Select(x => x.ToString())))
{
Profile_change = true;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(Profile_change);
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
bool valid = true;
if (m_CurrentElement != element)
{
double scale = exporterIFC.LinearScale;
m_CurrentElement = element;
if (StairsExporter.IsLegacyStairs(element))
{
ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element,
out m_NumberOfRisers, out m_NumberOfTreads,
out m_RiserHeight, out m_TreadLength, out m_TreadLengthAtInnerSide,
out m_NosingLength, out m_WaistThickness);
m_TreadLengthAtOffset = m_TreadLength;
m_WalkingLineOffset = m_WaistThickness / 2.0;
}
else if (element is Stairs)
{
Stairs stairs = element as Stairs;
m_NumberOfRisers = stairs.ActualRisersNumber;
m_NumberOfTreads = stairs.ActualTreadsNumber;
m_RiserHeight = stairs.ActualRiserHeight * scale;
m_TreadLength = stairs.ActualTreadDepth * scale;
}
else if (element is StairsRun)
{
StairsRun stairsRun = element as StairsRun;
StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType;
Stairs stairs = stairsRun.GetStairs();
StairsType stairsType = stairs.Document.GetElement(stairs.GetTypeId()) as StairsType;
m_NumberOfRisers = stairs.ActualRisersNumber;
m_NumberOfTreads = stairs.ActualTreadsNumber;
m_RiserHeight = stairs.ActualRiserHeight * scale;
m_TreadLength = stairs.ActualTreadDepth * scale;
m_TreadLengthAtOffset = m_TreadLength;
m_NosingLength = stairsRunType.NosingLength * scale;
m_WaistThickness = stairsRun.ActualRunWidth * scale;
m_WalkingLineOffset = m_WaistThickness / 2.0;
double treadLengthAtInnerSide;
if (ParameterUtil.GetDoubleValueFromElement(stairsType,
BuiltInParameter.STAIRSTYPE_MINIMUM_TREAD_WIDTH_INSIDE_BOUNDARY, out treadLengthAtInnerSide) != null)
{
m_TreadLengthAtInnerSide = treadLengthAtInnerSide * scale;
}
else
{
m_TreadLengthAtInnerSide = 0.0;
}
}
else
{
valid = false;
}
}
return(valid);
}
/// <summary>
/// Calculates total area for a roof
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
double scale = exporterIFC.LinearScale;
m_Area = ExporterIFCUtils.ComputeRoofProjectedArea(element) * scale * scale;
return(m_Area > MathUtil.Eps() * MathUtil.Eps());
}
private static Curve FindLongestCurve(Face roomFace)
{
Curve longestCurve = null;
try
{
IList <CurveLoop> curveLoopList = roomFace.GetEdgesAsCurveLoops();
List <Curve> outerCurves = new List <Curve>();
IList <IList <CurveLoop> > curveLoopLoop = ExporterIFCUtils.SortCurveLoops(curveLoopList);
foreach (IList <CurveLoop> curveLoops in curveLoopLoop)
{
foreach (CurveLoop curveLoop in curveLoops)
{
if (curveLoop.IsCounterclockwise(roomFace.ComputeNormal(new UV(0, 0))))
{
foreach (Curve curve in curveLoop)
{
outerCurves.Add(curve);
}
break;
}
}
}
outerCurves = outerCurves.OrderByDescending(o => o.ApproximateLength).ToList();
longestCurve = outerCurves.First();
}
catch (Exception ex)
{
string message = ex.Message;
}
return(longestCurve);
}
/// <summary>
/// Creates IfcAxis2Placement3D object.
/// </summary>
/// <param name="file">
/// The IFC file.
/// </param>
/// <param name="origin">
/// The origin.
/// </param>
/// <param name="zDirection">
/// The Z direction.
/// </param>
/// <param name="xDirection">
/// The X direction.
/// </param>
/// <returns>
/// The handle.
/// </returns>
public static IFCAnyHandle CreateAxis(IFCFile file, XYZ origin, XYZ zDirection, XYZ xDirection)
{
IFCAnyHandle direction = null;
IFCAnyHandle refDirection = null;
IFCAnyHandle location = null;
if (origin != null)
{
IList <double> measure = new List <double>();
measure.Add(origin.X); measure.Add(origin.Y); measure.Add(origin.Z);
location = CreateCartesianPoint(file, measure);
}
else
{
location = ExporterIFCUtils.GetGlobal3DOriginHandle();
}
bool exportzDirectionAndxDirection = (zDirection != null && xDirection != null && (!MathUtil.IsAlmostEqual(zDirection[2], 1.0) || !MathUtil.IsAlmostEqual(xDirection[0], 1.0)));
if (exportzDirectionAndxDirection)
{
IList <double> axisPts = new List <double>();
axisPts.Add(zDirection.X); axisPts.Add(zDirection.Y); axisPts.Add(zDirection.Z);
direction = CreateDirection(file, axisPts);
}
if (exportzDirectionAndxDirection)
{
IList <double> axisPts = new List <double>();
axisPts.Add(xDirection.X); axisPts.Add(xDirection.Y); axisPts.Add(xDirection.Z);
refDirection = CreateDirection(file, axisPts);
}
return(IFCInstanceExporter.CreateAxis2Placement3D(file, location, direction, refDirection));
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
bool valid = true;
if (StairsExporter.IsLegacyStairs(element))
{
double riserHeight, treadLength, treadLengthAtInnerSide, nosingLength, waistThickness = 0;
int numberOfTreads = 0;
ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element,
out m_NumberOfRisers, out numberOfTreads,
out riserHeight, out treadLength, out treadLengthAtInnerSide,
out nosingLength, out waistThickness);
}
else if (element is Stairs)
{
Stairs stairs = element as Stairs;
m_NumberOfRisers = stairs.ActualRisersNumber;
}
else if (element is StairsRun)
{
StairsRun stairsRun = element as StairsRun;
StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType;
m_NumberOfRisers = stairsRun.ActualRisersNumber;
}
else
{
valid = false;
}
// Get override from parameter
ParameterUtil.GetIntValueFromElementOrSymbol(element, "NumberOfRiser", out m_NumberOfRisers);
return(valid);
}
public int Compare(CurveArray x, CurveArray y)
{
IList <CurveLoop> curveLoopX = new List <CurveLoop> {
CurveArrayToCurveLoop(x)
};
double areaX = ExporterIFCUtils.ComputeAreaOfCurveLoops(curveLoopX);
IList <CurveLoop> curveLoopY = new List <CurveLoop> {
CurveArrayToCurveLoop(y)
};
double areaY = ExporterIFCUtils.ComputeAreaOfCurveLoops(curveLoopY);
if (areaX < areaY)
{
return(1);
}
if (areaX > areaY)
{
return(-1);
}
else
{
return(0);
}
}
static private CurveLoop GetOuterCurveLoop(PlanarFace targetFace)
{
CurveLoop currentCurveLoop = new CurveLoop();
if (targetFace != null)
{
IList <XYZ> Points = new List <XYZ>();
IList <IList <CurveLoop> > currentListOfListOfCurveLoops = ExporterIFCUtils.SortCurveLoops(targetFace.GetEdgesAsCurveLoops());
if (currentListOfListOfCurveLoops != null)
{
if (currentListOfListOfCurveLoops.Count > 0)
{
IList <CurveLoop> currentOuterLoop = currentListOfListOfCurveLoops[0];
if (currentOuterLoop != null)
{
if (currentOuterLoop.Count > 0)
{
currentCurveLoop = currentOuterLoop[0];
}
}
}
}
}
return(currentCurveLoop);
}
public void CollectLinkInstanceInfo()
{
try
{
Parameter param = m_instance.get_Parameter(BuiltInParameter.RVT_LINK_INSTANCE_NAME);
if (null != param)
{
instanceName = param.AsString();
}
if (null != m_instance.GetTotalTransform())
{
transformValue = m_instance.GetTotalTransform();
}
linkedDocument = m_instance.GetLinkDocument();
if (null != linkedDocument)
{
linkDocTitle = linkedDocument.Title;
}
if (null != linkedDocument)
{
ifcProjectGuid = ExporterIFCUtils.CreateProjectLevelGUID(linkedDocument, IFCProjectLevelGUIDType.Project);
}
}
catch (Exception ex)
{
string message = ex.Message;
}
}
/// <summary>
/// Sets string value of a built-in parameter of an element.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="builtInParameter">The built-in parameter.</param>
/// <param name="propertyValue">The property value.</param>
/// <exception cref="System.ArgumentNullException">Thrown when element is null.</exception>
/// <exception cref="System.ArgumentException">Thrown when builtInParameter in invalid.</exception>
public static void SetStringParameter(Element element, BuiltInParameter builtInParameter, string propertyValue)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (builtInParameter == BuiltInParameter.INVALID)
{
throw new ArgumentException("BuiltInParameter is INVALID", "builtInParameter");
}
Parameter parameter = element.get_Parameter(builtInParameter);
if (parameter != null &&
parameter.HasValue &&
parameter.StorageType == StorageType.String)
{
if (!parameter.IsReadOnly)
{
parameter.Set(propertyValue);
}
return;
}
ElementId parameterId = new ElementId(builtInParameter);
ExporterIFCUtils.AddValueString(element, parameterId, propertyValue);
}
/// <summary>
/// A special case function that can export a Rebar element as an IfcBuildingElementProxy for view-specific exports where the exact geometry of the rebar matters.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="rebarElement">The rebar element to be exported.</param>
/// <param name="productWrapper">The ProductWrapper object.</param>
/// <param name="cannotExportRebar">True if we tried to create an IFC entity but failed.</param>
/// <returns>True if the rebar was exported here, false otherwise.</returns>
/// <remarks>This functionality may be obsoleted in the future.</remarks>
private static IFCAnyHandle ExportRebarAsProxyElementInView(ExporterIFC exporterIFC, Element rebarElement, ProductWrapper productWrapper, out bool cannotExportRebar)
{
IFCAnyHandle rebarEntity = null;
cannotExportRebar = false;
if (rebarElement is Rebar && ExporterCacheManager.ExportOptionsCache.FilterViewForExport != null)
{
// The only options handled here is IfcBuildingElementProxy.
// Not Exported is handled previously, and ReinforcingBar vs Mesh will be handled later.
string ifcEnumType;
IFCExportType exportType = ExporterUtil.GetExportType(exporterIFC, rebarElement, out ifcEnumType);
if (exportType == IFCExportType.IfcBuildingElementProxy ||
exportType == IFCExportType.IfcBuildingElementProxyType)
{
GeometryElement rebarGeometry = ExporterIFCUtils.GetRebarGeometry(rebarElement as Rebar, ExporterCacheManager.ExportOptionsCache.FilterViewForExport);
if (rebarGeometry != null)
{
rebarEntity = ProxyElementExporter.ExportBuildingElementProxy(exporterIFC, rebarElement, rebarGeometry, productWrapper);
}
cannotExportRebar = IFCAnyHandleUtil.IsNullOrHasNoValue(rebarEntity);
}
}
return(rebarEntity);
}
/// <summary>
/// Update the local placements of the members of an assembly relative to the assembly.
/// </summary>
/// <param name="exporterIFC">The ExporerIFC.</param>
/// <param name="assemblyPlacement">The assembly local placement handle.</param>
/// <param name="elementPlacements">The member local placement handles.</param>
public static void SetLocalPlacementsRelativeToAssembly(ExporterIFC exporterIFC, IFCAnyHandle assemblyPlacement, ICollection <IFCAnyHandle> elementPlacements)
{
foreach (IFCAnyHandle elementHandle in elementPlacements)
{
IFCAnyHandle elementPlacement = null;
try
{
// The assembly may contain nested groups, that don't have an object placement. In this case, continue.
elementPlacement = IFCAnyHandleUtil.GetObjectPlacement(elementHandle);
}
catch
{
continue;
}
Transform relTrf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(assemblyPlacement, elementPlacement);
Transform inverseTrf = relTrf.Inverse;
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file, inverseTrf.Origin, inverseTrf.BasisZ, inverseTrf.BasisX);
// NOTE: caution that old IFCAXIS2PLACEMENT3D may be unused as the new one replace it.
// But we cannot delete it safely yet because we don't know if any handle is referencing it.
GeometryUtil.SetRelativePlacement(elementPlacement, relLocalPlacement);
GeometryUtil.SetPlacementRelTo(elementPlacement, assemblyPlacement);
}
}
/// <summary>
/// Calculates the reference.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
if (elementType == null)
{
m_ReferenceName = element.Name;
}
else
{
if (ExporterCacheManager.ExportOptionsCache.NamingOptions.UseFamilyAndTypeNameForReference || String.IsNullOrEmpty(elementType.Name))
{
if (!String.IsNullOrEmpty(elementType.Name))
{
m_ReferenceName = String.Format("{0}:{1}", ExporterIFCUtils.GetFamilyName(elementType), element.Name);
}
else
{
m_ReferenceName = ExporterIFCUtils.GetFamilyName(elementType);
}
}
else
{
m_ReferenceName = elementType.Name;
}
}
return(true);
}
private static List <Face3D> Profiles_FromElevationProfile(this Wall wall)
{
if (wall == null)
{
return(null);
}
if (!ExporterIFCUtils.HasElevationProfile(wall))
{
return(null);
}
IList <CurveLoop> curveLoops = ExporterIFCUtils.GetElevationProfile(wall);
if (curveLoops == null)
{
return(null);
}
List <Face3D> result = new List <Face3D>();
foreach (CurveLoop curveLoop in curveLoops)
{
Polygon3D polygon3D = curveLoop.ToSAM_Polygon3D();
if (polygon3D == null)
{
continue;
}
result.Add(new Face3D(polygon3D));
}
return(result);
}
static IFCAnyHandle CreateLocalPlacementForConnector(ExporterIFC exporterIFC, Connector connector, IFCAnyHandle elementHandle,
IFCFlowDirection flowDir)
{
try
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle elementPlacement = IFCAnyHandleUtil.GetObjectPlacement(elementHandle);
Transform origTrf = ExporterIFCUtils.GetUnscaledTransform(exporterIFC, elementPlacement);
Transform connectorCoordinateSystem = connector.CoordinateSystem;
if (flowDir == IFCFlowDirection.Sink)
{
// Reverse the direction of the connector.
connectorCoordinateSystem.BasisX = -connectorCoordinateSystem.BasisX;
connectorCoordinateSystem.BasisZ = -connectorCoordinateSystem.BasisZ;
}
Transform relTransform = origTrf.Inverse.Multiply(connectorCoordinateSystem);
XYZ scaledOrigin = UnitUtil.ScaleLength(relTransform.Origin);
IFCAnyHandle relLocalPlacement = ExporterUtil.CreateAxis2Placement3D(file,
scaledOrigin, relTransform.BasisZ, relTransform.BasisX);
return(IFCInstanceExporter.CreateLocalPlacement(file, elementPlacement, relLocalPlacement));
}
catch
{
}
return(null);
}
public void GetWallGrossAreaAndRollBack()
{
var testModel = Utils.GetTestModel("walls.rvt");
var doc = xru.OpenDoc(testModel);
var walls = new FilteredElementCollector(doc).WhereElementIsNotElementType().OfCategory(BuiltInCategory.OST_Walls).ToElements();
var wall = walls[0] as Wall;
double grossArea = 0;
var inserts = wall.FindInserts(true, true, true, true);
xru.Run(() =>
{
using (Transaction transaction = new Transaction(doc, "Temporary - only to get gross area"))
{
transaction.Start();
foreach (ElementId insertId in inserts)
{
doc.Delete(insertId);
}
doc.Regenerate();
var wallFaceReference = HostObjectUtils.GetSideFaces(wall, ShellLayerType.Exterior);
var face = doc.GetElement(wallFaceReference.First()).GetGeometryObjectFromReference(wallFaceReference.First()) as PlanarFace;
var wallFaceEdges = face.GetEdgesAsCurveLoops();
grossArea = ExporterIFCUtils.ComputeAreaOfCurveLoops(wallFaceEdges);
transaction.RollBack();
}
}, doc).Wait();
Assert.True(grossArea > 0);
}
/// <summary>
/// Create a sub-element GUID for a given element, or a random GUID if element is null, or subindex is nonpositive.
/// </summary>
/// <param name="element">The element - null allowed.</param>
/// <param name="subIndex">The index value - should be greater than 0.</param>
/// <returns></returns>
static public string CreateSubElementGUID(Element element, int subIndex)
{
if (element == null || subIndex <= 0)
{
return(CreateGUID());
}
return(ExporterIFCUtils.CreateSubElementGUID(element, subIndex));
}
static public Curve GetFamilyInstanceCutBaseLine(FamilyInstance fi)
{
XYZ dir;
CurveLoop loop = ExporterIFCUtils.GetInstanceCutoutFromWall(fi.Document, fi.Host as Wall, fi, out dir);
Curve curve = loop.Where(x => x.GetEndPoint(0).Z == x.GetEndPoint(1).Z).OrderBy(x => x.GetEndPoint(0).Z).FirstOrDefault();
return(curve);
}
private WallCollection GetWallInformation(UIDocument uidoc, Document revitDoc, Application app, Wall wall, WallType WallType)
{
Autodesk.Revit.Creation.Document credoc = revitDoc.Create;
Autodesk.Revit.Creation.Application creapp = app.Create;
View view = revitDoc.ActiveView;
ElementType type = WallType as ElementType;
Parameter b = type.get_Parameter((BuiltInParameter.WALL_ATTR_WIDTH_PARAM));
double width = b.AsDouble() / 2;
IList <Reference> sideFaces = HostObjectUtils.GetSideFaces(wall, ShellLayerType.Exterior);
Element e2 = revitDoc.GetElement(sideFaces[0]);
Face face = e2.GetGeometryObjectFromReference(sideFaces[0]) as Face;
// The normal of the wall external face.
XYZ normal = face.ComputeNormal(new UV(0, 0));
// Offset curve copies for visibility.
Transform offset = Transform.CreateTranslation(width * normal);
// If the curve loop direction is counter-
// clockwise, change its color to RED.
// Get edge loops as curve loops.
IList <CurveLoop> curveLoops = face.GetEdgesAsCurveLoops();
// ExporterIFCUtils class can also be used for
// non-IFC purposes. The SortCurveLoops method
// sorts curve loops (edge loops) so that the
// outer loops come first.
IList <IList <CurveLoop> > curveLoopLoop = ExporterIFCUtils.SortCurveLoops(curveLoops);
List <List <Curve> > Walls = new List <List <Curve> >();
WallCollection WCCC = new WallCollection();
foreach (IList <CurveLoop> curveLoops2 in curveLoopLoop)
{
foreach (CurveLoop curveLoop2 in curveLoops2)
{
// Check if curve loop is counter-clockwise.
CurveArray curves = creapp.NewCurveArray();
List <Curve> CC = new List <Curve>();
foreach (Curve curve in curveLoop2)
{
curves.Append(curve.CreateTransformed(offset));
CC.Add(curve.CreateTransformed(offset));
}
// Create model lines for an curve loop.
Walls.Add(CC);
WCCC.AddWall(CC);
}
}
return(WCCC);
}
private static IFCAnyHandle CopyRailingHandle(ExporterIFC exporterIFC, Element elem, ElementId catId, IFCAnyHandle origLocalPlacement,
IFCAnyHandle origRailing)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle origRailingObjectPlacement = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "ObjectPlacement");
IFCAnyHandle railingRelativePlacement = IFCAnyHandleUtil.GetInstanceAttribute(origRailingObjectPlacement, "RelativePlacement");
IFCAnyHandle parentRelativePlacement = IFCAnyHandleUtil.GetInstanceAttribute(origLocalPlacement, "RelativePlacement");
IFCAnyHandle newRelativePlacement = null;
IFCAnyHandle parentRelativeOrig = IFCAnyHandleUtil.GetInstanceAttribute(parentRelativePlacement, "Location");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(parentRelativeOrig))
{
IList <double> parentVec = IFCAnyHandleUtil.GetCoordinates(parentRelativeOrig);
IFCAnyHandle railingRelativeOrig = IFCAnyHandleUtil.GetInstanceAttribute(railingRelativePlacement, "Location");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(railingRelativeOrig))
{
IList <double> railingVec = IFCAnyHandleUtil.GetCoordinates(railingRelativeOrig);
IList <double> newMeasure = new List <double>();
newMeasure.Add(railingVec[0] - parentVec[0]);
newMeasure.Add(railingVec[1] - parentVec[1]);
newMeasure.Add(railingVec[2]);
IFCAnyHandle locPtHnd = ExporterUtil.CreateCartesianPoint(file, newMeasure);
newRelativePlacement = IFCInstanceExporter.CreateAxis2Placement3D(file, locPtHnd, null, null);
}
else
{
IList <double> railingMeasure = new List <double>();
railingMeasure.Add(-parentVec[0]);
railingMeasure.Add(-parentVec[1]);
railingMeasure.Add(0.0);
IFCAnyHandle locPtHnd = ExporterUtil.CreateCartesianPoint(file, railingMeasure);
newRelativePlacement = IFCInstanceExporter.CreateAxis2Placement3D(file, locPtHnd, null, null);
}
}
IFCAnyHandle newLocalPlacement = IFCInstanceExporter.CreateLocalPlacement(file, origLocalPlacement, newRelativePlacement);
IFCAnyHandle origRailingRep = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "Representation");
IFCAnyHandle newProdRep = ExporterUtil.CopyProductDefinitionShape(exporterIFC, elem, catId, origRailingRep);
string ifcEnumTypeAsString = IFCAnyHandleUtil.GetEnumerationAttribute(origRailing, "PredefinedType");
IFCRailingType railingType = GetIFCRailingTypeFromString(ifcEnumTypeAsString);
string copyGUID = ExporterIFCUtils.CreateGUID();
IFCAnyHandle copyOwnerHistory = IFCAnyHandleUtil.GetInstanceAttribute(origRailing, "OwnerHistory");
string copyName = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Name");
string copyDescription = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Description");
string copyObjectType = IFCAnyHandleUtil.GetStringAttribute(origRailing, "ObjectType");
string copyElemId = IFCAnyHandleUtil.GetStringAttribute(origRailing, "Tag");
return(IFCInstanceExporter.CreateRailing(file, copyGUID, copyOwnerHistory, copyName, copyDescription, copyObjectType,
newLocalPlacement, newProdRep,
copyElemId, railingType));
}
/// <summary>
/// Exports a roof to IfcRoof.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="roof">The roof element.</param>
/// <param name="geometryElement">The geometry element.</param>
/// <param name="productWrapper">The IFCProductWrapper.</param>
public static void Export(ExporterIFC exporterIFC, RoofBase roof, GeometryElement geometryElement, IFCProductWrapper productWrapper)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
// export parts or not
bool exportParts = PartExporter.CanExportParts(roof);
bool exportAsExtrusionCurtainRoof = false;
bool exportAsFootprintCurtainRoof = false;
if (roof is ExtrusionRoof)
{
ExtrusionRoof extrusionRoof = roof as ExtrusionRoof;
exportAsExtrusionCurtainRoof = ((extrusionRoof.CurtainGrids != null) && (extrusionRoof.CurtainGrids.Size != 0));
}
else if (roof is FootPrintRoof)
{
FootPrintRoof footprintRoof = roof as FootPrintRoof;
exportAsFootprintCurtainRoof = ((footprintRoof.CurtainGrids != null) && (footprintRoof.CurtainGrids.Size != 0));
}
if (exportParts)
{
if (!PartExporter.CanExportElementInPartExport(roof, roof.Level.Id, false))
{
return;
}
ExportRoofAsParts(exporterIFC, roof, geometryElement, productWrapper); // Right now, only flat roof could have parts.
}
else if (exportAsExtrusionCurtainRoof)
{
CurtainSystemExporter.ExportExtrusionRoof(exporterIFC, roof as ExtrusionRoof, productWrapper);
}
else if (exportAsFootprintCurtainRoof)
{
CurtainSystemExporter.ExportFootPrintRoof(exporterIFC, roof as FootPrintRoof, productWrapper);
}
else
{
string ifcEnumType = CategoryUtil.GetIFCEnumTypeName(exporterIFC, roof);
IFCAnyHandle roofHnd = ExporterIFCUtils.ExportRoofAsContainer(exporterIFC, ifcEnumType, roof,
geometryElement, productWrapper);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(roofHnd))
{
ExportRoof(exporterIFC, ifcEnumType, roof, geometryElement, productWrapper);
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, roof, productWrapper);
// call for host objects; curtain roofs excused from call (no material information)
HostObjectExporter.ExportHostObjectMaterials(exporterIFC, roof, productWrapper.GetAnElement(),
geometryElement, productWrapper, ElementId.InvalidElementId, IFCLayerSetDirection.Axis3);
}
tr.Commit();
}
}
/// <summary>
/// Creates a Project, Site, or Building GUID. If a shared parameter is set with a valid IFC GUID value,
/// that value will override the default one.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="guidType">The GUID being created.</param>
/// <returns>The IFC GUID value.</returns>
/// <remarks>For Sites, the user should only use this routine if there is no Site element in the file. Otherwise, they
/// should use CreateSiteGUID below, which takes an Element pointer.</remarks>
static public string CreateProjectLevelGUID(Document document, IFCProjectLevelGUIDType guidType)
{
string parameterName = "Ifc" + guidType.ToString() + " GUID";
ProjectInfo projectInfo = document.ProjectInformation;
BuiltInParameter parameterId = BuiltInParameter.INVALID;
switch (guidType)
{
case IFCProjectLevelGUIDType.Building:
parameterId = BuiltInParameter.IFC_BUILDING_GUID;
break;
case IFCProjectLevelGUIDType.Project:
parameterId = BuiltInParameter.IFC_PROJECT_GUID;
break;
case IFCProjectLevelGUIDType.Site:
parameterId = BuiltInParameter.IFC_SITE_GUID;
break;
default:
// This should eventually log an error.
return(null);
}
if (projectInfo != null)
{
string paramValue = null;
ParameterUtil.GetStringValueFromElement(projectInfo, parameterName, out paramValue);
if (!IsValidIFCGUID(paramValue) && parameterId != BuiltInParameter.INVALID)
{
ParameterUtil.GetStringValueFromElement(projectInfo, parameterId, out paramValue);
}
if (IsValidIFCGUID(paramValue))
{
return(paramValue);
}
}
// Only for 2022
//ElementId projectLevelElementId = new ElementId((int)guidType);
//System.Guid guid = ExportUtils.GetExportId(document, projectLevelElementId);
//string ifcGUID = ConvertToIFCGuid(guid);
string ifcGUID = ExporterIFCUtils.CreateProjectLevelGUID(document, guidType);
if ((projectInfo != null) && ExporterCacheManager.ExportOptionsCache.GUIDOptions.StoreIFCGUID)
{
if (parameterId != BuiltInParameter.INVALID)
{
ExporterCacheManager.GUIDsToStoreCache[new KeyValuePair <ElementId, BuiltInParameter>(projectInfo.Id, parameterId)] = ifcGUID;
}
}
return(ifcGUID);
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
bool valid = true;
if (StairsExporter.IsLegacyStairs(element))
{
double riserHeight, treadLength, nosingLength, waistThickness = 0;
int numberOfRisers, numberOfTreads = 0;
ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element,
out numberOfRisers, out numberOfTreads,
out riserHeight, out treadLength, out m_TreadLengthAtInnerSide,
out nosingLength, out waistThickness);
}
else if (element is Stairs || element is StairsRun)
{
Stairs stairs;
if (element is StairsRun)
{
StairsRun stairsRun = element as StairsRun;
stairs = stairsRun.GetStairs();
}
else
{
stairs = element as Stairs;
}
StairsType stairsType = stairs.Document.GetElement(stairs.GetTypeId()) as StairsType;
double treadLengthAtInnerSide;
if (ParameterUtil.GetDoubleValueFromElement(stairsType,
BuiltInParameter.STAIRSTYPE_MINIMUM_TREAD_WIDTH_INSIDE_BOUNDARY, out treadLengthAtInnerSide) != null)
{
m_TreadLengthAtInnerSide = UnitUtil.ScaleLength(treadLengthAtInnerSide);
}
if (m_TreadLengthAtInnerSide <= 0)
{
m_TreadLengthAtInnerSide = UnitUtil.ScaleLength(stairs.ActualTreadDepth);
}
}
else
{
valid = false;
}
// Get override from parameter
double treadLengthAtInnerSideOverride = 0.0;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out treadLengthAtInnerSideOverride) != null ||
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out treadLengthAtInnerSideOverride) != null)
{
m_TreadLengthAtInnerSide = UnitUtil.ScaleArea(treadLengthAtInnerSideOverride);
}
return(valid);
}
/// <summary>
/// Gets the GUID for the IFC entity type handle associated with an element.
/// </summary>
/// <param name="familyInstance">The family instance, if it exists.</param>
/// <param name="elementType">The element type to use for GUID generation if the family instance is null.</param>
/// <returns>The GUID.</returns>
public static string GetGUIDForFamilySymbol(FamilyInstance familyInstance, ElementType elementType)
{
if (familyInstance != null)
{
FamilySymbol originalFamilySymbol = ExporterIFCUtils.GetOriginalSymbol(familyInstance);
return(GUIDUtil.CreateGUID(originalFamilySymbol));
}
return(GUIDUtil.CreateGUID(elementType));
}
/// <summary>
/// Calculates extend to structure value for a wall.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element,">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
Wall wall = element as Wall;
if (wall != null)
{
m_ExtendToStructure = ExporterIFCUtils.IsWallJoinedToTop(wall);
}
return(true);
}
/// <summary>
/// Obtains the handle to an alternate local placement for a room-related element.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="placementToUse">The handle to the IfcLocalPlacement to use for the given room-related element.</param>
/// <returns>
/// The id of the spatial element related to the element. InvalidElementId if the element
/// is not room-related, in which case the output will contain the placement handle from
/// LocalPlacement.
/// </returns>
public ElementId UpdateRoomRelativeCoordinates(Element elem, out IFCAnyHandle placement)
{
placement = m_LocalPlacement;
FamilyInstance famInst = elem as FamilyInstance;
if (famInst == null)
{
return(ElementId.InvalidElementId);
}
Element roomOrSpace = null;
if (roomOrSpace == null)
{
try
{
roomOrSpace = ExporterCacheManager.SpaceInfoCache.ContainsRooms ? famInst.get_Room(ExporterCacheManager.ExportOptionsCache.ActivePhaseElement) : null;
}
catch
{
roomOrSpace = null;
}
}
if (roomOrSpace == null)
{
try
{
roomOrSpace = ExporterCacheManager.SpaceInfoCache.ContainsSpaces ? famInst.get_Space(ExporterCacheManager.ExportOptionsCache.ActivePhaseElement) : null;
}
catch
{
roomOrSpace = null;
}
}
if (roomOrSpace == null || roomOrSpace.Location == null)
{
return(ElementId.InvalidElementId);
}
ElementId roomId = roomOrSpace.Id;
IFCAnyHandle roomHnd = ExporterCacheManager.SpaceInfoCache.FindSpaceHandle(roomId);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(roomHnd))
{
return(ElementId.InvalidElementId);
}
IFCAnyHandle roomPlacementHnd = IFCAnyHandleUtil.GetObjectPlacement(roomHnd);
Transform trf = ExporterIFCUtils.GetRelativeLocalPlacementOffsetTransform(placement, roomPlacementHnd);
placement = ExporterUtil.CreateLocalPlacement(m_ExporterIFC.GetFile(), roomPlacementHnd, trf.Origin, trf.BasisZ, trf.BasisX);
return(roomId);
}
/// <summary>
/// Calculates total area for a roof
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "ProjectedArea", out m_Area);
if (m_Area > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
m_Area = UnitUtil.ScaleArea(ExporterIFCUtils.ComputeRoofProjectedArea(element));
return(m_Area > MathUtil.Eps() * MathUtil.Eps());
}
/// <summary>
/// Returns the GUID for a storey level, depending on whether we are using R2009 GUIDs or current GUIDs.
/// </summary>
/// <param name="level">
/// The level.
/// </param>
/// <returns>
/// The GUID.
/// </returns>
public static string GetLevelGUID(Level level)
{
if (!ExporterCacheManager.ExportOptionsCache.Use2009BuildingStoreyGUIDs)
{
return(ExporterIFCUtils.CreateAlternateGUID(level));
}
else
{
return(ExporterIFCUtils.CreateGUID(level));
}
}
