//**METHODS**ACTIONS public bool addSurface(int color, Surface surface) { PolyCurve border = PolyCurve.ByJoinedCurves(surface.PerimeterCurves()); if (!border.IsPlanar) { int n = border.NumberOfCurves; Point[] points = border.PointsAtEqualSegmentLength(3 * n); Plane plane = Plane.ByBestFitThroughPoints(points); border = (PolyCurve)border.PullOntoPlane(plane); //dispose points.ForEach(p => p.Dispose()); plane.Dispose(); } ///TODO: implemnt space filling curve based on offset List <Curve> fillCurves = new List <Curve>(); PolyCurve fillPath = PolyCurve.ByJoinedCurves(fillCurves); this[color].Add(fillPath); fillCurves.ForEach(c => c.Dispose()); border.Dispose(); return(true); }
public static Autodesk.DesignScript.Geometry.PolyCurve ToProtoType(this Autodesk.Revit.DB.CurveArray revitCurves, bool performHostUnitConversion = true) { if (revitCurves == null) { throw new ArgumentNullException("revitCurves"); } var protoCurves = revitCurves.Cast <Autodesk.Revit.DB.Curve>().Select(x => x.ToProtoType(false)); var converted = PolyCurve.ByJoinedCurves(protoCurves.ToArray()); foreach (var curve in protoCurves) { curve.Dispose(); } if (converted == null) { throw new Exception("An unexpected failure occurred when attempting to convert the curve"); } if (performHostUnitConversion) { UnitConverter.ConvertToDynamoUnits(ref converted); } return(converted); }
/// <exclude /> private Element ToHorizontalFloor(FloorType floorType, Level level) { Utils.Log(string.Format("MultiPoint.ToHorizontalFloor started...", "")); try { if (!SessionVariables.ParametersCreated) { UtilsObjectsLocation.CheckParameters(DocumentManager.Instance.CurrentDBDocument); } PolyCurve outline = PolyCurve.ByPoints(this.ShapePoints.Points.Select(p => p.RevitPoint).ToList(), true); outline = PolyCurve.ByJoinedCurves(outline.PullOntoPlane(Plane.XY()).Explode().Cast <Curve>().ToList()); var output = Floor.ByOutlineTypeAndLevel(outline, floorType, level); output.SetParameterByName(ADSK_Parameters.Instance.MultiPoint.Name, SerializeJSON()); Utils.Log(string.Format("MultiPoint.ToHorizontalFloor completed.", "")); return(output); } catch (Exception ex) { Utils.Log(string.Format("ERROR: MultiPoint.ToHorizontalFloor {0}", ex.Message)); throw ex; } }
public static List <PolyCurve> GetEdgeLoopsFromRevitFaceAsPolyCurves(Autodesk.Revit.DB.Face face) { return(face.EdgeLoops.Cast <EdgeArray>() .Select(x => x.Cast <Autodesk.Revit.DB.Edge>()) .Select(x => x.Select(t => t.AsCurveFollowingFace(face).ToProtoType(false))) .Select(x => PolyCurve.ByJoinedCurves(x)) .ToList()); }
/// <summary> /// Create a Revit Floor given it's curve outline and Level /// </summary> /// <param name="outlineCurves"></param> /// <param name="floorType"></param> /// <param name="level"></param> /// <returns>The floor</returns> public static Floor ByOutlineTypeAndLevel(Curve[] outlineCurves, FloorType floorType, Level level) { if (outlineCurves == null) { throw new ArgumentNullException("outlineCurves"); } return(ByOutlineTypeAndLevel(PolyCurve.ByJoinedCurves(outlineCurves), floorType, level)); }
/// <summary> /// Create a Revit Floor given its curve outline and Level /// </summary> /// <param name="outlineCurves"></param> /// <param name="floorType"></param> /// <param name="level"></param> /// <returns>The floor</returns> public static Floor ByOutlineTypeAndLevel(Curve[] outlineCurves, FloorType floorType, Level level) { if (outlineCurves == null) { throw new ArgumentNullException("outlineCurves"); } var floor = ByOutlineTypeAndLevel(PolyCurve.ByJoinedCurves(outlineCurves), floorType, level); DocumentManager.Regenerate(); return floor; }
public static Autodesk.DesignScript.Geometry.PolyCurve ToProtoType(this Autodesk.Revit.DB.CurveArray revitCurves) { if (revitCurves == null) { throw new ArgumentNullException("revitCurves"); } var protoCurves = revitCurves.Cast <Autodesk.Revit.DB.Curve>().Select(x => x.ToProtoType()); return(PolyCurve.ByJoinedCurves(protoCurves.ToArray())); }
/// <summary> /// Create a Revit Ceiling given its curve outline and Level /// </summary> /// <param name="outlineCurves"></param> /// <param name="ceilingType"></param> /// <param name="level"></param> /// <returns>The ceiling</returns> public static Ceiling ByOutlineTypeAndLevel(Curve[] outlineCurves, CeilingType ceilingType, Level level) { if (outlineCurves == null) { throw new ArgumentNullException("outlineCurves"); } var ceiling = ByOutlineTypeAndLevel(PolyCurve.ByJoinedCurves(outlineCurves), ceilingType, level); DocumentManager.Regenerate(); return(ceiling); }
public PolyCurve PolycurveToNative(Polycurve polycurve) { DS.Curve[] curves = new DS.Curve[polycurve.segments.Count]; for (var i = 0; i < polycurve.segments.Count; i++) { switch (polycurve.segments[i]) { case Line curve: curves[i] = LineToNative(curve); break; case Arc curve: curves[i] = ArcToNative(curve); break; case Circle curve: curves[i] = CircleToNative(curve); break; case Ellipse curve: curves[i] = EllipseToNative(curve); break; case Spiral curve: curves[i] = PolylineToNative(curve.displayValue); break; case Polycurve curve: curves[i] = PolycurveToNative(curve); break; case Polyline curve: curves[i] = PolylineToNative(curve); break; case Curve curve: curves[i] = CurveToNative(curve); break; } } PolyCurve polyCrv = null; if (curves.Any()) { polyCrv = PolyCurve.ByJoinedCurves(curves); polyCrv = polyCrv.SetDynamoProperties <PolyCurve>(GetDynamicMembersFromBase(polycurve)); } return(polyCrv); }
/// <summary> /// Create a Revit Roof given its curve outline and Level /// </summary> /// <param name="outline"></param> /// <param name="RoofType"></param> /// <param name="level"></param> /// <returns>The Roof</returns> public static Roof ByOutlineTypeAndLevel(Curve[] outline, RoofType roofType, Level level) { var polycurve = PolyCurve.ByJoinedCurves(outline); if (!polycurve.IsClosed) { throw new ArgumentException(Properties.Resources.OpenInputPolyCurveError); } var ca = new CurveArray(); polycurve.Curves().ForEach(x => ca.Append(x.ToRevitType())); var roof = new Roof(ca, level.InternalLevel, roofType.InternalRoofType); DocumentManager.Regenerate(); return(roof); }
private static List <PolyCurve> CurveLoopsAsPolyCurves(Face face, IEnumerable <IEnumerable <Autodesk.Revit.DB.Curve> > curveLoops) { List <PolyCurve> result = new List <PolyCurve>(); foreach (var curveLoop in curveLoops) { List <Autodesk.DesignScript.Geometry.Curve> curves = new List <Autodesk.DesignScript.Geometry.Curve>(); foreach (var curve in curveLoop) { curves.Add(curve.ToProtoType(false)); } result.Add(PolyCurve.ByJoinedCurves(curves)); curves.ForEach(x => x.Dispose()); curves.Clear(); } return(result); }
/// <summary> /// Creates a simplified version of the curve by creating lines with a maximum length defined. /// </summary> /// <param name="curve">Curve to polygonize</param> /// <param name="maxLength">Maximum length of subdivisions</param> /// <param name="asPolycurve">If true returns a Polycurve or a list of lines otherwise.</param> /// <returns></returns> public static object Polygonize(DSCurve curve, double maxLength, bool asPolycurve = false) { //TODO : Look into http://www.antigrain.com/research/adaptive_bezier/index.html if (curve == null) { throw new ArgumentNullException("curve"); } List <DSCurve> lines = new List <DSCurve>(); bool isStraight = curve.Length.AlmostEqualTo(curve.StartPoint.DistanceTo(curve.EndPoint)); if (isStraight) { lines.Add(curve); } else { int divisions = (int)Math.Ceiling(curve.Length / maxLength); if (divisions > 1) { var points = curve.PointsAtEqualSegmentLength(divisions); lines.Add(Line.ByStartPointEndPoint(curve.StartPoint, points.First())); for (var i = 0; i < points.Count() - 1; i++) { lines.Add(Line.ByStartPointEndPoint(points[i], points[i + 1])); } lines.Add(Line.ByStartPointEndPoint(points.Last(), curve.EndPoint)); } else { lines.Add(Line.ByStartPointEndPoint(curve.StartPoint, curve.EndPoint)); } } if (asPolycurve) { return(PolyCurve.ByJoinedCurves(lines)); } else { return(lines); } }
private static List <PolyCurve> EdgeLoopsAsPolyCurves(Face face, IEnumerable <IEnumerable <Edge> > edgeLoops) { List <PolyCurve> result = new List <PolyCurve>(); foreach (var edgeLoop in edgeLoops) { List <Autodesk.DesignScript.Geometry.Curve> curves = new List <Autodesk.DesignScript.Geometry.Curve>(); foreach (var edge in edgeLoop) { var dbCurve = edge.AsCurveFollowingFace(face); curves.Add(dbCurve.ToProtoType(false)); } result.Add(PolyCurve.ByJoinedCurves(curves)); curves.ForEach(x => x.Dispose()); curves.Clear(); } return(result); }
public void ByOutlineTypeAndLevel_PolyCurveFloorTypeLevel_ProducesFloorWithCorrectArea() { var elevation = 100; var level = Level.ByElevation(elevation); var outline = new[] { Line.ByStartPointEndPoint(Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(100, 0, 0)), Line.ByStartPointEndPoint(Point.ByCoordinates(100, 0, 0), Point.ByCoordinates(100, 100, 0)), Line.ByStartPointEndPoint(Point.ByCoordinates(100, 100, 0), Point.ByCoordinates(0, 100, 0)), Line.ByStartPointEndPoint(Point.ByCoordinates(0, 100, 0), Point.ByCoordinates(0, 0, 0)) }; var polyCurveOutline = PolyCurve.ByJoinedCurves(outline); var floorType = FloorType.ByName("Generic - 12\""); var floor = Floor.ByOutlineTypeAndLevel(polyCurveOutline, floorType, level); BoundingBoxVolume(floor.BoundingBox).ShouldBeApproximately(100 * 100 * 0.3048, 1e-3); }
public static PolyCurve ToNative(this SpecklePolycurve polycurve) { Curve[] curves = new Curve[polycurve.Segments.Count]; for (var i = 0; i < polycurve.Segments.Count; i++) { switch (polycurve.Segments[i]) { case SpeckleLine curve: curves[i] = curve.ToNative(); break; case SpeckleArc curve: curves[i] = curve.ToNative(); break; case SpeckleCircle curve: curves[i] = curve.ToNative(); break; case SpeckleEllipse curve: curves[i] = curve.ToNative(); break; case SpecklePolycurve curve: curves[i] = curve.ToNative(); break; case SpecklePolyline curve: curves[i] = curve.ToNative(); break; case SpeckleCurve curve: curves[i] = curve.ToNative(); break; } } var polyCrv = PolyCurve.ByJoinedCurves(curves); return(polyCrv.SetSpeckleProperties <PolyCurve>(polycurve.Properties)); }
public void AddToMatchingCurve(Curve curve) { // Prepare a curve list to create a polycurve from List <Curve> curvesTojoin = new List <Curve>(); curvesTojoin.Add(curve); // If the curve is connected to Curve 1 if (Curve1.StartPoint.IsAlmostEqualTo(curve.EndPoint) || Curve1.EndPoint.IsAlmostEqualTo(curve.StartPoint)) { // Add curve1 to the list and create a polycurve curvesTojoin.Add(Curve1); Curve newCurve = PolyCurve.ByJoinedCurves(curvesTojoin); this.Curve1 = newCurve; } // If the curve is connected to curve 2 else if (Curve2 != null && (Curve2.StartPoint.IsAlmostEqualTo(curve.EndPoint) || Curve2.EndPoint.IsAlmostEqualTo(curve.StartPoint))) { // Add curve 2 to the list and create a polycurve from them curvesTojoin.Add(Curve2); Curve newCurve = PolyCurve.ByJoinedCurves(curvesTojoin); this.Curve2 = newCurve; } else { // If the curve doesnt connect and curve 2 hasnt been defined yet // take is as curve 2 otherwise add the unconnectable curve to the undefined list and throw an error if (this.Curve2 == null) { this.Curve2 = curve; } else { Undefined.Add(curve); throw new ArgumentNullException("Cannot parametrize surface, try increasing the tolerance."); } } }
public static Dictionary <string, object> ConvertSiteOutlineToPolygon2d(List <Geometry> geomList, double inset = 5)// Geometry { string type = geomList[0].GetType().ToString(); List <Point2d> pointList = new List <Point2d>(); //Trace.WriteLine("list found is + " + type); List <NurbsCurve> nurbList = new List <NurbsCurve>(); if (type.IndexOf("Line") != -1) { List <Line> lineList = new List <Line>(); for (int i = 0; i < geomList.Count; i++) { lineList.Add((Line)geomList[i]); } for (int i = 0; i < lineList.Count; i++) { Point2d pointPerCurve = Point2d.ByCoordinates(lineList[i].StartPoint.X, lineList[i].StartPoint.Y); pointList.Add(pointPerCurve); if (i == lineList.Count) { pointList.Add(Point2d.ByCoordinates(lineList[i].EndPoint.X, lineList[i].EndPoint.Y)); } } } else if (type.IndexOf("NurbsCurve") != -1) { nurbList = new List <NurbsCurve>(); for (int i = 0; i < geomList.Count; i++) { nurbList.Add((NurbsCurve)geomList[i]); } /* * for (int i = 0; i < nurbList.Count; i++) * { * Point2d pointPerCurve = Point2d.ByCoordinates(nurbList[i].StartPoint.X, nurbList[i].StartPoint.Y); * pointList.Add(pointPerCurve); * if (i == nurbList.Count) pointList.Add(Point2d.ByCoordinates(nurbList[i].EndPoint.X, nurbList[i].EndPoint.Y)); * } */ } else { return(null); } PolyCurve pCrv = PolyCurve.ByJoinedCurves((Curve[])nurbList.ToArray()); Curve cInsetA = pCrv.Offset(inset); Curve cInsetB = pCrv.Offset(inset * -1); Curve cInset; Surface srfA = Surface.ByPatch(cInsetA), srfB = Surface.ByPatch(cInsetB); if (srfA.Area > srfB.Area) { cInset = cInsetB; } else { cInset = cInsetA; } srfA.Dispose(); srfB.Dispose(); List <Curve> curvList = new List <Curve>(); geomList = cInset.Explode().ToList(); for (int i = 0; i < geomList.Count; i++) { curvList.Add((Curve)geomList[i]); } for (int i = 0; i < curvList.Count; i++) { Point2d pointPerCurve = Point2d.ByCoordinates(curvList[i].StartPoint.X, curvList[i].StartPoint.Y); pointList.Add(pointPerCurve); if (i == curvList.Count) { pointList.Add(Point2d.ByCoordinates(curvList[i].EndPoint.X, curvList[i].EndPoint.Y)); } } //return new Polygon2d(pointList); return(new Dictionary <string, object> { { "InsetSiteOutline", (new Polygon2d(pointList)) } }); }
protected override (Curve boundary, List <Curve> holes) CreateBaseCurves() { // The D is pointing "down" so that it matches with the U. var holes = new List <Curve>(); var boundaryCurves = new List <Curve>(); var arcHeight = Math.Min( Length - (UsesDepth ? Depth : 0), Width / 2); Point[] points; if (IsCurved) { Plane arcCenter = null; using (var point = Point.ByCoordinates(Width / 2, arcHeight)) using (var zAxis = Vector.ZAxis()) { arcCenter = Plane.ByOriginNormal(point, zAxis); } boundaryCurves.Add(EllipseArc.ByPlaneRadiiAngles(arcCenter, Width / 2, arcHeight, 180, 180)); if (arcHeight < Length) { points = new[] { Point.ByCoordinates(Width, arcHeight), Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length), Point.ByCoordinates(0, arcHeight) }; // Outside of D has a square back. boundaryCurves.Add(PolyCurve.ByPoints(points)); points.ForEach(p => p.Dispose()); } else { points = new[] { Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length) }; // Outside of D is half an ellipse (or circle). boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1])); points.ForEach(p => p.Dispose()); } if (UsesDepth) { var curves = new List <Curve> { EllipseArc.ByPlaneRadiiAngles(arcCenter, (Width / 2) - Depth, arcHeight - Depth, 0, -180) }; if (arcHeight < Length - Depth) { points = new[] { Point.ByCoordinates(Depth, arcHeight), Point.ByCoordinates(Depth, Length - Depth), Point.ByCoordinates(Width - Depth, Length - Depth), Point.ByCoordinates(Width - Depth, arcHeight) }; curves.Add(PolyCurve.ByPoints(points)); points.ForEach(p => p.Dispose()); } else { points = new[] { Point.ByCoordinates(Depth, arcHeight), Point.ByCoordinates(Width - Depth, arcHeight) }; curves.Add(Line.ByStartPointEndPoint(points[0], points[1])); points.ForEach(p => p.Dispose()); } holes.Add(PolyCurve.ByJoinedCurves(curves)); curves.ForEach(x => x.Dispose()); } arcCenter.Dispose(); } else { // Faceted D. double baseWidth = Width * Math.Tan(Math.PI / 8); double sideWidth = baseWidth * arcHeight / (2 * Width); points = new[] { Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length), Point.ByCoordinates(0, arcHeight - sideWidth), Point.ByCoordinates((Width - baseWidth) / 2, 0), Point.ByCoordinates((Width + baseWidth) / 2, 0), Point.ByCoordinates(Width, arcHeight - sideWidth) }; boundaryCurves.Add(PolyCurve.ByPoints(points, connectLastToFirst: true)); points.ForEach(p => p.Dispose()); if (UsesDepth) { double angleA = Math.Atan2(2 * (arcHeight - sideWidth), Width - baseWidth); double offsetBaseWidth = baseWidth - (2 * Depth / Math.Tan((Math.PI - angleA) / 2)); double offsetSideWidth = sideWidth - (Depth / Math.Tan((angleA / 2) + (Math.PI / 4))); points = new[] { Point.ByCoordinates(Width - Depth, Length - Depth), Point.ByCoordinates(Width - Depth, arcHeight - offsetSideWidth), Point.ByCoordinates((Width + offsetBaseWidth) / 2, Depth), Point.ByCoordinates((Width - offsetBaseWidth) / 2, Depth), Point.ByCoordinates(Depth, arcHeight - offsetSideWidth), Point.ByCoordinates(Depth, Length - Depth) }; holes.Add(PolyCurve.ByPoints(points, connectLastToFirst: true)); points.ForEach(p => p.Dispose()); } } var boundary = PolyCurve.ByJoinedCurves(boundaryCurves); return(boundary, holes); }
protected override (Curve boundary, List <Curve> holes) CreateBaseCurves() { Curve boundary = null; Point[] points; if (IsCurved) { var holes = new List <Curve>(); var boundaryCurves = new List <Curve>(); var arcHeight = Math.Min(Length, Width / 2); using (Plane arcCenter = Plane.ByOriginNormal( Point.ByCoordinates(Width / 2, arcHeight), Vector.ZAxis())) { boundaryCurves.Add(EllipseArc.ByPlaneRadiiAngles(arcCenter, Width / 2, arcHeight, 180, 180)); if (UsesDepth) { if (arcHeight < Length) { // Top of U has straight parts. points = new[] { Point.ByCoordinates(Width, arcHeight), Point.ByCoordinates(Width, Length), Point.ByCoordinates(Width - Depth, Length), Point.ByCoordinates(Width - Depth, arcHeight) }; boundaryCurves.Add(PolyCurve.ByPoints(points)); points.ForEach(p => p.Dispose()); } else { points = new[] { Point.ByCoordinates(Width, Length), Point.ByCoordinates(Width - Depth, Length) }; // Top of U has no straight parts. boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1])); points.ForEach(p => p.Dispose()); } boundaryCurves.Add(EllipseArc.ByPlaneRadiiAngles(arcCenter, (Width / 2) - Depth, arcHeight - Depth, 0, -180)); if (arcHeight < Length) { // Top of U has straight parts. points = new[] { Point.ByCoordinates(Depth, arcHeight), Point.ByCoordinates(Depth, Length), Point.ByCoordinates(0, Length), Point.ByCoordinates(0, arcHeight) }; boundaryCurves.Add(PolyCurve.ByPoints(points)); points.ForEach(p => p.Dispose()); } else { // Top of U has no straight parts. points = new[] { Point.ByCoordinates(Depth, Length), Point.ByCoordinates(0, Length) }; boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1])); points.ForEach(p => p.Dispose()); } } else { // U has no interior. if (arcHeight < Length) { points = new[] { Point.ByCoordinates(Width, arcHeight), Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length), Point.ByCoordinates(0, arcHeight) }; boundaryCurves.Add(PolyCurve.ByPoints(points)); points.ForEach(p => p.Dispose()); } else { points = new[] { Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length) }; boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1])); points.ForEach(p => p.Dispose()); } } } boundary = PolyCurve.ByJoinedCurves(boundaryCurves); } else { // Straight U if (UsesDepth) { points = new[] { Point.ByCoordinates(0, 0), Point.ByCoordinates(Width, 0), Point.ByCoordinates(Width, Length), Point.ByCoordinates(Width - Depth, Length), Point.ByCoordinates(Width - Depth, Depth), Point.ByCoordinates(Depth, Depth), Point.ByCoordinates(Depth, Length), Point.ByCoordinates(0, Length) }; boundary = PolyCurve.ByPoints(points, connectLastToFirst: true); points.ForEach(p => p.Dispose()); } else { // Solid straight U (rectangle) points = new[] { Point.ByCoordinates(0, 0), Point.ByCoordinates(Width, 0), Point.ByCoordinates(Width, Length), Point.ByCoordinates(0, Length) }; boundary = PolyCurve.ByPoints(points, connectLastToFirst: true); points.ForEach(p => p.Dispose()); } } return(boundary, default); }
/// <summary> /// Gets a list of closed polycurve edges of surface. First list item is outside boundary. /// </summary> /// <param name="surface">The surface.</param> /// <returns name="edgeCrvList">Edges of surface.</returns> /// <exception cref="ArgumentNullException">Surface</exception> public static PolyCurve[] GetSurfaceLoops(Surface surface) { if (surface == null) { throw new ArgumentNullException(nameof(surface)); } var curves = surface.PerimeterCurves(); var loops = new List <PolyCurve>(); foreach (var curve in curves) { var added = false; for (var i = 0; i < loops.Count; i++) { var loop = loops[i]; if (loop.IsClosed) { continue; } if (loop.StartPoint.IsAlmostEqualTo(curve.StartPoint) || loop.StartPoint.IsAlmostEqualTo(curve.EndPoint) || loop.EndPoint.IsAlmostEqualTo(curve.StartPoint) || loop.EndPoint.IsAlmostEqualTo(curve.EndPoint)) { try { loops[i] = loop.Join(new[] { curve }); added = true; break; } catch (ApplicationException) { continue; } } } if (!added) { loops.Add(PolyCurve.ByJoinedCurves(new[] { curve })); } curve.Dispose(); } if (loops.Any(loop => !loop.IsClosed)) { throw new ArgumentException("Created non-closed polycurve."); } return(loops.OrderByDescending(c => { using (var s = Surface.ByPatch(c)) { return s.Area; } }).ToArray()); }
/// <summary> /// Create a Revit Floor given it's curve outline and Level /// </summary> /// <param name="outline">The outline.</param> /// <param name="floorType">Type of the floor.</param> /// <param name="level">The level.</param> /// <param name="structural">if set to <c>true</c> [structural].</param> /// <returns> /// The floor /// </returns> public static SlopedFloor ByOutlineTypeAndLevel(Autodesk.DesignScript.Geometry.PolyCurve outline, Revit.Elements.FloorType floorType, Revit.Elements.Level level, bool structural) { Utils.Log(string.Format("SlopedFloor.ByOutlineTypeAndLevel started...", "")); try { var profile = new CurveArray(); Autodesk.DesignScript.Geometry.Plane plane = Autodesk.DesignScript.Geometry.Plane.ByBestFitThroughPoints( outline.Curves().Cast <Autodesk.DesignScript.Geometry.Curve>().Select(x => x.StartPoint)); Vector normal = plane.Normal; if (normal.Dot(Vector.ZAxis()) <= 0) { normal = normal.Reverse(); } Autodesk.DesignScript.Geometry.Point origin = plane.Origin; Autodesk.DesignScript.Geometry.Point end = origin.Add(normal); Autodesk.DesignScript.Geometry.Point projection = Autodesk.DesignScript.Geometry.Point.ByCoordinates(end.X, end.Y, -1000); end = Autodesk.DesignScript.Geometry.Point.ByCoordinates(end.X, end.Y, end.Z + 1000); Autodesk.DesignScript.Geometry.Point intersection = null; var result = plane.Intersect(Autodesk.DesignScript.Geometry .Line.ByStartPointEndPoint(end, projection)); if (result.Length > 0) { intersection = result[0] as Autodesk.DesignScript.Geometry.Point; } else { var message = "Couldn't find intersection"; Utils.Log(string.Format("ERROR: SlopedFloor.ByOutlineTypeAndLevel {0}", message)); throw new Exception(message); } Autodesk.DesignScript.Geometry.Curve temp = Autodesk.DesignScript.Geometry.Line.ByBestFitThroughPoints(new Autodesk.DesignScript.Geometry.Point[] { origin, intersection }); PolyCurve flat = PolyCurve.ByJoinedCurves(outline.PullOntoPlane(Autodesk.DesignScript.Geometry.Plane.XY() .Offset(temp.StartPoint.Z)).Explode().Cast <Autodesk.DesignScript.Geometry.Curve>().ToList()); Autodesk.DesignScript.Geometry.Curve flatLine = temp.PullOntoPlane(Autodesk.DesignScript.Geometry.Plane.XY().Offset(temp.StartPoint.Z)); if (Math.Abs(Math.Abs(plane.Normal.Dot(Vector.ZAxis())) - 1) < 0.00001) { var f = Revit.Elements.Floor.ByOutlineTypeAndLevel(flat, floorType, level); f.InternalElement.Parameters.Cast <Autodesk.Revit.DB.Parameter>() .First(x => x.Id.IntegerValue.Equals(Autodesk.Revit.DB.BuiltInParameter.FLOOR_PARAM_IS_STRUCTURAL)) .Set(structural ? 1 : 0); plane.Dispose(); flatLine.Dispose(); flat.Dispose(); origin.Dispose(); end.Dispose(); projection.Dispose(); intersection.Dispose(); temp.Dispose(); return(new SlopedFloor(f.InternalElement as Autodesk.Revit.DB.Floor)); } double slope = (temp.EndPoint.Z - temp.StartPoint.Z) / flatLine.Length; foreach (Autodesk.DesignScript.Geometry.Curve c in flat.Curves()) { profile.Append(c.ToRevitType()); } Autodesk.Revit.DB.Line slopeArrow = flatLine.ToRevitType() as Autodesk.Revit.DB.Line; var ft = floorType.InternalElement as Autodesk.Revit.DB.FloorType; var lvl = level.InternalElement as Autodesk.Revit.DB.Level; var floor = new SlopedFloor(profile, slopeArrow, slope, ft, lvl, structural); floor.Level = level; floor.Floortype = floorType; floor.Structural = structural; //DocumentManager.Regenerate(); plane.Dispose(); flatLine.Dispose(); flat.Dispose(); origin.Dispose(); end.Dispose(); projection.Dispose(); intersection.Dispose(); temp.Dispose(); Utils.Log(string.Format("SlopedFloor.ByOutlineTypeAndLevel completed.", "")); return(floor); } catch (Exception ex) { Utils.Log(string.Format("ERROR: SlopedFloor.ByOutlineTypeAndLevel {0}", ex.Message)); throw ex; } }
public static Dictionary <string, Autodesk.DesignScript.Geometry.Surface> Create( Autodesk.DesignScript.Geometry.Surface surface, double offset, double depth) { // offset perimeter curves by the specified offset and create new surface. // makes sure there are space between outer perimeter and the amenity space List <Curve> inCrvs = surface.OffsetPerimeterCurves(offset)["insetCrvs"].ToList(); Surface inSrf = Surface.ByPatch(PolyCurve.ByJoinedCurves(inCrvs)); // get longest curve of the inSrf Curve max; List <Curve> others; Dictionary <string, dynamic> dict = inCrvs.MaximumLength(); if (dict["maxCrv"].Count < 1) { max = dict["otherCrvs"][0] as Curve; int count = dict["otherCrvs"].Count; List <Curve> rest = dict["otherCrvs"]; others = rest.GetRange(1, (count - 1)); } else { max = dict["maxCrv"][0] as Curve; others = dict["otherCrvs"]; } // get perimeter curves of input surface List <Curve> perimCrvs = surface.PerimeterCurves().ToList(); List <Curve> matchCrvs = max.FindMatchingVectorCurves(perimCrvs); // get longest curve Curve max2; Dictionary <string, dynamic> dict2 = matchCrvs.MaximumLength(); if (dict2["maxCrv"].Count < 1) { max2 = dict2["otherCrvs"][0] as Curve; } else { max2 = dict2["maxCrv"][0] as Curve; } Vector vec = max2.ByTwoCurves(max); Curve transLine = max.Translate(vec, depth) as Curve; Line extendLine = transLine.ExtendAtBothEnds(1); List <Curve> crvList = new List <Curve>() { max, extendLine }; Surface loftSrf = Surface.ByLoft(crvList); List <bool> boolLst = new List <bool>(); foreach (var crv in others) { bool b = max.DoesIntersect(crv); boolLst.Add(b); } List <Curve> intersectingCurves = others .Zip(boolLst, (name, filter) => new { name, filter, }) .Where(item => item.filter == true) .Select(item => item.name) .ToList(); List <Curve> extendCurves = new List <Curve>(); foreach (Curve crv in intersectingCurves) { var l = crv.ExtendAtBothEnds(1); extendCurves.Add(l); } List <Surface> split = loftSrf .SplitPlanarSurfaceByMultipleCurves(extendCurves) .OfType <Surface>() .ToList(); Surface amenitySurf = split.MaximumArea()["maxSrf"] as Surface; Surface remainSurf = inSrf.Split(amenitySurf)[0] as Surface; Dictionary <string, Surface> newOutput; newOutput = new Dictionary <string, Surface> { { amenitySurfaceOutputPort, amenitySurf }, { remainingSurfaceOutputPort, remainSurf } }; //Dispose redundant geometry inCrvs.ForEach(crv => crv.Dispose()); inSrf.Dispose(); max.Dispose(); perimCrvs.ForEach(crv => crv.Dispose()); matchCrvs.ForEach(crv => crv.Dispose()); max2.Dispose(); vec.Dispose(); transLine.Dispose(); extendLine.Dispose(); crvList.ForEach(crv => crv.Dispose()); loftSrf.Dispose(); intersectingCurves.ForEach(crv => crv.Dispose()); extendCurves.ForEach(crv => crv.Dispose()); return(newOutput); }
public static Dictionary <string, object> GroupCurves(List <DSCurve> curves) { if (curves == null) { throw new ArgumentNullException("lines"); } if (curves.Count < 2) { throw new ArgumentException("Needs 2 or more lines", "lines"); } Dictionary <gVertex, List <DSCurve> > graph = CurvesDependency(curves); Dictionary <int, List <DSCurve> > grouped = new Dictionary <int, List <DSCurve> >(); Dictionary <gVertex, int> vertices = new Dictionary <gVertex, int>(); foreach (gVertex v in graph.Keys) { // If already belongs to a polygon or is not a polygon vertex or already computed if (vertices.ContainsKey(v) || graph[v].Count > 2) { continue; } // grouped.Count() translates to the number of different groups created vertices.Add(v, grouped.Count()); grouped.Add(vertices[v], new List <DSCurve>()); foreach (DSCurve curve in graph[v]) { var startVertex = Points.ToVertex(curve.StartPoint); var endVertex = Points.ToVertex(curve.EndPoint); DSCurve nextCurve = curve; gVertex nextVertex = (startVertex.Equals(v)) ? endVertex : startVertex; while (!vertices.ContainsKey(nextVertex)) { vertices.Add(nextVertex, vertices[v]); grouped[vertices[v]].Add(nextCurve); // Next vertex doesn't have any other curve connected. if (graph[nextVertex].Count < 2) { break; } nextCurve = graph[nextVertex].Where(c => !c.Equals(nextCurve)).First(); startVertex = Points.ToVertex(nextCurve.StartPoint); endVertex = Points.ToVertex(nextCurve.EndPoint); nextVertex = (startVertex.Equals(nextVertex)) ? endVertex : startVertex; } if (!grouped[vertices[v]].Last().Equals(nextCurve)) { grouped[vertices[v]].Add(nextCurve); } } } List <PolyCurve> polyCurves = new List <PolyCurve>(); List <DSCurve> ungrouped = new List <DSCurve>(); foreach (var group in grouped.Values) { if (group.Count > 1) { polyCurves.Add(PolyCurve.ByJoinedCurves(group)); } else { ungrouped.Add(group.First()); } } return(new Dictionary <string, object>() { { "polycurves", polyCurves }, { "ungrouped", ungrouped } }); }