/***************************************************/
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 global::Topologic.Face ToTopologic(this Rhino.Geometry.NurbsSurface nurbsSurface)
{
if (nurbsSurface == null)
{
return(null);
}
int uDegree = nurbsSurface.Degree(0);
int vDegree = nurbsSurface.Degree(1);
bool isUPeriodic = nurbsSurface.IsPeriodic(0);
bool isVPeriodic = nurbsSurface.IsPeriodic(1);
bool isRational = nurbsSurface.IsRational;
NurbsSurfaceKnotList ghUKnots = nurbsSurface.KnotsU;
List <double> uKnots = ghUKnots.ToList();
NurbsSurfaceKnotList ghVKnots = nurbsSurface.KnotsV;
List <double> vKnots = ghVKnots.ToList();
// OCCT-compatible
uKnots.Insert(0, uKnots[0]);
uKnots.Add(uKnots.Last());
vKnots.Insert(0, vKnots[0]);
vKnots.Add(vKnots.Last());
NurbsSurfacePointList ghControlPoints = nurbsSurface.Points;
List <IList <Vertex> > controlPoints = new List <IList <Vertex> >();
List <IList <double> > weights = new List <IList <double> >();
for (int i = 0; i < ghControlPoints.CountU; ++i)
{
List <Vertex> controlPoints1D = new List <Vertex>();
List <double> weights1D = new List <double>();
for (int j = 0; j < ghControlPoints.CountV; ++j)
{
ControlPoint ghControlPoint = ghControlPoints.GetControlPoint(i, j);
controlPoints1D.Add(ghControlPoint.Location.ToTopologic());
weights1D.Add(ghControlPoint.Weight);
}
controlPoints.Add(controlPoints1D);
weights.Add(weights1D);
}
return(global::Topologic.Face.ByNurbsParameters(controlPoints, weights, uKnots, vKnots, isRational, isUPeriodic, isVPeriodic, uDegree, vDegree));
}
private Face ByNurbsSurface(Rhino.Geometry.NurbsSurface ghNurbsSurface)
{
int uDegree = ghNurbsSurface.Degree(0);
int vDegree = ghNurbsSurface.Degree(1);
bool isUClosed = ghNurbsSurface.IsClosed(0);
bool isVClosed = ghNurbsSurface.IsClosed(1);
bool isUPeriodic = ghNurbsSurface.IsPeriodic(0);
bool isVPeriodic = ghNurbsSurface.IsPeriodic(1);
bool isRational = ghNurbsSurface.IsRational;
NurbsSurfaceKnotList ghUKnots = ghNurbsSurface.KnotsU;
List <double> uKnots = ghUKnots.ToList();
NurbsSurfaceKnotList ghVKnots = ghNurbsSurface.KnotsV;
List <double> vKnots = ghVKnots.ToList();
// OCCT-compatible
uKnots.Insert(0, uKnots[0]);
uKnots.Add(uKnots.Last());
vKnots.Insert(0, vKnots[0]);
vKnots.Add(vKnots.Last());
NurbsSurfacePointList ghControlPoints = ghNurbsSurface.Points;
List <List <Topologic.Vertex> > controlPoints = new List <List <Topologic.Vertex> >();
List <List <double> > weights = new List <List <double> >();
for (int i = 0; i < ghControlPoints.CountU; ++i)
{
List <Topologic.Vertex> controlPoints1D = new List <Topologic.Vertex>();
List <double> weights1D = new List <double>();
for (int j = 0; j < ghControlPoints.CountV; ++j)
{
ControlPoint ghControlPoint = ghControlPoints.GetControlPoint(i, j);
controlPoints1D.Add(ByPoint(ghControlPoint.Location));
weights1D.Add(ghControlPoint.Weight);
}
controlPoints.Add(controlPoints1D);
weights.Add(weights1D);
}
return(Topologic.Face.ByNurbsParameters(controlPoints, weights, uKnots, vKnots, isRational, isUPeriodic, isVPeriodic, uDegree, vDegree));
}
/***************************************************/
private static BHG.NurbsSurface ToBHoMNurbsSurface(this RHG.BrepFace face)
{
RHG.Surface rhSurf = face.UnderlyingSurface();
if (rhSurf == null)
{
return(null);
}
RHG.NurbsSurface rhNurbsSurf = rhSurf.ToNurbsSurface();
List <BHG.SurfaceTrim> innerTrims = new List <BHG.SurfaceTrim>();
List <BHG.SurfaceTrim> outerTrims = new List <BHG.SurfaceTrim>();
foreach (RHG.BrepLoop loop in face.Loops)
{
if (loop.LoopType == RHG.BrepLoopType.Outer)
{
outerTrims.Add(loop.FromRhino());
}
else
{
innerTrims.Add(loop.FromRhino());
}
}
return(new BHG.NurbsSurface
(
rhNurbsSurf.Points.Select(x => x.Location.FromRhino()).ToList(),
rhNurbsSurf.Points.Select(x => x.Weight).ToList(),
rhNurbsSurf.KnotsU.ToList(),
rhNurbsSurf.KnotsV.ToList(),
rhNurbsSurf.Degree(0),
rhNurbsSurf.Degree(1),
innerTrims,
outerTrims
));
}
//public static Parasite_BrepSurface ToParasiteType(this DB.Face face, bool untrimmed = false)
//{
// var surface = face.ToRhinoSurface();
// if (surface is null)
// return null;
// var brep = Brep.CreateFromSurface(surface);
// if (brep is null)
// return null;
// if (untrimmed)
// return brep;
// var loops = face.GetEdgesAsCurveLoops().ToRhino().ToArray();
// try { return brep.TrimFaces(loops); }
// finally { brep.Dispose(); }
//}
//public static Parasite_BrepSolid ToParasiteType(DB.Solid solid)
//{
// return solid.Faces.
// Cast<DB.Face>().
// Select(x => x.ToRhino()).
// ToArray().
// JoinAndMerge(Revit.VertexTolerance);
//}
#endregion
#region NURBS SURFACE
public static Parasite_NurbsSurface ToParasiteType(Rhino.Geometry.NurbsSurface nurbsSurface, Dictionary <string, string> properties = null)
{
Parasite_NurbsSurface parasite_NurbsSurface = null;
if (!nurbsSurface.IsValid)
{
throw new ParasiteArgumentException("Please enter a valid Rhino Nurbs Surface");
}
else
{
if (nurbsSurface.IsSphere())
{
throw new ParasiteNotImplementedExceptions("There is still no support for Rhino NURBS Spheres");
}
else if (nurbsSurface.IsTorus())
{
throw new ParasiteNotImplementedExceptions("There is still no support for Rhino NURBS Torus");
}
else
{
NurbsSurfaceKnotList rhinoKnotsU = nurbsSurface.KnotsU;
NurbsSurfaceKnotList rhinoKnotsV = nurbsSurface.KnotsV;
NurbsSurfacePointList cp = nurbsSurface.Points;
double[] knotsU = new double[rhinoKnotsU.Count];
double[] knotsV = new double[rhinoKnotsV.Count];
double[][] weights = new double[cp.Count()][];
if (cp.Any((x) => !x.Location.IsValid))
{
throw new ParasiteArgumentException("The Rhino NURBS Surface had an invalid Control Point!");
}
Parasite_Point3d[][] vertices = new Parasite_Point3d[cp.Count()][];
for (int i = 0; i < rhinoKnotsU.Count; i++)
{
knotsU[i] = rhinoKnotsU[i];
knotsV[i] = rhinoKnotsV[i];
}
//for (int u = 0; u < cp.CountU; u++)
//{
// for (int v = 0; v < cp.CountV; v++)
// {
// Point3d controlP = cp.GetControlPoint(u, v).Location;
// double weight = cp.GetWeight(u, v);
// }
//}
int count = -1;
foreach (var item in cp)
{
count++;
if (item.Weight <= 1e-11)
{
weights[count] = new double[] { 0.0 }
}
;
weights[count] = new double[] { item.Weight };
vertices[count] = new Parasite_Point3d[] { ToParasiteType(item.Location) };
}
parasite_NurbsSurface = new Parasite_NurbsSurface(vertices, knotsU, knotsV, weights, nurbsSurface.Degree(0), nurbsSurface.Degree(1));
}
}
return(parasite_NurbsSurface);
}
#endregion
#endregion
}
