public static ICurve3D Transform(this Transform transform, ICurve3D curve3D) { if (transform == null || curve3D == null) return null; return Transform(transform, curve3D as dynamic); }
public static Edge ToTopologic(this ICurve3D curve3D) { if (curve3D == null) { return(null); } Point3D point3D_1 = curve3D.GetStart(); if (point3D_1 == null) { return(null); } Point3D point3D_2 = curve3D.GetEnd(); if (point3D_2 == null) { return(null); } if (point3D_1 == point3D_2) { return(null); } return(Edge.ByStartVertexEndVertex(ToTopologic(point3D_1), ToTopologic(point3D_2))); }
public static List <ISegmentable3D> ExtremeSegmentable3Ds(this IEnumerable <ISegmentable3D> segmentable3Ds, IEnumerable <ISegmentable3D> segmentable3Ds_Auxiliary, double tolerance = Core.Tolerance.Distance) { if (segmentable3Ds == null || segmentable3Ds_Auxiliary == null) { return(null); } List <ISegmentable3D> result = new List <ISegmentable3D>(); Dictionary <ISegmentable3D, List <Vector3D> > dictionary = new Dictionary <ISegmentable3D, List <Vector3D> >(); foreach (ISegmentable3D segmentable3D in segmentable3Ds) { ICurve3D curve3D = segmentable3D as ICurve3D; if (curve3D == null) { continue; } foreach (Point3D point3D in new Point3D[] { curve3D.GetStart(), curve3D.GetEnd() }) { List <Point3D> point3Ds_Intersection = segmentable3D.Intersections(segmentable3Ds_Auxiliary, tolerance); Point3D point3D_Closest = point3Ds_Intersection.Closest(point3D); ISegmentable3D segmentable3D_Closest = null; foreach (ISegmentable3D segmentable3D_Temp in segmentable3Ds_Auxiliary) { if (segmentable3D_Temp.On(point3D_Closest, tolerance)) { segmentable3D_Closest = segmentable3D_Temp; break; } } if (segmentable3D_Closest != null) { if (!dictionary.TryGetValue(segmentable3D_Closest, out List <Vector3D> vector3Ds)) { vector3Ds = new List <Vector3D>(); dictionary[segmentable3D_Closest] = vector3Ds; } Vector3D vector3D = new Vector3D(point3D_Closest, point3D); if (vector3Ds.Find(x => x.AlmostEqual(vector3D, tolerance)) == null) { vector3Ds.Add(vector3D); ISegmentable3D segmentable3D_Moved = segmentable3D_Closest.GetMoved(vector3D) as ISegmentable3D; result.Add(segmentable3D_Moved); } } } } return(result); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="dataAccess"> /// The DA object is used to retrieve from inputs and store in outputs. /// </param> protected override void SolveInstance(IGH_DataAccess dataAccess) { ISAMGeometry sAMGeometry = null; if (!dataAccess.GetData(0, ref sAMGeometry) || sAMGeometry == null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data"); return; } Point3D point3D = sAMGeometry as Point3D; if (point3D != null) { dataAccess.SetData(0, Geometry.Topologic.Convert.ToTopologic(point3D)); return; } ICurve3D curve3D = sAMGeometry as ICurve3D; if (curve3D != null) { dataAccess.SetData(0, Geometry.Topologic.Convert.ToTopologic(curve3D)); return; } Polygon3D polygon3D = sAMGeometry as Polygon3D; if (polygon3D != null) { dataAccess.SetData(0, Geometry.Topologic.Convert.ToTopologic(polygon3D)); return; } Face3D face3D = sAMGeometry as Face3D; if (face3D != null) { dataAccess.SetData(0, Geometry.Topologic.Convert.ToTopologic(face3D)); return; } Shell shell = sAMGeometry as Shell; if (shell != null) { Brep brep = Rhino.Convert.ToRhino(shell); if (brep != null) { dataAccess.SetData(0, brep.ToTopologic(Core.Tolerance.MacroDistance)); return; } } AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Cannot convert geometry"); }
public static Polygon3D ToSAM_Polygon3D(this CurveLoop curveLoop, double tolerance = Core.Tolerance.Distance) { List <Segment3D> segment3Ds = new List <Segment3D>(); foreach (Curve curve in curveLoop) { ICurve3D curve3D = curve.ToSAM(); if (curve3D is ISegmentable3D) { List <Segment3D> segment3Ds_Temp = ((ISegmentable3D)curve3D).GetSegments(); if (segment3Ds_Temp == null || segment3Ds_Temp.Count == 0) { continue; } segment3Ds.AddRange(segment3Ds_Temp); } } if (segment3Ds.Count < 3) { return(null); } int count = segment3Ds.Count; segment3Ds.Add(segment3Ds[0]); bool oriented = true; for (int i = 0; i < count; i++) { if (segment3Ds[i][1].Distance(segment3Ds[i + 1][0]) > tolerance) { oriented = false; break; } } segment3Ds.RemoveAt(count); if (oriented) { return(Spatial.Create.Polygon3D(segment3Ds.ConvertAll(x => x.GetStart()))); } List <Point3D> point3Ds = new List <Point3D>(); foreach (Segment3D segment3D in segment3Ds) { Spatial.Modify.Add(point3Ds, segment3D.GetStart(), tolerance); Spatial.Modify.Add(point3Ds, segment3D.GetEnd(), tolerance); } if (point3Ds == null || point3Ds.Count < 3) { return(null); } Spatial.Plane plane = Spatial.Create.Plane(point3Ds, tolerance); if (plane == null) { return(null); } List <Planar.Segment2D> segment2Ds = segment3Ds.ConvertAll(x => plane.Convert(plane.Project(x))); if (segment2Ds == null || segment2Ds.Count < 3) { return(null); } List <Planar.Polygon2D> polygon2Ds = Planar.Create.Polygon2Ds(segment2Ds, tolerance); if (polygon2Ds == null || polygon2Ds.Count == 0) { //Extra case for situation where segment2Ds does not are not properly sorted List <Planar.Point2D> point2Ds = new List <Planar.Point2D>(); List <Planar.Segment2D> segment2Ds_Temp = new List <Planar.Segment2D>(segment2Ds); point2Ds.Add(segment2Ds_Temp[0][0]); point2Ds.Add(segment2Ds_Temp[0][1]); segment2Ds_Temp.RemoveAt(0); while (segment2Ds_Temp.Count > 0) { Point2D point2D = point2Ds.Last(); segment2Ds_Temp.SortByDistance(point2D); Segment2D segment2D = segment2Ds_Temp[0]; if (segment2D[0].Distance(point2D) > segment2D[1].Distance(point2D)) { point2Ds.Add(segment2D[0]); } else { point2Ds.Add(segment2D[1]); } segment2Ds_Temp.RemoveAt(0); } return(plane.Convert(new Polygon2D(point2Ds))); } if (polygon2Ds.Count > 1) { polygon2Ds.Sort((x, y) => y.GetArea().CompareTo(x.GetArea())); } return(plane.Convert(polygon2Ds[0])); }
public static Aperture ToSAM_Aperture(this FamilyInstance familyInstance, Core.Revit.ConvertSettings convertSettings) { if (familyInstance == null) { return(null); } Aperture result = convertSettings?.GetObject <Aperture>(familyInstance.Id); if (result != null) { return(result); } if (Core.Revit.Query.Simplified(familyInstance)) { result = Core.Revit.Query.IJSAMObject <Aperture>(familyInstance); if (result != null) { convertSettings?.Add(familyInstance.Id, result); return(result); } } Point3D point3D_Location = Geometry.Revit.Query.Location(familyInstance); if (point3D_Location == null) { return(null); } PanelType panelType_Host = PanelType.Undefined; BuiltInCategory builtInCategory_Host = BuiltInCategory.INVALID; if (familyInstance.Host != null) { HostObject hostObject = familyInstance.Host as HostObject; if (hostObject != null) { builtInCategory_Host = (BuiltInCategory)hostObject.Category.Id.IntegerValue; List <Face3D> face3Ds_Temp = hostObject.Profiles(); if (face3Ds_Temp != null && face3Ds_Temp.Count != 0) { Geometry.Spatial.Plane plane_Host = face3Ds_Temp.Closest(point3D_Location)?.GetPlane(); if (plane_Host != null) { point3D_Location = plane_Host.Project(point3D_Location); } } HostObjAttributes hostObjAttributes = familyInstance.Document.GetElement(hostObject.GetTypeId()) as HostObjAttributes; if (hostObjAttributes != null) { panelType_Host = hostObjAttributes.PanelType(); } if (panelType_Host == PanelType.Undefined) { panelType_Host = hostObject.PanelType(); } } } ApertureConstruction apertureConstruction = ToSAM_ApertureConstruction(familyInstance, convertSettings); if (apertureConstruction == null && panelType_Host != PanelType.Undefined) { apertureConstruction = Analytical.Query.DefaultApertureConstruction(panelType_Host, familyInstance.ApertureType()); //Default Aperture Construction } Vector3D axisX = null; Vector3D normal = null; Vector3D axisY = null; if (builtInCategory_Host == BuiltInCategory.OST_Roofs) { axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false); axisY = familyInstance.FacingOrientation.ToSAM_Vector3D(false); normal = Geometry.Spatial.Query.AxisY(axisY, axisX); } else { axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false); normal = familyInstance.FacingOrientation.ToSAM_Vector3D(false); axisY = Geometry.Spatial.Query.AxisY(normal, axisX); } Geometry.Spatial.Plane plane = Geometry.Spatial.Create.Plane(point3D_Location, axisX, axisY); if (!plane.Normal.SameHalf(normal)) { plane.FlipZ(false); } List <Face3D> face3Ds = Geometry.Revit.Convert.ToSAM_Face3Ds(familyInstance); if (face3Ds == null || face3Ds.Count == 0) { return(null); } List <Point2D> point2Ds = new List <Point2D>(); foreach (Face3D face3D_Temp in face3Ds) { IClosedPlanar3D closedPlanar3D = face3D_Temp.GetExternalEdge3D(); if (closedPlanar3D is ICurvable3D) { List <ICurve3D> curve3Ds = ((ICurvable3D)closedPlanar3D).GetCurves(); foreach (ICurve3D curve3D in curve3Ds) { ICurve3D curve3D_Temp = plane.Project(curve3D); point2Ds.Add(plane.Convert(curve3D_Temp.GetStart())); } } } if (point2Ds == null || point2Ds.Count == 0) { return(null); } //TODO: Working on SAM Families (requested by Michal) string parameterName_Height = Core.Revit.Query.Name(ActiveSetting.Setting, typeof(Aperture), typeof(FamilyInstance), "GetHeight"); string parameterName_Width = Core.Revit.Query.Name(ActiveSetting.Setting, typeof(Aperture), typeof(FamilyInstance), "GetWidth"); if (!string.IsNullOrWhiteSpace(parameterName_Height) && !string.IsNullOrWhiteSpace(parameterName_Width)) { Parameter parameter_Height = familyInstance.LookupParameter(parameterName_Height); Parameter parameter_Width = familyInstance.LookupParameter(parameterName_Width); if (parameter_Height != null && parameter_Width != null && parameter_Height.HasValue && parameter_Width.HasValue && parameter_Height.StorageType == StorageType.Double && parameter_Width.StorageType == StorageType.Double) { double height = UnitUtils.ConvertFromInternalUnits(parameter_Height.AsDouble(), DisplayUnitType.DUT_METERS); double width = UnitUtils.ConvertFromInternalUnits(parameter_Width.AsDouble(), DisplayUnitType.DUT_METERS); BoundingBox2D boundingBox2D = new BoundingBox2D(point2Ds); double factor_Height = height / boundingBox2D.Height; double factor_Width = width / boundingBox2D.Width; point2Ds = point2Ds.ConvertAll(x => new Point2D(x.X * factor_Width, x.Y * factor_Height)); } } Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds); result = new Aperture(apertureConstruction, new Face3D(plane, rectangle2D)); result.UpdateParameterSets(familyInstance, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap)); convertSettings?.Add(familyInstance.Id, result); return(result); }
public static List <T> ToSAM <T>(this GeometryElement geometryElement, Transform transform = null) where T : ISAMGeometry { if (geometryElement == null) { return(null); } List <T> result = new List <T>(); foreach (GeometryObject geometryObject in geometryElement) { if (geometryObject is GeometryInstance) { GeometryInstance geometryInstance = (GeometryInstance)geometryObject; Transform geometryTransform = geometryInstance.Transform; if (transform != null) { geometryTransform = geometryTransform.Multiply(transform.Inverse); } GeometryElement geometryElement_Temp = geometryInstance.GetInstanceGeometry(geometryTransform); if (geometryElement_Temp == null) { continue; } List <T> sAMGeometries = ToSAM <T>(geometryElement_Temp); if (sAMGeometries != null && sAMGeometries.Count > 0) { result.AddRange(sAMGeometries); } } else if (geometryObject is Solid) { if (typeof(T).IsAssignableFrom(typeof(Shell))) { Shell shell = ((Solid)geometryObject).ToSAM(); if (shell != null) { result.Add((T)(ISAMGeometry)shell); } } else if (typeof(T).IsAssignableFrom(typeof(Face3D))) { List <Face3D> face3Ds = ((Solid)geometryObject).ToSAM_Face3Ds(); if (face3Ds != null) { foreach (Face3D face3D in face3Ds) { result.Add((T)(ISAMGeometry)face3D); } } } } else if (geometryObject is Line) { if (typeof(T).IsAssignableFrom(typeof(ISegmentable3D))) { Segment3D segment3D = ((Line)geometryObject).ToSAM(); if (segment3D != null) { result.Add((T)(ISAMGeometry)segment3D); } } } else if (geometryObject is Curve) { if (typeof(T).IsAssignableFrom(typeof(ICurve3D))) { ICurve3D curve3D = ((Curve)geometryObject).ToSAM(); if (curve3D != null) { result.Add((T)curve3D); } } } } return(result); }
public static IOpening ToSAM_Opening(this FamilyInstance familyInstance, ConvertSettings convertSettings) { if (familyInstance == null) { return(null); } IOpening result = convertSettings?.GetObject <IOpening>(familyInstance.Id); if (result != null) { return(result); } if (Core.Revit.Query.Simplified(familyInstance)) { result = Core.Revit.Query.IJSAMObjects <IOpening>(familyInstance)?.FirstOrDefault(); if (result != null) { convertSettings?.Add(familyInstance.Id, result); return(result); } } Point3D point3D_Location = Geometry.Revit.Query.LocationPoint3D(familyInstance); if (point3D_Location == null) { List <Solid> solids = Core.Revit.Query.Solids(familyInstance, new Options()); solids?.RemoveAll(x => x.Volume == 0); if (solids == null || solids.Count == 0) { return(null); } if (solids.Count > 1) { solids.Sort((x, y) => y.Volume.CompareTo(x.Volume)); } point3D_Location = solids[0].ComputeCentroid()?.ToSAM(); } if (point3D_Location == null) { return(null); } OpeningType openingType = ToSAM_OpeningType(familyInstance.Symbol, convertSettings); if (openingType == null) { return(null); } BuiltInCategory builtInCategory_Host = BuiltInCategory.INVALID; HostObject hostObject = familyInstance.Host as HostObject; if (hostObject != null) { builtInCategory_Host = (BuiltInCategory)hostObject.Category.Id.IntegerValue; } Vector3D axisX = null; Vector3D normal = null; Vector3D axisY = null; if (builtInCategory_Host == BuiltInCategory.OST_Roofs) { axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false); axisY = familyInstance.FacingOrientation.ToSAM_Vector3D(false); normal = Geometry.Spatial.Query.AxisY(axisY, axisX); } else { axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false); normal = familyInstance.FacingOrientation.ToSAM_Vector3D(false); axisY = Geometry.Spatial.Query.AxisY(normal, axisX); } Geometry.Spatial.Plane plane = Geometry.Spatial.Create.Plane(point3D_Location, axisX, axisY); if (!plane.Normal.SameHalf(normal)) { plane.FlipZ(false); } List <Face3D> face3Ds = Geometry.Revit.Convert.ToSAM_Geometries <Face3D>(familyInstance); if (face3Ds == null || face3Ds.Count == 0) { return(null); } List <Point2D> point2Ds = new List <Point2D>(); foreach (Face3D face3D_Temp in face3Ds) { IClosedPlanar3D closedPlanar3D = face3D_Temp.GetExternalEdge3D(); if (closedPlanar3D is ICurvable3D) { List <ICurve3D> curve3Ds = ((ICurvable3D)closedPlanar3D).GetCurves(); foreach (ICurve3D curve3D in curve3Ds) { ICurve3D curve3D_Temp = plane.Project(curve3D); point2Ds.Add(plane.Convert(curve3D_Temp.GetStart())); } } } if (point2Ds == null || point2Ds.Count == 0) { return(null); } Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds); result = Analytical.Create.Opening(openingType, new Face3D(plane, rectangle2D)); result.UpdateParameterSets(familyInstance); convertSettings?.Add(familyInstance.Id, result); return(result); }
private static List <Face3D> Profiles_FromLocation(this Wall wall, double tolerance_Angle = Core.Tolerance.Angle, double tolerance_Distance = Core.Tolerance.Distance) { BoundingBoxXYZ boundingBoxXYZ = wall.get_BoundingBox(null); if (boundingBoxXYZ == null) { return(null); } LocationCurve locationCurve = wall.Location as LocationCurve; if (locationCurve == null) { return(null); } ICurve3D curve3D_Location = Convert.ToSAM(locationCurve); IEnumerable <ICurve3D> curves = null; if (curve3D_Location is ISegmentable3D) { curves = ((ISegmentable3D)curve3D_Location).GetSegments().Cast <ICurve3D>(); } else { curves = new List <ICurve3D>() { curve3D_Location } }; Vector3D direction = Vector3D.WorldZ; #if Revit2017 || Revit2018 || Revit2019 || Revit2020 double max = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Max.Z, DisplayUnitType.DUT_METERS); #else double max = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Max.Z, UnitTypeId.Meters); #endif Spatial.Plane plane_max = new Spatial.Plane(new Point3D(0, 0, max), direction); #if Revit2017 || Revit2018 || Revit2019 || Revit2020 double min = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Min.Z, DisplayUnitType.DUT_METERS); #else double min = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Min.Z, UnitTypeId.Meters); #endif Spatial.Plane plane_min = new Spatial.Plane(new Point3D(0, 0, min), direction); double height = max - min; Document document = wall.Document; //List<Face3D> face3Ds_Cutting = new List<Face3D>(); //Dictionary<ElementId, List<Face3D>> dictionary = GeneratingElementIdDictionary(wall); //foreach (KeyValuePair<ElementId, List<Face3D>> keyValuePair in dictionary) //{ // if (keyValuePair.Value == null || keyValuePair.Value.Count == 0) // { // continue; // } // HostObject hostObject_Cutting = document.GetElement(keyValuePair.Key) as HostObject; // if (hostObject_Cutting == null) // { // continue; // } // if (hostObject_Cutting is Floor || hostObject_Cutting is RoofBase) // { // List<Face3D> face3Ds_Temp = hostObject_Cutting.Profiles(); // if (face3Ds_Temp != null && face3Ds_Temp.Count != 0) // { // face3Ds_Cutting.AddRange(face3Ds_Temp); // } // } //} List <Face3D> result = new List <Face3D>(); foreach (ICurve3D curve3D in curves) { if (curve3D == null) { continue; } ICurve3D maxCurve = Spatial.Query.Project(plane_max, curve3D); ICurve3D minCurve = Spatial.Query.Project(plane_min, curve3D); Point3D point3D_1 = minCurve.GetEnd(); Point3D point3D_2 = maxCurve.GetStart(); Point3D point3D_3 = maxCurve.GetEnd(); Point3D point3D_4 = minCurve.GetStart(); if (point3D_1.Distance(point3D_3) < point3D_1.Distance(point3D_2)) { Point3D point_Temp = point3D_2; maxCurve.Reverse(); point3D_2 = point3D_3; point3D_3 = point_Temp; } List <Point3D> point3Ds = new List <Point3D>() { point3D_4, point3D_3, point3D_2, point3D_1 }; if (wall.Flipped) { point3Ds.Reverse(); } Face3D face3D = new Face3D(new Polygon3D(point3Ds, tolerance_Distance)); result.Add(face3D); //Spatial.Plane plane = Spatial.Create.Plane(point3Ds, tolerance_Distance); //if (plane == null) //{ // continue; //} //Vector3D vector3D = new Vector3D(point3D_4, point3D_3); //Segment2D segment2D = plane.Convert(new Segment3D(point3D_4, point3D_1)); //List<Segment2D> segment2Ds_Intersection = new List<Segment2D>(); //foreach (Face3D face3D_Cutting in face3Ds_Cutting) //{ // PlanarIntersectionResult planarIntersectionResult = Spatial.Create.PlanarIntersectionResult(plane, face3D_Cutting, tolerance_Angle, tolerance_Distance); // if (planarIntersectionResult == null || !planarIntersectionResult.Intersecting) // { // continue; // } // List<Segment2D> segment2Ds_Intersection_Temp = planarIntersectionResult.GetGeometry2Ds<Segment2D>(); // if (segment2Ds_Intersection_Temp != null && segment2Ds_Intersection_Temp.Count > 0) // { // segment2Ds_Intersection.AddRange(segment2Ds_Intersection_Temp); // } //} //List<Face2D> face2Ds = Profiles_From2D(segment2D, plane.Convert(vector3D), segment2Ds_Intersection, tolerance_Distance); //if (face2Ds != null && face2Ds.Count > 0) //{ // result.AddRange(face2Ds.ConvertAll(x => plane.Convert(x))); //} } if (result != null && result.Count > 0) { return(result); } return(result); }
public static List <Face3D> Profiles_Wall(this Wall wall) { if (wall == null) { return(null); } List <Face3D> result = Profiles_FromSketch(wall, !wall.Flipped); if (result != null && result.Count > 0) { return(result); } BoundingBoxXYZ boundingBoxXYZ = wall.get_BoundingBox(null); if (boundingBoxXYZ != null) { LocationCurve locationCurve = wall.Location as LocationCurve; if (locationCurve != null) { ICurve3D curve3D_Location = Convert.ToSAM(locationCurve); IEnumerable <ICurve3D> curves = null; if (curve3D_Location is ISegmentable3D) { curves = ((ISegmentable3D)curve3D_Location).GetSegments().Cast <ICurve3D>(); } else { curves = new List <ICurve3D>() { curve3D_Location } }; double max = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Max.Z, DisplayUnitType.DUT_METERS); Spatial.Plane plane_max = new Spatial.Plane(new Point3D(0, 0, max), new Vector3D(0, 0, 1)); double min = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Min.Z, DisplayUnitType.DUT_METERS); Spatial.Plane plane_min = new Spatial.Plane(new Point3D(0, 0, min), new Vector3D(0, 0, 1)); result = new List <Face3D>(); foreach (ICurve3D curve3D in curves) { if (curve3D == null) { continue; } ICurve3D maxCurve = plane_max.Project(curve3D); ICurve3D minCurve = plane_min.Project(curve3D); Point3D point3D_1 = minCurve.GetEnd(); Point3D point3D_2 = maxCurve.GetStart(); Point3D point3D_3 = maxCurve.GetEnd(); if (point3D_1.Distance(point3D_3) < point3D_1.Distance(point3D_2)) { Point3D point_Temp = point3D_2; maxCurve.Reverse(); point3D_2 = point3D_3; point3D_3 = point_Temp; } List <Point3D> point3Ds = new List <Point3D>() { minCurve.GetStart(), point3D_3, point3D_2, point3D_1 }; if (wall.Flipped) { point3Ds.Reverse(); } result.Add(new Face3D(new Polygon3D(point3Ds))); } if (result != null && result.Count > 0) { return(result); } } } if (!ExporterIFCUtils.HasElevationProfile(wall)) { return(null); } IList <CurveLoop> curveLoops = ExporterIFCUtils.GetElevationProfile(wall); if (curveLoops == null) { return(null); } result = new List <Face3D>(); foreach (CurveLoop curveLoop in curveLoops) { Polygon3D polygon3D = curveLoop.ToSAM_Polygon3D(); if (polygon3D != null) { result.Add(new Face3D(polygon3D)); } } return(result); }
public static Line ToRevit_Line(this ICurve3D curve3D) { return(Line.CreateBound(curve3D.GetStart().ToRevit(), curve3D.GetEnd().ToRevit())); }