/***************************************************/ public static RHG.Curve IToRhino(this BHG.ICurve curve) { if (curve == null) { return(null); } object result = Convert.ToRhino(curve as dynamic); if (result is RHG.Curve) { return((RHG.Curve)result); } else if (result is RHG.Arc) { return(new RHG.ArcCurve((RHG.Arc)result)); } else if (result is RHG.Circle) { return(new RHG.ArcCurve((RHG.Circle)result)); } else if (result is RHG.Ellipse) { return(((RHG.Ellipse)result).ToNurbsCurve()); } else if (result is RHG.Line) { return(new RHG.LineCurve((RHG.Line)result)); } return(Convert.ToRhino(curve as dynamic)); }
/***************************************************/ private static BHG.PlanarSurface ToBHoMPlanarSurface(this RHG.BrepFace face) { RHG.Surface rhSurf = face.UnderlyingSurface(); if (rhSurf == null) { return(null); } BHG.PlanarSurface bhs = rhSurf.FromRhino() as BHG.PlanarSurface; List <BHG.ICurve> internalBoundaries = new List <BHG.ICurve>(); BHG.ICurve externalBoundary = bhs.ExternalBoundary; foreach (RHG.BrepLoop loop in face.Loops) { if (loop.LoopType == RHG.BrepLoopType.Inner) { internalBoundaries.Add(new BHG.PolyCurve { Curves = loop.Trims.Select(x => rhSurf.Pushup(x, BHG.Tolerance.Distance).FromRhino()).ToList() }); } else if (loop.LoopType == RHG.BrepLoopType.Outer) { externalBoundary = new BHG.PolyCurve { Curves = loop.Trims.Select(x => rhSurf.Pushup(x, BHG.Tolerance.Distance).FromRhino()).ToList() } } ; } return(BH.Engine.Geometry.Create.PlanarSurface(externalBoundary, internalBoundaries)); }
/***************************************************/ public static BHG.ISurface FromRhino(this RHG.NurbsSurface surface) { if (surface == null) { return(null); } if (surface.IsPlanar(BH.oM.Geometry.Tolerance.Distance)) { BHG.ICurve externalEdge = RHG.Curve.JoinCurves(surface.ToBrep().DuplicateNakedEdgeCurves(true, false)).FirstOrDefault().FromRhino(); return(new BHG.PlanarSurface(externalEdge, new List <BHG.ICurve>())); } BHG.NurbsSurface bhs = new BHG.NurbsSurface ( surface.Points.Select(x => x.Location.FromRhino()).ToList(), surface.Points.Select(x => x.Weight).ToList(), surface.KnotsU.ToList(), surface.KnotsV.ToList(), surface.Degree(0), surface.Degree(1), new List <BHG.SurfaceTrim>(), new List <BHG.SurfaceTrim>() ); return(bhs); }
public static TBD.buildingElement BuildingElement(TBD.Building tbdBuilding, BH.oM.Geometry.ICurve panelCurve) { /*int index = 0; * TBD.buildingElement tbdBuildingElement = null; * while ((tbdBuildingElement = tbdBuilding.GetBuildingElement(index)) != null) * { * if (tbdBuildingElement. == panelCurve) * return tbdBuildingElement; * index++; * }*/ return(null); }
/***************************************************/ public static BHG.ISurface FromRhino(this RHG.Surface surface) { if (surface == null) { return(null); } if (surface.IsPlanar(BHG.Tolerance.Distance)) { BHG.ICurve externalEdge = RHG.Curve.JoinCurves(surface.ToBrep().DuplicateNakedEdgeCurves(true, false)).FirstOrDefault().FromRhino(); return(new BHG.PlanarSurface(externalEdge, new List <oM.Geometry.ICurve>())); } return(surface.ToNurbsSurface().FromRhino()); }
/***************************************************/ public static BHG.IGeometry FromRhino(this RHG.Brep brep) { if (brep == null) { return(null); } string log; if (!brep.IsValidWithLog(out log)) { Reflection.Compute.RecordError("Conversion failed, Rhino Brep is invalid: " + log); return(null); } if (brep.Faces.Count == 0) { return(null); } if (brep.IsSolid) { return(brep.ToBHoMSolid()); } if (brep.IsPlanarSurface()) { BHG.ICurve externalEdge = RHG.Curve.JoinCurves(brep.DuplicateNakedEdgeCurves(true, false)).FirstOrDefault().FromRhino(); List <BHG.ICurve> internalEdges = RHG.Curve.JoinCurves(brep.DuplicateNakedEdgeCurves(false, true)).Select(c => c.FromRhino()).ToList(); return(new BHG.PlanarSurface(externalEdge, internalEdges)); } if (brep.Faces.Count == 1) { return(brep.Faces[0].FromRhino()); } // Default case - return open Polysurface return(new BHG.PolySurface() { Surfaces = brep.Faces.Select(s => s.FromRhino()).ToList() }); }
public static global::Topologic.Topology TopologyByGeometry(BH.oM.Geometry.IGeometry geometry, double tolerance = 0.0001) { BH.oM.Geometry.Point bhomPoint = geometry as BH.oM.Geometry.Point; if (bhomPoint != null) { return(Create.VertexByPoint(bhomPoint)); } // Handle polyline and polycurve first BH.oM.Geometry.Polyline bhomPolyline = geometry as BH.oM.Geometry.Polyline; if (bhomPolyline != null) { if (bhomPolyline.ControlPoints.Count < 2) { throw new Exception("An invalid polyline with fewer than 2 control points is given."); } else if (bhomPolyline.ControlPoints.Count == 2) { BH.oM.Geometry.Line bhomLine = BH.Engine.Geometry.Create.Line(bhomPolyline.ControlPoints[0], bhomPolyline.ControlPoints[1]); return(Create.EdgeByLine(bhomLine)); } else { return(Create.WireByPolyLine(bhomPolyline)); } } BH.oM.Geometry.PolyCurve bhomPolyCurve = geometry as BH.oM.Geometry.PolyCurve; if (bhomPolyCurve != null) { if (bhomPolyCurve.Curves.Count == 0) { throw new Exception("An invalid polycurve with no curve is given."); } else if (bhomPolyCurve.Curves.Count == 1) { BH.oM.Geometry.ICurve bhomACurve = bhomPolyCurve.Curves[0]; return(Create.EdgeByCurve(bhomACurve)); } else { return(Create.WireByPolyCurve(bhomPolyCurve)); } } // Then curve BH.oM.Geometry.ICurve bhomCurve = geometry as BH.oM.Geometry.ICurve; if (bhomCurve != null) { return(Create.EdgeByCurve(bhomCurve)); } // Do polysurface first. BH.oM.Geometry.PolySurface bhomPolySurface = geometry as BH.oM.Geometry.PolySurface; if (bhomPolySurface != null) { return(Create.ShellByPolySurface(bhomPolySurface, tolerance)); } // Then surface BH.oM.Geometry.ISurface bhomSurface = geometry as BH.oM.Geometry.ISurface; if (bhomSurface != null) { return(Create.FaceBySurface(bhomSurface)); } BH.oM.Geometry.ISolid bhomSolid = geometry as BH.oM.Geometry.ISolid; if (bhomSolid != null) { return(Create.CellBySolid(bhomSolid, tolerance)); } BH.oM.Geometry.BoundingBox bhomBoundingBox = geometry as BH.oM.Geometry.BoundingBox; if (bhomBoundingBox != null) { return(Create.CellByBoundingBox(bhomBoundingBox)); } BH.oM.Geometry.CompositeGeometry bhomCompositeGeometry = geometry as BH.oM.Geometry.CompositeGeometry; if (bhomCompositeGeometry != null) { return(Create.ClusterByCompositeGeometry(bhomCompositeGeometry, tolerance)); } BH.oM.Geometry.Mesh bhomMesh = geometry as BH.oM.Geometry.Mesh; if (bhomMesh != null) { return(Create.TopologyByMesh(bhomMesh)); } throw new NotImplementedException("This BHoM geometry is not yet supported."); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private static void AddBrepTrim(this RHG.Brep brep, RHG.BrepFace face, BHG.SurfaceTrim trim, RHG.BrepLoopType loopType) { RHG.BrepLoop loop = brep.Loops.Add(loopType, face); List <BHG.ICurve> subParts3d = trim.Curve3d.ISubParts().ToList(); List <BHG.ICurve> subParts2d = trim.Curve2d.ISubParts().ToList(); double rhinoTolerance = Query.DocumentTolerance(); for (int i = 0; i < subParts3d.Count; i++) { BHG.ICurve bhc = subParts3d[i]; RHG.Curve rhc = bhc.IToRhino(); int startId = brep.AddVertex(rhc.PointAtStart); int endId = brep.AddVertex(rhc.PointAtEnd); RHG.BrepTrim rhTrim; RHG.Curve rhc2d = subParts2d[i].IToRhino(); rhc2d.ChangeDimension(2); int crv2d = brep.Curves2D.Add(rhc2d); if (rhc.IsValid) { bool rev3d = true; RHG.BrepEdge edge = null; foreach (RHG.BrepEdge e in brep.Edges) { if (e.StartVertex.VertexIndex == endId && e.EndVertex.VertexIndex == startId && rhc.IsSameEdge(e)) { edge = e; break; } } if (edge == null) { int crv = brep.Curves3D.Add(rhc); edge = brep.Edges.Add(startId, endId, crv, rhinoTolerance); rev3d = false; } rhTrim = brep.Trims.Add(edge, rev3d, loop, crv2d); } else { rhTrim = brep.Trims.AddSingularTrim(brep.Vertices[startId], loop, RHG.IsoStatus.None, crv2d); } rhTrim.SetTolerances(rhinoTolerance, rhinoTolerance); //TODO: In Rhino 6 this could be replaced with Surface.IsIsoParametric(Curve) RHG.Point3d start = rhc2d.PointAtStart; RHG.Point3d end = rhc2d.PointAtEnd; if (rhc2d.IsLinear()) { if (Math.Abs(start.X - end.X) <= rhinoTolerance) { RHG.Interval domainU = brep.Surfaces[face.SurfaceIndex].Domain(0); if (Math.Abs(start.X - domainU.Min) <= rhinoTolerance) { rhTrim.IsoStatus = RHG.IsoStatus.West; } else if (Math.Abs(start.X - domainU.Max) <= rhinoTolerance) { rhTrim.IsoStatus = RHG.IsoStatus.East; } else { rhTrim.IsoStatus = RHG.IsoStatus.X; } } else if (Math.Abs(start.Y - end.Y) <= rhinoTolerance) { RHG.Interval domainV = brep.Surfaces[face.SurfaceIndex].Domain(1); if (Math.Abs(start.Y - domainV.Min) <= rhinoTolerance) { rhTrim.IsoStatus = RHG.IsoStatus.South; } else if (Math.Abs(start.Y - domainV.Max) <= rhinoTolerance) { rhTrim.IsoStatus = RHG.IsoStatus.North; } else { rhTrim.IsoStatus = RHG.IsoStatus.Y; } } } } }
public static Point3dVector ToOSM(this BHG.ICurve crv) { return(ToOSM(crv as dynamic)); }
/***************************************************/ /**** Public Methods - Interfaces ****/ /***************************************************/ public static bool IIsEqual(this BHG.ICurve bhCurve, RHG.Curve rhCurve, double tolerance = BHG.Tolerance.Distance) { return(IsEqual(bhCurve as dynamic, rhCurve as dynamic, tolerance)); }
/***************************************************/ public static BuildingElement BuildingElementOpening(this BuildingElement be, BHG.ICurve bound) { return(be.BuildingElementOpening(new List <BHG.ICurve> { bound })); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static Opening Opening(BHG.ICurve curve) { return(Opening(curve as dynamic)); }