private GH_Brep NonPlanarBrep(double depth, IList <PolylineCurve> curveList) { var nonPlanarBrep = new List <Brep>(); var topBrep = Brep.CreatePatch(new[] { curveList[0] }, 5, 5, _tolerance[0]); nonPlanarBrep.Add(topBrep); BrepFace face = topBrep.Faces[0]; Vector3d faceNormal = face.NormalAt(face.Domain(0).Mid, face.Domain(1).Mid); if (Vector3d.VectorAngle(faceNormal, Vector3d.ZAxis) < Vector3d.VectorAngle(faceNormal, -Vector3d.ZAxis)) { faceNormal = -faceNormal; } Brep bottomBrep = topBrep.DuplicateBrep(); bottomBrep.Translate(faceNormal * depth); nonPlanarBrep.Add(bottomBrep); IEnumerable <Curve> edgeCurveList = topBrep.Edges.Select(edge => edge.DuplicateCurve()); nonPlanarBrep.AddRange(edgeCurveList.Select(edgeCurve => Surface.CreateExtrusion(edgeCurve, faceNormal * depth).ToBrep())); return(new GH_Brep(Brep.JoinBreps(nonPlanarBrep, _tolerance[0])[0] ?? topBrep)); }
public void renderPatch() { //Brep patchSurface = Brep.CreatePatch(curvelist, 4, 4, mScene.rhinoDoc.ModelAbsoluteTolerance); Brep patchSurface = Brep.CreatePatch(allPoints, 10, 10, mScene.rhinoDoc.ModelAbsoluteTolerance); Guid planGuid = UtilOld.addRhinoObjectSceneNode(ref mScene, ref patchSurface, ref mesh_m, "patchSurface", out planeSN); //clear profile curves foreach (Guid id in curveGuids) { foreach (SceneNode sn in mScene.tableGeometry.children) { if (sn.guid == id) { mScene.tableGeometry.children.Remove(sn); break; } } } allPoints.Clear(); curvelist.Clear(); }
private GH_Brep CreateSlabBrep(double depth, IList <PolylineCurve> curveList, IEnumerable <Point3d> topPts) { if (depth > 0) { Vector3d normal = Vector3d.CrossProduct(curveList[0].TangentAtEnd, curveList[0].TangentAtStart); curveList[1] = new PolylineCurve(topPts.Select(pt => pt - normal * depth)); Brep loftBrep = Brep.CreateFromLoft(curveList, Point3d.Unset, Point3d.Unset, LoftType.Straight, false)[0]; Brep capedBrep = loftBrep.CapPlanarHoles(_tolerance[0]); if (capedBrep == null) { return(NonPlanarBrep(depth, curveList)); } CheckBrepOrientation(capedBrep); return(new GH_Brep(capedBrep)); } return(new GH_Brep(curveList[0].IsPlanar() ? Brep.CreatePlanarBreps(curveList[0], _tolerance[0])[0] : Brep.CreatePatch(new[] { curveList[0] }, 5, 5, _tolerance[0]))); }
private Brep ToSurface(Face face, double tolerance) { Rhino.Geometry.Surface ghSurface = ToRhinoSurface(face); double width = 0.0, height = 0.0; bool canGetSurfaceSize = ghSurface.GetSurfaceSize(out width, out height); if (!canGetSurfaceSize) { throw new Exception("Fails to get the surface size."); } double maxSize = Math.Max(width, height); double maxSizeAndMargin = maxSize + 2; ghSurface = ghSurface.Extend(IsoStatus.North, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.South, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.West, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.East, maxSizeAndMargin, true); //List<Wire> wires = face.Wires; //List<GeometryBase> ghGeometryBases = new List<GeometryBase>(); //foreach (Wire wire in wires) //{ // List<Object> ghCurves = ToCurves(wire); // foreach (Object ghCurve in ghCurves) // { // GeometryBase geometryBase = ghCurve as GeometryBase; // if (geometryBase != null) // { // ghGeometryBases.Add(geometryBase); // } // } //} //2.Create the Brep //Brep ghBrep = ghNurbsSurface.ToBrep(); //Brep ghBrep = new Brep(); //// 2a. Add vertices //List<Vertex> vertices = face.Vertices; //foreach (Vertex vertex in vertices) //{ // Point3d ghPoint = ToPoint(vertex); // BrepVertex ghBrepVertex = ghBrep.Vertices.Add(ghPoint, 0.0); // String ghBrepVertexLog = ""; // if (!ghBrepVertex.IsValidWithLog(out ghBrepVertexLog)) // { // throw new Exception("Fails to create a valid BrepVertex with the following message: " + ghBrepVertexLog); // } //} //// 2b. Add 3D curves and edges. The index dictionaries are used to identify the IDs of the edges. //List<Edge> edges = face.Edges; //Dictionary<Edge, Tuple<int, int>> edge2DIndices = new Dictionary<Edge, Tuple<int, int>>(); // edge, curve, reverse curve //Dictionary<Edge, int> edge3DIndices = new Dictionary<Edge, int>(); //Dictionary<Edge, BrepEdge> edgeIndices = new Dictionary<Edge, BrepEdge>(); //foreach (Edge edge in edges) //{ // Curve ghCurve3D = ToCurve(edge); // Curve ghCurve2D = ghSurface.Pullback(ghCurve3D, 0.0001); // // 2D curves --> need to check if the endpoints are near to previously generated points // // if yes, change the value // int curve3DID = ghBrep.Curves3D.Add(ghCurve3D); // int curve2DID = ghBrep.Curves2D.Add(ghCurve2D); // Curve ghReverseCurve2D = ghCurve2D.DuplicateCurve(); // ghReverseCurve2D.Reverse(); // int reverseCurve2DID = ghBrep.Curves2D.Add(ghReverseCurve2D); // Point3d ghStartPoint = ghCurve3D.PointAtStart; // Point3d ghEndPoint = ghCurve3D.PointAtEnd; // int startVertexIndex = -1; // int endVertexIndex = -1; // foreach (BrepVertex ghBrepVertex in ghBrep.Vertices) // { // Point3d ghBrepPoint = ghBrepVertex.Location; // if (startVertexIndex == -1 && ghBrepPoint.DistanceTo(ghStartPoint) < 0.0001) // { // startVertexIndex = ghBrepVertex.VertexIndex; // } // if (endVertexIndex == -1 && ghBrepPoint.DistanceTo(ghEndPoint) < 0.0001) // { // endVertexIndex = ghBrepVertex.VertexIndex; // } // } // BrepEdge ghBrepEdge = ghBrep.Edges.Add(startVertexIndex, endVertexIndex, curve3DID, 0.0001); // String brepEdgeLog = ""; // if (!ghBrepEdge.IsValidWithLog(out brepEdgeLog)) // { // throw new Exception("Fails to create a valid BrepEdge with the following message: " + brepEdgeLog); // } // edge3DIndices.Add(edge, curve3DID); // edge2DIndices.Add(edge, Tuple.Create(curve2DID, reverseCurve2DID)); // edgeIndices.Add(edge, ghBrepEdge); //} //// 2c. Add surface //int ghSurfaceIndex = ghBrep.AddSurface(ghSurface); //// 2d. Add face //BrepFace ghBrepFace = ghBrep.Faces.Add(ghSurfaceIndex); //// 2e. Create outer loop //Wire outerWire = face.ExternalBoundary; //ProcessFace(outerWire, ref ghBrep, ghBrepFace, BrepLoopType.Outer, ghSurface, edge2DIndices, edgeIndices); //// 2g. Create inner loops //List<Wire> innerWires = face.InternalBoundaries; //foreach (Wire innerWire in innerWires) //{ // ProcessFace(innerWire, ref ghBrep, ghBrepFace, BrepLoopType.Inner, ghSurface, edge2DIndices, edgeIndices); //} //String brepFaceLog = ""; //if (!ghBrepFace.IsValidWithLog(out brepFaceLog)) //{ // throw new Exception("Fails to create a valid Face with the following message: " + brepFaceLog); //} //ghBrep.Compact(); List <GeometryBase> ghGeometryBases = new List <GeometryBase>(); List <Edge> outerEdges = face.ExternalBoundary.Edges; List <Curve> ghCurves = new List <Curve>(); foreach (Edge edge in outerEdges) { Curve ghCurve3D = ToCurve(edge); ghGeometryBases.Add(ghCurve3D); ghCurves.Add(ghCurve3D); } //ghGeometryBases.AddRange(ghBrep.Curves2D); //ghGeometryBases.AddRange(ghBrep.Trims); //ghGeometryBases.AddRange(ghBrep.Vertices); Brep ghBrep2 = Brep.CreatePatch( ghGeometryBases, ghSurface, 20, 20, true, true, tolerance, 100.0, 1, new Boolean[] { true, true, true, true }, tolerance); //return ghBrep2; // always returns the trimmed surface BrepFace ghSurfaceAsBrepFace = ghSurface as BrepFace; if (ghBrep2 == null) { return(null); } List <Wire> internalBoundaries = face.InternalBoundaries; if (internalBoundaries.Count == 0) { return(ghBrep2); } BrepFace ghBrepFace = ghBrep2.Faces[0]; //return ghBrepFace.ToBrep(); // may return the untrimmed surface! List <Curve> ghInternalCurves = new List <Curve>(); foreach (Wire internalBoundary in internalBoundaries) { List <Object> ghCurvesFromWireAsObjects = ToCurves(internalBoundary); foreach (Object ghCurveFromWireAsObject in ghCurvesFromWireAsObjects) { Curve ghCurveFromWire = ghCurveFromWireAsObject as Curve; if (ghCurveFromWire != null) { Curve[] ghPulledCurveFromWire = ghCurveFromWire.PullToBrepFace(ghBrepFace, tolerance); ghInternalCurves.AddRange(ghPulledCurveFromWire); } } } //ghCurves.AddRange(ghInternalCurves); Brep ghBrep3 = ghBrepFace.Split(ghInternalCurves, tolerance); //return ghBrep3.Faces[0].DuplicateFace(true); return(ghBrep3.Faces.ExtractFace(0)); //Brep[] ghBreps3 = ghBrep2.Split(ghInternalCurves, 0.0001); //return ghBreps3.First(); //String brepLog = ""; //if (!ghBrep.IsValidWithLog(out brepLog)) //{ // throw new Exception("Fails to create a valid Brep with the following message: " + brepLog); //} //if (!ghBrep.IsValidGeometry(out brepLog)) //{ // throw new Exception("Fails to create a valid Brep with the following message: " + brepLog); //} //if (!ghBrep.IsValidTopology(out brepLog)) //{ // throw new Exception("Fails to create a valid Brep with the following message: " + brepLog); //} //if (!ghBrep.IsValidTolerancesAndFlags(out brepLog)) //{ // throw new Exception("Fails to create a valid Brep with the following message: " + brepLog); //} //return ghBrep; }
public static Brep ToRhino(global::Topologic.Face face, double tolerance = Core.Tolerance.Distance) { Rhino.Geometry.Surface ghSurface = ToRhino(face); double width = 0.0, height = 0.0; bool canGetSurfaceSize = ghSurface.GetSurfaceSize(out width, out height); if (!canGetSurfaceSize) { throw new Exception("Fails to get the surface size."); } double maxSize = Math.Max(width, height); double maxSizeAndMargin = maxSize + 2; ghSurface = ghSurface.Extend(IsoStatus.North, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.South, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.West, maxSizeAndMargin, true); ghSurface = ghSurface.Extend(IsoStatus.East, maxSizeAndMargin, true); List <GeometryBase> ghGeometryBases = new List <GeometryBase>(); IList <Edge> outerEdges = face.ExternalBoundary.Edges; List <Curve> ghCurves = new List <Curve>(); foreach (Edge edge in outerEdges) { Curve ghCurve3D = ToRhino(edge); ghGeometryBases.Add(ghCurve3D); ghCurves.Add(ghCurve3D); } Brep ghBrep2 = Brep.CreatePatch( ghGeometryBases, ghSurface, 20, 20, true, true, tolerance, 100.0, 1, new Boolean[] { true, true, true, true }, tolerance); BrepFace ghSurfaceAsBrepFace = ghSurface as BrepFace; if (ghBrep2 == null) { return(null); } IList <Wire> internalBoundaries = face.InternalBoundaries; if (internalBoundaries.Count == 0) { return(ghBrep2); } BrepFace ghBrepFace = ghBrep2.Faces[0]; List <Curve> ghInternalCurves = new List <Curve>(); foreach (Wire internalBoundary in internalBoundaries) { List <Curve> ghCurvesFromWireAsObjects = ToRhino(internalBoundary); foreach (Curve ghCurveFromWireAsObject in ghCurvesFromWireAsObjects) { Curve ghCurveFromWire = ghCurveFromWireAsObject as Curve; if (ghCurveFromWire != null) { Curve[] ghPulledCurveFromWire = ghCurveFromWire.PullToBrepFace(ghBrepFace, tolerance); ghInternalCurves.AddRange(ghPulledCurveFromWire); } } } Brep ghBrep3 = ghBrepFace.Split(ghInternalCurves, tolerance); return(ghBrep3.Faces.ExtractFace(0)); }
public Brep CreateBrep() { List <Point3d> curvePts = Vertices.Select(x => x.Point).ToList(); //var brpPoints = curvePts.Select(x => new Point(x)).ToList(); curvePts.Add(curvePts[0]); Polyline pl = new Polyline(curvePts); Curve plcrv = pl.ToNurbsCurve(); var result = Brep.CreatePlanarBreps(plcrv, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance); if (result != null && result.Length == 1) { //result[0].SetVertices(); return(result[0]); } if (Vertices.Count == 4) { var bFace = Brep.CreateFromCornerPoints(Vertices[0].Point, Vertices[1].Point, Vertices[2].Point, Vertices[3].Point, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance); //bFace.SetVertices(); return(bFace); } if (Vertices.Count == 3) { var bFace = Brep.CreateFromCornerPoints(Vertices[0].Point, Vertices[1].Point, Vertices[2].Point, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance); //bFace.SetVertices(); return(bFace); } ComputeCentroid(); var brepFace = Brep.CreatePatch(new List <GeometryBase>() { plcrv, new Point(Centroid) }, 5, 5, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance / 1000); //var brepFace = Brep.CreateFromMesh(FMesh, true); //brpPoints.Add(new Point(Centroid)); //brepFace.SetVertices(); return(brepFace); /* * else * { * Brep faceBrep = new Brep(); * ComputeCentroid(); * for (int i = 0; i < Vertices.Count; i++) * { * faceBrep.Append(Brep.CreateFromCornerPoints(Centroid, Vertices[i].Point, Vertices[(i + 1) % Vertices.Count].Point, * Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)); * } * faceBrep.JoinNakedEdges(Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance); * return faceBrep; * } * * */ }
///////////////////////////////// public Vector3d normalDirection(List <Point3d> groundPoints, Polyline outline, out double slopeRatio, out Brep ground) { //create patch double MCminZ = 0; var outrectsegs = TuringAndCorbusierPlugIn.InstanceClass.kdgInfoSet.outrect.DuplicateSegments(); foreach (var seg in outrectsegs) { groundPoints.Add(seg.PointAtStart); groundPoints.Add(seg.PointAtEnd); } foreach (Point3d pointz in groundPoints) { if (pointz.Z < MCminZ) { MCminZ = pointz.Z; } } BoundingBox bb = new BoundingBox(groundPoints); var dgnl = bb.Diagonal; var cp = bb.Center; Vector3d dgnl_shadow = new Vector3d(dgnl.X, dgnl.Y, 0); List <Point3d> external_points = new List <Point3d>(); Point3d p1 = new Point3d(cp) + dgnl_shadow; Point3d p2 = new Point3d(cp) - dgnl_shadow; Vector3d dgnl_shadow_perp = new Vector3d(); var zz = dgnl_shadow_perp.PerpendicularTo(dgnl_shadow); Point3d p3 = new Point3d(cp) - dgnl_shadow_perp; Point3d p4 = new Point3d(cp) + dgnl_shadow_perp; external_points.Add(p1); external_points.Add(p2); external_points.Add(p3); external_points.Add(p4); List <Rhino.Geometry.Point> pts = groundPoints.Select(n => new Rhino.Geometry.Point(n)).ToList(); pts.AddRange(external_points.Select(n => new Rhino.Geometry.Point(n)).ToList()); Brep patch = Brep.CreatePatch(pts, 30, 30, 1); Surface surface = patch.Surfaces[0]; //Rhino.RhinoDoc.ActiveDoc.Objects.AddBrep(patch); //evaluate surface & extract x and y from average normal int resolution = 10; double xDir = 0; double yDir = 0; for (int i = 0; i < resolution + 1; i++) { for (int j = 0; j < resolution + 1; j++) { Point3d point; Vector3d[] derivatives; surface.Evaluate((double)i / (double)resolution, (double)j / (double)resolution, 1, out point, out derivatives); Vector3d normal = Vector3d.CrossProduct(derivatives[0], derivatives[1]); normal.Unitize(); xDir += normal.X; yDir += normal.Y; } } //unit vector of average normal direction Vector3d avrgNormal = new Vector3d(xDir, yDir, 0); avrgNormal.Unitize(); ////create line along average normal vector from polyline center, and get longest intersecting segment //Point3d center = outline.CenterPoint(); //Point3d lineEnd = new Point3d(center); //lineEnd.Transform(Transform.Translation(-outline.BoundingBox.Diagonal.Length * avrgNormal)); //Line dirLine = new Line(lineEnd, outline.BoundingBox.Diagonal.Length * avrgNormal * 2); //Rhino.RhinoDoc.ActiveDoc.Objects.AddLine(dirLine); //Rhino.RhinoDoc.ActiveDoc.Objects.AddPolyline(outline); //var lxp = Rhino.Geometry.Intersect.Intersection.CurveCurve(dirLine.ToNurbsCurve(), outline.ToNurbsCurve(), 0, 0); ////get end points of segment and project onto the patch //Point3d pt1 = lxp[0].PointA; //Point3d pt2 = lxp[lxp.Count - 1].PointA; //double moveL = patch.GetBoundingBox(false).Diagonal.Length; //pt1.Transform(Transform.Translation(-moveL * Vector3d.ZAxis)); //pt2.Transform(Transform.Translation(-moveL * Vector3d.ZAxis)); //List<Brep> brep = new List<Brep>(); //brep.Add(patch); //List<Point3d> twoPts = new List<Point3d>(); //twoPts.Add(pt1); //twoPts.Add(pt2); //Point3d ptpt1 = Rhino.Geometry.Intersect.Intersection.ProjectPointsToBreps(brep, twoPts, Vector3d.ZAxis, 0)[0]; //Point3d ptpt2 = Rhino.Geometry.Intersect.Intersection.ProjectPointsToBreps(brep, twoPts, Vector3d.ZAxis, 0)[1]; slopeRatio = 0; //create line from projected points and calculate slope ratio //Line slopeLine = new Line(ptpt1, ptpt2); //slopeRatio = slopeLine.Direction.Z / Math.Pow(Math.Pow(slopeLine.Direction.X, 2) + Math.Pow(slopeLine.Direction.Y, 2), 0.5); ground = patch; return(avrgNormal); }