public Curve[] Explode() { IntPtr const_ptr_parent = IntPtr.Zero; IntPtr const_ptr_this = IntPtr.Zero; IntPtr const_ptr_this_dimstyle = IntPtr.Zero; TextObject parent = _GetConstObjectParent() as TextObject; if (null != parent) { const_ptr_parent = parent.ConstPointer(); } else { const_ptr_this = ConstPointer(); //const_ptr_this_dimstyle = ConstPointerForDimStyle(); } var dimstyle = DimensionStyle; if (null == parent) { const_ptr_this_dimstyle = dimstyle.ConstPointer(); } Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr ptr_curves = curves.NonConstPointer(); UnsafeNativeMethods.RHC_RhinoGetTextOutlines(const_ptr_parent, const_ptr_this, const_ptr_this_dimstyle, ptr_curves); GC.KeepAlive(dimstyle); // GC_KeepAlive: Nov. 1, 2018 GC.KeepAlive(parent); // GC_KeepAlive: Nov. 1, 2018 return(curves.ToNonConstArray()); }
/// <summary> /// Constructs an array of <see cref="Hatch">hatches</see> from a set of curves. /// </summary> /// <param name="curves">An array, a list or any enumerable set of <see cref="Curve"/>.</param> /// <param name="hatchPatternIndex">The index of the hatch pattern in the document hatch pattern table.</param> /// <param name="rotationRadians">The relative rotation of the pattern.</param> /// <param name="scale">A scaling factor.</param> /// <param name="tolerance"></param> /// <returns>An array of hatches. The array might be empty on error.</returns> /// <exception cref="ArgumentNullException">If curves is null.</exception> /// <since>6.0</since> public static Hatch[] Create(IEnumerable <Curve> curves, int hatchPatternIndex, double rotationRadians, double scale, double tolerance) { if (curves == null) { throw new ArgumentNullException("curves"); } var curvearray = new Runtime.InteropWrappers.SimpleArrayCurvePointer(curves); IntPtr ptr_curve_array = curvearray.NonConstPointer(); var hatcharray = new Runtime.InteropWrappers.SimpleArrayGeometryPointer(); IntPtr ptr_hatch_array = hatcharray.NonConstPointer(); UnsafeNativeMethods.RHC_RhinoCreateHatches(ptr_curve_array, tolerance, hatchPatternIndex, rotationRadians, scale, ptr_hatch_array); GeometryBase[] g = hatcharray.ToNonConstArray(); if (g == null) { return(new Hatch[0]); } List <Hatch> hatches = new List <Hatch>(); for (int i = 0; i < g.Length; i++) { Hatch hatch = g[i] as Hatch; if (hatch != null) { hatches.Add(hatch); } } GC.KeepAlive(curves); return(hatches.ToArray()); }
/// <summary> /// Explodes this text entity into an array of curves. /// </summary> /// <returns>An array of curves that forms the outline or content of this text entity.</returns> public Curve[] Explode() { IntPtr pConstThis = ConstPointer(); Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr pCurves = curves.NonConstPointer(); UnsafeNativeMethods.ON_TextEntity_Explode(pConstThis, pCurves); return(curves.ToNonConstArray()); }
/// <summary> /// Gets 3d curves that define the boundaries of the hatch /// </summary> /// <param name="outer">true to get the outer curves, false to get the inner curves</param> /// <returns></returns> public Curve[] Get3dCurves(bool outer) { using (Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) { IntPtr pCurveArray = curves.NonConstPointer(); IntPtr pConstThis = ConstPointer(); UnsafeNativeMethods.ON_Hatch_LoopCurve3d(pConstThis, pCurveArray, outer); return(curves.ToNonConstArray()); } }
//skipping // const ON_PolyCurve* PolyProfile() const; // int GetProfileCurves( ON_SimpleArray<const ON_Curve*>& profile_curves ) const; #if RHINO_SDK /// <summary> /// Constructs all the Wireframe curves for this Extrusion. /// </summary> /// <returns>An array of Wireframe curves.</returns> public Curve[] GetWireframe() { IntPtr ptr_const_this = ConstPointer(); using (var output = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) { IntPtr ptr_curve_array = output.NonConstPointer(); UnsafeNativeMethods.CRhinoExtrusionObject_GetWireFrame(ptr_const_this, ptr_curve_array); return(output.ToNonConstArray()); } }
/// <summary> /// Generate geometry that would be used to draw the hatch with a given hatch pattern /// </summary> /// <param name="pattern"></param> /// <param name="patternScale"></param> /// <param name="bounds"></param> /// <param name="lines"></param> /// <param name="solidBrep"></param> public void CreateDisplayGeometry(DocObjects.HatchPattern pattern, double patternScale, out Curve[] bounds, out Line[] lines, out Brep solidBrep) { IntPtr const_ptr_this = ConstPointer(); IntPtr const_ptr_pattern = pattern.ConstPointer(); using (var curve_array = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) using (var line_array = new Runtime.InteropWrappers.SimpleArrayLine()) { IntPtr ptr_curves = curve_array.NonConstPointer(); IntPtr ptr_lines = line_array.NonConstPointer(); IntPtr ptr_brep = UnsafeNativeMethods.CRhinoHatchPattern_CreateDisplay(const_ptr_this, const_ptr_pattern, patternScale, ptr_curves, ptr_lines); solidBrep = (ptr_brep == IntPtr.Zero) ? null : new Brep(ptr_brep, null); bounds = curve_array.ToNonConstArray(); lines = line_array.ToArray(); } }
/// <summary> /// Builds a surface from an autosorted network of curves/edges. /// </summary> /// <param name="curves">An array, a list or any enumerable set of curves/edges, sorted automatically into U and V curves.</param> /// <param name="continuity">continuity along edges, 0 = loose, 1 = pos, 2 = tan, 3 = curvature.</param> /// <param name="edgeTolerance">tolerance to use along network surface edge.</param> /// <param name="interiorTolerance">tolerance to use for the interior curves.</param> /// <param name="angleTolerance">angle tolerance to use.</param> /// <param name="error"> /// If the NurbsSurface could not be created, the error value describes where /// the failure occured. 0 = success, 1 = curve sorter failed, 2 = network initializing failed, /// 3 = failed to build surface, 4 = network surface is not valid. /// </param> /// <returns>A NurbsSurface or null on failure.</returns> public static NurbsSurface CreateNetworkSurface(IEnumerable <Curve> curves, int continuity, double edgeTolerance, double interiorTolerance, double angleTolerance, out int error) { Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer _curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(curves); IntPtr pCurves = _curves.NonConstPointer(); error = 0; IntPtr pNS = UnsafeNativeMethods.RHC_RhinoNetworkSurface2(pCurves, continuity, edgeTolerance, interiorTolerance, angleTolerance, ref error); _curves.Dispose(); if (pNS != IntPtr.Zero) { return(new NurbsSurface(pNS, null)); } return(null); }
/// <summary> /// Builds a surface from an ordered network of curves/edges. /// </summary> /// <param name="uCurves">An array, a list or any enumerable set of U curves.</param> /// <param name="uContinuityStart"> /// continuity at first U segment, 0 = loose, 1 = pos, 2 = tan, 3 = curvature. /// </param> /// <param name="uContinuityEnd"> /// continuity at last U segment, 0 = loose, 1 = pos, 2 = tan, 3 = curvature. /// </param> /// <param name="vCurves">An array, a list or any enumerable set of V curves.</param> /// <param name="vContinuityStart"> /// continuity at first V segment, 0 = loose, 1 = pos, 2 = tan, 3 = curvature. /// </param> /// <param name="vContinuityEnd"> /// continuity at last V segment, 0 = loose, 1 = pos, 2 = tan, 3 = curvature. /// </param> /// <param name="edgeTolerance">tolerance to use along network surface edge.</param> /// <param name="interiorTolerance">tolerance to use for the interior curves.</param> /// <param name="angleTolerance">angle tolerance to use.</param> /// <param name="error"> /// If the NurbsSurface could not be created, the error value describes where /// the failure occured. 0 = success, 1 = curve sorter failed, 2 = network initializing failed, /// 3 = failed to build surface, 4 = network surface is not valid. /// </param> /// <returns>A NurbsSurface or null on failure.</returns> public static NurbsSurface CreateNetworkSurface(IEnumerable <Curve> uCurves, int uContinuityStart, int uContinuityEnd, IEnumerable <Curve> vCurves, int vContinuityStart, int vContinuityEnd, double edgeTolerance, double interiorTolerance, double angleTolerance, out int error) { Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer _uCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(uCurves); Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer _vCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(vCurves); IntPtr pUCurves = _uCurves.NonConstPointer(); IntPtr pVCurves = _vCurves.NonConstPointer(); error = 0; IntPtr pNS = UnsafeNativeMethods.RHC_RhinoNetworkSurface(pUCurves, uContinuityStart, uContinuityEnd, pVCurves, vContinuityStart, vContinuityEnd, edgeTolerance, interiorTolerance, angleTolerance, ref error); _uCurves.Dispose(); _vCurves.Dispose(); if (pNS != IntPtr.Zero) { return(new NurbsSurface(pNS, null)); } return(null); }
public Curve[] CreateCurves(DimensionStyle dimstyle, bool bAllowOpen, double smallCapsScale = 1.0, double spacing = 0.0) { IntPtr const_ptr_parent = IntPtr.Zero; IntPtr const_ptr_this = IntPtr.Zero; TextObject parent = _GetConstObjectParent() as TextObject; if (null != parent) { const_ptr_parent = parent.ConstPointer(); } else { const_ptr_this = ConstPointer(); } Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr ptr_curves = curves.NonConstPointer(); var const_ptr_dimstyle = dimstyle.ConstPointer(); UnsafeNativeMethods.RHC_RhinoGetPlanarCurvesFromText(const_ptr_parent, const_ptr_this, const_ptr_dimstyle, !bAllowOpen, smallCapsScale, spacing, ptr_curves); return(curves.ToNonConstArray()); }
/// <summary> /// Explodes this PolyCurve into a list of Curve segments. This will <b>not explode</b> nested polycurves. /// Call <see cref="RemoveNesting"/> first if you need all individual segments. /// </summary> /// <returns>An array of polycurve segments.</returns> public Curve[] Explode() { Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr pConstThis = ConstPointer(); IntPtr pCurveArray = curves.NonConstPointer(); UnsafeNativeMethods.ON_PolyCurve_SegmentCurves(pConstThis, pCurveArray); int count = UnsafeNativeMethods.ON_CurveArray_Count(pCurveArray); Curve[] rc = new Curve[count]; for (int i = 0; i < count; i++) { IntPtr pConstSegmentCurve = UnsafeNativeMethods.ON_CurveArray_Get(pCurveArray, i); if (IntPtr.Zero == pConstSegmentCurve) { continue; } IntPtr pNewCurve = UnsafeNativeMethods.ON_Curve_DuplicateCurve(pConstSegmentCurve); rc[i] = GeometryBase.CreateGeometryHelper(pNewCurve, null) as Curve; } curves.Dispose(); return(rc); }
/// <summary> /// Explodes this PolyCurve into a list of Curve segments. This will <b>not explode</b> nested polycurves. /// Call <see cref="RemoveNesting"/> first if you need all individual segments. /// </summary> /// <returns>An array of polycurve segments.</returns> public Curve[] Explode() { Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr pConstThis = ConstPointer(); IntPtr pCurveArray = curves.NonConstPointer(); UnsafeNativeMethods.ON_PolyCurve_SegmentCurves(pConstThis, pCurveArray); int count = UnsafeNativeMethods.ON_CurveArray_Count(pCurveArray); Curve[] rc = new Curve[count]; for (int i = 0; i < count; i++) { IntPtr pConstSegmentCurve = UnsafeNativeMethods.ON_CurveArray_Get(pCurveArray, i); if (IntPtr.Zero == pConstSegmentCurve) continue; IntPtr pNewCurve = UnsafeNativeMethods.ON_Curve_DuplicateCurve(pConstSegmentCurve); rc[i] = GeometryBase.CreateGeometryHelper(pNewCurve, null) as Curve; } curves.Dispose(); return rc; }
/// <summary> /// Executes unrolling operations. /// </summary> /// <param name="unrolledCurves">An array of unrolled curves is assigned during the call in this out parameter.</param> /// <param name="unrolledPoints">An array of unrolled points is assigned during the call in this out parameter.</param> /// <param name="unrolledDots">An array of unrolled text dots is assigned during the call in this out parameter.</param> /// <returns>An array of breps. This array can be empty.</returns> /// <since>5.0</since> public Brep[] PerformUnroll(out Curve[] unrolledCurves, out Point3d[] unrolledPoints, out TextDot[] unrolledDots) { unrolledCurves = new Curve[0]; unrolledPoints = new Point3d[0]; unrolledDots = new TextDot[0]; IntPtr ptr_unroller = IntPtr.Zero; if (m_surface != null) { IntPtr const_ptr_surface = m_surface.ConstPointer(); ptr_unroller = UnsafeNativeMethods.CRhinoUnroll_NewSrf(const_ptr_surface, m_absolute_tolerance, m_relative_tolerance); } else if (m_brep != null) { IntPtr const_ptr_brep = m_brep.ConstPointer(); ptr_unroller = UnsafeNativeMethods.CRhinoUnroll_NewBrp(const_ptr_brep, m_absolute_tolerance, m_relative_tolerance); } if (ptr_unroller == IntPtr.Zero) { throw new Exception("Unable to access input surface or brep"); } var rc = new Brep[0]; if (0 == UnsafeNativeMethods.CRhinoUnroll_PrepareFaces(ptr_unroller)) { if (m_curves.Count > 0) { var crvs = new Runtime.InteropWrappers.SimpleArrayCurvePointer(m_curves); IntPtr const_ptr_curves = crvs.ConstPointer(); UnsafeNativeMethods.CRhinoUnroll_PrepareCurves(ptr_unroller, const_ptr_curves); } if (m_points.Count > 0) { Point3d[] pts = m_points.ToArray(); UnsafeNativeMethods.CRhinoUnroll_PreparePoints(ptr_unroller, pts.Length, pts); } if (m_dots.Count > 0) { using (var dots = new Runtime.InteropWrappers.SimpleArrayGeometryPointer(m_dots)) { IntPtr const_ptr_dots = dots.ConstPointer(); UnsafeNativeMethods.CRhinoUnroll_PrepareDots(ptr_unroller, const_ptr_dots); } } int brep_count = 0; int curve_count = 0; int point_count = 0; int dot_count = 0; double explode_dist = -1; if (m_explode_output) { explode_dist = m_explode_spacing; } IntPtr ptr_results = UnsafeNativeMethods.CRhinoUnroll_CreateFlatBreps(ptr_unroller, explode_dist, ref brep_count, ref curve_count, ref point_count, ref dot_count); if (ptr_results != IntPtr.Zero) { if (brep_count > 0) { rc = new Brep[brep_count]; for (int i = 0; i < brep_count; i++) { IntPtr ptr_brep = UnsafeNativeMethods.CRhinoUnrollResults_GetBrep(ptr_results, i); if (ptr_brep != IntPtr.Zero) { rc[i] = new Brep(ptr_brep, null); } } } if (curve_count > 0) { unrolledCurves = new Curve[curve_count]; for (int i = 0; i < curve_count; i++) { IntPtr ptr_curve = UnsafeNativeMethods.CRhinoUnrollResults_GetCurve(ptr_results, i); if (ptr_curve != IntPtr.Zero) { unrolledCurves[i] = new Curve(ptr_curve, null); } } } if (point_count > 0) { unrolledPoints = new Point3d[point_count]; UnsafeNativeMethods.CRhinoUnrollResults_GetPoints(ptr_results, point_count, unrolledPoints); } if (dot_count > 0) { unrolledDots = new TextDot[dot_count]; for (int i = 0; i < dot_count; i++) { IntPtr ptr_dots = UnsafeNativeMethods.CRhinoUnrollResults_GetDot(ptr_results, i); if (ptr_dots != IntPtr.Zero) { unrolledDots[i] = new TextDot(ptr_dots, null); } } } UnsafeNativeMethods.CRhinoUnrollResults_Delete(ptr_results); } } UnsafeNativeMethods.CRhinoUnroll_Delete(ptr_unroller); return(rc); }
/// <summary> /// Intersects a Brep and a Surface. /// </summary> /// <param name="brep">A brep to be intersected.</param> /// <param name="surface">A surface to be intersected.</param> /// <param name="tolerance">A tolerance value.</param> /// <param name="intersectionCurves">The intersection curves array argument. This out reference is assigned during the call.</param> /// <param name="intersectionPoints">The intersection points array argument. This out reference is assigned during the call.</param> /// <returns>true on success; false on failure.</returns> public static bool BrepSurface(Brep brep, Surface surface, double tolerance, out Curve[] intersectionCurves, out Point3d[] intersectionPoints) { intersectionCurves = new Curve[0]; intersectionPoints = new Point3d[0]; Runtime.InteropWrappers.SimpleArrayPoint3d outputPoints = new Runtime.InteropWrappers.SimpleArrayPoint3d(); IntPtr outputPointsPtr = outputPoints.NonConstPointer(); Runtime.InteropWrappers.SimpleArrayCurvePointer outputCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr outputCurvesPtr = outputCurves.NonConstPointer(); IntPtr brepPtr = brep.ConstPointer(); IntPtr surfacePtr = surface.ConstPointer(); bool rc = UnsafeNativeMethods.ON_Intersect_BrepSurface(brepPtr, surfacePtr, tolerance, outputCurvesPtr, outputPointsPtr); if (rc) { intersectionCurves = outputCurves.ToNonConstArray(); intersectionPoints = outputPoints.ToArray(); } outputPoints.Dispose(); outputCurves.Dispose(); return rc; }
/// <summary> /// Generate geometry that would be used to draw the hatch with a given hatch pattern /// </summary> /// <param name="pattern"></param> /// <param name="patternScale"></param> /// <param name="bounds"></param> /// <param name="lines"></param> /// <param name="solidBrep"></param> public void CreateDisplayGeometry(DocObjects.HatchPattern pattern, double patternScale, out Curve[] bounds, out Line[] lines, out Brep solidBrep) { IntPtr const_ptr_this = ConstPointer(); IntPtr const_ptr_pattern = pattern.ConstPointer(); using(var curve_array = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) using(var line_array = new Runtime.InteropWrappers.SimpleArrayLine()) { IntPtr ptr_curves = curve_array.NonConstPointer(); IntPtr ptr_lines = line_array.NonConstPointer(); IntPtr ptr_brep = UnsafeNativeMethods.CRhinoHatchPattern_CreateDisplay(const_ptr_this, const_ptr_pattern, patternScale, ptr_curves, ptr_lines); solidBrep = (ptr_brep==IntPtr.Zero) ? null : new Brep(ptr_brep, null); bounds = curve_array.ToNonConstArray(); lines = line_array.ToArray(); } }
/// <summary> /// Gets 3d curves that define the boundaries of the hatch /// </summary> /// <param name="outer">true to get the outer curves, false to get the inner curves</param> /// <returns></returns> public Curve[] Get3dCurves(bool outer) { using (Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) { IntPtr pCurveArray = curves.NonConstPointer(); IntPtr pConstThis = ConstPointer(); UnsafeNativeMethods.ON_Hatch_LoopCurve3d(pConstThis, pCurveArray, outer); return curves.ToNonConstArray(); } }
/// <summary> /// Explodes this text entity into an array of curves. /// </summary> /// <returns>An array of curves that forms the outline or content of this text entity.</returns> public Curve[] Explode() { IntPtr pConstThis = ConstPointer(); Runtime.InteropWrappers.SimpleArrayCurvePointer curves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr pCurves = curves.NonConstPointer(); UnsafeNativeMethods.ON_TextEntity_Explode(pConstThis, pCurves); return curves.ToNonConstArray(); }
/// <summary> /// Intersects a curve with a Brep face. /// </summary> /// <param name="curve">A curve.</param> /// <param name="face">A brep face.</param> /// <param name="tolerance">Fitting and near miss tolerance.</param> /// <param name="overlapCurves">A overlap curves array argument. This out reference is assigned during the call.</param> /// <param name="intersectionPoints">A points array argument. This out reference is assigned during the call.</param> /// <returns>true on success, false on failure.</returns> public static bool CurveBrepFace(Curve curve, BrepFace face, double tolerance, out Curve[] overlapCurves, out Point3d[] intersectionPoints) { overlapCurves = new Curve[0]; intersectionPoints = new Point3d[0]; Runtime.InteropWrappers.SimpleArrayPoint3d outputPoints = new Runtime.InteropWrappers.SimpleArrayPoint3d(); IntPtr outputPointsPtr = outputPoints.NonConstPointer(); Runtime.InteropWrappers.SimpleArrayCurvePointer outputCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr outputCurvesPtr = outputCurves.NonConstPointer(); IntPtr curvePtr = curve.ConstPointer(); IntPtr facePtr = face.ConstPointer(); bool rc = UnsafeNativeMethods.RHC_RhinoCurveFaceIntersect(curvePtr, facePtr, tolerance, outputCurvesPtr, outputPointsPtr); if (rc) { overlapCurves = outputCurves.ToNonConstArray(); intersectionPoints = outputPoints.ToArray(); } outputPoints.Dispose(); outputCurves.Dispose(); return rc; }
/// <summary> /// Intersects two Surfaces. /// </summary> /// <param name="surfaceA">First Surface for intersection.</param> /// <param name="surfaceB">Second Surface for intersection.</param> /// <param name="tolerance">Intersection tolerance.</param> /// <param name="intersectionCurves">The intersection curves will be returned here.</param> /// <param name="intersectionPoints">The intersection points will be returned here.</param> /// <returns>true on success, false on failure.</returns> public static bool SurfaceSurface(Surface surfaceA, Surface surfaceB, double tolerance, out Curve[] intersectionCurves, out Point3d[] intersectionPoints) { intersectionCurves = new Curve[0]; intersectionPoints = new Point3d[0]; Runtime.InteropWrappers.SimpleArrayPoint3d outputPoints = new Runtime.InteropWrappers.SimpleArrayPoint3d(); IntPtr outputPointsPtr = outputPoints.NonConstPointer(); Runtime.InteropWrappers.SimpleArrayCurvePointer outputCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer(); IntPtr outputCurvesPtr = outputCurves.NonConstPointer(); IntPtr srfPtrA = surfaceA.ConstPointer(); IntPtr srfPtrB = surfaceB.ConstPointer(); bool rc = UnsafeNativeMethods.RHC_RhinoIntersectSurfaces( srfPtrA, srfPtrB, tolerance, outputCurvesPtr, outputPointsPtr); if (rc) { intersectionCurves = outputCurves.ToNonConstArray(); intersectionPoints = outputPoints.ToArray(); } outputPoints.Dispose(); outputCurves.Dispose(); return rc; }
//skipping // const ON_PolyCurve* PolyProfile() const; // int GetProfileCurves( ON_SimpleArray<const ON_Curve*>& profile_curves ) const; #if RHINO_SDK /// <summary> /// Constructs all the Wireframe curves for this Extrusion. /// </summary> /// <returns>An array of Wireframe curves.</returns> public Curve[] GetWireframe() { IntPtr ptr_const_this = ConstPointer(); using (var output = new Runtime.InteropWrappers.SimpleArrayCurvePointer()) { IntPtr ptr_curve_array = output.NonConstPointer(); UnsafeNativeMethods.CRhinoExtrusionObject_GetWireFrame(ptr_const_this, ptr_curve_array); return output.ToNonConstArray(); } }