protected CustomBrepObject(Brep brep) : base(true) { IntPtr pConstBrep = brep.ConstPointer(); m_pRhinoObject = UnsafeNativeMethods.CRhinoCustomObject_New2(pConstBrep); }
protected CustomBrepObject(Brep brep) : base(true) { Guid type_id = GetType().GUID; IntPtr const_ptr_brep = brep.ConstPointer(); m_pRhinoObject = UnsafeNativeMethods.CRhinoCustomObject_New2(type_id, const_ptr_brep); }
/// <summary> /// Compute the VolumeMassProperties for a single Brep. /// </summary> /// <param name="brep">Brep to measure.</param> /// <returns>The VolumeMassProperties for the given Brep or null on failure.</returns> /// <exception cref="System.ArgumentNullException">When brep is null.</exception> public static VolumeMassProperties Compute(Brep brep) { if (brep == null) { throw new ArgumentNullException("brep"); } IntPtr pBrep = brep.ConstPointer(); const double relativeTolerance = 1.0e-6; const double absoluteTolerance = 1.0e-6; IntPtr rc = UnsafeNativeMethods.ON_Brep_MassProperties(false, pBrep, relativeTolerance, absoluteTolerance); return(IntPtr.Zero == rc ? null : new VolumeMassProperties(rc, false)); }
/// <summary> /// Compute the VolumeMassProperties for a single Brep. /// </summary> /// <param name="brep">Brep to measure.</param> /// <param name="volume">true to calculate volume.</param> /// <param name="firstMoments">true to calculate volume first moments, volume, and volume centroid.</param> /// <param name="secondMoments">true to calculate volume second moments.</param> /// <param name="productMoments">true to calculate volume product moments.</param> /// <returns>The VolumeMassProperties for the given Brep or null on failure.</returns> /// <exception cref="System.ArgumentNullException">When brep is null.</exception> /// <since>6.3</since> public static VolumeMassProperties Compute(Brep brep, bool volume, bool firstMoments, bool secondMoments, bool productMoments) { if (brep == null) { throw new ArgumentNullException(nameof(brep)); } IntPtr pBrep = brep.ConstPointer(); const double relative_tolerance = 1.0e-6; const double absolute_tolerance = 1.0e-6; IntPtr rc = UnsafeNativeMethods.ON_Brep_MassProperties(false, pBrep, volume, firstMoments, secondMoments, productMoments, relative_tolerance, absolute_tolerance); GC.KeepAlive(brep); return(IntPtr.Zero == rc ? null : new VolumeMassProperties(rc, false)); }
/// <summary> /// Projects a Curve onto a Brep along a given direction. /// </summary> /// <param name="curve">Curve to project.</param> /// <param name="brep">Brep to project onto.</param> /// <param name="direction">Direction of projection.</param> /// <param name="tolerance">Tolerance to use for projection.</param> /// <returns>An array of projected curves or empty array if the projection set is empty.</returns> public static Curve[] ProjectToBrep(Curve curve, Brep brep, Vector3d direction, double tolerance) { IntPtr brep_ptr = brep.ConstPointer(); IntPtr curve_ptr = curve.ConstPointer(); using (SimpleArrayCurvePointer rc = new SimpleArrayCurvePointer()) { IntPtr rc_ptr = rc.NonConstPointer(); return UnsafeNativeMethods.RHC_RhinoProjectCurveToBrep(brep_ptr, curve_ptr, direction, tolerance, rc_ptr) ? rc.ToNonConstArray() : new Curve[0]; } }
/// <summary> /// Splits a curve into pieces using a polysurface. /// </summary> /// <param name="cutter">A cutting surface or polysurface.</param> /// <param name="tolerance">A tolerance for computing intersections.</param> /// <returns>An array of curves. This array can be empty.</returns> public Curve[] Split(Brep cutter, double tolerance) { if (cutter == null) throw new ArgumentNullException("cutter"); IntPtr pConstThis = ConstPointer(); IntPtr pConstBrep = cutter.ConstPointer(); using (Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer pieces = new SimpleArrayCurvePointer()) { IntPtr pPieces = pieces.NonConstPointer(); UnsafeNativeMethods.RHC_RhinoCurveSplit(pConstThis, pConstBrep, tolerance, pPieces); return pieces.ToNonConstArray(); } }
/// <summary> /// Draws all the wireframe curves of a brep object. /// </summary> /// <param name="brep">Brep to draw.</param> /// <param name="color">Color of Wireframe curves.</param> /// <param name="wireDensity"> /// "Density" of wireframe curves. /// <para>-1 = no internal wires.</para> /// <para> 0 = default internal wires.</para> /// <para>>0 = custom high density.</para> /// </param> public void DrawBrepWires(Brep brep, System.Drawing.Color color, int wireDensity) { int argb = color.ToArgb(); IntPtr pBrep = brep.ConstPointer(); UnsafeNativeMethods.CRhinoDisplayPipeline_DrawBrep(m_ptr, pBrep, argb, wireDensity); }
/// <summary> /// Draws a shaded mesh representation of a brep. /// </summary> /// <param name="brep">Brep to draw.</param> /// <param name="material">Material to draw faces with.</param> public void DrawBrepShaded(Brep brep, DisplayMaterial material) { IntPtr pBrep = brep.ConstPointer(); IntPtr pMaterial = IntPtr.Zero; if (null != material) pMaterial = material.ConstPointer(); UnsafeNativeMethods.CRhinoDisplayPipeline_DrawShadedBrep(m_ptr, pBrep, pMaterial); }
/// <summary> /// Compute the VolumeMassProperties for a single Brep. /// </summary> /// <param name="brep">Brep to measure.</param> /// <returns>The VolumeMassProperties for the given Brep or null on failure.</returns> /// <exception cref="System.ArgumentNullException">When brep is null.</exception> public static VolumeMassProperties Compute(Brep brep) { if (brep == null) throw new ArgumentNullException("brep"); IntPtr pBrep = brep.ConstPointer(); const double relativeTolerance = 1.0e-6; const double absoluteTolerance = 1.0e-6; IntPtr rc = UnsafeNativeMethods.ON_Brep_MassProperties(false, pBrep, relativeTolerance, absoluteTolerance); return IntPtr.Zero == rc ? null : new VolumeMassProperties(rc, false); }
/// <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> /// Intersects a curve with a Brep. This function returns the 3D points of intersection /// and 3D overlap curves. If an error occurs while processing overlap curves, this function /// will return false, but it will still provide partial results. /// </summary> /// <param name="curve">Curve for intersection.</param> /// <param name="brep">Brep for intersection.</param> /// <param name="tolerance">Fitting and near miss tolerance.</param> /// <param name="overlapCurves">The overlap 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> /// <example> /// <code source='examples\vbnet\ex_elevation.vb' lang='vbnet'/> /// <code source='examples\cs\ex_elevation.cs' lang='cs'/> /// <code source='examples\py\ex_elevation.py' lang='py'/> /// </example> public static bool CurveBrep(Curve curve, Brep brep, 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 brepPtr = brep.ConstPointer(); bool rc = UnsafeNativeMethods.ON_Intersect_CurveBrep(curvePtr, brepPtr, tolerance, outputCurvesPtr, outputPointsPtr); if (rc) { overlapCurves = outputCurves.ToNonConstArray(); intersectionPoints = outputPoints.ToArray(); } outputPoints.Dispose(); outputCurves.Dispose(); return rc; }
protected CustomBrepObject(Brep brep) : base(true) { Guid type_id = GetType().GUID; IntPtr pConstBrep = brep.ConstPointer(); m_pRhinoObject = UnsafeNativeMethods.CRhinoCustomObject_New2(type_id, pConstBrep); }