public static Curve ToCurve(RG.Curve value, double factor)
{
switch (value)
{
case RG.NurbsCurve nurbsCurve:
return(ToCurve(nurbsCurve, factor));
default:
return(ToCurve(value.ToNurbsCurve(), factor));
}
}
/***************************************************/
public static BHG.ICurve FromRhino(this RHG.Curve rCurve)
{
if (rCurve == null)
{
return(null);
}
Type curveType = rCurve.GetType();
if (rCurve.IsLinear() && rCurve.SpanCount < 2)
{
return(new BHG.Line {
Start = rCurve.PointAtStart.FromRhino(), End = rCurve.PointAtEnd.FromRhino(), Infinite = false
});
}
if (rCurve.IsCircle())
{
RHG.Circle circle = new RHG.Circle();
rCurve.TryGetCircle(out circle);
return(circle.FromRhino());
}
else if (rCurve.IsArc() || typeof(RHG.ArcCurve).IsAssignableFrom(curveType))
{
RHG.Arc arc = new RHG.Arc();
rCurve.TryGetArc(out arc);
return(arc.FromRhino());
}
else if (rCurve.IsPolyline() || typeof(RHG.PolylineCurve).IsAssignableFrom(curveType))
{
RHG.Polyline polyline = new RHG.Polyline();
rCurve.TryGetPolyline(out polyline);
return(polyline.FromRhino());
}
else if (rCurve.IsClosed && rCurve.IsEllipse())
{
RHG.Ellipse ellipse = new RHG.Ellipse();
rCurve.TryGetEllipse(out ellipse);
return(ellipse.FromRhino());
}
else if (rCurve is RHG.NurbsCurve)
{
return(((RHG.NurbsCurve)rCurve).FromRhino());
}
else if (rCurve is RHG.PolyCurve)
{
return(((RHG.PolyCurve)rCurve).FromRhino()); //The test of IsPolyline above is very important to make sure we can cast to PolyCurve here
}
else
{
return((rCurve.ToNurbsCurve()).FromRhino());
}
}
public static string ToSVG(this Rg.Curve input)
{
Rg.NurbsCurve nurbs = input.ToNurbsCurve();
nurbs.MakePiecewiseBezier(true);
Rhino.Geometry.BezierCurve[] bezier = Rg.BezierCurve.CreateCubicBeziers(nurbs, 0, 0);
string output = "M " + input.PointAtStart.ToSVG();
for (int i = 0; i < bezier.Count(); i++)
{
output += " C " + bezier[i].GetControlVertex3d(1).ToSVG() + bezier[i].GetControlVertex3d(2).ToSVG() + bezier[i].GetControlVertex3d(3).ToSVG();
}
output += " ";
return(output);
}
/// <summary>
/// Returns a Windows Media Bezier Spline Path Geometry from a Rhinocommon Curve
/// </summary>
/// <param name="input">Rhinocommon Curve</param>
/// <returns>System Windows Media Bezier Curve Path Geometry </returns>
public static Sm.PathGeometry ToGeometry(this Rg.Curve input)
{
Rg.NurbsCurve nurbsCurve = input.ToNurbsCurve();
nurbsCurve.MakePiecewiseBezier(true);
Rg.BezierCurve[] bezier = Rg.BezierCurve.CreateCubicBeziers(nurbsCurve, 0, 0);
Sm.PathFigure figure = new Sm.PathFigure();
Sm.PathGeometry geometry = new Sm.PathGeometry();
Sm.PathFigureCollection figureCollection = new Sm.PathFigureCollection();
Sm.PathSegmentCollection segmentCollection = new Sm.PathSegmentCollection();
figure.StartPoint = bezier[0].GetControlVertex3d(0).ToWindowsPoint();
for (int i = 0; i < bezier.Count(); i++)
{
Sm.BezierSegment segment = new Sm.BezierSegment(bezier[i].GetControlVertex3d(1).ToWindowsPoint(), bezier[i].GetControlVertex3d(2).ToWindowsPoint(), bezier[i].GetControlVertex3d(3).ToWindowsPoint(), true);
segmentCollection.Add(segment);
}
figure.Segments = segmentCollection;
figureCollection.Add(figure);
geometry.Figures = figureCollection;
return(geometry);
}
static internal IEnumerable <Autodesk.Revit.DB.Curve> ToHost(this Rhino.Geometry.Curve curve, double curveTolerance = double.PositiveInfinity)
{
curveTolerance = Math.Min(Revit.ShortCurveTolerance, Math.Abs(curveTolerance));
Debug.Assert(!curve.IsShort(curveTolerance));
var simplifiedCurve = curve.Simplify(CurveSimplifyOptions.SplitAtFullyMultipleKnots, curveTolerance, Revit.AngleTolerance);
if (simplifiedCurve != null)
{
curve = simplifiedCurve;
}
switch (curve)
{
case Rhino.Geometry.LineCurve line:
yield return(Autodesk.Revit.DB.Line.CreateBound(line.PointAtStart.ToHost(), line.PointAtEnd.ToHost()));
break;
case Rhino.Geometry.PolylineCurve polyline:
for (int p = 1; p < polyline.PointCount; ++p)
{
yield return(Autodesk.Revit.DB.Line.CreateBound(polyline.Point(p - 1).ToHost(), polyline.Point(p).ToHost()));
}
break;
case Rhino.Geometry.ArcCurve arc:
if (arc.IsClosed)
{
yield return(Autodesk.Revit.DB.Arc.Create(arc.Arc.Plane.ToHost(), arc.Arc.Radius, 0.0, (2.0 * Math.PI) - 2e-8));
}
else
{
yield return(Autodesk.Revit.DB.Arc.Create(arc.Arc.StartPoint.ToHost(), arc.Arc.EndPoint.ToHost(), arc.Arc.MidPoint.ToHost()));
}
break;
case Rhino.Geometry.PolyCurve polyCurve:
polyCurve.RemoveNesting();
polyCurve.RemoveShortSegments(curveTolerance);
for (int s = 0; s < polyCurve.SegmentCount; ++s)
{
foreach (var segment in polyCurve.SegmentCurve(s).ToHost())
{
yield return(segment);
}
}
break;
case Rhino.Geometry.NurbsCurve nurbsCurve:
if (nurbsCurve.IsLinear(Revit.VertexTolerance))
{
yield return(Autodesk.Revit.DB.Line.CreateBound(nurbsCurve.PointAtStart.ToHost(), nurbsCurve.PointAtEnd.ToHost()));
yield break;
}
if (nurbsCurve.TryGetPolyline(out var polylineSegment))
{
polylineSegment.ReduceSegments(curveTolerance);
foreach (var segment in polylineSegment.GetSegments())
{
yield return(Autodesk.Revit.DB.Line.CreateBound(segment.From.ToHost(), segment.To.ToHost()));
}
yield break;
}
if (nurbsCurve.TryGetArc(out var arcSegment, Revit.VertexTolerance))
{
yield return(Autodesk.Revit.DB.Arc.Create(arcSegment.StartPoint.ToHost(), arcSegment.EndPoint.ToHost(), arcSegment.MidPoint.ToHost()));
yield break;
}
if (nurbsCurve.IsClosed)
{
if (nurbsCurve.TryGetCircle(out var circle, Revit.VertexTolerance))
{
yield return(Autodesk.Revit.DB.Arc.Create(circle.Plane.ToHost(), circle.Radius, 0.0, 2.0 * (2.0 * Math.PI) - 2e-8));
yield break;
}
if (nurbsCurve.TryGetEllipse(out var ellipse, Revit.VertexTolerance))
{
yield return(Autodesk.Revit.DB.Ellipse.CreateCurve(ellipse.Plane.Origin.ToHost(), ellipse.Radius1, ellipse.Radius2, ellipse.Plane.XAxis.ToHost(), ellipse.Plane.YAxis.ToHost(), 0.0, (2.0 * Math.PI) - 2e-8));
yield break;
}
foreach (var segment in nurbsCurve.Split(nurbsCurve.Domain.Mid))
{
foreach (var c in segment.ToHost())
{
yield return(c);
}
}
}
else
{
nurbsCurve.Knots.RemoveMultipleKnots(1, nurbsCurve.Degree, Revit.VertexTolerance);
var degree = nurbsCurve.Degree;
var knots = nurbsCurve.Knots.ToHost();
var controlPoints = nurbsCurve.Points.ToHost();
Debug.Assert(degree >= 1);
Debug.Assert(controlPoints.Count > nurbsCurve.Degree);
Debug.Assert(knots.Count == nurbsCurve.Degree + controlPoints.Count + 1);
Autodesk.Revit.DB.Curve nurbSpline = null;
try
{
if (nurbsCurve.IsRational)
{
var weights = new List <double>(controlPoints.Count);
foreach (var p in nurbsCurve.Points)
{
Debug.Assert(p.Weight > 0.0);
weights.Add(p.Weight);
}
Debug.Assert(weights.Count == controlPoints.Count);
nurbSpline = NurbSpline.CreateCurve(nurbsCurve.Degree, knots, controlPoints, weights);
}
else
{
nurbSpline = NurbSpline.CreateCurve(nurbsCurve.Degree, knots, controlPoints);
}
}
catch (Autodesk.Revit.Exceptions.ApplicationException e)
{
Debug.Fail(e.Source, e.Message);
}
yield return(nurbSpline);
}
break;
default:
foreach (var c in curve.ToNurbsCurve().ToHost())
{
yield return(c);
}
break;
}
}
static internal IEnumerable <Autodesk.Revit.DB.Curve> ToHost(this Rhino.Geometry.Curve curve)
{
var simplifiedCurve = curve.Simplify(CurveSimplifyOptions.SplitAtFullyMultipleKnots, Revit.ModelAbsoluteTolerance, Math.PI / 1800.0);
if (simplifiedCurve != null)
{
curve = simplifiedCurve;
}
switch (curve)
{
case Rhino.Geometry.PolyCurve polyCurve:
polyCurve.RemoveNesting();
for (int s = 0; s < polyCurve.SegmentCount; ++s)
{
foreach (var segment in polyCurve.SegmentCurve(s).ToHost())
{
yield return(segment);
}
}
break;
case Rhino.Geometry.NurbsCurve nurbsCurve:
if (nurbsCurve.IsClosed)
{
foreach (var segment in nurbsCurve.Split(nurbsCurve.Domain.Mid))
{
foreach (var c in segment.ToHost())
{
yield return(c);
}
}
}
else
{
nurbsCurve.Knots.RemoveMultipleKnots(1, nurbsCurve.Degree, Revit.ModelAbsoluteTolerance);
var degree = nurbsCurve.Degree;
var knots = nurbsCurve.Knots.ToHost();
var controlPoints = nurbsCurve.Points.ToHost();
Debug.Assert(degree >= 1);
Debug.Assert(controlPoints.Count > nurbsCurve.Degree);
Debug.Assert(knots.Count == nurbsCurve.Degree + controlPoints.Count + 1);
Autodesk.Revit.DB.Curve nurbSpline = null;
try
{
if (nurbsCurve.IsRational)
{
var weights = new List <double>(controlPoints.Count);
foreach (var p in nurbsCurve.Points)
{
Debug.Assert(p.Weight > 0.0);
weights.Add(p.Weight);
}
Debug.Assert(weights.Count == controlPoints.Count);
nurbSpline = NurbSpline.CreateCurve(nurbsCurve.Degree, knots, controlPoints, weights);
}
else
{
nurbSpline = NurbSpline.CreateCurve(nurbsCurve.Degree, knots, controlPoints);
}
}
catch (Autodesk.Revit.Exceptions.ApplicationException e)
{
Debug.Fail(e.Source, e.Message);
}
yield return(nurbSpline);
}
break;
default:
foreach (var c in ToHost(curve.ToNurbsCurve()))
{
yield return(c);
}
break;
}
}
protected bool CurveSegments(List<Curve> L, Curve crv, bool recursive)
{
if (crv == null) { return false; }
PolyCurve polycurve = crv as PolyCurve;
if (polycurve != null)
{
if (recursive) { polycurve.RemoveNesting(); }
Curve[] segments = polycurve.Explode();
if (segments == null) { return false; }
if (segments.Length == 0) { return false; }
if (recursive)
{
foreach (Curve S in segments)
{
CurveSegments(L, S, true);
}
}
else
{
foreach (Curve S in segments)
{
L.Add(S.DuplicateShallow() as Curve);
}
}
return true;
}
PolylineCurve polyline = crv as PolylineCurve;
if (polyline != null)
{
if (recursive)
{
for (int i = 0; i < (polyline.PointCount - 1); i++)
{
L.Add(new LineCurve(polyline.Point(i), polyline.Point(i + 1)));
}
}
else
{
L.Add(polyline.DuplicateCurve());
}
return true;
}
Polyline p;
if (crv.TryGetPolyline(out p))
{
if (recursive)
{
for (int i = 0; i < (p.Count - 1); i++)
{
L.Add(new LineCurve(p[i], p[i + 1]));
}
}
else
{
L.Add(new PolylineCurve(p));
}
return true;
}
//Maybe it's a LineCurve?
LineCurve line = crv as LineCurve;
if (line != null)
{
L.Add(line.DuplicateCurve());
return true;
}
//It might still be an ArcCurve...
ArcCurve arc = crv as ArcCurve;
if (arc != null)
{
L.Add(arc.DuplicateCurve());
return true;
}
//Nothing else worked, lets assume it's a nurbs curve and go from there...
NurbsCurve nurbs = crv.ToNurbsCurve();
if (nurbs == null) { return false; }
double t0 = nurbs.Domain.Min;
double t1 = nurbs.Domain.Max;
int LN = L.Count;
do
{
double t;
if (!nurbs.GetNextDiscontinuity(Continuity.C1_locus_continuous, t0, t1, out t)) { break; }
Interval trim = new Interval(t0, t);
if (trim.Length < 1e-10)
{
t0 = t;
continue;
}
Curve M = nurbs.DuplicateCurve();
M = M.Trim(trim);
if (M.IsValid) { L.Add(M); }
t0 = t;
} while (true);
if (L.Count == LN) { L.Add(nurbs); }
return true;
}
