IList <CurveLoop> GetCurveLoops(Document doc, Reference rf) { IList <CurveLoop> curveloop = new List <CurveLoop>(); GeometryObject geometryObject = doc.GetElement(rf).GetGeometryObjectFromReference(rf); try { PlanarFace planarFace = geometryObject as PlanarFace; curveloop = planarFace.GetEdgesAsCurveLoops(); } catch { HermiteFace hermiteFace = geometryObject as HermiteFace; if (hermiteFace == null) { RuledFace ruledFace = geometryObject as RuledFace; curveloop = ruledFace.GetEdgesAsCurveLoops(); } else { curveloop = hermiteFace.GetEdgesAsCurveLoops(); } } return(curveloop); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; uidoc = uiapp.ActiveUIDocument; Application app = uiapp.Application; doc = uidoc.Document; sel = uidoc.Selection; Reference rf = sel.PickObject(ObjectType.Face, "Select Face"); Element ele = doc.GetElement(rf); GeometryObject geoobject = ele.GetGeometryObjectFromReference(rf); PlanarFace face = geoobject as PlanarFace; Plane plane = face.Faceby3pointPlane(); XYZ direction = face.ComputeNormal(UV.Zero); using (Transaction tran = new Transaction(doc, "Set view by face")) { tran.Start(); SketchPlane skt = SketchPlane.Create(doc, plane); View3D view3d = doc.ActiveView as View3D; view3d.OrientTo(plane.Normal); doc.ActiveView.SketchPlane = skt; uidoc.RefreshActiveView(); uidoc.ShowElements(ele.Id); tran.Commit(); } return(Result.Succeeded); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; UIDocument uidoc = uiapp.ActiveUIDocument; Document doc = uidoc.Document; Selection selection = uidoc.Selection; Reference reff = selection.PickObject(ObjectType.PointOnElement); Element elem = doc.GetElement(reff); GeometryObject obj = elem.GetGeometryObjectFromReference(reff); Category targetCategory = null; if (obj.GraphicsStyleId != ElementId.InvalidElementId) { GraphicsStyle gs = doc.GetElement(obj.GraphicsStyleId) as GraphicsStyle; if (gs != null) { targetCategory = gs.Category; } } using (Transaction ts = new Transaction(doc, "hide selected cad layer")) { ts.Start(); doc.ActiveView.SetVisibility(targetCategory, false); ts.Commit(); } return(Result.Succeeded); }
public static List <Solid> Getsolids(this GeometryObject geoobj, Transform trs) { var solids = new List <Solid>(); if (geoobj is Solid solid) { if (trs != null || trs != Transform.Identity) { solid = SolidUtils.CreateTransformed(solid, trs); } solids.Add(solid); } else if (geoobj is GeometryInstance geoInstance) { var transform = geoInstance.Transform; var symbolgeometry = geoInstance.SymbolGeometry; var enu = symbolgeometry.GetEnumerator(); while (enu.MoveNext()) { var temgeoobj = enu.Current as GeometryObject; solids.AddRange(Getsolids(temgeoobj, transform)); } } else if (geoobj is GeometryElement geoElement) { var enu = geoElement.GetEnumerator(); while (enu.MoveNext()) { var temgeoobj = enu.Current as GeometryObject; solids.AddRange(Getsolids(temgeoobj, trs)); } } return(solids); }
public static GeoRss10Where ToGeoRss10Where(this GeometryObject geom) { if (geom is Point) { return(((Point)geom).ToGeoRss10Where()); } if (geom is LineString) { return(((LineString)geom).ToGeoRss10Where()); } if (geom is Polygon) { return(((Polygon)geom).ToGeoRss10Where()); } if (geom is MultiPolygon) { return(((MultiPolygon)geom).ToGeoRss10Where()); } if (geom is MultiPoint) { return(((MultiPoint)geom).ToGeoRss10Where()); } throw new NotImplementedException(); }
public override Value Evaluate(FSharpList <Value> args) { var parameter = ((Value.Number)args[0]).Item; var thisCurve = ((Value.Container)args[1]).Item as Curve; var thisEdge = (thisCurve != null) ? null : (((Value.Container)args[1]).Item as Edge); if (thisCurve == null && thisEdge == null && ((Value.Container)args[1]).Item is Reference) { var r = (Reference)((Value.Container)args[1]).Item; if (r != null) { var refElem = dynRevitSettings.Doc.Document.GetElement(r.ElementId); if (refElem != null) { GeometryObject geob = refElem.GetGeometryObjectFromReference(r); thisEdge = geob as Edge; if (thisEdge == null) { thisCurve = geob as Curve; } } } } var result = (thisCurve != null) ? (!XyzOnCurveOrEdge.curveIsReallyUnbound(thisCurve) ? thisCurve.ComputeDerivatives(parameter, true) : thisCurve.ComputeDerivatives(parameter, false)) : (thisEdge == null ? null : thisEdge.ComputeDerivatives(parameter)); return(Value.NewContainer(result)); }
/// <summary> /// Located the buttom of a slab object. /// </summary> /// <param name="floor">A floor object.</param> /// <param name="bubbleEnd">The bubble end of new reference plane.</param> /// <param name="freeEnd">The free end of new reference plane.</param> /// <param name="thirdPnt">The third point of new reference plane.</param> private void LocateSlab(Floor floor, ref Autodesk.Revit.DB.XYZ bubbleEnd, ref Autodesk.Revit.DB.XYZ freeEnd, ref Autodesk.Revit.DB.XYZ thirdPnt) { //Obtain the geometry data of the floor. GElement geometry = floor.get_Geometry(m_options); Face buttomFace = null; //foreach (GeometryObject go in geometry.Objects) IEnumerator <GeometryObject> Objects = geometry.GetEnumerator(); while (Objects.MoveNext()) { GeometryObject go = Objects.Current; Solid solid = go as Solid; if (null == solid) { continue; } else { //Get the bottom face of this floor. buttomFace = GeoHelper.GetBottomFace(solid.Faces); } } Mesh mesh = buttomFace.Triangulate(); GeoHelper.Distribute(mesh, ref bubbleEnd, ref freeEnd, ref thirdPnt); }
public override IEnumerable <AssociativeNode> BuildOutputAst(List <AssociativeNode> inputAstNodes) { GeometryObject geob = null; string stableRep = string.Empty; AssociativeNode node; if (SelectedElement != null) { var dbDocument = DocumentManager.Instance.CurrentDBDocument; if (dbDocument != null) { var element = dbDocument.GetElement(SelectedElement); if (element != null) { geob = element.GetGeometryObjectFromReference(SelectedElement); } } stableRep = SelectedElement.ConvertToStableRepresentation(dbDocument); } var args = new List <AssociativeNode> { AstFactory.BuildStringNode(stableRep) }; node = AstFactory.BuildFunctionCall( "GeometryObjectSelector", "ByReferenceStableRepresentation", args); return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), node) }); }
public static IGeoRSS ToGeoRss10(this GeometryObject geom) { if (geom is Point) { return(((Point)geom).ToGeoRss10Point()); } if (geom is LineString) { return(((LineString)geom).ToGeoRss10Line()); } if (geom is Polygon && ((Polygon)geom).LineStrings.Count == 1) { return(((Polygon)geom).ToGeoRss10Polygon()); } if (geom is Polygon && ((Polygon)geom).LineStrings.Count > 1) { return(((Polygon)geom).ToGeoRss10Where()); } if (geom is MultiPolygon) { return(((MultiPolygon)geom).ToGeoRss10Where()); } if (geom is MultiPoint) { return(((MultiPoint)geom).ToGeoRss10Where()); } throw new NotImplementedException(); }
/// <summary> /// generate data of a Mesh /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddMesh(GeometryObject obj, Transform transform) { Mesh mesh = obj as Mesh; if (null == mesh) { return; } //a face has a mesh, all meshes are made of triangles for (int i = 0; i < mesh.NumTriangles; i++) { MeshTriangle triangular = mesh.get_Triangle(i); List <XYZ> points = new List <XYZ>(); try { for (int n = 0; n < 3; n++) { Autodesk.Revit.DB.XYZ point = triangular.get_Vertex(n); Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform); points.Add(newPoint); } Autodesk.Revit.DB.XYZ iniPoint = points[0]; points.Add(iniPoint); m_curve3Ds.Add(points); } catch { } } }
/// <summary> /// get all planar faces of an extrusion /// </summary> /// <param name="extrusion">the extrusion to read</param> /// <returns>a list of all planar faces of the extrusion</returns> public List <PlanarFace> GetPlanarFaces(Extrusion extrusion) { // the option to get geometry elements Options m_geoOptions = m_application.Create.NewGeometryOptions(); m_geoOptions.View = m_document.ActiveView; m_geoOptions.ComputeReferences = true; // get the planar faces List <PlanarFace> m_planarFaces = new List <PlanarFace>(); Autodesk.Revit.DB.GeometryElement geoElement = extrusion.get_Geometry(m_geoOptions); //foreach (GeometryObject geoObject in geoElement.Objects) IEnumerator <GeometryObject> Objects = geoElement.GetEnumerator(); while (Objects.MoveNext()) { GeometryObject geoObject = Objects.Current; Solid geoSolid = geoObject as Solid; if (null == geoSolid) { continue; } foreach (Face geoFace in geoSolid.Faces) { if (geoFace is PlanarFace) { m_planarFaces.Add(geoFace as PlanarFace); } } } return(m_planarFaces); }
/// <summary> /// Extracts solids from a geometry object. see: https://forums.autodesk.com/t5/revit-api-forum/getting-beam-column-and-wall-geometry/td-p/8138893 /// </summary> /// <param name="gObj"></param> /// <returns></returns> public static List <Solid> GetSolids(GeometryObject gObj) { List <Solid> solids = new List <Solid>(); if (gObj is Solid) // already solid { Solid solid = gObj as Solid; if (solid.Faces.Size > 0 && Math.Abs(solid.Volume) > 0) // skip invalid solid { solids.Add(gObj as Solid); } } else if (gObj is GeometryInstance) // find solids from GeometryInstance { IEnumerator <GeometryObject> gIter2 = (gObj as GeometryInstance).GetInstanceGeometry().GetEnumerator(); gIter2.Reset(); while (gIter2.MoveNext()) { solids.AddRange(GetSolids(gIter2.Current)); } } else if (gObj is GeometryElement) // find solids from GeometryElement { IEnumerator <GeometryObject> gIter2 = (gObj as GeometryElement).GetEnumerator(); gIter2.Reset(); while (gIter2.MoveNext()) { solids.AddRange(GetSolids(gIter2.Current)); } } return(solids); }
public static IList <Edge> GetEdgesofGeometryObject(this GeometryObject geoobj) { IList <Edge> result = new List <Edge>(); List <Edge> temresult = new List <Edge>(); if (geoobj is GeometryElement) { GeometryElement geoele = geoobj as GeometryElement; foreach (GeometryObject geoitem in geoele) { temresult.AddRange(GetEdgesofGeometryObject(geoitem)); } } else if (geoobj is GeometryInstance) { GeometryElement geoele = (geoobj as GeometryInstance).SymbolGeometry; foreach (GeometryObject obj in geoele) { if (obj is Solid) { //result.Add(obj as Face); temresult.AddRange(GetEdgesofGeometryObject(obj)); } } } else if (geoobj is Solid) { Solid solid = geoobj as Solid; //temresult.Add(solid); foreach (Face face in solid.Faces) { temresult.AddRange(GetEdgesofGeometryObject(face)); } } else if (geoobj is Face) { Face face = geoobj as Face; //foreach (EdgeArrayArray edgearrayarray in face.EdgeLoops) { foreach (EdgeArray edgeArray in face.EdgeLoops) { var enu = edgeArray.GetEnumerator(); while (enu.MoveNext()) { var edge = enu.Current as Edge; if (edge != null) { temresult.Add(edge); } } } } } else if (geoobj is Edge) { temresult.Add(geoobj as Edge); } result = temresult; return(result); }
public static List <Spatial.Face3D> BottomProfiles(this HostObject hostObject) { List <Spatial.Face3D> result = new List <Spatial.Face3D>(); foreach (Reference reference in HostObjectUtils.GetBottomFaces(hostObject)) { GeometryObject geometryObject = hostObject.GetGeometryObjectFromReference(reference); if (geometryObject == null) { continue; } Autodesk.Revit.DB.Face face = geometryObject as Autodesk.Revit.DB.Face; if (face == null) { continue; } List <Spatial.Face3D> face3Ds = face.ToSAM(); if (face3Ds == null || face3Ds.Count == 0) { continue; } result.AddRange(face3Ds); } return(result); }
/// <summary> /// calculates the restore data /// </summary> /// <returns></returns> public static RestoreData GetRestoreData(GeometryObject geometryObject) { Node node = geometryObject as Node; if (node != null) { return(GetRestoreData(node)); } Edge edge = geometryObject as Edge; if (edge != null) { return(GetRestoreData(edge)); } Label label = geometryObject as Label; if (label != null) { return(GetRestoreData(label)); } GeometryGraph graph = geometryObject as GeometryGraph; if (graph != null) { return(GetRestoreData(graph)); } return(null); }
public static AbstractGeometryType ToGml(this GeometryObject geometry) { if (geometry is Point) { return(ToGmlPoint((Point)geometry)); } if (geometry is MultiPoint) { return(ToGmlMultiPoint((MultiPoint)geometry)); } if (geometry is LineString) { return(ToGmlLineString((LineString)geometry)); } if (geometry is MultiLineString) { return(ToGmlMultiCurve((MultiLineString)geometry)); } if (geometry is Polygon) { return(ToGmlPolygon((Polygon)geometry)); } if (geometry is MultiPolygon) { return(ToGmlMultiSurface((MultiPolygon)geometry)); } return(null); }
public static Face RequestFaceSelection(string message) { var doc = DocumentManager.Instance.CurrentUIDocument; Face f = null; Selection choices = doc.Selection; choices.Elements.Clear(); dynSettings.Controller.DynamoLogger.Log(message); //create some geometry options so that we computer references var opts = new Options { ComputeReferences = true, DetailLevel = ViewDetailLevel.Medium, IncludeNonVisibleObjects = false }; Reference faceRef = doc.Selection.PickObject(ObjectType.Face); if (faceRef != null) { GeometryObject geob = DocumentManager.Instance.CurrentDBDocument.GetElement(faceRef).GetGeometryObjectFromReference(faceRef); f = geob as Face; } return(f); }
/// <summary> /// Sets best material id for current export state. /// </summary> /// <param name="geometryObject">The geometry object to get the best material id.</param> /// <param name="exporterIFC">The ExporterIFC object.</param> public static void SetBestMaterialIdInExporter(GeometryObject geometryObject, ExporterIFC exporterIFC) { ElementId materialId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC); if (materialId != ElementId.InvalidElementId) exporterIFC.SetMaterialIdForCurrentExportState(materialId); }
/// <summary> /// Extract a 3D solid from a Revit GeometryObject /// </summary> /// <param name="geoObject"></param> /// <param name="_outSolid"></param> /// <returns></returns> public static bool TryeGetGeometryDataFromGeometryObject(GeometryObject geoObject, out Solid _outSolid, out DynamoSolid _outDynSolid) { DynamoSolid outdynSolid = null; Solid outSolid = null; bool success; // Check if its is a Geometry Instance if (geoObject is GeometryInstance) { GeometryInstance geoInstance = geoObject as GeometryInstance; foreach (Solid solid in geoInstance.GetInstanceGeometry()) { // Skip to next element in iteration if any of the following conditions are met if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size) { continue; } DynamoSolid dynSolidGeo = ToDynamoSolid(solid); // Sometimes a geometry element can be a null solid if (dynSolidGeo != null) { outdynSolid = dynSolidGeo; outSolid = solid; } } } // Check if it is Solid else if (geoObject is Solid) { Solid solid = geoObject as Solid; DynamoSolid dynSolidGeo = ToDynamoSolid(solid); // Sometimes a geometry element can be a null solid if (dynSolidGeo != null) { outdynSolid = dynSolidGeo; outSolid = solid; } } if (outdynSolid == null && outSolid == null) { success = false; } else { success = true; } _outDynSolid = outdynSolid; _outSolid = outSolid; return(success); }
public override IEnumerable <AssociativeNode> BuildOutputAst(List <AssociativeNode> inputAstNodes) { GeometryObject geob = null; string stableRep = string.Empty; var dbDocument = DocumentManager.Instance.CurrentDBDocument; if (SelectedElement == null || dbDocument == null) { return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) }); } if (SelectedElement.UVPoint == null) { return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) }); } var pt = SelectedElement.UVPoint; //this is a selected point on a face var ptArgs = new List <AssociativeNode>() { AstFactory.BuildDoubleNode(pt.U), AstFactory.BuildDoubleNode(pt.V) }; AssociativeNode node = AstFactory.BuildFunctionCall ( "Autodesk.DesignScript.Geometry.UV", "ByCoordinates", ptArgs ); return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), node) }); }
/// <summary> /// Gets all solid objects from geometry object. /// </summary> /// <param name="gObj">Geometry object from where to get solids. </param> /// <returns>The solids of the geometry object. </returns> static public List <Solid> GetSolids(GeometryObject gObj) { List <Solid> solids = new List <Solid>(); if (gObj is Solid) // already solid { Solid solid = gObj as Solid; if (solid.Faces.Size > 0 && solid.Volume > 0) // some solid may have not any face?! { solids.Add(gObj as Solid); } } else if (gObj is GeometryInstance) // find solids from GeometryInstance { IEnumerator <GeometryObject> gIter2 = (gObj as GeometryInstance).GetInstanceGeometry().GetEnumerator(); gIter2.Reset(); while (gIter2.MoveNext()) { solids.AddRange(GetSolids(gIter2.Current)); } } else if (gObj is GeometryElement) // find solids from GeometryElement, this will not happen at all? { IEnumerator <GeometryObject> gIter2 = (gObj as GeometryElement).GetEnumerator(); gIter2.Reset(); while (gIter2.MoveNext()) { solids.AddRange(GetSolids(gIter2.Current)); } } return(solids); }
/// <summary> /// Tessellate the curves of path reinforcement. /// </summary> private void Tessellate() { Options option = new Options(); option.DetailLevel = ViewDetailLevel.Fine; Autodesk.Revit.DB.GeometryElement geoElem = m_pathRein.get_Geometry(option); //GeometryObjectArray geoArray = geoElem.Objects; IEnumerator <GeometryObject> Objects = geoElem.GetEnumerator(); //foreach (GeometryObject geo in geoArray) while (Objects.MoveNext()) { GeometryObject geo = Objects.Current; if (geo is Curve) { Curve curve = geo as Curve; m_curves.Add(curve.Tessellate() as List <XYZ>); } } IList <ElementId> curveIds = m_pathRein.GetCurveElementIds(); foreach (ElementId id in curveIds) { ModelCurve modelCurve = m_commandData.Application.ActiveUIDocument.Document.GetElement(id) as ModelCurve; m_path.Add(modelCurve.GeometryCurve.Tessellate() as List <XYZ>); } }
/// <summary> /// The method is used to get extrusion's face along to the specified parameters /// </summary> /// <param name="extrusion">the extrusion</param> /// <param name="view">options view</param> /// <param name="ExtOrInt">If true indicate getting exterior extrusion face, else getting interior extrusion face</param> /// <returns>the face</returns> static public Face GetExtrusionFace(Extrusion extrusion, View view, bool ExtOrInt) { Face face = null; FaceArray faces = null; if (extrusion.IsSolid) { Options options = new Options(); options.ComputeReferences = true; options.View = view; //GeometryObjectArray geoArr = extrusion.get_Geometry(options).Objects; IEnumerator <GeometryObject> Objects = extrusion.get_Geometry(options).GetEnumerator(); //foreach (GeometryObject geoObj in geoArr) while (Objects.MoveNext()) { GeometryObject geoObj = Objects.Current; if (geoObj is Solid) { Solid s = geoObj as Solid; faces = s.Faces; } } if (ExtOrInt) { face = GetExteriorFace(faces); } else { face = GetInteriorFace(faces); } } return(face); }
/// <summary> /// generate data of a Geometry Instance. /// </summary> /// <param name="obj">a geometry object of element.</param> private void AddInstance(GeometryObject obj) { Autodesk.Revit.DB.GeometryInstance instance = obj as Autodesk.Revit.DB.GeometryInstance; Autodesk.Revit.DB.GeometryElement geoElement = instance.SymbolGeometry; AddGeometryElement(geoElement); }
/// <summary> /// generate data of a Mesh. /// </summary> /// <param name="obj">a geometry object of element.</param> private void AddMesh(GeometryObject obj) { Mesh mesh = obj as Mesh; List <XYZ> points = new List <XYZ>(); // get all triangles of the mesh. for (int i = 0; i < mesh.NumTriangles; i++) { MeshTriangle trigangle = mesh.get_Triangle(i); for (int j = 0; j < 3; j++) { // A vertex of the triangle. Autodesk.Revit.DB.XYZ point = trigangle.get_Vertex(j); double x = point.X; double y = point.Y; double z = point.Z; points.Add(point); } Autodesk.Revit.DB.XYZ iniPoint = points[0]; points.Add(iniPoint); m_curve3Ds.Add(points); } }
private void MeshData(GeometryObject obj) { Mesh mesh = obj as Mesh; if (null == mesh) { return; } StringBuilder str = new StringBuilder(); for (int i = 0; i < mesh.NumTriangles; i++) { MeshTriangle triangular = mesh.get_Triangle(i); List <XYZ> points = new List <XYZ>(); for (int n = 0; n < 3; n++) { XYZ point = triangular.get_Vertex(n); points.Add(point); str.Append(point.ToString() + "\n"); } XYZ iniPoint = points[0]; points.Add(iniPoint); } TaskDialog td = new TaskDialog("vertex"); td.MainContent = str.ToString(); td.Show(); }
/// <summary> /// Get geometry of the pathReinforcement /// </summary> /// <param name="pathRein">pathReinforcement created</param> private List <List <XYZ> > GetGeometry(PathReinforcement pathRein) { Options options = m_profile.CommandData.Application.Application.Create.NewGeometryOptions(); options.DetailLevel = ViewDetailLevel.Medium; options.ComputeReferences = true; Autodesk.Revit.DB.GeometryElement geoElem = pathRein.get_Geometry(options); List <Curve> curvesList = new List <Curve>(); //GeometryObjectArray gObjects = geoElem.Objects; IEnumerator <GeometryObject> Objects = geoElem.GetEnumerator(); //foreach (GeometryObject geo in gObjects) while (Objects.MoveNext()) { GeometryObject geo = Objects.Current; Curve curve = geo as Curve; curvesList.Add(curve); } List <List <XYZ> > pointsPreview = new List <List <XYZ> >(); foreach (Curve curve in curvesList) { pointsPreview.Add(curve.Tessellate() as List <XYZ>); } return(pointsPreview); }
private void SolidData(GeometryObject obj) { Solid solid = obj as Solid; if (null == solid) { return; } FaceArray faces = solid.Faces; if (faces.Size == 0) { return; } foreach (Face f in faces) { Mesh mesh = f.Triangulate(); if (null == mesh) { return; } MeshData(mesh); } }
private static bool FindFaceInGeometryObject(GeometryObject geob, ref Face face) { var instance = geob as GeometryInstance; if (instance != null) { foreach (var geob_inner in instance.GetInstanceGeometry()) { FindFaceInGeometryObject(geob_inner, ref face); } } else { var solid = geob as Solid; if (solid != null) { foreach (Face f in solid.Faces) { if (f == face) { face = f; return(true); } } } } return(false); }
public static List <Solid> Getsolids(this GeometryObject geoobj) { var solids = new List <Solid>(); if (geoobj is Solid solid) { solids.Add(solid); } else if (geoobj is GeometryInstance geoInstance) { var transform = geoInstance.Transform; var symbolgeometry = geoInstance.SymbolGeometry; var enu = symbolgeometry.GetEnumerator(); while (enu.MoveNext()) { var temgeoobj = enu.Current as GeometryObject; solids.AddRange(Getsolids(temgeoobj)); } } else if (geoobj is GeometryElement geoElement) { var enu = geoElement.GetEnumerator(); while (enu.MoveNext()) { var temgeoobj = enu.Current as GeometryObject; solids.AddRange(Getsolids(temgeoobj)); } } return(solids); }
static private bool RecursionObject(GeometryElement geometryElement, ref List <GeometryObject> geometryObjects) { if (geometryElement == null) { return(false); } IEnumerator <GeometryObject> geometryObjectEnum = geometryElement.GetEnumerator(); while (geometryObjectEnum.MoveNext()) { GeometryObject currentGeometryObject = geometryObjectEnum.Current; var type = currentGeometryObject.GetType(); if (type.Equals(typeof(GeometryInstance))) { RecursionObject((currentGeometryObject as GeometryInstance).GetInstanceGeometry(), ref geometryObjects); } else if (type.Equals(typeof(GeometryElement))) { RecursionObject(currentGeometryObject as GeometryElement, ref geometryObjects); } else/* if (type.Equals(typeof(Solid)))*/ { geometryObjects.Add(currentGeometryObject); } } return(true); }
/// <summary> /// Initializes a new instance of the <see cref="Feature"/> class. /// </summary> /// <param name="geometry">The Geometry Object.</param> /// <param name="properties">The properties.</param> public Feature(GeometryObject geometry, Dictionary<string, object> properties) { if (properties != null) this.Properties = properties; else this.Properties = new Dictionary<string, object>(); this.Geometry = geometry; this.Type = GeoJsonObjectType.Feature; }
/// <summary> /// Sets best material id for current export state. /// </summary> /// <param name="geometryObject">The geometry object to get the best material id.</param> /// <param name="element">The element to get its structual material if no material found in its geometry.</param> /// <param name="overrideMaterialId">The material id to override the one gets from geometry object.</param> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <returns>The material id.</returns> public static ElementId SetBestMaterialIdInExporter(GeometryObject geometryObject, Element element, ElementId overrideMaterialId, ExporterIFC exporterIFC) { ElementId materialId = overrideMaterialId != ElementId.InvalidElementId ? overrideMaterialId : GetBestMaterialIdFromGeometryOrParameter(geometryObject, exporterIFC, element); if (materialId != ElementId.InvalidElementId) exporterIFC.SetMaterialIdForCurrentExportState(materialId); return materialId; }
private static void GetAllCurves(GeometryObject geometry, List<Curve> curves) { if (geometry is GeometryElement) { GetAllCurves(geometry as GeometryElement, curves); return; } if (geometry is Solid) { GetAllCurves(geometry as Solid, curves); return; } }
/// <summary> /// Tell if the geometry object A and B are overlapped. /// </summary> /// <param name="geometryA">geometry object A</param> /// <param name="geometryB">geometry object B</param> /// <returns>return true if A and B are overlapped, or else return false.</returns> public static bool IsOverlapped(GeometryObject geometryA, GeometryObject geometryB) { List<Face> facesOfA = new List<Face>(); List<Curve> curvesOfB = new List<Curve>(); GetAllFaces(geometryA, facesOfA); GetAllCurves(geometryB, curvesOfB); foreach (Face face in facesOfA) { foreach (Curve curve in curvesOfB) { if (face.Intersect(curve) == Autodesk.Revit.DB.SetComparisonResult.Overlap) { return true; } } } return false; }
/// <summary> /// generate data of a Curve /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddCurve(GeometryObject obj, Transform transform) { Curve curve = obj as Curve; if (null == curve) { return; } if (curve.IsBound) { List<XYZ> points = curve.Tessellate() as List<XYZ>; List<XYZ> result = new List<XYZ>(); foreach (Autodesk.Revit.DB.XYZ point in points) { Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform); result.Add(newPoint); } m_curve3Ds.Add(result); } }
private void Stream(ArrayList data, GeometryObject geomObj) { data.Add(new Snoop.Data.ClassSeparator(typeof(GeometryObject))); data.Add(new Snoop.Data.Bool("IsElementGeometry", geomObj.IsElementGeometry)); data.Add(new Snoop.Data.String("Visibility", geomObj.Visibility.ToString())); data.Add(new Snoop.Data.ElementId("GraphicStyleId", geomObj.GraphicsStyleId, m_activeDoc)); data.Add(new Snoop.Data.String("Type", geomObj.GetType().Name)); Curve crv = geomObj as Curve; if (crv != null) { Stream(data, crv); return; } Edge edg = geomObj as Edge; if (edg != null) { Stream(data, edg); return; } GeometryElement elem = geomObj as GeometryElement; if (elem != null) { Stream(data, elem); return; } Face face = geomObj as Face; if (face != null) { Stream(data, face); return; } GeometryInstance inst = geomObj as GeometryInstance; if (inst != null) { Stream(data, inst); return; } Mesh mesh = geomObj as Mesh; if (mesh != null) { Stream(data, mesh); return; } Profile prof = geomObj as Profile; if (prof != null) { Stream(data, prof); return; } Solid solid = geomObj as Solid; if (solid != null) { Stream(data, solid); return; } Point point = geomObj as Point; if (point != null) { Stream(data, point); return; } }
/// <summary> /// Return a triangulated face set from the list of faces /// </summary> /// <param name="exporterIFC">exporter IFC</param> /// <param name="element">the element</param> /// <param name="options">the body export options</param> /// <param name="geomObject">the geometry object</param> /// <returns>returns the handle</returns> private static IFCAnyHandle ExportSurfaceAsTriangulatedFaceSet(ExporterIFC exporterIFC, Element element, BodyExporterOptions options, GeometryObject geomObject) { IFCFile file = exporterIFC.GetFile(); List<List<XYZ>> triangleList = new List<List<XYZ>>(); if (geomObject is Solid) { Solid geomSolid = geomObject as Solid; FaceArray faces = geomSolid.Faces; foreach (Face face in faces) { double tessellationLevel = options.TessellationControls.LevelOfDetail; Mesh faceTriangulation = face.Triangulate(tessellationLevel); for (int i = 0; i < faceTriangulation.NumTriangles; ++i) { List<XYZ> triangleVertices = new List<XYZ>(); MeshTriangle triangle = faceTriangulation.get_Triangle(i); for (int tri = 0; tri < 3; ++tri) { XYZ vert = triangle.get_Vertex(tri); triangleVertices.Add(vert); } triangleList.Add(triangleVertices); } } } else if (geomObject is Mesh) { Mesh geomMesh = geomObject as Mesh; for (int i = 0; i < geomMesh.NumTriangles; ++i) { List<XYZ> triangleVertices = new List<XYZ>(); MeshTriangle triangle = geomMesh.get_Triangle(i); for (int tri = 0; tri < 3; ++tri) { XYZ vert = triangle.get_Vertex(tri); triangleVertices.Add(vert); } triangleList.Add(triangleVertices); } } return GeometryUtil.GetIndexedTriangles(file, triangleList); }
private static void ParseSolid(GeometryObject obj, List<XYZ> pts) { var solid = obj as Solid; foreach (Edge gEdge in solid.Edges) { Curve c = gEdge.AsCurve(); if (c is Line) { pts.Add(c.Evaluate(0, true)); pts.Add(c.Evaluate(1,true)); } else { IList<XYZ> xyzArray = gEdge.Tessellate(); pts.AddRange(xyzArray); } } }
private static bool ProcessObjectForGStyle(Document doc, GeometryObject geomObj, ref ElementId overrideCatId, ref bool initOverrideCatId) { GraphicsStyle gStyle = doc.GetElement(geomObj.GraphicsStyleId) as GraphicsStyle; if (gStyle == null) return true; if (gStyle.GraphicsStyleCategory == null) return true; ElementId currCatId = gStyle.GraphicsStyleCategory.Id; if (currCatId == ElementId.InvalidElementId) return true; if (!initOverrideCatId) { initOverrideCatId = true; overrideCatId = currCatId; return true; } if (currCatId != overrideCatId) { overrideCatId = ElementId.InvalidElementId; return false; } return true; }
/// <summary> /// Exports a geometry object to IFC body representation. /// </summary> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="categoryId">The category id.</param> /// <param name="geometryObject">The geometry object.</param> /// <param name="options">The settings for how to export the body.</param> /// <param name="exportBodyParams">The extrusion creation data.</param> /// <returns>The body data.</returns> public static BodyData ExportBody(ExporterIFC exporterIFC, Element element, ElementId categoryId, ElementId overrideMaterialId, GeometryObject geometryObject, BodyExporterOptions options, IFCExtrusionCreationData exportBodyParams) { IList<GeometryObject> geomList = new List<GeometryObject>(); if (geometryObject is Solid) { IList<Solid> splitVolumes = GeometryUtil.SplitVolumes(geometryObject as Solid); foreach (Solid solid in splitVolumes) geomList.Add(solid); } else geomList.Add(geometryObject); return ExportBody(exporterIFC, element, categoryId, overrideMaterialId, geomList, options, exportBodyParams); }
/// <summary> /// generate data of a Profile /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddProfile(GeometryObject obj, Transform transform) { Profile profile = obj as Profile; if (null == profile) { return; } foreach (Curve curve in profile.Curves) { AddCurve(curve, transform); } }
private static bool ExportBodyAsSolid(ExporterIFC exporterIFC, Element element, BodyExporterOptions options, IList<HashSet<IFCAnyHandle>> currentFaceHashSetList, GeometryObject geomObject) { IFCFile file = exporterIFC.GetFile(); Document document = element.Document; bool exportedAsSolid = false; try { if (geomObject is Solid) { Solid solid = geomObject as Solid; exportedAsSolid = ExportPlanarBodyIfPossible(exporterIFC, solid, currentFaceHashSetList); if (exportedAsSolid) return exportedAsSolid; SolidOrShellTessellationControls tessellationControls = options.TessellationControls; TriangulatedSolidOrShell solidFacetation = SolidUtils.TessellateSolidOrShell(solid, tessellationControls); if (solidFacetation.ShellComponentCount == 1) { TriangulatedShellComponent component = solidFacetation.GetShellComponent(0); int numberOfTriangles = component.TriangleCount; int numberOfVertices = component.VertexCount; if (numberOfTriangles > 0 && numberOfVertices > 0) { IList<IFCAnyHandle> vertexHandles = new List<IFCAnyHandle>(); HashSet<IFCAnyHandle> currentFaceSet = new HashSet<IFCAnyHandle>(); // create list of vertices first. for (int ii = 0; ii < numberOfVertices; ii++) { XYZ vertex = component.GetVertex(ii); XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex); IFCAnyHandle vertexHandle = ExporterUtil.CreateCartesianPoint(file, vertexScaled); vertexHandles.Add(vertexHandle); } try { IList<LinkedList<int>> facets = ConvertTrianglesToPlanarFacets(component); foreach (LinkedList<int> facet in facets) { IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>(); int numVertices = facet.Count; if (numVertices < 3) continue; foreach (int vertexIndex in facet) { vertices.Add(vertexHandles[vertexIndex]); } IFCAnyHandle faceOuterLoop = IFCInstanceExporter.CreatePolyLoop(file, vertices); IFCAnyHandle faceOuterBound = IFCInstanceExporter.CreateFaceOuterBound(file, faceOuterLoop, true); HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>(); faceBounds.Add(faceOuterBound); IFCAnyHandle face = IFCInstanceExporter.CreateFace(file, faceBounds); currentFaceSet.Add(face); } } catch { for (int ii = 0; ii < numberOfTriangles; ii++) { TriangleInShellComponent triangle = component.GetTriangle(ii); IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>(); vertices.Add(vertexHandles[triangle.VertexIndex0]); vertices.Add(vertexHandles[triangle.VertexIndex1]); vertices.Add(vertexHandles[triangle.VertexIndex2]); IFCAnyHandle faceOuterLoop = IFCInstanceExporter.CreatePolyLoop(file, vertices); IFCAnyHandle faceOuterBound = IFCInstanceExporter.CreateFaceOuterBound(file, faceOuterLoop, true); HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>(); faceBounds.Add(faceOuterBound); IFCAnyHandle face = IFCInstanceExporter.CreateFace(file, faceBounds); currentFaceSet.Add(face); } } finally { currentFaceHashSetList.Add(currentFaceSet); exportedAsSolid = true; } } } } return exportedAsSolid; } catch { string errMsg = String.Format("TessellateSolidOrShell failed in IFC export for element \"{0}\" with id {1}", element.Name, element.Id); document.Application.WriteJournalComment(errMsg, false/*timestamp*/); return false; } }
/// <summary> /// Create an IFCSolidInfo from the created geometry. /// </summary> /// <param name="id">The id associated with the geometry in the IFC file.</param> /// <param name="geometryObject">The created geometry.</param> /// <returns>The IFCSolidInfo class.</returns> public static IFCSolidInfo Create(int id, GeometryObject geometryObject) { return new IFCSolidInfo(id, geometryObject); }
/// <summary> /// generate data of a Solid /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddSolid(GeometryObject obj, Transform transform) { Solid solid = obj as Solid; if (null == solid) { return; } //a solid has many faces FaceArray faces = solid.Faces; if (faces.Size == 0) { return; } foreach (Face face in faces) { AddFace(face, transform); } }
protected IFCSolidInfo(int id, GeometryObject geometryObject) { Id = id; GeometryObject = geometryObject; }
protected IFCSolidInfo() { Id = -1; GeometryObject = null; }
private static void ParseInstanceGeometry(GeometryObject obj, List<XYZ> pts) { var geomInst = obj as GeometryInstance; foreach (GeometryObject gObj in geomInst.GetInstanceGeometry()) { if (gObj is Solid) { ParseSolid(gObj, pts); } else if (gObj is GeometryInstance) { ParseInstanceGeometry(gObj, pts); } } }
private static bool FindFaceInGeometryObject(GeometryObject geob, ref Face face) { var instance = geob as GeometryInstance; if (instance != null) { foreach (var geob_inner in instance.GetInstanceGeometry()) { FindFaceInGeometryObject(geob_inner, ref face); } } else { var solid = geob as Solid; if (solid != null) { foreach (Face f in solid.Faces) { if (f == face) { face = f; return true; } } } } return false; }
/// <summary> /// generate data of a Mesh /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddMesh(GeometryObject obj, Transform transform) { Mesh mesh = obj as Mesh; if (null == mesh) { return; } //a face has a mesh, all meshes are made of triangles for (int i = 0; i < mesh.NumTriangles; i++) { MeshTriangle triangular = mesh.get_Triangle(i); List<XYZ> points = new List<XYZ>(); try { for (int n = 0; n < 3; n++) { Autodesk.Revit.DB.XYZ point = triangular.get_Vertex(n); Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform); points.Add(newPoint); } Autodesk.Revit.DB.XYZ iniPoint = points[0]; points.Add(iniPoint); m_curve3Ds.Add(points); } catch { } } }
/// <summary> /// Adds a new object to the cache. /// </summary> /// <param name="geometryObject">The object.</param> public void AddGeometryObject(GeometryObject geometryObject) { m_geometryObjects.Add(geometryObject); }
/// <summary> /// generate data of a Instance /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddInstance(GeometryObject obj, Transform transform) { GeometryInstance instance = obj as GeometryInstance; if (null == instance) { return; } //get a transformation of the affine 3-space Transform allTransform = AddTransform(transform, instance.Transform); GeometryElement instanceGeometry = instance.SymbolGeometry; if (null == instanceGeometry) { return; } //get all geometric primitives contained in the GeometryElement GeometryObjectArray instanceGeometries = instanceGeometry.Objects; AddGeometryObjects(instanceGeometries, allTransform); }
/// <summary> /// Exports a geometry object to IFC body representation. /// </summary> /// <param name="application">The Revit application.</param> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <param name="categoryId">The category id.</param> /// <param name="geometryObject">The geometry object.</param> /// <param name="options">The settings for how to export the body.</param> /// <param name="exportBodyParams">The extrusion creation data.</param> /// <returns>The body data.</returns> public static BodyData ExportBody(Autodesk.Revit.ApplicationServices.Application application, ExporterIFC exporterIFC, Element element, ElementId categoryId, GeometryObject geometryObject, BodyExporterOptions options, IFCExtrusionCreationData exportBodyParams) { IList<GeometryObject> geomList = new List<GeometryObject>(); geomList.Add(geometryObject); return ExportBody(application, exporterIFC, element, categoryId, geomList, options, exportBodyParams); }
/// <summary> /// get the solids in a Geometric primitive /// </summary> /// <param name="obj">a geometry object of element</param> /// <param name="transform"></param> private void AddGeoElement(GeometryObject obj, Transform transform) { GeometryElement geometry = obj as GeometryElement; if (null == geometry) { return; } //get all geometric primitives contained in the GeometryElement GeometryObjectArray geometries = geometry.Objects; AddGeometryObjects(geometries, transform); }
/// <summary> /// Gets the best material id from the geometry or its structural material parameter. /// </summary> /// <param name="geometryObject">The geometry object.</param> /// <param name="exporterIFC">The exporter.</param> /// <param name="element">The element.</param> /// <returns>The material id.</returns> public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryObject geometryObject, ExporterIFC exporterIFC, Element element) { ElementId matId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC); if (matId == ElementId.InvalidElementId && element != null) matId = GetBestMaterialIdFromParameter(element); return matId; }
/// <summary> /// generate data of a Face /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddFace(GeometryObject obj, Transform transform) { Face face = obj as Face; if (null == face) { return; } Mesh mesh = face.Triangulate(); if (null == mesh) { return; } AddMesh(mesh, transform); }
private static bool ExportBodyAsSolid(ExporterIFC exporterIFC, Element element, BodyExporterOptions options, IList<HashSet<IFCAnyHandle>> currentFaceHashSetList, GeometryObject geomObject) { IFCFile file = exporterIFC.GetFile(); Document document = element.Document; bool exportedAsSolid = false; try { if (geomObject is Solid) { Solid solid = geomObject as Solid; exportedAsSolid = ExportPlanarBodyIfPossible(exporterIFC, solid, currentFaceHashSetList); if (exportedAsSolid) return exportedAsSolid; SolidOrShellTessellationControls tessellationControlsOriginal = options.TessellationControls; SolidOrShellTessellationControls tessellationControls = ExporterUtil.GetTessellationControl(element, tessellationControlsOriginal); TriangulatedSolidOrShell solidFacetation = null; // We will make (up to) 2 attempts. First we will use tessellationControls, and then we will try tessellationControlsOriginal, but only // if they are different. for (int ii = 0; ii < 2; ii++) { if (ii == 1 && tessellationControls.Equals(tessellationControlsOriginal)) break; try { SolidOrShellTessellationControls tessellationControlsToUse = (ii == 0) ? tessellationControls : tessellationControlsOriginal; solidFacetation = SolidUtils.TessellateSolidOrShell(solid, tessellationControlsToUse); break; } catch { solidFacetation = null; } } // Only handle one solid or shell. if (solidFacetation != null && solidFacetation.ShellComponentCount == 1) { TriangulatedShellComponent component = solidFacetation.GetShellComponent(0); int numberOfTriangles = component.TriangleCount; int numberOfVertices = component.VertexCount; // We are going to limit the number of triangles to 50,000. This is a arbitrary number // that should prevent the solid faceter from creating too many extra triangles to sew the surfaces. // We may evaluate this number over time. if ((numberOfTriangles > 0 && numberOfVertices > 0) && (numberOfTriangles < 50000)) { IList<IFCAnyHandle> vertexHandles = new List<IFCAnyHandle>(); HashSet<IFCAnyHandle> currentFaceSet = new HashSet<IFCAnyHandle>(); if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView) { List<List<double>> coordList = new List<List<double>>(); // create list of vertices first. for (int i = 0; i < numberOfVertices; i++) { List<double> vertCoord = new List<double>(); XYZ vertex = component.GetVertex(i); XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex); vertCoord.Add(vertexScaled.X); vertCoord.Add(vertexScaled.Y); vertCoord.Add(vertexScaled.Z); coordList.Add(vertCoord); } } else { // create list of vertices first. for (int ii = 0; ii < numberOfVertices; ii++) { XYZ vertex = component.GetVertex(ii); XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex); IFCAnyHandle vertexHandle = ExporterUtil.CreateCartesianPoint(file, vertexScaled); vertexHandles.Add(vertexHandle); } if (!ExportPlanarFacetsIfPossible(file, component, vertexHandles, currentFaceSet)) { // Export all of the triangles instead. for (int ii = 0; ii < numberOfTriangles; ii++) { TriangleInShellComponent triangle = component.GetTriangle(ii); IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>(); vertices.Add(vertexHandles[triangle.VertexIndex0]); vertices.Add(vertexHandles[triangle.VertexIndex1]); vertices.Add(vertexHandles[triangle.VertexIndex2]); IFCAnyHandle face = CreateFaceFromVertexList(file, vertices); currentFaceSet.Add(face); } } currentFaceHashSetList.Add(currentFaceSet); exportedAsSolid = true; } } } } return exportedAsSolid; } catch { string errMsg = String.Format("TessellateSolidOrShell failed in IFC export for element \"{0}\" with id {1}", element.Name, element.Id); document.Application.WriteJournalComment(errMsg, false/*timestamp*/); return false; } }
/// <summary> /// generate data of a Edge /// </summary> /// <param name="obj"></param> /// <param name="transform"></param> private void AddEdge(GeometryObject obj, Transform transform) { Edge edge = obj as Edge; if (null == edge) { return; } List<XYZ> points = edge.Tessellate() as List<XYZ>; List<XYZ> result = new List<XYZ>(); foreach (Autodesk.Revit.DB.XYZ point in points) { Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform); result.Add(newPoint); } m_curve3Ds.Add(result); }
/// <summary> /// Gets the best material id for the geometry. /// </summary> /// <param name="geometryObject">The geometry object to get the best material id.</param> /// <param name="exporterIFC">The ExporterIFC object.</param> /// <returns>The material id.</returns> public static ElementId GetBestMaterialIdForGeometry(GeometryObject geometryObject, ExporterIFC exporterIFC) { if (geometryObject is GeometryElement) return GetBestMaterialIdForGeometry(geometryObject as GeometryElement, exporterIFC, null); if (!(geometryObject is Solid)) return ElementId.InvalidElementId; Solid solid = geometryObject as Solid; // We need to figure out the most common material id for the internal faces. // Other faces will override this. IDictionary<ElementId, int> countMap = new Dictionary<ElementId, int>(); ElementId mostPopularId = ElementId.InvalidElementId; int numMostPopular = 0; foreach (Face face in solid.Faces) { if (face == null) continue; ElementId currentMaterialId = face.MaterialElementId; if (currentMaterialId == ElementId.InvalidElementId) continue; int currentCount = 0; if (countMap.ContainsKey(currentMaterialId)) { countMap[currentMaterialId]++; currentCount = countMap[currentMaterialId]; } else { countMap[currentMaterialId] = 1; currentCount = 1; } if (currentCount > numMostPopular) { mostPopularId = currentMaterialId; numMostPopular = currentCount; } } return mostPopularId; }
/// <summary> /// Creates a SweptSolidExporter. /// </summary> /// <param name="exporterIFC">The exporter.</param> /// <param name="element">The element.</param> /// <param name="solid">The solid.</param> /// <param name="normal">The normal of the plane that the path lies on.</param> /// <returns>The SweptSolidExporter.</returns> public static SweptSolidExporter Create(ExporterIFC exporterIFC, Element element, SimpleSweptSolidAnalyzer sweptAnalyzer, GeometryObject geomObject) { try { if (sweptAnalyzer == null) return null; SweptSolidExporter sweptSolidExporter = null; IList<Revit.IFC.Export.Utility.GeometryUtil.FaceBoundaryType> faceBoundaryTypes; IList<CurveLoop> faceBoundaries = GeometryUtil.GetFaceBoundaries(sweptAnalyzer.ProfileFace, null, out faceBoundaryTypes); string profileName = null; if (element != null) { ElementType type = element.Document.GetElement(element.GetTypeId()) as ElementType; if (type != null) profileName = type.Name; } // Is it really an extrusion? if (sweptAnalyzer.PathCurve is Line) { Line line = sweptAnalyzer.PathCurve as Line; // invalid case if (MathUtil.VectorsAreOrthogonal(line.Direction, sweptAnalyzer.ProfileFace.FaceNormal)) return null; sweptSolidExporter = new SweptSolidExporter(); sweptSolidExporter.RepresentationType = ShapeRepresentationType.SweptSolid; Plane plane = new Plane(sweptAnalyzer.ProfileFace.FaceNormal, sweptAnalyzer.ProfileFace.Origin); sweptSolidExporter.RepresentationItem = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, profileName, faceBoundaries, plane, line.Direction, UnitUtil.ScaleLength(line.Length)); } else { sweptSolidExporter = new SweptSolidExporter(); if (ExporterCacheManager.ExportOptionsCache.ExportAs4) { // Use tessellated geometry in IFC Reference View if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView) { // TODO: Create CreateSimpleSweptSolidAsTessellation routine that takes advantage of the superior tessellation of this class. BodyExporterOptions options = new BodyExporterOptions(false); sweptSolidExporter.RepresentationItem = BodyExporter.ExportBodyAsTriangulatedFaceSet(exporterIFC, element, options, geomObject); sweptSolidExporter.RepresentationType = ShapeRepresentationType.Tessellation; } else { sweptSolidExporter.RepresentationItem = CreateSimpleSweptSolid(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve); sweptSolidExporter.RepresentationType = ShapeRepresentationType.AdvancedSweptSolid; } } else { sweptSolidExporter.Facets = CreateSimpleSweptSolidAsBRep(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve); sweptSolidExporter.RepresentationType = ShapeRepresentationType.Brep; } } return sweptSolidExporter; } catch (Exception) { return null; } }