/***************************************************/
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 RHG.GeometryBase ToRhino(this BHG.NurbsSurface surface)
{
if (surface == null)
{
return(null);
}
List <int> uvCount = surface.UVCount();
RHG.NurbsSurface rhSurface = RHG.NurbsSurface.Create(3, true, surface.UDegree + 1, surface.VDegree + 1, uvCount[0], uvCount[1]);
for (int i = 0; i < rhSurface.KnotsU.Count; i++)
{
rhSurface.KnotsU[i] = surface.UKnots[i];
}
for (int i = 0; i < rhSurface.KnotsV.Count; i++)
{
rhSurface.KnotsV[i] = surface.VKnots[i];
}
for (int i = 0; i < uvCount[0]; i++)
{
for (int j = 0; j < uvCount[1]; j++)
{
rhSurface.Points.SetControlPoint(i, j, new RHG.ControlPoint(surface.ControlPoints[j + (uvCount[1] * i)].ToRhino(), surface.Weights[j + (uvCount[1] * i)]));
}
}
if (!rhSurface.IsValid)
{
return(null);
}
if (surface.OuterTrims.Count == 0 && surface.InnerTrims.Count == 0)
{
return(rhSurface);
}
else
{
RHG.Brep brep = new RHG.Brep();
int srf = brep.AddSurface(rhSurface);
RHG.BrepFace face = brep.Faces.Add(srf);
foreach (BHG.SurfaceTrim trim in surface.OuterTrims)
{
brep.AddBrepTrim(face, trim, RHG.BrepLoopType.Outer);
}
foreach (BHG.SurfaceTrim trim in surface.InnerTrims)
{
brep.AddBrepTrim(face, trim, RHG.BrepLoopType.Inner);
}
return(brep.IsValid ? brep : null);
}
}
//private void ProcessFace(
// Wire wire, ref Brep ghBrep, BrepFace ghBrepFace, BrepLoopType ghBrepLoopType, Rhino.Geometry.Surface ghSurface,
// Dictionary<Edge, Tuple<int, int>> edge2DIndices, Dictionary<Edge, BrepEdge> edgeIndices)
//{
// List<Edge> edges = wire.Edges;
// BrepLoop ghBrepLoop = ghBrep.Loops.Add(ghBrepLoopType, ghBrepFace);
// // 2f.For each loop, add a trim(2D edge)
// List<BrepEdge> ghEdges = new List<BrepEdge>();
// List<Tuple<Curve, int, Curve, int>> gh2DCurves = new List<Tuple<Curve, int, Curve, int>>(); // original curve, index, reverse curve, reverse index
// foreach (Edge edge in edges)
// {
// Tuple<int, int> thisEdge2DIndices = edge2DIndices.
// Where(edgeIndexPair => edgeIndexPair.Key.IsSame(edge)).
// Select(edgeIndexPair => edgeIndexPair.Value).
// FirstOrDefault();
// int thisEdge2DIndex = thisEdge2DIndices.Item1;
// int thisReverseEdge2DIndex = thisEdge2DIndices.Item2;
// Curve ghCurve2D = ghBrep.Curves2D[thisEdge2DIndex];
// Curve ghReverseCurve2D = ghBrep.Curves2D[thisReverseEdge2DIndex];
// gh2DCurves.Add(Tuple.Create(ghCurve2D, thisEdge2DIndex, ghReverseCurve2D, thisReverseEdge2DIndex));
// BrepEdge ghBrepEdge = edgeIndices.
// Where(edgeIndexPair => edgeIndexPair.Key.IsSame(edge)).
// Select(edgeIndexPair => edgeIndexPair.Value).
// FirstOrDefault();
// String ghBrepEdgeLog = "";
// if (!ghBrepEdge.IsValidWithLog(out ghBrepEdgeLog))
// {
// throw new Exception("Fails to create a valid Brep with the following message: " + ghBrepEdgeLog);
// }
// ghEdges.Add(ghBrepEdge);
// }
// for (int currentEntryID = 0; currentEntryID < gh2DCurves.Count; ++currentEntryID)
// {
// int previousEntryID = currentEntryID - 1;
// if (previousEntryID < 0)
// {
// previousEntryID = edges.Count - 1;
// }
// bool isCurrentStartEqualToPreviousStart = gh2DCurves[currentEntryID].Item1.PointAtStart.DistanceTo(
// gh2DCurves[previousEntryID].Item1.PointAtStart) < tolerance;
// bool isCurrentStartEqualToPreviousEnd = gh2DCurves[currentEntryID].Item1.PointAtStart.DistanceTo(
// gh2DCurves[previousEntryID].Item1.PointAtEnd) < tolerance;
// bool isTrimReversed = false;
// if (!isCurrentStartEqualToPreviousStart && !isCurrentStartEqualToPreviousEnd)
// {
// // Reverse trim
// isTrimReversed = true;
// }
// BrepTrim ghBrepTrim = ghBrep.Trims.Add(
// ghEdges[currentEntryID], // 3D edge
// isTrimReversed, // is reversed?
// ghBrepLoop, // 2D loop
// isTrimReversed ? gh2DCurves[currentEntryID].Item4 : gh2DCurves[currentEntryID].Item2); // 2D curve index, use the reversed one if reversed
// ghBrepTrim.IsoStatus = ghSurface.IsIsoparametric(gh2DCurves[currentEntryID].Item1);
// ghBrepTrim.TrimType = BrepTrimType.Boundary;
// ghBrepTrim.SetTolerances(0.0, 0.0);
// String ghBrepTrimLog = "";
// if (!ghBrepTrim.IsValidWithLog(out ghBrepTrimLog))
// {
// throw new Exception("Fails to create a valid BrepTrim with the following message: " + ghBrepTrimLog);
// }
// }
// String brepLoopLog = "";
// if (!ghBrepLoop.IsValidWithLog(out brepLoopLog))
// {
// throw new Exception("Fails to create a valid outer BrepLoop with the following message: " + brepLoopLog);
// }
//}
private Rhino.Geometry.NurbsSurface ToRhinoNurbsSurface(Topologic.NurbsSurface nurbsSurface)
{
int uDegree = nurbsSurface.UDegree;
int vDegree = nurbsSurface.VDegree;
bool isRational = nurbsSurface.IsURational && nurbsSurface.IsVRational;
int uCount = nurbsSurface.NumOfUControlVertices;
int vCount = nurbsSurface.NumOfVControlVertices;
Rhino.Geometry.NurbsSurface ghNurbsSurface = Rhino.Geometry.NurbsSurface.Create(
3,
isRational,
uDegree + 1,
vDegree + 1,
uCount,
vCount
);
int i = 0;
for (int u = 0; u < uCount; ++u)
{
for (int v = 0; v < vCount; ++v)
{
Topologic.Vertex controlVertex = nurbsSurface.ControlVertex(u, v);
ghNurbsSurface.Points.SetPoint(u, v, ToPoint(controlVertex));
++i;
}
}
List <double> uKnots = nurbsSurface.UKnots;
uKnots = uKnots.GetRange(1, uKnots.Count - 2);
for (int u = 0; u < uKnots.Count; u++)
{
ghNurbsSurface.KnotsU[u] = uKnots[u];
}
List <double> vKnots = nurbsSurface.VKnots;
vKnots = vKnots.GetRange(1, vKnots.Count - 2);
for (int v = 0; v < vKnots.Count; v++)
{
ghNurbsSurface.KnotsV[v] = vKnots[v];
}
if (!ghNurbsSurface.IsValid)
{
throw new Exception("A valid surface cannot be created from this Face.");
}
return(ghNurbsSurface);
}
/// <summary> btnNewDwgPlane creates new drawing plane perpedicular to camera centered around chosed origin </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnNewDwgPlane_Click(object sender, EventArgs e)
{
Rhino.Geometry.Point3d pt1 = org;
Rhino.Geometry.Transform move1 = Rhino.Geometry.Transform.Translation(view3.MainViewport.CameraX);
Rhino.Geometry.Transform move2 = Rhino.Geometry.Transform.Translation(view3.MainViewport.CameraY);
var xRev = view3.MainViewport.CameraX;
var yRev = view3.MainViewport.CameraY;
xRev.Reverse();
yRev.Reverse();
Rhino.Geometry.Transform move3 = Rhino.Geometry.Transform.Translation(xRev);
Rhino.Geometry.Transform move4 = Rhino.Geometry.Transform.Translation(yRev);
Rhino.Geometry.Point3d pt2 = org;
Rhino.Geometry.Point3d pt3 = org;
Rhino.Geometry.Point3d pt4 = org;
Rhino.Geometry.Point3d pt5 = org;
//Rhino.Geometry.Vector3d.l
pt2.Transform(move1);
pt2.Transform(move2);
pt3.Transform(move3);
pt3.Transform(move4);
pt4.Transform(move1);
pt4.Transform(move4);
pt5.Transform(move3);
pt5.Transform(move2);
srf1 = Rhino.Geometry.NurbsSurface.CreateFromCorners(pt2, pt4, pt3, pt5);
plane1 = new Plane(org, view3.MainViewport.CameraX, view3.MainViewport.CameraY);
Rhino.Geometry.Transform scale1 = Rhino.Geometry.Transform.Scale(org, 400);
srf1.Transform(scale1);
mRhinoDoc.Objects.AddPoint(pt1);
mRhinoDoc.Objects.AddPoint(pt2);
mRhinoDoc.Objects.AddPoint(pt3);
mRhinoDoc.Objects.AddPoint(pt4);
mRhinoDoc.Objects.AddPoint(pt5);
mRhinoDoc.Objects.AddSurface(srf1);
mRhinoDoc.Views.Redraw();
}
private Topologic.Face BySurface(Rhino.Geometry.Surface ghSurface)
{
SumSurface ghSumSurface = ghSurface as SumSurface;
if (ghSumSurface != null)
{
return(BySumSurface(ghSumSurface));
}
RevSurface ghRevSurface = ghSurface as RevSurface;
if (ghRevSurface != null)
{
return(ByRevSurface(ghRevSurface));
}
PlaneSurface ghPlaneSurface = ghSurface as PlaneSurface;
if (ghPlaneSurface != null)
{
return(ByPlaneSurface(ghPlaneSurface));
}
//ClippingPlaneSurface ghClippingPlaneSurface = ghSurface as ClippingPlaneSurface;
//if (ghClippingPlaneSurface != null)
//{
// return ByClippingPlaneSurface(ghClippingPlaneSurface);
//}
Extrusion ghExtrusion = ghSurface as Extrusion;
if (ghExtrusion != null)
{
return(ByExtrusion(ghExtrusion));
}
Rhino.Geometry.NurbsSurface ghNurbsSurface = ghSurface as Rhino.Geometry.NurbsSurface;
if (ghNurbsSurface != null)
{
return(ByNurbsSurface(ghNurbsSurface));
}
//BrepFace ghBrepFace = ghSurface as BrepFace;
//if (ghBrepFace != null)
//{
// return ByBrepFace(ghBrepFace);
//}
throw new Exception("This type of surface is not yet supported.");
}
public static NurbsSurface ToCore(this RG.NurbsSurface surface)
{
var controlPoints = new Matrix <Point4d>(surface.Points.CountU, surface.Points.CountV);
for (int i = 0; i < surface.Points.CountU; i++)
{
for (int j = 0; j < surface.Points.CountV; j++)
{
surface.Points.GetPoint(i, j, out RG.Point4d pt);
controlPoints[i, j] = pt.ToCore();
}
}
return(new NurbsSurface(controlPoints, surface.OrderU - 1, surface.OrderV - 1));
}
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));
}
public static global::Topologic.Face ToTopologic(this Rhino.Geometry.Surface surface)
{
if (surface == null)
{
return(null);
}
SumSurface sumSurface = surface as SumSurface;
if (sumSurface != null)
{
return(sumSurface.ToTopologic());
}
RevSurface revSurface = surface as RevSurface;
if (revSurface != null)
{
return(revSurface.ToTopologic());
}
PlaneSurface planeSurface = surface as PlaneSurface;
if (planeSurface != null)
{
return(planeSurface.ToTopologic());
}
Rhino.Geometry.Extrusion ghExtrusion = surface as Rhino.Geometry.Extrusion;
if (ghExtrusion != null)
{
return(ghExtrusion.ToTopologic());
}
Rhino.Geometry.NurbsSurface ghNurbsSurface = surface as Rhino.Geometry.NurbsSurface;
if (ghNurbsSurface != null)
{
return(ghNurbsSurface.ToTopologic());
}
return(null);
}
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 void RenderRhinoWires(RHG.NurbsSurface surface, Rhino.Display.DisplayPipeline pipeline, Color bhColour, int thickness)
{
pipeline.DrawSurface(surface, bhColour, thickness);
}
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobjectIndex)
{
if (IntPtr.Zero == pGeometry)
{
return(null);
}
var type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry);
if (type < 0)
{
return(null);
}
GeometryBase rc = null;
switch (type)
{
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Curve: //1
rc = new Curve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsCurve: //2
rc = new NurbsCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolyCurve: // 3
rc = new PolyCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PolylineCurve: //4
rc = new PolylineCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ArcCurve: //5
rc = new ArcCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_LineCurve: //6
rc = new LineCurve(pGeometry, parent, subobjectIndex);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Mesh: //7
rc = new Mesh(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Point: //8
rc = new Point(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_TextDot: //9
rc = new TextDot(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Surface: //10
rc = new Surface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Brep: //11
rc = new Brep(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_NurbsSurface: //12
rc = new NurbsSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_RevSurface: //13
rc = new RevSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PlaneSurface: //14
rc = new PlaneSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_ClippingPlaneSurface: //15
rc = new ClippingPlaneSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Hatch: // 17
rc = new Hatch(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SumSurface: //19
rc = new SumSurface(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepFace: //20
{
int faceindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex);
if (ptr_brep != IntPtr.Zero && faceindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Faces[faceindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepEdge: // 21
{
int edgeindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex);
if (ptr_brep != IntPtr.Zero && edgeindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Edges[edgeindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_InstanceReference: // 23
rc = new InstanceReferenceGeometry(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Extrusion: //24
rc = new Extrusion(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointCloud: // 26
rc = new PointCloud(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DetailView: // 27
rc = new DetailView(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Light: //32
rc = new Light(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_PointGrid: //33
rc = new Point3dGrid(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_MorphControl: //34
rc = new MorphControl(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepLoop: //35
{
int loopindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex);
if (ptr_brep != IntPtr.Zero && loopindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Loops[loopindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_BrepTrim: // 36
{
int trimindex = -1;
IntPtr ptr_brep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex);
if (ptr_brep != IntPtr.Zero && trimindex >= 0)
{
Brep b = new Brep(ptr_brep, parent);
rc = b.Trims[trimindex];
}
}
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Leader: // 38
rc = new Leader(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_SubD: // 39
rc = new SubD(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimLinear: //40
rc = new LinearDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimAngular: //41
rc = new AngularDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimRadial: //42
rc = new RadialDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_DimOrdinate: //43
rc = new OrdinateDimension(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Centermark: //44
rc = new Centermark(pGeometry, parent);
break;
case UnsafeNativeMethods.OnGeometryTypeConsts.ON_Text: //45
rc = new TextEntity(pGeometry, parent);
break;
default:
rc = new UnknownGeometry(pGeometry, parent, subobjectIndex);
break;
}
return(rc);
}
public NurbsSurface ToNurbsSurface()
{
return(NurbsSurface.CreateFromCylinder(this));
}
public NurbsSurface ToNurbsSurface()
{
return(NurbsSurface.CreateFromTorus(this));
}
public static NurbsSurface ToCore(this RG.NurbsSurface surface) => throw new NotImplementedException();
public static global::Topologic.Face ToTopologic(Rhino.Geometry.Extrusion extrusion)
{
Rhino.Geometry.NurbsSurface ghNurbsSurface = extrusion?.ToNurbsSurface();
return(ghNurbsSurface?.ToTopologic());
}
/***************************************************/
public static void RenderRhinoMeshes(RHG.NurbsSurface surface, Rhino.Display.DisplayPipeline pipeline, DisplayMaterial material)
{
pipeline.DrawBrepShaded(surface.ToBrep(), material);
}
private Topologic.Face BySumSurface(SumSurface ghSumSurface)
{
Rhino.Geometry.NurbsSurface ghNurbsSurface = ghSumSurface.ToNurbsSurface();
return(ByNurbsSurface(ghNurbsSurface));
}
//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
}
/// <summary> btnNewDwgPlane creates new drawing plane perpedicular to camera centered around chosed origin </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnNewDwgPlane_Click(object sender, EventArgs e)
{
Rhino.Geometry.Point3d pt1 = org;
Rhino.Geometry.Transform move1 = Rhino.Geometry.Transform.Translation(view3.MainViewport.CameraX);
Rhino.Geometry.Transform move2 = Rhino.Geometry.Transform.Translation(view3.MainViewport.CameraY);
var xRev = view3.MainViewport.CameraX;
var yRev = view3.MainViewport.CameraY;
xRev.Reverse();
yRev.Reverse();
Rhino.Geometry.Transform move3 = Rhino.Geometry.Transform.Translation(xRev);
Rhino.Geometry.Transform move4 = Rhino.Geometry.Transform.Translation(yRev);
Rhino.Geometry.Point3d pt2 = org;
Rhino.Geometry.Point3d pt3 = org;
Rhino.Geometry.Point3d pt4 = org;
Rhino.Geometry.Point3d pt5 = org;
//Rhino.Geometry.Vector3d.l
pt2.Transform(move1);
pt2.Transform(move2);
pt3.Transform(move3);
pt3.Transform(move4);
pt4.Transform(move1);
pt4.Transform(move4);
pt5.Transform(move3);
pt5.Transform(move2);
srf1 = Rhino.Geometry.NurbsSurface.CreateFromCorners(pt2, pt4, pt3, pt5);
plane1 = new Plane(org, view3.MainViewport.CameraX, view3.MainViewport.CameraY);
Rhino.Geometry.Transform scale1 = Rhino.Geometry.Transform.Scale(org, 400);
srf1.Transform(scale1);
mRhinoDoc.Objects.AddPoint(pt1);
mRhinoDoc.Objects.AddPoint(pt2);
mRhinoDoc.Objects.AddPoint(pt3);
mRhinoDoc.Objects.AddPoint(pt4);
mRhinoDoc.Objects.AddPoint(pt5);
mRhinoDoc.Objects.AddSurface(srf1);
mRhinoDoc.Views.Redraw();
}
/// <summary>
/// Constructs a SurfaceGHData object from a Rhino.Geometry.NurbsSurface
/// </summary>
/// <param name="surface">A Rhino NurbsSurface</param>
public SurfaceGhData(RG.NurbsSurface surface)
{
// TODO: Handle conversion.
Value = null;
}
private Face ByExtrusion(Extrusion ghExtrusion)
{
Rhino.Geometry.NurbsSurface ghNurbsSurface = ghExtrusion.ToNurbsSurface();
return(ByNurbsSurface(ghNurbsSurface));
}
public static global::Topologic.Face ToTopologic(this PlaneSurface planeSurface)
{
Rhino.Geometry.NurbsSurface ghNurbsSurface = planeSurface?.ToNurbsSurface();
return(ghNurbsSurface?.ToTopologic());
}
public NurbsSurface ToNurbsSurface()
{
return(NurbsSurface.CreateFromSphere(this));
}
/***************************************************/
public static RHG.Mesh CreatePreviewMesh(RHG.NurbsSurface surface, RHG.MeshingParameters parameters)
{
return(CreatePreviewMesh(surface.ToBrep(), parameters));
}
