private void SetCurveType(Rg.Curve curve)
{
Rg.Circle R = new Rg.Circle();
Rg.Arc A = new Rg.Arc();
Rg.Ellipse S = new Rg.Ellipse();
Rg.Polyline P = new Rg.Polyline();
if (curve.TryGetCircle(out R))
{
curveType = CurveTypes.Circle;
}
else if (curve.TryGetArc(out A))
{
curveType = CurveTypes.Arc;
}
else if (curve.TryGetEllipse(out S))
{
curveType = CurveTypes.Ellipse;
}
else if (curve.IsLinear())
{
curveType = CurveTypes.Line;
}
else if (curve.TryGetPolyline(out P))
{
curveType = CurveTypes.Polyline;
}
else
{
curveType = CurveTypes.Spline;
}
}
/***************************************************/
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());
}
}
/***************************************************/
private static BHG.ICurve ToBHoMTrimCurve(this RHG.Curve curve)
{
if (curve.IsArc())
{
RHG.Arc arc;
curve.TryGetArc(out arc);
return(arc.FromRhino());
}
else
{
return(curve.FromRhino());
}
}
/// <summary>
/// Convert a Rhino curve to a Nucleus one
/// </summary>
/// <param name="curve"></param>
/// <returns></returns>
public static Curve Convert(RC.Curve curve)
{
if (curve == null)
{
return(null);
}
if (curve is RC.LineCurve)
{
return(Convert((RC.LineCurve)curve));
}
else if (curve.IsLinear())
{
return(Convert(new RC.Line(curve.PointAtStart, curve.PointAtEnd)));
}
else if (curve.IsPolyline())
{
RC.Polyline pLine;
if (curve.TryGetPolyline(out pLine))
{
return(Convert(pLine));
}
}
else if (curve is RC.PolyCurve)
{
return(Convert((RC.PolyCurve)curve));
}
else if (curve.IsArc())
{
RC.Arc arc;
if (curve.TryGetArc(out arc))
{
return(Convert(arc));
}
}
throw new NotImplementedException();
}