public static Surface IsovistFromPoint(BaseGraph baseGraph, DSPoint point) { if (baseGraph == null) { throw new ArgumentNullException("graph"); } if (point == null) { throw new ArgumentNullException("point"); } Vertex origin = Vertex.ByCoordinates(point.X, point.Y, point.Z); List <Vertex> vertices = Graphical.Graphs.VisibilityGraph.VertexVisibility(origin, baseGraph.graph); List <DSPoint> points = vertices.Select(v => Points.ToPoint(v)).ToList(); Surface isovist; // TODO: Implement better way of checking if polygon is self intersecting Autodesk.DesignScript.Geometry.Polygon polygon = Autodesk.DesignScript.Geometry.Polygon.ByPoints(points); //fix back // // if(Graphical.Geometry.Polygon.Intersection(polygon).Length > 0) // { // points.Add(point); // polygon = Polygon.by(points); // // } return(Surface.ByPatch(polygon)); }
//ADDED CODE : SUBHAJIT DAS++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //makes surface patch for closed polylines public static List <Surface> MakeSurfaceForPolygon2d(List <Polygon2d> poly, double height = 3) { if (poly == null) { return(null); } for (int i = 0; i < poly.Count; i++) { if (poly[i] == null || poly[i].Points == null || poly[i].Points.Count == 0) { return(null); } } List <Surface> surfaceList = new List <Surface>(); for (int i = 0; i < poly.Count; i++) { if (poly[i] == null) { continue; } //List<Point> ptList = pointFromPoint2dList(poly[i].Points); //PolyCurve pCurve = PolyCurve.ByPoints(ptList); Polygon pCurve = PolygonByPolygon2d(poly[i], height); if (pCurve == null) { continue; } surfaceList.Add(Surface.ByPatch(pCurve)); } return(surfaceList); }
private static Surface CreateOneSurface() { var rect = Rectangle.ByWidthLength(5, 5); var surface = Surface.ByPatch(rect); return(surface); }
public static void AssertLabelsGoodStartingLocationAndOrientation <K, T>(List <PlanarUnfolder.UnfoldableFaceLabel <K, T> > labels) where K : IUnfoldableEdge where T : IUnfoldablePlanarFace <K> { // get aligned geometry var alignedGeo = labels.Select(x => x.AlignedLabelGeometry).ToList(); // assert that the bounding box of the label at least intersects the face it represents for (int i = 0; i < alignedGeo.Count; i++) { var curveList = alignedGeo[i]; var curvePoints = curveList.Select(x => x.StartPoint); var labelPlane = Plane.ByBestFitThroughPoints(curvePoints); var testsurf = Surface.ByPatch(Rectangle.ByWidthLength(1, 1). Transform(CoordinateSystem.ByPlane(labelPlane)) as Curve); //check that the aligned curves intersect the surface they are aligned to Assert.IsTrue(curveList.SelectMany(x => labels[i].UnfoldableFace.SurfaceEntities.Select(x.DoesIntersect)).Any()); Console.WriteLine("This label was in the right spot at the start of the unfold"); //also assert that the face normal is parallel with the normal of the boundingbox plane var face = labels[i].UnfoldableFace.SurfaceEntities; UnfoldTestUtils.AssertSurfacesAreCoplanar(testsurf, face.First()); Console.WriteLine("This label was in the right orientation at the start of the unfold"); testsurf.Dispose(); labelPlane.Dispose(); } }
public static Surface IsovistFromPoint(BaseGraph baseGraph, DSPoint point) { if (baseGraph == null) { throw new ArgumentNullException("graph"); } if (point == null) { throw new ArgumentNullException("point"); } gVertex origin = gVertex.ByCoordinates(point.X, point.Y, point.Z); List <gVertex> vertices = Graphical.Graphs.VisibilityGraph.VertexVisibility(origin, baseGraph.graph); List <DSPoint> points = vertices.Select(v => Points.ToPoint(v)).ToList(); Surface isovist; // TODO: Implement better way of checking if polygon is self intersectingç Polygon polygon = Polygon.ByPoints(points); if (polygon.SelfIntersections().Length > 0) { points.Add(point); polygon = Polygon.ByPoints(points); } return(Surface.ByPatch(polygon)); }
public void IsovistFromPointReturnsCorrectSurfaceAreaTest() { // Create origin point Point originPoint = layoutPolygon.Center(); // Create isovist form the origin point Surface isovist = Isovist.FromPoint(new List <Polygon> { layoutPolygon }, new List <Polygon> { layoutPolygon }, originPoint); // Checks if the area of the isovist is equal to the area of the layout // as there are no obstructions the entire layout should be visible from the origin point Assert.AreEqual(isovist.Area, Surface.ByPatch(layoutPolygon).Area); }
public static List <Polygon2d> Trim(this Polygon2d polygon, Polygon2d other) { if (other == null) { return(null); } Geometry[] dTrimmed = null; { Polygon dPolyThis = DynamoGeometry.PolygonByPolygon2d(polygon, 0); Surface dSurfaceThis = Surface.ByPatch(dPolyThis); Polygon dPolyOther = DynamoGeometry.PolygonByPolygon2d(other, 0); Surface dSurfaceOther = Surface.ByPatch(dPolyOther); Solid dSolidOther = dSurfaceOther.Thicken(1.0, true); dTrimmed = dSurfaceThis.SubtractFrom(dSolidOther); dPolyThis.Dispose(); dSurfaceThis.Dispose(); dPolyOther.Dispose(); dSurfaceOther.Dispose(); dSolidOther.Dispose(); } List <Polygon2d> polygons = new List <Polygon2d>(); foreach (Geometry dGeometry in dTrimmed) { List <Point2d> points = new List <Point2d>(); Curve[] dCurves = ((Surface)dGeometry).PerimeterCurves(); foreach (Curve dCurve in dCurves) { Point dPoint = dCurve.StartPoint; points.Add(new Point2d(dPoint.X, dPoint.Y)); dPoint.Dispose(); dCurve.Dispose(); } polygons.Add(new Polygon2d(points)); dGeometry.Dispose(); } return(polygons); }
public void BeforeTest() { surface = Surface.ByPatch(PolyCurve.ByPoints(new List <Point> { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(27.129, 25.08, 0), Point.ByCoordinates(10.318, 36.351, 0), Point.ByCoordinates(-7.419, 16.573, 0) }, true)); List <double> newRange = DSCore.Math.RemapRange(new List <double> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0, 1) as List <double>; uParams = newRange; vParams = newRange; }
public void RightObstacleTest() { // Create a rectangle object with 4 equal sides to check openess score var origin = Point.ByCoordinates(10, 0); var surface = Surface.ByPatch(Rectangle.ByWidthLength(CoordinateSystem.ByOrigin(origin), 10, 10)); // Calculate openess score var openessScore = Openess.FromSurface(surface, 0, new List <Polygon> { }, new List <Polygon> { obstacle }); // Check of score equals 75%, as the entire right side is blocked by the obstacle Assert.AreEqual(75d, openessScore); // Dispose unused geometry obstacle.Dispose(); origin.Dispose(); }
public void BottomObstacleTest() { // Create a rectangle object with 4 equal sides to check openess score Point origin = Point.ByCoordinates(0, -10); Surface surface = Surface.ByPatch(Rectangle.ByWidthLength(CoordinateSystem.ByOrigin(origin), 10, 10)); // Calculate openess score double openessScore = Openess.FromSurface(surface, 0, new List <Polygon> { }, new List <Polygon> { obstacle }); // Check of score equals 0.25, as the entire bottom is blocked by the obstacle Assert.AreEqual(0.25, openessScore); // Dispose unused geometry obstacle.Dispose(); origin.Dispose(); }
public void IsovistFromPointDetectsObstructionsInLayoutTest() { // Create obstruction Polygon internals = Rectangle.ByWidthLength(5, 5) as Polygon; // Create origin point Point originPoint = Point.ByCoordinates(3, 3); // Create isovist form the origin point Surface isovist = Isovist.FromPoint(new List <Polygon> { layoutPolygon }, new List <Polygon> { internals }, originPoint); // Checks that the area returned by the isovist is not equal to the area of the layout // and that the isovist does not intersect the midpoint of the obstacle. Assert.AreNotEqual(Surface.ByPatch(layoutPolygon).Area, isovist.Area); Assert.False(isovist.DoesIntersect(internals.Center())); }
public void ObstacleOnBothSides() { List <Polygon> obstaclePolygons = new List <Polygon>() { obstacle.Translate(-10) as Polygon, obstacle.Translate(10) as Polygon }; // Create a rectangle object with 4 equal sides to check openess score Surface surface = Surface.ByPatch(Rectangle.ByWidthLength(10, 10)); // Calculate openess score double openessScore = Openess.FromSurface(surface, 0, new List <Polygon> { }, obstaclePolygons); // Check if score equals 0.50, as the entire right and left side is blocked by the obstacles Assert.AreEqual(0.50, openessScore); // Dispose unused geometry obstaclePolygons.ForEach(poly => poly.Dispose()); }
public static Surface IsovistFromPoint( Point point, List <Polygon> boundary, [DefaultArgument("[]")] List <Polygon> obstructions) { var baseGraph = BaseGraph.ByBoundaryAndInternalPolygons(boundary, obstructions); if (baseGraph == null) { throw new ArgumentNullException("graph"); } if (point == null) { throw new ArgumentNullException("point"); } GTGeom.Vertex origin = GTGeom.Vertex.ByCoordinates(point.X, point.Y, point.Z); List <GTGeom.Vertex> vertices = VisibilityGraph.VertexVisibility(origin, baseGraph.graph); var points = vertices.Select(v => GTGeom.Points.ToPoint(v)).ToList(); var polygon = Polygon.ByPoints(points); // if polygon is self intersecting, make new polygon if (polygon.SelfIntersections().Length > 0) { points.Add(point); polygon = Polygon.ByPoints(points); } var surface = Surface.ByPatch(polygon); polygon.Dispose(); points.ForEach(p => p.Dispose()); return(surface); }
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)) } }); }
/// <summary> /// Get surface points inside a closed boundary /// </summary> /// <param name="boundary">A closed curve</param> /// <param name="tolerance">A value between 0 and 1 to define the precision of the tessellation along non-straight curves.</param> /// <returns> /// The List of Points /// </returns> public List <Point> GetPointsInBoundary(Curve boundary, double tolerance = 0.1) { Utils.Log(string.Format("CivilSurface.GetPointsInBoundary started...", "")); if (!boundary.IsClosed) { string message = "The Curve provided is not closed."; Utils.Log(string.Format("ERROR: CivilSurface.GetPointsInBoundary {0}", message)); throw new Exception(message); } Plane xy = Plane.XY(); Curve boundaryXY = boundary.PullOntoPlane(xy); Surface surf = null; List <Point> pointsInside = new List <Point>(); Polygon polygon = null; try { surf = Surface.ByPatch(boundaryXY); } catch { string message = "Unable to create surface form boundary."; Utils.Log(string.Format("ERROR: CivilSurface.GetPointsInBoundary {0}", message)); } if (surf != null) { pointsInside = this.GetSurfacePoints().Where(p => Point.ByCoordinates(p.X, p.Y).DoesIntersect(surf)).ToList(); } else { if (tolerance <= 0 || tolerance > 1) { tolerance = 1; } if (boundary is PolyCurve) { PolyCurve pc = boundary as PolyCurve; List <Point> points = new List <Point>(); for (int i = 0; i < pc.NumberOfCurves; ++i) { Curve c = pc.CurveAtIndex(i); try { Line line = c as Line; points.Add(c.StartPoint); } catch { for (double j = 0; j < 1; j = j + tolerance) { points.Add(c.PointAtParameter(j)); } } c.Dispose(); } polygon = Polygon.ByPoints(points.Select(p => Point.ByCoordinates(p.X, p.Y))); foreach (var item in points) { if (item != null) { item.Dispose(); } } points.Clear(); } else if (boundary is Circle) { List <Point> points = new List <Point>(); for (double j = 0; j < 1; j = j + tolerance) { points.Add(boundary.PointAtParameter(j)); } polygon = Polygon.ByPoints(points.Select(p => Point.ByCoordinates(p.X, p.Y))); foreach (var item in points) { if (item != null) { item.Dispose(); } } points.Clear(); } else if (boundary is Rectangle) { polygon = Polygon.ByPoints(((Rectangle)boundary).Curves().Select(c => c.StartPoint).Select(p => Point.ByCoordinates(p.X, p.Y))); } else if (boundary is Polygon) { polygon = boundary as Polygon; } pointsInside = this.GetSurfacePoints().Where(p => polygon.ContainmentTest(Point.ByCoordinates(p.X, p.Y))).ToList(); } if (polygon != null) { polygon.Dispose(); } xy.Dispose(); if (boundaryXY != null) { boundaryXY.Dispose(); } if (surf != null) { surf.Dispose(); } Utils.Log(string.Format("CivilSurface.GetPointsInBoundary completed.", "")); return(pointsInside); }
public void BeforeTest() { Rectangle layoutPolygon = Rectangle.ByWidthLength(500, 500); surface = Surface.ByPatch(layoutPolygon); }
/// <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()); }
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); }