C# Curve.ConstPointer方法代码示例

    /// <summary>
    /// Intersects a (sub)curve and a surface.
    /// </summary>
    /// <param name="curve">Curve for intersection.</param>
    /// <param name="curveDomain">Domain of surbcurve to take into consideration for Intersections.</param>
    /// <param name="surface">Surface for intersection.</param>
    /// <param name="tolerance">Intersection tolerance. If the curve approaches the surface to within tolerance, 
    /// an intersection is assumed.</param>
    /// <param name="overlapTolerance">The tolerance with which the curves are tested.</param>
    /// <returns>A collection of intersection events.</returns>
    public static CurveIntersections CurveSurface(Curve curve, Interval curveDomain, Surface surface, double tolerance, double overlapTolerance)
    {
      Interval domain = curve.Domain;
      double t0 = Math.Max(domain.Min, curveDomain.Min);
      double t1 = Math.Min(domain.Max, curveDomain.Max);
      if (t0 >= t1) { return null; }

      IntPtr pCurve = curve.ConstPointer();
      IntPtr pSurface = surface.ConstPointer();
      IntPtr pIntersectArray = UnsafeNativeMethods.ON_Intersect_CurveSurface2(pCurve, pSurface, t0, t1, tolerance, overlapTolerance);
      return CurveIntersections.Create(pIntersectArray);
    }

    /// <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>
 /// Finds the intersections between two curves. 
 /// </summary>
 /// <param name="curveA">First curve for intersection.</param>
 /// <param name="curveB">Second curve for intersection.</param>
 /// <param name="tolerance">Intersection tolerance. If the curves approach each other to within tolerance, 
 /// an intersection is assumed.</param>
 /// <param name="overlapTolerance">The tolerance with which the curves are tested.</param>
 /// <returns>A collection of intersection events.</returns>
 /// <example>
 /// <code source='examples\vbnet\ex_intersectcurves.vb' lang='vbnet'/>
 /// <code source='examples\cs\ex_intersectcurves.cs' lang='cs'/>
 /// <code source='examples\py\ex_intersectcurves.py' lang='py'/>
 /// </example>
 public static CurveIntersections CurveCurve(Curve curveA, Curve curveB, double tolerance, double overlapTolerance)
 {
   IntPtr pCurveA = curveA.ConstPointer();
   IntPtr pCurveB = curveB.ConstPointer();
   IntPtr pIntersectArray = UnsafeNativeMethods.ON_Intersect_CurveCurve(pCurveA, pCurveB, tolerance, overlapTolerance);
   return CurveIntersections.Create(pIntersectArray);
 }

 /// <summary>
 /// Finds the places where a curve intersects itself. 
 /// </summary>
 /// <param name="curve">Curve for self-intersections.</param>
 /// <param name="tolerance">Intersection tolerance. If the curve approaches itself to within tolerance, 
 /// an intersection is assumed.</param>
 /// <returns>A collection of intersection events.</returns>
 public static CurveIntersections CurveSelf(Curve curve, double tolerance)
 {
   IntPtr pCurve = curve.ConstPointer();
   IntPtr pIntersectArray = UnsafeNativeMethods.ON_Intersect_CurveSelf(pCurve, tolerance);
   return CurveIntersections.Create(pIntersectArray);
 }

    /// <summary>
    /// Intersects a curve with an (infinite) plane.
    /// </summary>
    /// <param name="curve">Curve to intersect.</param>
    /// <param name="plane">Plane to intersect with.</param>
    /// <param name="tolerance">Tolerance to use during intersection.</param>
    /// <returns>A list of intersection events or null if no intersections were recorded.</returns>
    public static CurveIntersections CurvePlane(Curve curve, Plane plane, double tolerance)
    {
      if (!plane.IsValid)
        return null;

      // Use dedicated plane intersector in Rhino5
      IntPtr pConstCurve = curve.ConstPointer();
      IntPtr pIntersectArray = UnsafeNativeMethods.ON_Curve_IntersectPlane(pConstCurve, ref plane, tolerance);
      return CurveIntersections.Create(pIntersectArray);
    }

    /// <summary>
    /// Intersects a curve with an (infinite) plane.
    /// </summary>
    /// <param name="curve">Curve to intersect.</param>
    /// <param name="plane">Plane to intersect with.</param>
    /// <param name="tolerance">Tolerance to use during intersection.</param>
    /// <returns>A list of intersection events or null if no intersections were recorded.</returns>
    public static CurveIntersections CurvePlane(Curve curve, Plane plane, double tolerance)
    {
      if (!plane.IsValid)
        return null;

#if USING_V5_SDK
      // Use dedicated plane intersector in Rhino5
      IntPtr pConstCurve = curve.ConstPointer();
      IntPtr pIntersectArray = UnsafeNativeMethods.ON_Curve_IntersectPlane(pConstCurve, ref plane, tolerance);
      return CurveIntersections.Create(pIntersectArray);
#else
      PlaneSurface section = ExtendThroughBox(plane, curve.GetBoundingBox(false), 1.0); //should this be 1.0 or 100.0*tolerance?
      if (section == null)
        return null;
      CurveIntersections rc = CurveSurface(curve, section, tolerance, 5 * tolerance);
      section.Dispose();
      return rc;
#endif
    }