Represents a base class that is common to most RhinoCommon curve types.
A curve represents an entity that can be all visited by providing a single parameter, usually called t.
Constructors
Curve
#Protected serialization constructor for internal use.
Parameters:
| info (SerializationInfo) | Serialization data. |
| context (StreamingContext) | Serialization stream. |
Properties
Gets the maximum algebraic degree of any span or a good estimate if curve spans are not algebraic.
Gets the dimension of the object.
The dimension is typically three. For parameter space trimming curves the dimension is two. In rare cases the dimension can be one or greater than three.
Disposed
Indicates if this object has been disposed or the document it originally belonged to has been disposed.
HasBrepForm
Returns true if the Brep.TryConvertBrep function will be successful for this object
HasUserData
Gets true if this class has any custom information attached to it through UserData.
Gets a value indicating whether or not this curve is a closed curve.
IsDeformable
true if object can be accurately modified with "squishy" transformations like projections, shears, and non-uniform scaling.
IsDocumentControlled
If true this object may not be modified. Any properties or functions that attempt to modify this object when it is set to "IsReadOnly" will throw a NotSupportedException.
Overrides: CommonObject.IsDocumentControlled
Gets a value indicating whether or not this curve is considered to be Periodic.
IsShallowDuplicate
Is this instance a 'shallow copy'. Shallow copies are no different than regular instances with the exception that they will convert to complete independent 'deep' copies if a non const operation is perform on the instance (something that mutates the internal data)
Returns true if the curve is a cubic, non-rational, uniform NURBS curve that is either periodic or has natural end conditions. Otherwise, false is returned.
Remarks: A "natural" spline has zero 2nd derivatives (and hence zero curvature) at the start and end. A "periodic" spline has unclampled periodic knots and periodic control points.
ObjectType
Useful for switch statements that need to differentiate between basic object types like points, curves, surfaces, and so on.
Evaluates point at the middle, or mid, of the curve.
Evaluates point at the start of the curve.
Gets the number of non-empty smooth (c-infinity) spans in the curve.
Evaluate unit tangent vector at the end of the curve.
Remarks: No error handling.
Returns: Unit tangent vector of the curve at the end point.
Evaluates the unit tangent vector at the start of the curve.
Remarks: No error handling.
Returns: Unit tangent vector of the curve at the start point.
UserData
List of custom information that is attached to this class.
UserDictionary
Dictionary of custom information attached to this class. The dictionary is actually user data provided as an easy to use shareable set of information.
Methods
If this curve is closed, then modify it so that the start/end point is at curve parameter t.
Parameters:
| t (double) | Curve parameter of new start/end point. The returned curves domain will start at t. |
Returns: true on success, false on failure.
Changes the dimension of a curve.
Parameters:
| desiredDimension (int) | The desired dimension. |
Returns: true if the curve's dimension was already desiredDimension or if the curve's dimension was successfully changed to desiredDimension; otherwise false.
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in the world XY plane. Only works with simple (no self intersections) closed, planar curves.
Returns: The orientation of this curve with respect to world XY plane.
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in a given plane. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| plane (Plane) | The plane in which to solve the orientation. |
Returns: The orientation of this curve in the given plane.
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| xform (Transform) | Transformation to map the curve to the world XY plane. |
Returns: The orientation of this curve in the world XY-plane.
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in a given plane. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| upDirection (Vector3d) | A vector that is considered "up". |
Returns: The orientation of this curve with respect to a defined up direction.
Finds the parameter of the point on a curve that is closest to testPoint. If the maximumDistance parameter is > 0, then only points whose distance to the given point is <= maximumDistance will be returned. Using a positive value of maximumDistance can substantially speed up the search.
Parameters:
| testPoint (Point3d) | Point to project. |
| t (out double) | parameter of local closest point returned here. |
| maximumDistance (double) | The maximum allowed distance. Past this distance, the search is given up and false is returned. Use 0 to turn off this parameter. |
Returns: true on success, false on failure.
Finds parameter of the point on a curve that is closest to testPoint. If the maximumDistance parameter is > 0, then only points whose distance to the given point is <= maximumDistance will be returned. Using a positive value of maximumDistance can substantially speed up the search.
[ConstOperation]
public bool ClosestPoints(Curve otherCurve, out Point3d pointOnThisCurve, out Point3d pointOnOtherCurve)
Gets closest points between this and another curves.
[ConstOperation]
public bool ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry, double maximumDistance)
Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.
Parameters:
| geometry (IEnumerable<GeometryBase>) | A list, an array or any enumerable set of geometry to search. |
| pointOnCurve (out Point3d) | The point on curve. This out parameter is assigned during this call. |
| pointOnObject (out Point3d) | The point on geometry. This out parameter is assigned during this call. |
| whichGeometry (out int) | The index of the geometry. This out parameter is assigned during this call. |
| maximumDistance (double) | Maximum allowable distance. Past this distance, the research is given up and false is returned. |
Returns: true on success; false if no object was found or selected.
Exceptions:
| ArgumentNullException | If geometry is null. |
[ConstOperation]
public bool ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry)
Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.
Parameters:
| geometry (IEnumerable<GeometryBase>) | A list, an array or any enumerable set of geometry to search. |
| pointOnCurve (out Point3d) | The point on curve. This out parameter is assigned during this call. |
| pointOnObject (out Point3d) | The point on geometry. This out parameter is assigned during this call. |
| whichGeometry (out int) | The index of the geometry. This out parameter is assigned during this call. |
Returns: true on success; false if no object was found or selected.
Exceptions:
| ArgumentNullException | If geometry is null. |
Looks for segments that are shorter than tolerance that can be combined. For NURBS of degree greater than 1, spans are combined by removing knots. Similarly for NURBS segments of polycurves. Otherwise, RemoveShortSegments() is called. Does not change the domain, but it will change the relative parameterization.
Parameters:
| tolerance (double) |
Returns: True if short segments were combined or removed. False otherwise.
ComponentIndex
If this piece of geometry is a component in something larger, like a BrepEdge in a Brep, then this function returns the component index.
Returns: This object's component index. If this object is not a sub-piece of a larger geometric entity, then the returned index has m_type = ComponentIndex.InvalidType and m_index = -1.
ConstructConstObject
Assigns a parent object and a sub-object index to this.
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
obsoleteUse version that takes a tolerance
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
obsoleteUse version that takes a tolerance
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset. Both curve and point are projected to the World XY plane.
Parameters:
| testPoint (Point3d) | Point to test. |
Returns: Relationship between point and curve region.
Gets the curve's control polygon.
Returns: The control polygon as a polyline if successful, null otherwise.
public static Curve CreateArcBlend(Point3d startPt, Vector3d startDir, Point3d endPt, Vector3d endDir, double controlPointLengthRatio)
Creates a polycurve consisting of two tangent arc segments that connect two points and two directions.
Parameters:
| startPt (Point3d) | Start of the arc blend curve. |
| startDir (Vector3d) | Start direction of the arc blend curve. |
| endPt (Point3d) | End of the arc blend curve. |
| endDir (Vector3d) | End direction of the arc blend curve. |
| controlPointLengthRatio (double) | The ratio of the control polygon lengths of the two arcs. Note, a value of 1.0 means the control polygon lengths for both arcs will be the same. |
Returns: The arc blend curve, or null on error.
Creates an arc-cornered (rounded) rectangular curve.
Parameters:
| rectangle (Rectangle3d) | The rectangle. |
| radius (double) | The arc radius at each corner. |
Returns: Aa arc-cornered rectangular curve if successful, null otherwise.
public static Curve CreateArcLineArcBlend(Point3d startPt, Vector3d startDir, Point3d endPt, Vector3d endDir, double radius)
Creates an arc-line-arc blend curve between two curves. The output is generally a PolyCurve with three segments: arc, line, arc. In some cases, one or more of those segments will be absent because they would have 0 length. If there is only a single segment, the result will either be an ArcCurve or a LineCurve.
Remarks: The first arc segment will start at startPt, with starting tangent startDir. The second arc segment will end at endPt with end tangent endDir. The line segment will start from the end of the first arc segment and end at start of the second arc segment, and it will be tangent to both arcs at those points.
Parameters:
| startPt (Point3d) | Start of the blend curve. |
| startDir (Vector3d) | Start direction of the blend curve. |
| endPt (Point3d) | End of the blend curve. |
| endDir (Vector3d) | End direction of the arc blend curve. |
| radius (double) | The radius of the arc segments. |
Returns: The blend curve if successful, false otherwise.
public static Curve CreateBlendCurve(Curve curve0, double t0, bool reverse0, BlendContinuity continuity0, Curve curve1, double t1, bool reverse1, BlendContinuity continuity1)
Makes a curve blend between two curves at the parameters specified with the directions and continuities specified.
Parameters:
| curve0 (Curve) | First curve to blend from. |
| t0 (double) | Parameter on first curve for blend endpoint. |
| reverse0 (bool) | If false, the blend will go in the natural direction of the curve. If true, the blend will go in the opposite direction to the curve. |
| continuity0 (BlendContinuity) | Continuity for the blend at the start. |
| curve1 (Curve) | Second curve to blend from. |
| t1 (double) | Parameter on second curve for blend endpoint. |
| reverse1 (bool) | If false, the blend will go in the natural direction of the curve. If true, the blend will go in the opposite direction to the curve. |
| continuity1 (BlendContinuity) | Continuity for the blend at the end. |
Returns: The blend curve on success, or null on failure.
public static Curve CreateBlendCurve(Curve curveA, Curve curveB, BlendContinuity continuity, double bulgeA, double bulgeB)
Create a Blend curve between two existing curves.
Remarks: Note: This function only blends with G0, G1, or G2 continuity.
Parameters:
| curveA (Curve) | Curve to blend from (blending will occur at curve end point). |
| curveB (Curve) | Curve to blend to (blending will occur at curve start point). |
| continuity (BlendContinuity) | Continuity of blend, either position (G0), tangency (G1), or curvature (G2). |
| bulgeA (double) | Bulge factor at curveA end of blend. Values near 1.0 work best. |
| bulgeB (double) | Bulge factor at curveB end of blend. Values near 1.0 work best. |
Returns: A curve representing the blend between A and B or null on failure.
Create a Blend curve between two existing curves.
Remarks: Note: This function only blends with G0, G1, or G2 continuity.
Parameters:
| curveA (Curve) | Curve to blend from (blending will occur at curve end point). |
| curveB (Curve) | Curve to blend to (blending will occur at curve start point). |
| continuity (BlendContinuity) | Continuity of blend, either position (G0), tangency (G1), or curvature (G2). |
Returns: A curve representing the blend between A and B or null on failure.
Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar.
obsoleteUse version that takes tolerance as input
Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar.
public static Curve[] CreateBooleanDifference(Curve curveA, IEnumerable<Curve> subtractors, double tolerance)
Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.
Parameters:
| curveA (Curve) | The first closed, planar curve. |
| subtractors (IEnumerable<Curve>) | curves to subtract from the first closed curve. |
| tolerance (double) |
Returns: Result curves on success, empty array if no difference could be calculated.
obsoleteUse version that takes tolerance as input
Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.
Parameters:
| curveA (Curve) | The first closed, planar curve. |
| subtractors (IEnumerable<Curve>) | curves to subtract from the first closed curve. |
Returns: Result curves on success, empty array if no difference could be calculated.
Calculates the boolean intersection of two closed, planar curves. Note, curves must be co-planar.
obsoleteUse version that takes tolerance as input
Calculates the boolean intersection of two closed, planar curves. Note, curves must be co-planar.
public static CurveBooleanRegions CreateBooleanRegions(IEnumerable<Curve> curves, Plane plane, bool combineRegions, double tolerance)
Calculates curve Boolean regions, which trims and splits curves based on their overlapping regions.
Parameters:
| curves (IEnumerable<Curve>) | The input curves. |
| plane (Plane) | Regions will be found in the projection of the curves to this plane. |
| combineRegions (bool) | If true, then adjacent regions will be combined. |
| tolerance (double) | Function tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: The curve Boolean regions if successful, null of no successful.
public static CurveBooleanRegions CreateBooleanRegions(IEnumerable<Curve> curves, Plane plane, IEnumerable<Point3d> points, bool combineRegions, double tolerance)
Curve Boolean method, which trims and splits curves based on their overlapping regions.
Parameters:
| curves (IEnumerable<Curve>) | The input curves. |
| plane (Plane) | Regions will be found in the projection of the curves to this plane. |
| points (IEnumerable<Point3d>) | These points will be projected to plane. All regions that contain at least one of these points will be found. |
| combineRegions (bool) | If true, then adjacent regions will be combined. |
| tolerance (double) | Function tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: The curve Boolean regions if successful, null of no successful.
public static Curve[] CreateBooleanUnion(IEnumerable<Curve> curves, double tolerance, out int[] indexMap)
Calculates the boolean union of two or more closed, planar curves, and reports which input curve ended up in which output curve. Note, curves must be co-planar.
Parameters:
| curves (IEnumerable<Curve>) | The co-planar curves to union. |
| tolerance (double) | The 3d fitting and intersecting tolerance. |
| indexMap (out int[]) | An array with one entry per input curve. The value at index i is the index, in the returned array, of the union result that input curve i contributed to (the outer boundary curve of that result), or -1 if the input curve was not matched to any output curve. The input curves are indexed in the order they are enumerated curves. |
Returns: Result curves on success, empty array if no union could be calculated.
Calculates the boolean union of two or more closed, planar curves. Note, curves must be co-planar.
Parameters:
| curves (IEnumerable<Curve>) | The co-planar curves to union. |
| tolerance (double) |
Returns: Result curves on success, empty array if no union could be calculated.
obsoleteUse version that takes tolerance as input
Calculates the boolean union of two or more closed, planar curves. Note, curves must be co-planar.
Parameters:
| curves (IEnumerable<Curve>) | The co-planar curves to union. |
Returns: Result curves on success, empty array if no union could be calculated.
public static Curve CreateCatenaryCurveFromApex(Point3d catenary_start, Point3d catenary_end, Vector3d axis_dir, Point3d catenary_apex, bool bSmooth, int point_count, out Point3d apex_out, out double parameter_out, out double length_out, out double max_deviation_out)
Generate a catenary curve through catenary apex.
Parameters:
| catenary_start (Point3d) | catenary start point |
| catenary_end (Point3d) | catenary end point |
| axis_dir (Vector3d) | catenary axis/gravity direction |
| catenary_apex (Point3d) | desired catenary apex point |
| bSmooth (bool) | if false generates polyline output |
| point_count (int) | number of points in the output curve |
| apex_out (out Point3d) | apex point of the output catenary curve |
| parameter_out (out double) | output catenary parameter "a" in the formula y = a * cosh(x/a) |
| length_out (out double) | output catenary length |
| max_deviation_out (out double) | sampled max deviation between the output curve and the analytic catenary |
Returns: A catenary Curve or null if unsuccessful
public static Curve CreateCatenaryCurveFromLength(Point3d catenary_start, Point3d catenary_end, Vector3d axis_dir, double catenary_length, bool bSmooth, int point_count, out Point3d apex_out, out double parameter_out, out double length_out, out double max_deviation_out)
Generate a catenary curve of specific length.
Parameters:
| catenary_start (Point3d) | catenary start point |
| catenary_end (Point3d) | catenary end point |
| axis_dir (Vector3d) | catenary axis/gravity direction |
| catenary_length (double) | the desired catenary length |
| bSmooth (bool) | if false generates polyline output |
| point_count (int) | number of points in the output curve |
| apex_out (out Point3d) | apex point of the output catenary curve |
| parameter_out (out double) | output catenary parameter "a" in the formula y = a * cosh(x/a) |
| length_out (out double) | output catenary length |
| max_deviation_out (out double) | sampled max deviation between the output curve and the analytic catenary |
Returns: A catenary Curve or null if unsuccessful
public static Curve CreateCatenaryCurveFromParameter(Point3d catenary_start, Point3d catenary_end, Vector3d axis_dir, double catenary_parameter, bool bSmooth, int point_count, out Point3d apex_out, out double parameter_out, out double length_out, out double max_deviation_out)
Generate a catenary curve from catenary parameter.
Parameters:
| catenary_start (Point3d) | catenary start point |
| catenary_end (Point3d) | catenary end point |
| axis_dir (Vector3d) | catenary axis/gravity direction |
| catenary_parameter (double) | catenary parameter |
| bSmooth (bool) | if false generates polyline output |
| point_count (int) | number of points in the output curve |
| apex_out (out Point3d) | apex point of the output catenary curve |
| parameter_out (out double) | output catenary parameter "a" in the formula y = a * cosh(x/a) |
| length_out (out double) | output catenary length |
| max_deviation_out (out double) | sampled max deviation between the output curve and the analytic catenary |
Returns: A catenary Curve or null if unsuccessful
public static Curve CreateCatenaryCurveThroughPoint(Point3d catenary_start, Point3d catenary_end, Vector3d axis_dir, Point3d through_point, bool bSmooth, int point_count, out Point3d apex_out, out double parameter_out, out double length_out, out double max_deviation_out)
Generate a catenary curve through a point
Parameters:
| catenary_start (Point3d) | catenary start point |
| catenary_end (Point3d) | catenary end point |
| axis_dir (Vector3d) | catenary axis/gravity direction |
| through_point (Point3d) | point on the catenary between catenary_start and catenary_end |
| bSmooth (bool) | if false generates polyline output |
| point_count (int) | number of points in the output curve |
| apex_out (out Point3d) | apex point of the output catenary curve |
| parameter_out (out double) | output catenary parameter "a" in the formula y = a * cosh(x/a) |
| length_out (out double) | output catenary length |
| max_deviation_out (out double) | sampled max deviation between the output curve and the analytic catenary |
Returns: A catenary Curve or null if unsuccessful
Creates a conic-corned (rounded) rectangular curve.
Parameters:
| rectangle (Rectangle3d) | The rectangle. |
| rho (double) | The rho value at each corner, in the exclusive range (0.0, 1.0). |
Returns: A conic-cornered rectangular curve if successful, null otherwise.
Constructs a curve from a set of control-point locations.
Parameters:
| points (IEnumerable<Point3d>) | Control points. |
| degree (int) | Degree of curve. The number of control points must be at least degree+1. |
Constructs a control-point of degree=3 (or less).
Parameters:
| points (IEnumerable<Point3d>) | Control points of curve. |
public static Curve[] CreateCurve2View(Curve curveA, Curve curveB, Vector3d vectorA, Vector3d vectorB, double tolerance, double angleTolerance)
Creates a third curve from two curves that are planar in different construction planes. The new curve looks the same as each of the original curves when viewed in each plane.
Parameters:
| curveA (Curve) | The first curve. |
| curveB (Curve) | The second curve. |
| vectorA (Vector3d) | A vector defining the normal direction of the plane which the first curve is drawn upon. |
| vectorB (Vector3d) | A vector defining the normal direction of the plane which the second curve is drawn upon. |
| tolerance (double) | The tolerance for the operation. |
| angleTolerance (double) | The angle tolerance for the operation. |
Returns: An array containing one or more curves if successful.
public static Arc CreateFillet(Curve curve0, Curve curve1, double radius, double t0Base, double t1Base)
Computes the fillet arc for a curve filleting operation.
Parameters:
| curve0 (Curve) | First curve to fillet. |
| curve1 (Curve) | Second curve to fillet. |
| radius (double) | Fillet radius. |
| t0Base (double) | Parameter on curve0 where the fillet ought to start (approximately). |
| t1Base (double) | Parameter on curve1 where the fillet ought to end (approximately). |
Returns: The fillet arc on success, or Arc.Unset on failure.
public static Curve CreateFilletCornersCurve(Curve curve, double radius, double tolerance, double angleTolerance)
Rounds the corners of a kinked curve with arcs of a single, specified radius.
Parameters:
| curve (Curve) | The curve to fillet. |
| radius (double) | The fillet radius. |
| tolerance (double) | The tolerance. When in doubt, use the document's model space absolute tolerance. |
| angleTolerance (double) | The angle tolerance in radians. When in doubt, use the document's model space angle tolerance. |
Returns: The filleted curve if successful. null on failure.
public static Curve[] CreateFilletCurves(Curve curve0, Point3d point0, Curve curve1, Point3d point1, double radius, bool join, bool trim, bool arcExtension, double tolerance, double angleTolerance)
Creates a tangent arc between two curves and trims or extends the curves to the arc.
Parameters:
| curve0 (Curve) | The first curve to fillet. |
| point0 (Point3d) | A point on the first curve that is near the end where the fillet will be created. |
| curve1 (Curve) | The second curve to fillet. |
| point1 (Point3d) | A point on the second curve that is near the end where the fillet will be created. |
| radius (double) | The radius of the fillet. |
| join (bool) | Join the output curves. |
| trim (bool) | Trim copies of the input curves to the output fillet curve. |
| arcExtension (bool) | Applies when arcs are filleted but need to be extended to meet the fillet curve or chamfer line. If true, then the arc is extended maintaining its validity. If false, then the arc is extended with a line segment, which is joined to the arc converting it to a polycurve. |
| tolerance (double) | The tolerance, generally the document's absolute tolerance. |
| angleTolerance (double) |
Returns: The results of the fillet operation. The number of output curves depends on the input curves and the values of the parameters that were used during the fillet operation. In most cases, the output array will contain either one or three curves, although two curves can be returned if the radius is zero and join = false. For example, if both join and trim = true, then the output curve will be a polycurve containing the fillet curve joined with trimmed copies of the input curves. If join = false and trim = true, then three curves, the fillet curve and trimmed copies of the input curves, will be returned. If both join and trim = false, then just the fillet curve is returned.
public static Curve CreateInterpolatedCurve(IEnumerable<Point3d> points, int degree, CurveKnotStyle knots, Vector3d startTangent, Vector3d endTangent)
Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Parameters:
| points (IEnumerable<Point3d>) | Points to interpolate. For periodic curves if the final point is a duplicate of the initial point it is ignored. (Count must be >=2) |
| degree (int) | The degree of the curve >=1. Note: Even degree > 3 periodic interpolation results in a non-periodic closed curve. |
| knots (CurveKnotStyle) | Knot-style to use and specifies if the curve should be periodic. |
| startTangent (Vector3d) | A starting tangent. |
| endTangent (Vector3d) | An ending tangent. |
Returns: interpolated curve on success. null on failure.
public static Curve CreateInterpolatedCurve(IEnumerable<Point3d> points, int degree, CurveKnotStyle knots)
Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Parameters:
| points (IEnumerable<Point3d>) | Points to interpolate. For periodic curves if the final point is a duplicate of the initial point it is ignored. (Count must be >=2) |
| degree (int) | The degree of the curve >=1. Note: Even degree > 3 periodic interpolation results in a non-periodic closed curve. |
| knots (CurveKnotStyle) | Knot-style to use and specifies if the curve should be periodic. |
Returns: interpolated curve on success. null on failure.
Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Parameters:
| points (IEnumerable<Point3d>) | Points to interpolate (Count must be >= 2) |
| degree (int) | The degree of the curve >=1. Degree must be odd. |
Returns: interpolated curve on success. null on failure.
public static Curve[] CreateMatchCurve(Curve curve0, bool reverse0, BlendContinuity continuity, Curve curve1, bool reverse1, PreserveEnd preserve, bool average)
Changes a curve end to meet a specified curve with a specified continuity.
Parameters:
| curve0 (Curve) | The open curve to change. |
| reverse0 (bool) | Reverse the direction of the curve to change before matching. |
| continuity (BlendContinuity) | The continuity at the curve end. |
| curve1 (Curve) | The open curve to match. |
| reverse1 (bool) | Reverse the direction of the curve to match before matching. |
| preserve (PreserveEnd) | Prevent modification of the curvature at the end opposite the match for curves with fewer than six control points. |
| average (bool) | Adjust both curves to match each other. |
Returns: The results of the curve matching, if successful, otherwise an empty array.
Constructs a mean, or average, curve from two curves.
Parameters:
| curveA (Curve) | A first curve. |
| curveB (Curve) | A second curve. |
| angleToleranceRadians (double) | The angle tolerance, in radians, used to match kinks between curves. If you are unsure how to set this parameter, then either use the document's angle tolerance RhinoDoc.AngleToleranceRadians, or the default value (RhinoMath.UnsetValue) |
Returns: The average curve, or null on error.
Exceptions:
| ArgumentNullException | If curveA or curveB are null. |
Constructs a mean, or average, curve from two curves.
Returns: The average curve, or null on error.
Exceptions:
| ArgumentNullException | If curveA or curveB are null. |
public static NurbsCurve CreateNurbsCurveFit(Curve curve, Interval domain, NurbsCurveFitParameters rebuildOptions, out Line maximumSeparation, out double thisSeparationParameter, out double nurbsSeparationParameter)
Rebuilds the curve to a NURBS curve with the specified options.
Parameters:
| curve (Curve) | The input curve you would like to rebuild |
| domain (Interval) | The domain to process |
| rebuildOptions (NurbsCurveFitParameters) | Specifies how to rebuild the curve |
| maximumSeparation (out Line) | |
| thisSeparationParameter (out double) | |
| nurbsSeparationParameter (out double) |
Returns: The resulting curveb
Removes kinks from a curve. Periodic curves deform smoothly without kinks.
Parameters:
| curve (Curve) | The curve to make periodic. Curve must have degree >= 2. |
| smooth (bool) | If true, smooths any kinks in the curve and moves control points to make a smooth curve. If false, control point locations are not changed or changed minimally (only one point may move) and only the knot vector is altered. |
Returns: The resulting curve if successful, null otherwise.
Removes kinks from a curve. Periodic curves deform smoothly without kinks.
Parameters:
| curve (Curve) | The curve to make periodic. Curve must have degree >= 2. |
Returns: The resulting curve if successful, null otherwise.
Creates a revision cloud curve from a planar curve.
Parameters:
| curve (Curve) | The input planar curve. |
| segmentCount (int) | The number of segments in the output revision cloud curve. If zero, the number of segments in the output revision cloud curve is based on the NURB form of the input curve. |
| angle (double) | The angle in radians, between PI/2.0 and PI radians (90 and 180 degrees). This angle indicates the amount of bulge in the segments. |
| flip (bool) | The arc segments in output revision cloud curve will be in the opposite direction to the input curve. |
Returns: A revision cloud curve is successful, false otherwise.
Creates a revision cloud curve from points that make up a planar polyline.
Parameters:
| points (IEnumerable<Point3d>) | The input points. |
| angle (double) | The angle in radians, between PI/2.0 and PI radians (90 and 180 degrees). This angle indicates the amount of bulge in the segments. |
| flip (bool) | The arc segments in output revision cloud curve will be in the opposite direction to the input curve. |
Returns: A revision cloud curve is successful, false otherwise.
public static Curve CreateSoftEditCurve(Curve curve, double t, Vector3d delta, double length, bool fixEnds)
Creates a soft edited curve from an existing curve using a smooth field of influence.
Parameters:
| curve (Curve) | The curve to soft edit. |
| t (double) | A parameter on the curve to move from. This location on the curve is moved, and the move is smoothly tapered off with increasing distance along the curve from this parameter. |
| delta (Vector3d) | The direction and magnitude, or maximum distance, of the move. |
| length (double) | The distance along the curve from the editing point over which the strength of the editing falls off smoothly. |
| fixEnds (bool) |
Returns: The soft edited curve if successful. null on failure.
public static Curve[] CreateTextOutlines(string text, string font, double textHeight, int textStyle, bool closeLoops, Plane plane, double smallCapsScale, double tolerance)
Creates outline curves created from a text string. The functionality is similar to what you find in Rhino's TextObject command or TextEntity.Explode() in RhinoCommon.
Parameters:
| text (string) | The text from which to create outline curves. |
| font (string) | The text font. If the font does not exist on the system. Rhino will use a substitute with similar properties. |
| textHeight (double) | The text height. |
| textStyle (int) | The font style. The font style can be any number of the following: 0 - Normal, 1 - Bold, 2 - Italic |
| closeLoops (bool) | Set this value to True when dealing with normal fonts and when you expect closed loops. You may want to set this to False when specifying a single-stroke font where you don't want closed loops. |
| plane (Plane) | The plane on which the outline curves will lie. |
| smallCapsScale (double) | Displays lower-case letters as small caps. Set the relative text size to a percentage of the normal text. |
| tolerance (double) | The tolerance for the operation. |
Returns: An array containing one or more curves if successful.
public static Curve[] CreateTweenCurves(Curve curve0, Curve curve1, int numCurves, double tolerance)
Creates curves between two open or closed input curves. Uses the control points of the curves for finding tween curves. That means the first control point of first curve is matched to first control point of the second curve and so on. There is no matching of curves direction. Caller must match input curves direction before calling the function.
obsoleteUse version that takes tolerance as input
Creates curves between two open or closed input curves. Uses the control points of the curves for finding tween curves. That means the first control point of first curve is matched to first control point of the second curve and so on. There is no matching of curves direction. Caller must match input curves direction before calling the function.
public static Curve[] CreateTweenCurvesWithMatching(Curve curve0, Curve curve1, int numCurves, double tolerance)
Creates curves between two open or closed input curves. Make the structure of input curves compatible if needed. Refits the input curves to have the same structure. The resulting curves are usually more complex than input unless input curves are compatible and no refit is needed. There is no matching of curves direction. Caller must match input curves direction before calling the function.
obsoleteUse version that takes tolerance as input
Creates curves between two open or closed input curves. Make the structure of input curves compatible if needed. Refits the input curves to have the same structure. The resulting curves are usually more complex than input unless input curves are compatible and no refit is needed. There is no matching of curves direction. Caller must match input curves direction before calling the function.
public static Curve[] CreateTweenCurvesWithSampling(Curve curve0, Curve curve1, int numCurves, int numSamples, double tolerance)
Creates curves between two open or closed input curves. Use sample points method to make curves compatible. This is how the algorithm works: Divides the two curves into an equal number of points, finds the midpoint between the corresponding points on the curves and interpolates the tween curve through those points. There is no matching of curves direction. Caller must match input curves direction before calling the function.
Parameters:
| curve0 (Curve) | The first, or starting, curve. |
| curve1 (Curve) | The second, or ending, curve. |
| numCurves (int) | Number of tween curves to create. |
| numSamples (int) | Number of sample points along input curves. |
| tolerance (double) | The tolerance. When in doubt, use the document's model absolute tolerance. |
Returns: >An array of tween curves. This array can be empty.
public static Curve[] CreateTweenCurvesWithSampling(Curve curve0, Curve curve1, int numCurves, int numSamples)
obsoleteUse version that takes tolerance as input
Creates curves between two open or closed input curves. Use sample points method to make curves compatible. This is how the algorithm works: Divides the two curves into an equal number of points, finds the midpoint between the corresponding points on the curves and interpolates the tween curve through those points. There is no matching of curves direction. Caller must match input curves direction before calling the function.
Evaluate the curvature vector at a curve parameter.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Curvature vector of the curve at the parameter t.
DataCRC
Returns a CRC calculated from the information that defines the object. This CRC can be used as a quick way to see if two objects are not identical.
Parameters:
| currentRemainder (uint) | The current remainder value. |
Returns: CRC of the information the defines the object.
DeleteAllUserStrings
public void DeleteAllUserStrings()
Parameters:
| key (string) |
[ConstOperation]
public Vector3d[] DerivativeAt(double t, int derivativeCount, CurveEvaluationSide side)
Evaluate the derivatives at the specified curve parameter.
Parameters:
| t (double) | Curve parameter to evaluate. |
| derivativeCount (int) | Number of derivatives to evaluate, must be at least 0. |
| side (CurveEvaluationSide) | Side of parameter to evaluate. If the parameter is at a kink, it makes a big difference whether the evaluation is from below or above. |
Returns: An array of vectors that represents all the derivatives starting at zero.
Evaluate the derivatives at the specified curve parameter.
Dispose
public void Dispose()
Actively reclaims unmanaged resources that this instance uses.
Dispose
#For derived class implementers.
This method is called with argument true when class user calls Dispose(), while with argument false when the Garbage Collector invokes the finalizer, or Finalize() method.
You must reclaim all used unmanaged resources in both cases, and can use this chance to call Dispose on disposable fields if the argument is true.
Also, you must call the base virtual method within your overriding method.
Parameters:
| disposing (bool) | true if the call comes from the Dispose() method; false if it comes from the Garbage Collector finalizer. |
Overrides: GeometryBase.Dispose
[ConstOperation]
public Point3d[] DivideAsContour(Point3d contourStart, Point3d contourEnd, double interval)
Divides this curve at fixed steps along a defined contour line.
[ConstOperation]
public double[] DivideByCount(int segmentCount, bool includeEnds, out Point3d[] points)
Divide the curve into a number of equal-length segments.
Parameters:
| segmentCount (int) | Segment count. Note that the number of division points may differ from the segment count. |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| points (out Point3d[]) | A list of division points. If the function returns successfully, this point-array will be filled in. |
Returns: Array containing division curve parameters on success, null on failure.
Divide the curve into a number of equal-length segments.
Parameters:
| segmentCount (int) | Segment count. Note that the number of division points may differ from the segment count. |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
Returns: List of curve parameters at the division points on success, null on failure.
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, bool reverse, out Point3d[] points)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| reverse (bool) | If true, then the divisions start from the end of the curve. |
| points (out Point3d[]) | If function is successful, points at each parameter value are returned in points. |
Returns: Array containing division curve parameters if successful, null on failure.
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, bool reverse)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| reverse (bool) | If true, then the divisions start from the end of the curve. |
Returns: Array containing division curve parameters if successful, null on failure.
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, out Point3d[] points)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| points (out Point3d[]) | If function is successful, points at each parameter value are returned in points. |
Returns: Array containing division curve parameters if successful, null on failure.
Divide the curve into specific length segments.
Calculates 3d points on a curve where the linear distance between the points is equal.
Remarks: Unlike the other divide methods, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.
Parameters:
| distance (double) | The distance between division points. |
| curveParameters (out double[]) | If successful, an array of curve parameters at the point locations. |
Returns: An array of equidistant points, or null on error.
Calculates 3d points on a curve where the linear distance between the points is equal.
Remarks: Unlike the other divide methods, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.
Parameters:
| distance (double) | The distance between division points. |
Returns: An array of equidistant points, or null on error.
Determines whether two curves travel more or less in the same direction.
Constructs an exact duplicate of this Curve.
Overrides: GeometryBase.Duplicate
Constructs an exact duplicate of this curve.
Returns: An exact copy of this curve.
Duplicates curve segments. Explodes polylines, polycurves and G1 discontinuous NURBS curves. Single segment curves, such as lines, arcs, unkinked NURBS curves, are duplicated.
Remarks: Unlike GetSubCurves(), this method produces results based on the curve's data structure.
Returns: An array of all the segments that make up this curve.
DuplicateShallow
Constructs a light copy of this object. By "light", it is meant that the same underlying data is used until something is done to attempt to change it. For example, you could have a shallow copy of a very heavy mesh object and the same underlying data will be used when doing things like inspecting the number of faces on the mesh. If you modify the location of one of the mesh vertices, the shallow copy will create a full duplicate of the underlying mesh data and the shallow copy will become a deep copy.
Returns: An object of the same type as this object.
This behavior is overridden by implementing classes.
EnsurePrivateCopy
public void EnsurePrivateCopy()
If you want to keep a copy of this class around by holding onto it in a variable after a command completes, call EnsurePrivateCopy to make sure that this class is not tied to the document. You can call this function as many times as you want.
[ConstOperation]
public Curve Extend(CurveEnd side, CurveExtensionStyle style, IEnumerable<GeometryBase> geometry)
Extends a curve until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| style (CurveExtensionStyle) | The style or type of extension to use. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
Extends a curve to a point.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| style (CurveExtensionStyle) | The style or type of extension to use. |
| endPoint (Point3d) | A new end point. |
Returns: New extended curve result on success, null on failure.
Extends a curve by a specific length.
Parameters:
| side (CurveEnd) | Curve end to extend. |
| length (double) | Length to add to the curve end. |
| style (CurveExtensionStyle) | Extension style. |
Returns: A curve with extended ends or null on failure.
Where possible, analytically extends curve to include the given domain. This will not work on closed curves. The original curve will be identical to the restriction of the resulting curve to the original curve domain.
Parameters:
| t0 (double) | Start of extension domain, if the start is not inside the Domain of this curve, an attempt will be made to extend the curve. |
| t1 (double) | End of extension domain, if the end is not inside the Domain of this curve, an attempt will be made to extend the curve. |
Returns: Extended curve on success, null on failure.
Where possible, analytically extends curve to include the given domain. This will not work on closed curves. The original curve will be identical to the restriction of the resulting curve to the original curve domain.
Parameters:
| domain (Interval) | Extension domain. |
Returns: Extended curve on success, null on failure.
Extends a curve by an Arc until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
Extends a curve by a line until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
Extends a curve on a surface.
Extends a curve on a surface.
Returns the parameter values of all local extrema. Parameter values are in increasing order so consecutive extrema define an interval on which each component of the curve is monotone. Note, non-periodic curves always return the end points.
Parameters:
| direction (Vector3d) | The direction in which to perform the calculation. |
Returns: The parameter values of all local extrema.
[ConstOperation]
public Curve Fair(double distanceTolerance, double angleTolerance, int clampStart, int clampEnd, int iterations)
Fairs a curve object. Fair works best on degree 3 (cubic) curves. Attempts to remove large curvature variations while limiting the geometry changes to be no more than the specified tolerance.
Parameters:
| distanceTolerance (double) | Maximum allowed distance the faired curve is allowed to deviate from the input. |
| angleTolerance (double) | (in radians) kinks with angles <= angleTolerance are smoothed out 0.05 is a good default. |
| clampStart (int) | The number of (control vertices-1) to preserve at start. 0 = preserve start point 1 = preserve start point and 1st derivative 2 = preserve start point, 1st and 2nd derivative |
| clampEnd (int) | Same as clampStart. |
| iterations (int) | The number of iterations to use in adjusting the curve. |
Returns: Returns new faired Curve on success, null on failure.
public bool FilletSurfaceToCurve(BrepFace face, double t, double u, double v, double radius, int alignToCurve, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, double tolerance, List<Brep> out_fillets, out double[] fitResults)
Creates a constant-radius fillet surface between a surface and the curve.
Parameters:
| face (BrepFace) | the face being filleted. |
| t (double) | A parameter on the curve, indicating region of fillet. |
| u (double) | A parameter in the u direction of the face indicating which side of the curve to fillet. |
| v (double) | A parameter in the v direction of the face indicating which side of the curve to fillet. |
| radius (double) | The radius of the constant-radius fillet desired. NOTE: using arcSliders will change the shape of the arcs themselves |
| alignToCurve (int) | Does the user want the fillet to align to the curve? 0 - No, ignore the curve's b-spline structure 1 - Yes, match the curves's degree, spans, CVs as much as possible 2 - Same as 1, but iterate to fit to tolerance Note that a value of 1 or 2 will cause nBezierSrfs to be ignored |
| railDegree (int) | Desired fillet degree (3 or 5) in the u-direction, along the curve |
| arcDegree (int) | Desired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs.If 2, then the surface is rational in v |
| arcSliders (IEnumerable<double>) | Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical(1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical(1) |
| numBezierSrfs (int) | If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. |
| tolerance (double) | The tolerance. In in doubt, the document's absolute tolerance. |
| out_fillets (List<Brep>) | he results of the fillet calculation. |
| fitResults (out double[]) | array of doubles indicating fitting results: [0] max 3d point deviation along curve [1] max 3d point deviation along face [2] max angle deviation along face(in degrees) [3] max angle deviation between Bézier surfaces(in degrees) [4] max curvature difference between Bézier surfaces |
Returns: true if successful, false otherwise.
[ConstOperation]
public bool FilletSurfaceToRail(BrepFace faceWithCurve, BrepFace secondFace, double u1, double v1, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, bool extend, FilletSurfaceSplitType split_type, double tolerance, List<Brep> out_fillets, List<Brep> out_breps0, List<Brep> out_breps1, out double[] fitResults)
Creates a surface between two surfaces, with a fixed rail curve on the first surface.
Remarks: The trim or split input Breps are in OutBreps0, and OutBreps1. If the input faces are from the same Brep, nothing will be added to OutBreps1.If you specified a split type of RhinoFilletSurfaceSplitType::Nothing, then nothing will be added to either OutBreps0 or OutBreps1.
Parameters:
| faceWithCurve (BrepFace) | The first face on which the curve exists |
| secondFace (BrepFace) | The second face |
| u1 (double) | A parameter in the u direction of the second face at the side you want to keep after filleting. |
| v1 (double) | A parameter in the v direction of the second face at the side you want to keep after filleting. |
| railDegree (int) | Desired fillet degree (3 or 5) in the u-direction, along the rails |
| arcDegree (int) | esired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs.If 2, then the surface is rational in v |
| arcSliders (IEnumerable<double>) | Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical(1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical(1) |
| numBezierSrfs (int) | If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. |
| extend (bool) | If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. |
| split_type (FilletSurfaceSplitType) | The split type |
| tolerance (double) | The tolerance. In in doubt, the document's absolute tolerance. |
| out_fillets (List<Brep>) | The results of the fillet calculation. |
| out_breps0 (List<Brep>) | The trim or split results of the Brep owned by faceWithCurve. |
| out_breps1 (List<Brep>) | The trim or split results of the Brep owned by pFace1. |
| fitResults (out double[]) | array of doubles indicating fitting results: [0] max 3d point deviation along surface 0 [1] max 3d point deviation along surface 1 [2] max angle deviation along surface 0 (in degrees) [3] max angle deviation along surface 1 (in degrees) [4] max angle deviation between Bézier surfaces(in degrees) [5] max curvature difference between Bézier surfaces |
Returns: true if successful, false otherwise.
public bool FindLocalInflection(Vector3d N, Interval subDomain, double seed, out double curveParameter, out double angleError)
Local minimization for point on a curve with tangent perpendicular to N.
Remarks: The algorithm minimizes the square of the dot product of N with the curve tangent. It is possible that the result will not be close to zero.
Parameters:
| N (Vector3d) | This vector and the curve tangent define a plane. In this plane, there is a vector V perpendicular to the tangent. |
| subDomain (Interval) | Subdomain of curve to evaluate. This must not be empty. |
| seed (double) | A seed parameter, which must be included in the subdomain. |
| curveParameter (out double) | The parameter on the curve if successful, RhinoMath.UnsetValue if unsuccessful. |
| angleError (out double) | The measure, in radians, of the angle between N and V. The angle will be zero when the result is an inflection. |
Returns: true if the minimization succeeds, regardless of angle_error, false if unsuccessful.
Fits a new curve through an existing curve.
Parameters:
| degree (int) | The degree of the returned Curve. Must be bigger than 1. |
| fitTolerance (double) | The fitting tolerance. If fitTolerance is RhinoMath.UnsetValue or <=0.0, the document absolute tolerance is used. |
| angleTolerance (double) | The kink smoothing tolerance in radians. If angleTolerance is 0.0, all kinks are smoothed If angleTolerance is >0.0, kinks smaller than angleTolerance are smoothed If angleTolerance is RhinoMath.UnsetValue or <0.0, the document angle tolerance is used for the kink smoothing |
Returns: Returns a new fitted Curve if successful, null on failure.
Returns a 3d frame at a parameter.
GetBoundingBox
Bounding box solver. Gets the world axis aligned bounding box for the geometry.
Parameters:
| accurate (bool) | If true, a physically accurate bounding box will be computed. If not, a bounding box estimate will be computed. For some geometry types there is no difference between the estimate and the accurate bounding box. Estimated bounding boxes can be computed much (much) faster than accurate (or "tight") bounding boxes. Estimated bounding boxes are always similar to or larger than accurate bounding boxes. |
Returns: The bounding box of the geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Parameters:
| plane (Plane) | Orientation plane for BoundingBox. |
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.
Parameters:
| xform (Transform) | Transformation to apply to object prior to the BoundingBox computation. The geometry itself is not modified. |
Returns: The accurate bounding box of the transformed geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
Returns the type of conic section based on the curve's shape.
[ConstOperation]
public ConicSectionType GetConicSectionType(out Point3d focus1, out Point3d focus2, out Point3d center)
Returns the type of conic section based on the curve's shape.
[ConstOperation]
public bool GetCurveParameterFromNurbsFormParameter(double nurbsParameter, out double curveParameter)
Convert a NURBS curve parameter to a curve parameter.
public static bool GetDistancesBetweenCurves(Curve curveA, Curve curveB, double tolerance, out double maxDistance, out double maxDistanceParameterA, out double maxDistanceParameterB, out double minDistance, out double minDistanceParameterA, out double minDistanceParameterB)
Calculates the minimum and maximum distances between two curves. This function is useful for computing curve deviation. If you are not computing curve deviation, use ClosestPoints(Curve, Point3d, Point3d).
Parameters:
| curveA (Curve) | A curve. |
| curveB (Curve) | Another curve. |
| tolerance (double) | A tolerance value. |
| maxDistance (out double) | The maximum distance value. This is an out reference argument. |
| maxDistanceParameterA (out double) | The maximum distance parameter on curve A. This is an out reference argument. |
| maxDistanceParameterB (out double) | The maximum distance parameter on curve B. This is an out reference argument. |
| minDistance (out double) | The minimum distance value. This is an out reference argument. |
| minDistanceParameterA (out double) | The minimum distance parameter on curve A. This is an out reference argument. |
| minDistanceParameterB (out double) | The minimum distance parameter on curve B. This is an out reference argument. |
Returns: true if the operation succeeded; otherwise false.
public static bool GetFilletPoints(Curve curve0, Curve curve1, double radius, double t0Base, double t1Base, out double t0, out double t1, out Plane filletPlane)
Finds points at which to cut a pair of curves so that a fillet of given radius can be inserted.
Remarks: A fillet point is a pair of curve parameters (t0,t1) such that there is a circle of radius point3 tangent to curve c0 at t0 and tangent to curve c1 at t1. Of all possible fillet points this function returns the one which is the closest to the base point t0Base, t1Base. Distance from the base point is measured by the sum of arc lengths along the two curves.
Parameters:
| curve0 (Curve) | First curve to fillet. |
| curve1 (Curve) | Second curve to fillet. |
| radius (double) | Fillet radius. |
| t0Base (double) | Parameter value for base point on curve0. |
| t1Base (double) | Parameter value for base point on curve1. |
| t0 (out double) | Parameter value of fillet point on curve 0. |
| t1 (out double) | Parameter value of fillet point on curve 1. |
| filletPlane (out Plane) | The fillet is contained in this plane with the fillet center at the plane origin. |
Returns: true on success, false on failure.
Gets the length of the curve with a fractional tolerance of 1.0e-8.
Returns: The length of the curve on success, or zero on failure.
Get the length of a sub-section of the curve.
Parameters:
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve (must be non-decreasing). |
Returns: The length of the sub-curve on success, or zero on failure.
Get the length of the curve.
Parameters:
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: The length of the curve on success, or zero on failure.
Get the length of a sub-section of the curve with a fractional tolerance of 1e-8.
Parameters:
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve (must be non-decreasing). |
Returns: The length of the sub-curve on success, or zero on failure.
[ConstOperation]
public bool GetLocalPerpPoint(Point3d testPoint, double seedParmameter, Interval subDomain, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
[ConstOperation]
public bool GetLocalPerpPoint(Point3d testPoint, double seedParmameter, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
[ConstOperation]
public bool GetLocalTangentPoint(Point3d testPoint, double seedParmameter, Interval subDomain, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is tangent to a test point.
[ConstOperation]
public bool GetLocalTangentPoint(Point3d testPoint, double seedParmameter, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is tangent to a test point.
[ConstOperation]
public bool GetNextDiscontinuity(Continuity continuityType, double t0, double t1, double cosAngleTolerance, double curvatureTolerance, out double t)
Searches for a derivative, tangent, or curvature discontinuity.
Parameters:
| continuityType (Continuity) | Type of continuity to search for. |
| t0 (double) | Search begins at t0. If there is a discontinuity at t0, it will be ignored. This makes it possible to repeatedly call GetNextDiscontinuity() and step through the discontinuities. |
| t1 (double) | (t0 != t1) If there is a discontinuity at t1 it will be ignored unless continuityType is a locus discontinuity type and t1 is at the start or end of the curve. |
| cosAngleTolerance (double) | default = cos(1 degree) Used only when continuity is G1_continuous or G2_continuous. If the cosine of the angle between two tangent vectors is <= cosAngleTolerance, then a G1 discontinuity is reported. For G2, values tighter than cos(1 degree) are treated as cos(1 degree), and angles less than about 18 degrees are doubled for the curvature direction test. With the default, a G2 discontinuity is reported if the curvature vectors differ by more than 2 degrees. |
| curvatureTolerance (double) | (default = RhinoMath.SqrtEpsilon) Used only when continuity is G2_continuous. If K0 and K1 are curvatures evaluated from above and below and |K0 - K1| <= curvatureTolerance, then the curvature is considered continuous. Otherwise, a curvature discontinuity is reported if the curvature direction test fails or ||K0| - |K1|| > 0.05 * max(|K0|, |K1|). Increasing curvatureTolerance can only loosen the test. |
| t (out double) | If a discontinuity is found, then t reports the parameter at the discontinuity. |
Returns: Parametric continuity tests c = (C0_continuous, ..., G2_continuous): true if a parametric discontinuity was found strictly between t0 and t1. Note well that all curves are parametrically continuous at the ends of their domains. Locus continuity tests c = (C0_locus_continuous, ...,G2_locus_continuous): true if a locus discontinuity was found strictly between t0 and t1 or at t1 is the at the end of a curve. Note well that all open curves (IsClosed()=false) are locus discontinuous at the ends of their domains. All closed curves (IsClosed()=true) are at least C0_locus_continuous at the ends of their domains.
[ConstOperation]
public bool GetNextDiscontinuity(Continuity continuityType, double t0, double t1, out double t)
Searches for a derivative, tangent, or curvature discontinuity.
Remarks: G1 uses a 1 degree tangent angle tolerance. G2 reports a discontinuity if the curvature vectors differ in direction by more than 2 degrees or in magnitude by more than 5%. These tolerances do not depend on the document's angle tolerance.
Parameters:
| continuityType (Continuity) | Type of continuity to search for. |
| t0 (double) | Search begins at t0. If there is a discontinuity at t0, it will be ignored. This makes it possible to repeatedly call GetNextDiscontinuity() and step through the discontinuities. |
| t1 (double) | (t0 != t1) If there is a discontinuity at t1 it will be ignored unless continuityType is a locus discontinuity type and t1 is at the start or end of the curve. |
| t (out double) | If a discontinuity is found, then t reports the parameter at the discontinuity. |
Returns: Parametric continuity tests c = (C0_continuous, ..., G2_continuous): true if a parametric discontinuity was found strictly between t0 and t1. Note well that all curves are parametrically continuous at the ends of their domains. Locus continuity tests c = (C0_locus_continuous, ...,G2_locus_continuous): true if a locus discontinuity was found strictly between t0 and t1 or at t1 is the at the end of a curve. Note well that all open curves (IsClosed()=false) are locus discontinuous at the ends of their domains. All closed curves (IsClosed()=true) are at least C0_locus_continuous at the ends of their domains.
[ConstOperation]
public bool GetNurbsFormParameterFromCurveParameter(double curveParameter, out double nurbsParameter)
Convert a curve parameter to a NURBS curve parameter.
GetObjectData
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.
Parameters:
| info (SerializationInfo) | The System.Runtime.Serialization.SerializationInfo to populate with data. |
| context (StreamingContext) | The destination (see System.Runtime.Serialization.StreamingContext) for this serialization. |
Gets a collection of perpendicular frames along the curve. Perpendicular frames are also known as 'Zero-twisting frames' and they minimize rotation from one frame to the next.
Parameters:
| parameters (IEnumerable<double>) | A collection of strictly increasing curve parameters to place perpendicular frames on. |
Returns: An array of perpendicular frames on success or null on failure.
Exceptions:
| InvalidOperationException | Thrown when the curve parameters are not increasing. |
Gets subcurves from a curve. The results will be similar to what is produced by Rhino's Explode command.
Remarks: Unlike DuplicateSegments(), this method produces results based on the curve's geometry.
Returns: An array of subcurves that make up this curve.
Parameters:
| key (string) | id used to retrieve the string. |
Returns: string associated with the key if successful. null if no key was found.
GetUserStrings
Gets a copy of all (user key string, user value string) pairs attached to this geometry.
Returns: A new collection.
Does a NURBS curve representation of this curve exist?
Returns: 0 unable to create NURBS representation with desired accuracy. 1 success - NURBS parameterization matches the curve's to the desired accuracy 2 success - NURBS point locus matches the curve's and the domain of the NURBS curve is correct. However, This curve's parameterization and the NURBS curve parameterization may not match. This situation happens when getting NURBS representations of curves that have a transcendental parameterization like circles.
Returns a curve's inflection points. An inflection point is a location on a curve at which the sign of the curvature (i.e., the concavity) changes. The curvature at these locations is always 0.
Returns: An array of points if successful, null if not successful or on error.
Returns a curve's inflection points. An inflection point is a location on a curve at which the sign of the curvature (i.e., the concavity) changes. The curvature at these locations is always 0.
Parameters:
| curveParameters (out double[]) | An array of curve parameters at the inflection points. |
Returns: An array of points if successful, null if not successful or on error.
Test a curve to see if it can be represented by an arc or circle within RhinoMath.ZeroTolerance.
Returns: true if the curve can be represented by an arc or a circle within tolerance.
Test a curve to see if it can be represented by an arc or circle within the given tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if the curve can be represented by an arc or a circle within tolerance.
Test a curve to see if it can be represented by a circle within RhinoMath.ZeroTolerance.
Returns: true if the Curve can be represented by a circle within tolerance.
Test a curve to see if it can be represented by a circle within the given tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if the curve can be represented by a circle to within tolerance.
[ConstOperation]
public bool IsClosable(double tolerance, double minimumAbsoluteSize, double minimumRelativeSize)
Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.
Parameters:
| tolerance (double) | Maximum allowable distance between start and end. If start - end gap is greater than tolerance, this function will return false. |
| minimumAbsoluteSize (double) | If greater than 0.0 and none of the interior sampled points are at least minimumAbsoluteSize from start, this function will return false. |
| minimumRelativeSize (double) | If greater than 1.0 and chord length is less than minimumRelativeSize*gap, this function will return false. |
Returns: true if start and end points are close enough based on above conditions.
Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.
Parameters:
| tolerance (double) | Maximum allowable distance between start and end. If start - end gap is greater than tolerance, this function will return false. |
Returns: true if start and end points are close enough based on above conditions.
Test continuity at a curve parameter value.
Remarks: G1 uses a 1 degree tangent angle tolerance. G2 reports a discontinuity if the curvature vectors differ in direction by more than 2 degrees or in magnitude by more than 5%. These tolerances do not depend on the document's angle tolerance.
Parameters:
| continuityType (Continuity) | Type of continuity to test for. |
| t (double) | Parameter to test. |
Returns: true if the curve has at least the c type continuity at the parameter t.
Test a curve to see if it can be represented by an ellipse within RhinoMath.ZeroTolerance.
Returns: true if the Curve can be represented by an ellipse within tolerance.
Test a curve to see if it can be represented by an ellipse within a given tolerance.
Parameters:
| tolerance (double) | Tolerance to use for checking. |
Returns: true if the Curve can be represented by an ellipse within tolerance.
Test a curve to see if it lies in a specific plane.
Test a curve to see if it lies in a specific plane.
Parameters:
| testPlane (Plane) | Plane to test for. |
Returns: true if the maximum distance from the curve to the testPlane is <= RhinoMath.ZeroTolerance.
Test a curve to see if it is linear to within RhinoMath.ZeroTolerance units (1e-12).
Returns: true if the curve is linear.
Test a curve to see if it is linear to within the custom tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking linearity. |
Returns: true if the ends of the curve are farther than tolerance apart and the maximum distance from any point on the curve to the line segment connecting the curve ends is <= tolerance.
Test a curve for planarity.
Returns: true if the curve is planar (flat) to within RhinoMath.ZeroTolerance units (1e-12).
Test a curve for planarity.
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if there is a plane such that the maximum distance from the curve to the plane is <= tolerance.
Several types of Curve can have the form of a polyline including a degree 1 NurbsCurve, a PolylineCurve, and a PolyCurve all of whose segments are some form of polyline. IsPolyline tests a curve to see if it can be represented as a polyline.
Returns: true if this curve can be represented as a polyline; otherwise, false.
Used to quickly find short curves.
Used to quickly find short curves.
Remarks: Faster than calling Length() and testing the result.
Parameters:
| tolerance (double) | Length threshold value for "shortness". |
Returns: true if the length of the curve is <= tolerance.
IsValidWithLog
Determines if an object is valid. Also provides a report on errors if this object happens not to be valid.
Parameters:
| log (out string) | A textual log. This out parameter is assigned during this call. |
Returns: true if this object is valid; false otherwise.
public static Curve[] JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection, bool simpleJoin, out int[] key)
Joins a collection of curve segments together.
Parameters:
| inputCurves (IEnumerable<Curve>) | An array, a list or any enumerable set of curve segments to join. |
| joinTolerance (double) | Joining tolerance, i.e. the distance between segment end-points that is allowed. |
| preserveDirection (bool) | If true, curve endpoints will be compared to curve start points. If false, all start and endpoints will be compared and copies of input curves may be reversed in output. |
| simpleJoin (bool) | Set true to use the simple joining method. In general, set this parameter to false. |
| key (out int[]) | inputCurves[i] is part of returnValue[key[i]] |
Returns: An array of joined curves. This array can be empty.
Exceptions:
| ArgumentNullException | If inputCurves is null. |
public static Curve[] JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection, out int[] key)
Joins a collection of curve segments together.
Parameters:
| inputCurves (IEnumerable<Curve>) | An array, a list or any enumerable set of curve segments to join. |
| joinTolerance (double) | Joining tolerance, i.e. the distance between segment end-points that is allowed. |
| preserveDirection (bool) | If true, curve endpoints will be compared to curve start points. If false, all start and endpoints will be compared and copies of input curves may be reversed in output. |
| key (out int[]) | inputCurves[i] is part of returnValue[key[i]] |
Returns: An array of joined curves. This array can be empty.
Exceptions:
| ArgumentNullException | If inputCurves is null. |
public static Curve[] JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection)
Joins a collection of curve segments together.
Parameters:
| inputCurves (IEnumerable<Curve>) | An array, a list or any enumerable set of curve segments to join. |
| joinTolerance (double) | Joining tolerance, i.e. the distance between segment end-points that is allowed. |
| preserveDirection (bool) | If true, curve endpoints will be compared to curve start points. If false, all start and endpoints will be compared and copies of input curves may be reversed in output. |
Returns: An array of joined curves. This array can be empty.
Exceptions:
| ArgumentNullException | If inputCurves is null. |
Joins a collection of curve segments together.
Parameters:
| inputCurves (IEnumerable<Curve>) | An array, a list or any enumerable set of curve segments to join. |
| joinTolerance (double) | Joining tolerance, i.e. the distance between segment end-points that is allowed. |
Returns: An array of joined curves. This array can be empty.
Exceptions:
| ArgumentNullException | If inputCurves is null. |
Joins a collection of curve segments together.
Parameters:
| inputCurves (IEnumerable<Curve>) | Curve segments to join. |
Returns: An array of joined curves. This array can be empty.
[ConstOperation]
[EditorBrowsable(EditorBrowsableState.Never)]
public bool LcoalClosestPoint(Point3d testPoint, double seed, out double t)
obsoleteTypo: use LocalClosestPoint
Find parameter of the point on a curve that is locally closest to the testPoint. The search for a local close point starts at a seed parameter.
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, double fractionalTolerance, Interval subdomain)
Gets the parameter along the curve which coincides with a given length along the curve.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the sub-domain. |
| t (out double) | Parameter such that the length of the curve from the start of the sub-domain to t is s. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve rather than the whole curve. |
Returns: true on success, false on failure.
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, double fractionalTolerance)
Gets the parameter along the curve which coincides with a given length along the curve.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the curve. |
| t (out double) | Parameter such that the length of the curve from the curve start point to t equals s. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: true on success, false on failure.
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, Interval subdomain)
Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the sub-domain. |
| t (out double) | Parameter such that the length of the curve from the start of the sub-domain to t is s. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve rather than the whole curve. |
Returns: true on success, false on failure.
Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Find parameter of the point on a curve that is locally closest to the testPoint. The search for a local close point starts at a seed parameter.
If IsClosed, just return true. Otherwise, decide if curve can be closed as follows: Linear curves polylinear curves with 2 segments, NURBS with 3 or less control points cannot be made closed. Also, if tolerance > 0 and the gap between start and end is larger than tolerance, curve cannot be made closed. Adjust the curve's endpoint to match its start point.
Parameters:
| tolerance (double) | If nonzero, and the gap is more than tolerance, curve cannot be made closed. |
Returns: true on success, false on failure.
MakeDeformable
If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.
Returns: false if object cannot be converted to a deformable object. true if object was already deformable or was converted into a deformable object.
public static bool MakeEndsMeet(Curve curveA, bool adjustStartCurveA, Curve curveB, bool adjustStartCurveB)
Makes adjustments to the ends of one or both input curves so that they meet at a point.
Returns a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points.
Returns: An array of points if successful, null if not successful or on error.
Returns a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points.
Parameters:
| curveParameters (out double[]) | An array of curve parameters at the maximum curvature points. |
Returns: An array of points if successful, null if not successful or on error.
MemoryEstimate
Computes an estimate of the number of bytes that this object is using in memory.
Returns: An estimated memory footprint.
NonConstOperation
#protected override void NonConstOperation()
For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.
Overrides: GeometryBase.NonConstOperation
[ConstOperation]
public bool NormalizedLengthParameter(double s, out double t, double fractionalTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. |
Returns: true on success, false on failure.
[ConstOperation]
public bool NormalizedLengthParameter(double s, out double t, double fractionalTolerance)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: true on success, false on failure.
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. |
Returns: true on success, false on failure.
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, double fractionalTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| fractionalTolerance (double) | Desired fractional precision for each segment. fabs("true" length - actual length)/(actual length) <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. A 0.0 s value corresponds to sub-domain->Min() and a 1.0 s value corresponds to sub-domain->Max(). |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, double fractionalTolerance)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| fractionalTolerance (double) | Desired fractional precision for each segment. fabs("true" length - actual length)/(actual length) <= fractionalTolerance. |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. A 0.0 s value corresponds to sub-domain->Min() and a 1.0 s value corresponds to sub-domain->Max(). |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
[ConstOperation]
public Curve[] Offset(Plane plane, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| plane (Plane) | Offset solution plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
Returns: Offset curves on success, null on failure.
[ConstOperation]
public Curve[] Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| directionPoint (Point3d) | A point that indicates the direction of the offset. |
| normal (Vector3d) | The normal to the offset plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
Returns: Offset curves on success, null on failure.
[ConstOperation]
public Curve[] Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, double angleTolerance, bool loose, CurveOffsetCornerStyle cornerStyle, CurveOffsetEndStyle endStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| directionPoint (Point3d) | A point that indicates the direction of the offset. |
| normal (Vector3d) | The normal to the offset plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| angleTolerance (double) | The angle tolerance, in radians, used to decide whether to split at kinks. |
| loose (bool) | If false, offset within tolerance. If true, offset by moving edit points. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
| endStyle (CurveOffsetEndStyle) | End style for non-loose, non-closed curve offsets. |
Returns: Offset curves on success, null on failure.
Finds a curve by offsetting an existing curve normal to a surface. The caller is responsible for ensuring that the curve lies on the input surface.
Parameters:
| surface (Surface) | Surface from which normals are calculated. |
| height (double) | Offset distance. |
Returns: Curve offset normal to the surface, if successful, null otherwise. The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset.
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, double distance, double fittingTolerance)
Offset this curve on a brep face surface. This curve must lie on the surface.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| distance (double) | A distance to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, double[] curveParameters, double[] offsetDistances, double fittingTolerance)
Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| curveParameters (double[]) | Curve parameters corresponding to the offset distances. |
| offsetDistances (double[]) | distances to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face, curveParameters or offsetDistances are null. |
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, Point2d throughPoint, double fittingTolerance)
Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| throughPoint (Point2d) | 2d point on the brep face to offset through. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, double distance, double fittingTolerance)
Offset a curve on a surface. This curve must lie on the surface.
Parameters:
| surface (Surface) | A surface on which to offset. |
| distance (double) | A distance to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface is null. |
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, double[] curveParameters, double[] offsetDistances, double fittingTolerance)
Offset this curve on a surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.
Parameters:
| surface (Surface) | A surface on which to offset. |
| curveParameters (double[]) | Curve parameters corresponding to the offset distances. |
| offsetDistances (double[]) | Distances to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface, curveParameters or offsetDistances are null. |
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, Point2d throughPoint, double fittingTolerance)
Offset a curve on a surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.
Parameters:
| surface (Surface) | A surface on which to offset. |
| throughPoint (Point2d) | 2d point on the brep face to offset through. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface is null. |
Finds a curve by offsetting an existing curve tangent to a surface. The caller is responsible for ensuring that the curve lies on the input surface.
Parameters:
| surface (Surface) | Surface from which tangents are calculated. |
| height (double) | Offset distance. |
Returns: Curve offset tangent to the surface, if successful, null otherwise. The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset.
OnSwitchToNonConst
protected override void OnSwitchToNonConst()
Is called when a non-constant operation occurs.
Overrides: CommonObject.OnSwitchToNonConst
Return a 3d frame at a parameter. This is slightly different than FrameAt in that the frame is computed in a way so there is minimal rotation from one frame to the next.
public static RegionContainment PlanarClosedCurveRelationship(Curve curveA, Curve curveB, Plane testPlane, double tolerance)
Determines whether two coplanar simple closed curves are disjoint or intersect; otherwise, if the regions have a containment relationship, discovers which curve encloses the other.
public static bool PlanarCurveCollision(Curve curveA, Curve curveB, Plane testPlane, double tolerance)
Determines if two coplanar curves collide (intersect).
Evaluates point at a curve parameter.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Point (location of curve at the parameter t).
Gets a point at a certain length along the curve. The length must be non-negative and less than or equal to the length of the curve. Lengths will not be wrapped when the curve is closed or periodic.
Parameters:
| length (double) | Length along the curve between the start point and the returned point. |
Returns: Point on the curve at the specified length from the start point or Poin3d.Unset on failure.
Gets a point at a certain normalized length along the curve. The length must be between or including 0.0 and 1.0, where 0.0 equals the start of the curve and 1.0 equals the end of the curve.
Parameters:
| length (double) | Normalized length along the curve between the start point and the returned point. |
Returns: Point on the curve at the specified normalized length from the start point or Poin3d.Unset on failure.
Projects a Curve onto a Brep along a given direction.
public static Curve[] ProjectToBrep(Curve curve, IEnumerable<Brep> breps, Vector3d direction, double tolerance, out int[] brepIndices)
Projects a Curve onto a collection of Breps along a given direction.
Parameters:
| curve (Curve) | Curve to project. |
| breps (IEnumerable<Brep>) | Breps to project onto. |
| direction (Vector3d) | Direction of projection. |
| tolerance (double) | Tolerance to use for projection. |
| brepIndices (out int[]) | (out) Integers that identify for each resulting curve which Brep it was projected onto. |
Returns: An array of projected curves or null if the projection set is empty.
public static Curve[] ProjectToBrep(Curve curve, IEnumerable<Brep> breps, Vector3d direction, double tolerance)
Projects a Curve onto a collection of Breps along a given direction.
Parameters:
| curve (Curve) | Curve to project. |
| breps (IEnumerable<Brep>) | Breps to project onto. |
| direction (Vector3d) | Direction of projection. |
| tolerance (double) | Tolerance to use for projection. |
Returns: An array of projected curves or empty array if the projection set is empty.
public static Curve[] ProjectToBrep(IEnumerable<Curve> curves, IEnumerable<Brep> breps, Vector3d direction, double tolerance, bool loose, out int[] curveIndices, out int[] brepIndices)
Projects a collection of Curves onto a collection of Breps along a given direction.
Parameters:
| curves (IEnumerable<Curve>) | Curves to project. |
| breps (IEnumerable<Brep>) | Breps to project onto. |
| direction (Vector3d) | Direction of projection. |
| tolerance (double) | Tolerance to use for projection. |
| loose (bool) | If true, then project curve edit points onto Brep surfaces. |
| curveIndices (out int[]) | Index of which curve in the input list was the source for a curve in the return array. |
| brepIndices (out int[]) | Index of which brep was used to generate a curve in the return array. |
Returns: An array of projected curves. Array is empty if the projection set is empty.
public static Curve[] ProjectToBrep(IEnumerable<Curve> curves, IEnumerable<Brep> breps, Vector3d direction, double tolerance, out int[] curveIndices, out int[] brepIndices)
Projects a collection of Curves onto a collection of Breps along a given direction.
Parameters:
| curves (IEnumerable<Curve>) | Curves to project. |
| breps (IEnumerable<Brep>) | Breps to project onto. |
| direction (Vector3d) | Direction of projection. |
| tolerance (double) | Tolerance to use for projection. |
| curveIndices (out int[]) | Index of which curve in the input list was the source for a curve in the return array. |
| brepIndices (out int[]) | Index of which brep was used to generate a curve in the return array. |
Returns: An array of projected curves. Array is empty if the projection set is empty.
public static Curve[] ProjectToBrep(IEnumerable<Curve> curves, IEnumerable<Brep> breps, Vector3d direction, double tolerance)
Projects a collection of Curves onto a collection of Breps along a given direction.
Parameters:
| curves (IEnumerable<Curve>) | Curves to project. |
| breps (IEnumerable<Brep>) | Breps to project onto. |
| direction (Vector3d) | Direction of projection. |
| tolerance (double) | Tolerance to use for projection. |
Returns: An array of projected curves or empty array if the projection set is empty.
public static Curve[] ProjectToMesh(Curve curve, IEnumerable<Mesh> meshes, Vector3d direction, double tolerance)
Projects a curve to a set of meshes using a direction and tolerance.
Parameters:
| curve (Curve) | A curve. |
| meshes (IEnumerable<Mesh>) | A list, an array, or any enumerable of meshes. |
| direction (Vector3d) | A direction vector. |
| tolerance (double) | A tolerance value. |
Returns: An array of curves if successful, an empty array otherwise.
Projects a curve to a mesh using a direction and tolerance.
public static Curve[] ProjectToMesh(IEnumerable<Curve> curves, IEnumerable<Mesh> meshes, Vector3d direction, double tolerance, bool loose)
Projects a curve to a set of meshes using a direction and tolerance.
Parameters:
| curves (IEnumerable<Curve>) | A list, an array, or any enumerable of curves. |
| meshes (IEnumerable<Mesh>) | A list, an array, or any enumerable of meshes. |
| direction (Vector3d) | A direction vector. |
| tolerance (double) | A tolerance value. |
| loose (bool) | If true, then project curve edit points onto meshes. |
Returns: An array of curves if successful, an empty array otherwise.
public static Curve[] ProjectToMesh(IEnumerable<Curve> curves, IEnumerable<Mesh> meshes, Vector3d direction, double tolerance)
Projects a curve to a set of meshes using a direction and tolerance.
Parameters:
| curves (IEnumerable<Curve>) | A list, an array, or any enumerable of curves. |
| meshes (IEnumerable<Mesh>) | A list, an array, or any enumerable of meshes. |
| direction (Vector3d) | A direction vector. |
| tolerance (double) | A tolerance value. |
Returns: An array of curves if successful, an empty array otherwise.
Constructs a curve by projecting an existing curve to a plane.
Pulls this curve to a brep face and returns the result of that operation.
Returns: An array containing the resulting curves after pulling. This array could be empty.
Exceptions:
| ArgumentNullException | If face is null. |
Pull a curve to a BrepFace using closest point projection.
Parameters:
| curve (Curve) | Curve to pull. |
| face (BrepFace) | Brep face that pulls. |
| tolerance (double) | Tolerance to use for pulling. |
| loose (bool) | If true, the curve's edit points are pulled back to the Brep face's underlying surface. If any edit point misses the surface, the curve will not be created. |
Returns: An array of pulled curves, or an empty array on failure.
Pull a curve to a BrepFace using closest point projection.
Projects this curve onto a mesh.
Parameters:
| mesh (Mesh) | Mesh to project onto. |
| tolerance (double) | Input tolerance. When in doubt, the document's model absolute tolerance. |
| loose (bool) | If true, the curve's edit points are pulled back to the mesh. If any edit point misses the mesh, the curve will not be created. |
Returns: A curve if success, or null on failure.
Makes a polyline approximation of the curve and gets the closest point on the mesh for each point on the curve. Then it "connects the points" so that you have a polyline on the mesh.
Rebuild a curve with a specific point count.
[ConstOperation]
public NurbsCurve RebuildToMatchTemplateCurve(Curve templateCurve, bool flipSourceDirection, bool preserveEndTangents, bool makeSubDFriendly, out Line maximumDeviation)
Rebuilds this curve so it takes on the degree, knot vector, and control point count of a template curve.
Parameters:
| templateCurve (Curve) | The curve to match. |
| flipSourceDirection (bool) | If true and this curve is open, its direction is flipped (reversed) before sampling. Set this when this curve runs opposite the template. |
| preserveEndTangents (bool) | If true and the result is open with at least 4 control points, the interior end control points are adjusted so the result's end tangents match this curve's. |
| makeSubDFriendly (bool) | If true, the result is converted to a SubD friendly curve. |
| maximumDeviation (out Line) | A line from this curve to the rebuilt curve at the point of maximum separation (the "from" point is on this curve, the "to" point is on the rebuilt curve), or Line.Unset if it cannot be computed. |
Returns: The rebuilt NURBS curve, or null if the template curve is unusable or the rebuild fails.
Looks for segments that are shorter than tolerance that can be removed. Does not change the domain, but it will change the relative parameterization.
Parameters:
| tolerance (double) | Tolerance which defines "short" segments. |
Returns: true if removable short segments were found. false if no removable short segments were found.
Repairs a curve.
Parameters:
| tolerance (double) | The repair tolerance. |
Returns: true if successful, false otherwise.
Reparameterizes a curve using automatic parameterization.
Remarks: Poorly parameterized objects may not intersect and trim properly when combined with other objects. "Poorly parameterized" means the curve's domain or the surface's u or v spaces are tiny or huge compared to the size of the object. When curves are parameterized with a [0,1] domain, both the accuracy and the precision of geometric calculations like intersections and closest points are reduced, sometimes dramatically. Ideally the domain of a curve is close to it's length.
Returns: The reparameterized curve if successful, null otherwise.
Reverses the direction of the curve.
Remarks: If reversed, the domain changes from [a,b] to [-b,-a]
Returns: true on success, false on failure.
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out Curve[] crossSections, out Surface[] ruledSurfaces)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
| crossSections (out Curve[]) | Contains lines between input and the offset that might be useful as input to Brep.CreateFromSweep or some other surface creation tool. |
| ruledSurfaces (out Surface[]) | Contain ruled surfaces between the input and the parts of the offset that correspond exactly. Note, there will be gaps between these at blends. |
Returns: The offset curve if successful.
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out double[] outputParameters, out double[] curveParameters)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
| outputParameters (out double[]) | A list of parameter, paired with curveParameters, from the output curve for creating cross sections. |
| curveParameters (out double[]) | A list of parameter, paired with outputParameters, from the input curve for creating cross sections. |
Returns: The offset curve if successful.
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
Returns: The offset curve if successful.
public Curve RibbonOffset(RibbonOffsetParameters ribbonParameters, out Curve[] railCurves, out Curve[] crossSectionCurves, out Brep[] brepSurfaces)
Ribbon offset method to mimic RibbonOffset command
Parameters:
| ribbonParameters (RibbonOffsetParameters) | The ribbon offset parameters |
| railCurves (out Curve[]) | on success an array of split curves representing the sweep rail segments, null on failure |
| crossSectionCurves (out Curve[]) | on success an array of cross section curves used during brep creation, null on failure |
| brepSurfaces (out Brep[]) | on success and array of breps representing the ribbon surfaces, null on failure |
Returns: return an offset curve on success, null on failure
Rotate
Rotates the object about the specified axis. A positive rotation angle results in a counter-clockwise rotation about the axis (right hand rule).
Scale
Scales the object by the specified factor. The scale is centered at the origin.
Parameters:
| scaleFactor (double) | The uniform scaling factor. |
Returns: true if geometry successfully scaled.
Forces the curve to end at a specified point. Not all curve types support this operation.
Remarks: Some end points cannot be moved. Be sure to check return code
Parameters:
| point (Point3d) | New end point of curve. |
Returns: true on success, false on failure.
Forces the curve to start at a specified point. Not all curve types support this operation.
Remarks: Some start points cannot be moved. Be sure to check return code.
Parameters:
| point (Point3d) | New start point of curve. |
Returns: true on success, false on failure.
SetUserString
Attach a user string (key,value combination) to this geometry.
[ConstOperation]
public Curve Simplify(CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)
Returns a geometrically equivalent PolyCurve.
The PolyCurve has the following properties
1. All the PolyCurve segments are LineCurve, PolylineCurve, ArcCurve, or NurbsCurve.
2. The NURBS Curves segments do not have fully multiple interior knots.
3. Rational NURBS curves do not have constant weights.
4. Any segment for which IsLinear() or IsArc() is true is a Line, Polyline segment, or an Arc.
5. Adjacent co-linear or co-circular segments are combined.
6. Segments that meet with G1-continuity have there ends tuned up so that they meet with G1-continuity to within machine precision.
Parameters:
| options (CurveSimplifyOptions) | Simplification options. |
| distanceTolerance (double) | A distance tolerance for the simplification. |
| angleToleranceRadians (double) | An angle tolerance for the simplification. |
Returns: New simplified curve on success, null on failure.
[ConstOperation]
public Curve SimplifyEnd(CurveEnd end, CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)
Same as SimplifyCurve, but simplifies only the last two segments at "side" end.
Parameters:
| end (CurveEnd) | If CurveEnd.Start the function simplifies the last two start side segments, otherwise if CurveEnd.End the last two end side segments are simplified. |
| options (CurveSimplifyOptions) | Simplification options. |
| distanceTolerance (double) | A distance tolerance for the simplification. |
| angleToleranceRadians (double) | An angle tolerance for the simplification. |
Returns: New simplified curve on success, null on failure.
public Curve Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem, Plane plane)
Smooths a curve by averaging the positions of control points in a specified region.
Parameters:
| smoothFactor (double) | The smoothing factor, which controls how much control points move towards the average of the neighboring control points. Note that this smoothFactor is equivalent to twice the smooth factor used in the Smooth command: on a polyline, Rhino _Smooth with a factor of 0.2 is the same as Polyline.Smooth(double) with a factor of 0.4. |
| bXSmooth (bool) | When true control points move in X axis direction. |
| bYSmooth (bool) | When true control points move in Y axis direction. |
| bZSmooth (bool) | When true control points move in Z axis direction. |
| bFixBoundaries (bool) | When true the curve ends don't move. |
| coordinateSystem (SmoothingCoordinateSystem) | The coordinates to determine the direction of the smoothing. |
| plane (Plane) | If SmoothingCoordinateSystem.CPlane specified, then the construction plane. |
Returns: The smoothed curve if successful, null otherwise.
public Curve Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem)
Smooths a curve by averaging the positions of control points in a specified region.
Parameters:
| smoothFactor (double) | The smoothing factor, which controls how much control points move towards the average of the neighboring control points. Note that this smoothFactor is equivalent to twice the smooth factor used in the Smooth command: on a polyline, Rhino _Smooth with a factor of 0.2 is the same as Polyline.Smooth(double) with a factor of 0.4. |
| bXSmooth (bool) | When true control points move in X axis direction. |
| bYSmooth (bool) | When true control points move in Y axis direction. |
| bZSmooth (bool) | When true control points move in Z axis direction. |
| bFixBoundaries (bool) | When true the curve ends don't move. |
| coordinateSystem (SmoothingCoordinateSystem) | The coordinates to determine the direction of the smoothing. |
Returns: The smoothed curve if successful, null otherwise.
SortCurves
#public static bool SortCurves(ICollection<Curve> inputCurves, double tolerance, out IList<IList<SortedSegment>> groups)
Sorts the curves into joinable segment groups. No joining is performed, the curves are only analyzed for start/end proximity.
Parameters:
| inputCurves (ICollection<Curve>) | The curves to sort |
| tolerance (double) | The tolerance to bridge any gaps between curves |
| groups (out IList<IList<Curve.SortedSegment>>) | The groups of curves that can be formed upon joining. A curve that cannot be joined to any other curve forms a group of size 1. No joining is performed. |
Get the domain of the curve span with the given index. Use the SpanCount property to test how many spans there are.
Parameters:
| spanIndex (int) | Index of span. |
Returns: Interval of the span with the given index.
Returns the vector of span division parameters for this curve.
Returns: An array of parameter values that mark the boundaries between spans of the curve.
Splits a curve into pieces using a polysurface.
obsoleteUse version that takes an angle tolerance
Splits a curve into pieces using a polysurface.
Splits (divides) the curve at the specified parameter. The parameter must be in the interior of the curve's domain.
Parameters:
| t (double) | Parameter to split the curve at in the interval returned by Domain(). |
Returns: Two curves on success, null on failure.
Splits (divides) the curve at a series of specified parameters. The parameter must be in the interior of the curve domain.
Parameters:
| t (IEnumerable<double>) | Parameters to split the curve at in the interval returned by Domain(). |
Returns: Multiple curves on success, null on failure.
Splits a curve into pieces using a cutting plane.
[ConstOperation]
public Curve[] Split(Surface cutter, double tolerance, double angleToleranceRadians)
Splits a curve into pieces using a surface.
obsoleteUse version that takes an angle tolerance
Splits a curve into pieces using a surface.
Evaluates the unit tangent vector at a curve parameter.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Unit tangent vector of the curve at the parameter t.
[ConstOperation]
public PolyCurve ToArcsAndLines(double tolerance, double angleTolerance, double minimumLength, double maximumLength)
Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straight-line segments.
Parameters:
| tolerance (double) | The tolerance. This is the maximum deviation from arc midpoints to the curve. When in doubt, use the document's model space absolute tolerance. |
| angleTolerance (double) | The angle tolerance in radians. This is the maximum deviation of the arc end directions from the curve direction. When in doubt, use the document's model space angle tolerance. |
| minimumLength (double) | The minimum segment length. |
| maximumLength (double) | The maximum segment length. |
Returns: PolyCurve on success, null on error.
ToJSON
Create a JSON string representation of this object
Parameters:
| options (SerializationOptions) |
Constructs a NURBS curve representation of this curve.
Returns: NURBS representation of the curve on success, null on failure.
Constructs a NURBS curve representation of this curve.
Parameters:
| subdomain (Interval) | The NURBS representation for this portion of the curve is returned. |
Returns: NURBS representation of the curve on success, null on failure.
[ConstOperation]
public PolylineCurve ToPolyline(double tolerance, double angleTolerance, double minimumLength, double maximumLength)
Gets a polyline approximation of a curve.
Parameters:
| tolerance (double) | The tolerance. This is the maximum deviation from line midpoints to the curve. When in doubt, use the document's model space absolute tolerance. |
| angleTolerance (double) | The angle tolerance in radians. This is the maximum deviation of the line directions. When in doubt, use the document's model space angle tolerance. |
| minimumLength (double) | The minimum segment length. |
| maximumLength (double) | The maximum segment length. |
Returns: PolyCurve on success, null on error.
[ConstOperation]
public PolylineCurve ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint, Interval curveDomain)
Gets a polyline approximation of a curve.
Parameters:
| mainSegmentCount (int) | If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount sub-parts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed. |
| subSegmentCount (int) | An amount of subsegments. |
| maxAngleRadians (double) | ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices. |
| maxChordLengthRatio (double) | Maximum permitted value of (distance chord midpoint to curve) / (length of chord). |
| maxAspectRatio (double) | If maxAspectRatio < 1.0, the parameter is ignored. If 1 <= maxAspectRatio < sqrt(2), it is treated as if maxAspectRatio = sqrt(2). This parameter controls the maximum permitted value of (length of longest chord) / (length of shortest chord). |
| tolerance (double) | If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline. |
| minEdgeLength (double) | The minimum permitted edge length. |
| maxEdgeLength (double) | If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length. |
| keepStartPoint (bool) | If true the starting point of the curve is added to the polyline. If false the starting point of the curve is not added to the polyline. |
| curveDomain (Interval) | This sub-domain of the NURBS curve is approximated. |
Returns: PolylineCurve on success, null on error.
[ConstOperation]
public PolylineCurve ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint)
Gets a polyline approximation of a curve.
Parameters:
| mainSegmentCount (int) | If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount sub-parts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed. |
| subSegmentCount (int) | An amount of subsegments. |
| maxAngleRadians (double) | ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices. |
| maxChordLengthRatio (double) | Maximum permitted value of (distance chord midpoint to curve) / (length of chord). |
| maxAspectRatio (double) | If maxAspectRatio < 1.0, the parameter is ignored. If 1 <= maxAspectRatio < sqrt(2), it is treated as if maxAspectRatio = sqrt(2). This parameter controls the maximum permitted value of (length of longest chord) / (length of shortest chord). |
| tolerance (double) | If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline. |
| minEdgeLength (double) | The minimum permitted edge length. |
| maxEdgeLength (double) | If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length. |
| keepStartPoint (bool) | If true the starting point of the curve is added to the polyline. If false the starting point of the curve is not added to the polyline. |
Returns: PolylineCurve on success, null on error.
Evaluate the torsion of a curve at a parameter. Sometimes also called the "second curvature", torsion is the rate of change of a curve's osculating plane.
Remarks: See Barrett O'Neill, Elementary Differential Geometry, page 69.
Parameters:
| t (double) | The evaluation parameter. |
Returns: The torsion if successful.
Transform
Transforms the geometry. If the input Transform has a SimilarityType of OrientationReversing, you may want to consider flipping the transformed geometry after calling this function when it makes sense. For example, you may want to call Flip() on a Brep after transforming it.
Parameters:
| xform (Transform) | Transformation to apply to geometry. |
Returns: true if geometry successfully transformed.
Translate
Translates the object along the specified vector.
Translate
Translates the object along the specified vector.
Parameters:
| translationVector (Vector3d) | A moving vector. |
Returns: true if geometry successfully translated.
Shortens a curve by a given length
Removes portions of the curve outside the specified interval.
Remarks: If curve is open, then trimming interval must be an increasing interval. If curve is closed, and trimming interval is a decreasing interval, then the portion of the curve across the start/end is returned.
Returns: Trimmed portion of this curve is successful, null on failure.
Removes portions of the curve outside the specified interval.
Remarks: If curve is open, then trimming interval must be an increasing interval. If curve is closed, and trimming interval is a decreasing interval, then the portion of the curve across the start/end is returned.
Parameters:
| domain (Interval) | Trimming interval. |
Returns: Trimmed curve if successful, null on failure.
Trims the curve in-place by removing portions of the curve outside the specified interval.
Trims the curve in-place by removing portions of the curve outside the specified interval.
Remarks: Portions of the curve before curve(domain[0]) and after curve(domain[1]) are removed.
Parameters:
| domain (Interval) | Trimming interval. |
Returns: True if successful, false otherwise.
Try to convert this curve into an Arc using a custom tolerance.
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
Parameters:
| arc (out Arc) | On success, the Arc will be filled in. |
Returns: true if the curve could be converted into an arc.
Try to convert this curve into an Arc using a custom tolerance.
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
Try to convert this curve into a Circle using a custom tolerance.
Try to convert this curve into a circle using RhinoMath.ZeroTolerance.
Parameters:
| circle (out Circle) | On success, the Circle will be filled in. |
Returns: true if the curve could be converted into a Circle.
Try to convert this curve into an Ellipse using a custom tolerance.
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
Parameters:
| ellipse (out Ellipse) | On success, the Ellipse will be filled in. |
Returns: true if the curve could be converted into an Ellipse.
Try to convert this curve into an Ellipse using a custom tolerance.
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
Test a curve for planarity and return the plane.
Test a curve for planarity and return the plane.
Parameters:
| plane (out Plane) | On success, the plane parameters are filled in. |
Returns: true if there is a plane such that the maximum distance from the curve to the plane is <= RhinoMath.ZeroTolerance.
Several types of Curve can have the form of a polyline including a degree 1 NurbsCurve, a PolylineCurve, and a PolyCurve all of whose segments are some form of polyline. IsPolyline tests a curve to see if it can be represented as a polyline.
Several types of Curve can have the form of a polyline including a degree 1 NurbsCurve, a PolylineCurve, and a PolyCurve all of whose segments are some form of polyline. IsPolyline tests a curve to see if it can be represented as a polyline.
Parameters:
| polyline (out Polyline) | If true is returned, then the polyline form is returned here. |
Returns: true if this curve can be represented as a polyline; otherwise, false.