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
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.
Returns: true on success, false on failure.
Changes the dimension of a curve.
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.
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.
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.
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.
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.
Returns: true on success, false on failure.
Gets closest points between this and another curves.
Returns: true on success; false on error.
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.
[ConstOperation]
public bool ClosestPoints()
geometry,
A list, an array or any enumerable set of geometry to search.
out Point3d
pointOnCurve,
The point on curve. This out parameter is assigned during this call.
out Point3d
pointOnObject,
The point on geometry. This out parameter is assigned during this call.
out int
whichGeometry,
The index of the geometry. This out parameter is assigned during this call.
maximumDistance
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. |
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.
[ConstOperation]
public bool ClosestPoints()
geometry,
A list, an array or any enumerable set of geometry to search.
out Point3d
pointOnCurve,
The point on curve. This out parameter is assigned during this call.
out Point3d
pointOnObject,
The point on geometry. This out parameter is assigned during this call.
out int
whichGeometry
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.
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.
[ConstOperation]
public PointContainment Contains()
testPoint,
Point to test.
plane,
Plane in which to compare point and region.
tolerance
Tolerance to use during comparison.
Returns: Relationship between point and curve region.
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
Returns: Relationship between point and curve region.
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.
obsoleteUse version that takes a tolerance
Returns: Relationship between point and curve region.
Gets the curve's control polygon.
Returns: The control polygon as a polyline if successful, null otherwise.
Creates a polycurve consisting of two tangent arc segments that connect two points and two directions.
public static Curve CreateArcBlend()
startPt,
Start of the arc blend curve.
startDir,
Start direction of the arc blend curve.
endPt,
End of the arc blend curve.
endDir,
End direction of the arc blend curve.
controlPointLengthRatio
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.
Returns: Aa arc-cornered rectangular curve if successful, null otherwise.
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.
Returns: The blend curve if successful, false otherwise.
Makes a curve blend between two curves at the parameters specified with the directions and continuities specified.
public static Curve CreateBlendCurve()
curve0,
First curve to blend from.
t0,
Parameter on first curve for blend endpoint.
reverse0,
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,
Continuity for the blend at the start.
curve1,
Second curve to blend from.
t1,
Parameter on second curve for blend endpoint.
reverse1,
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
Continuity for the blend at the end.
Returns: The blend curve on success, or null on failure.
Create a Blend curve between two existing curves.
public static Curve CreateBlendCurve()
curveA,
Curve to blend from (blending will occur at curve end point).
curveB,
Curve to blend to (blending will occur at curve start point).
continuity,
Continuity of blend, either position (G0), tangency (G1), or curvature (G2).
bulgeA,
Bulge factor at curveA end of blend. Values near 1.0 work best.
bulgeB
Bulge factor at curveB end of blend. Values near 1.0 work best.
Remarks: Note: This function only blends with G0, G1, or G2 continuity.
Returns: A curve representing the blend between A and B or null on failure.
Create a Blend curve between two existing curves.
public static Curve CreateBlendCurve()
curveA,
Curve to blend from (blending will occur at curve end point).
curveB,
Curve to blend to (blending will occur at curve start point).
continuity
Continuity of blend, either position (G0), tangency (G1), or curvature (G2).
Remarks: Note: This function only blends with G0, G1, or G2 continuity.
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.
Returns: Result curves on success, empty array if no difference could be calculated.
Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar.
obsoleteUse version that takes tolerance as input
Returns: Result curves on success, empty array if no difference could be calculated.
Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.
public static Curve[] CreateBooleanDifference()
curveA,
The first closed, planar curve.
subtractors,
curves to subtract from the first closed curve.
tolerance
Returns: Result curves on success, empty array if no difference could be calculated.
Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.
public static Curve[] CreateBooleanDifference()
curveA,
The first closed, planar curve.
subtractors
curves to subtract from the first closed curve.
obsoleteUse version that takes tolerance as input
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.
Returns: Result curves on success, empty array if no intersection 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
Returns: Result curves on success, empty array if no intersection could be calculated.
Calculates curve Boolean regions, which trims and splits curves based on their overlapping regions.
public static CurveBooleanRegions CreateBooleanRegions()
curves,
The input curves.
plane,
Regions will be found in the projection of the curves to this plane.
combineRegions,
If true, then adjacent regions will be combined.
tolerance
Function tolerance. When in doubt, use the document's model absolute tolerance.
Returns: The curve Boolean regions if successful, null of no successful.
Curve Boolean method, which trims and splits curves based on their overlapping regions.
public static CurveBooleanRegions CreateBooleanRegions()
curves,
The input curves.
plane,
Regions will be found in the projection of the curves to this plane.
points,
These points will be projected to plane. All regions that contain at least one of these points will be found.
combineRegions,
If true, then adjacent regions will be combined.
tolerance
Function tolerance. When in doubt, use the document's model absolute tolerance.
Returns: The curve Boolean regions if successful, null of no successful.
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.
public static Curve[] CreateBooleanUnion()
curves,
The co-planar curves to union.
tolerance,
The 3d fitting and intersecting tolerance.
indexMap
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.
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.
obsoleteUse version that takes tolerance as input
Returns: Result curves on success, empty array if no union could be calculated.
Generate a catenary curve through catenary apex.
public static Curve CreateCatenaryCurveFromApex()
catenary_start,
catenary start point
catenary_end,
catenary end point
axis_dir,
catenary axis/gravity direction
catenary_apex,
desired catenary apex point
bSmooth,
if false generates polyline output
point_count,
number of points in the output curve
out Point3d
apex_out,
apex point of the output catenary curve
out double
parameter_out,
output catenary parameter "a" in the formula y = a * cosh(x/a)
out double
length_out,
output catenary length
out double
max_deviation_out
sampled max deviation between the output curve and the analytic catenary
Returns: A catenary Curve or null if unsuccessful
Generate a catenary curve of specific length.
public static Curve CreateCatenaryCurveFromLength()
catenary_start,
catenary start point
catenary_end,
catenary end point
axis_dir,
catenary axis/gravity direction
catenary_length,
the desired catenary length
bSmooth,
if false generates polyline output
point_count,
number of points in the output curve
out Point3d
apex_out,
apex point of the output catenary curve
out double
parameter_out,
output catenary parameter "a" in the formula y = a * cosh(x/a)
out double
length_out,
output catenary length
out double
max_deviation_out
sampled max deviation between the output curve and the analytic catenary
Returns: A catenary Curve or null if unsuccessful
Generate a catenary curve from catenary parameter.
public static Curve CreateCatenaryCurveFromParameter()
catenary_start,
catenary start point
catenary_end,
catenary end point
axis_dir,
catenary axis/gravity direction
catenary_parameter,
catenary parameter
bSmooth,
if false generates polyline output
point_count,
number of points in the output curve
out Point3d
apex_out,
apex point of the output catenary curve
out double
parameter_out,
output catenary parameter "a" in the formula y = a * cosh(x/a)
out double
length_out,
output catenary length
out double
max_deviation_out
sampled max deviation between the output curve and the analytic catenary
Returns: A catenary Curve or null if unsuccessful
Generate a catenary curve through a point
public static Curve CreateCatenaryCurveThroughPoint()
catenary_start,
catenary start point
catenary_end,
catenary end point
axis_dir,
catenary axis/gravity direction
through_point,
point on the catenary between catenary_start and catenary_end
bSmooth,
if false generates polyline output
point_count,
number of points in the output curve
out Point3d
apex_out,
apex point of the output catenary curve
out double
parameter_out,
output catenary parameter "a" in the formula y = a * cosh(x/a)
out double
length_out,
output catenary length
out double
max_deviation_out
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.
public static Curve CreateConicCornerRectangle()
rectangle,
The rectangle.
rho
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.
public static Curve CreateControlPointCurve()
points,
Control points.
degree
Degree of curve. The number of control points must be at least degree+1.
Constructs a control-point of degree=3 (or less).
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.
public static Curve[] CreateCurve2View()
curveA,
The first curve.
curveB,
The second curve.
vectorA,
A vector defining the normal direction of the plane which the first curve is drawn upon.
vectorB,
A vector defining the normal direction of the plane which the second curve is drawn upon.
tolerance,
The tolerance for the operation.
angleTolerance
The angle tolerance for the operation.
Returns: An array containing one or more curves if successful.
Computes the fillet arc for a curve filleting operation.
Returns: The fillet arc on success, or Arc.Unset on failure.
Rounds the corners of a kinked curve with arcs of a single, specified radius.
public static Curve CreateFilletCornersCurve()
curve,
The curve to fillet.
radius,
The fillet radius.
tolerance,
The tolerance. When in doubt, use the document's model space absolute tolerance.
angleTolerance
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.
Creates a tangent arc between two curves and trims or extends the curves to the arc.
public static Curve[] CreateFilletCurves()
curve0,
The first curve to fillet.
point0,
A point on the first curve that is near the end where the fillet will be created.
curve1,
The second curve to fillet.
point1,
A point on the second curve that is near the end where the fillet will be created.
radius,
The radius of the fillet.
join,
Join the output curves.
trim,
Trim copies of the input curves to the output fillet curve.
arcExtension,
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,
The tolerance, generally the document's absolute tolerance.
angleTolerance
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.
Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
public static Curve CreateInterpolatedCurve()
points,
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,
The degree of the curve >=1. Note: Even degree > 3 periodic interpolation results in a non-periodic closed curve.
knots,
Knot-style to use and specifies if the curve should be periodic.
startTangent,
A starting tangent.
endTangent
An ending tangent.
Returns: interpolated curve on success. null on failure.
Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
public static Curve CreateInterpolatedCurve()
points,
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,
The degree of the curve >=1. Note: Even degree > 3 periodic interpolation results in a non-periodic closed curve.
knots
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.
public static Curve CreateInterpolatedCurve()
points,
Points to interpolate (Count must be >= 2)
degree
The degree of the curve >=1. Degree must be odd.
Returns: interpolated curve on success. null on failure.
Changes a curve end to meet a specified curve with a specified continuity.
public static Curve[] CreateMatchCurve()
curve0,
The open curve to change.
reverse0,
Reverse the direction of the curve to change before matching.
continuity,
The continuity at the curve end.
curve1,
The open curve to match.
reverse1,
Reverse the direction of the curve to match before matching.
preserve,
Prevent modification of the curvature at the end opposite the match for curves with fewer than six control points.
average
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.
public static Curve CreateMeanCurve()
curveA,
A first curve.
curveB,
A second curve.
angleToleranceRadians
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. |
Rebuilds the curve to a NURBS curve with the specified options.
public static NurbsCurve CreateNurbsCurveFit()
curve,
The input curve you would like to rebuild
domain,
The domain to process
rebuildOptions,
Specifies how to rebuild the curve
out Line
maximumSeparation,
out double
thisSeparationParameter,
out double
nurbsSeparationParameter
Returns: The resulting curveb
Removes kinks from a curve. Periodic curves deform smoothly without kinks.
public static Curve CreatePeriodicCurve()
curve,
The curve to make periodic. Curve must have degree >= 2.
smooth
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.
Returns: The resulting curve if successful, null otherwise.
Creates a revision cloud curve from a planar curve.
public static Curve CreateRevisionCloud()
curve,
The input planar curve.
segmentCount,
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,
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
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.
public static Curve CreateRevisionCloud()
points,
The input points.
angle,
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
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 soft edited curve from an existing curve using a smooth field of influence.
public static Curve CreateSoftEditCurve()
curve,
The curve to soft edit.
t,
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,
The direction and magnitude, or maximum distance, of the move.
length,
The distance along the curve from the editing point over which the strength of the editing falls off smoothly.
fixEnds
Returns: The soft edited curve if successful. null on failure.
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.
public static Curve[] CreateTextOutlines()
text,
The text from which to create outline curves.
font,
The text font. If the font does not exist on the system. Rhino will use a substitute with similar properties.
textHeight,
The text height.
textStyle,
The font style. The font style can be any number of the following: 0 - Normal, 1 - Bold, 2 - Italic
closeLoops,
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,
The plane on which the outline curves will lie.
smallCapsScale,
Displays lower-case letters as small caps. Set the relative text size to a percentage of the normal text. Use 1.0 for no small caps.
tolerance
The tolerance for the operation.
Returns: An array containing one or more curves if successful.
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.
Returns: An array of tween curves. This array can be empty.
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
Returns: An array of tween curves. This array can be empty.
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.
Returns: An array of tween curves. This array can be empty.
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
Returns: An array of tween curves. This array can be empty.
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.
public static Curve[] CreateTweenCurvesWithSampling()
curve0,
The first, or starting, curve.
curve1,
The second, or ending, curve.
numCurves,
Number of tween curves to create.
numSamples,
Number of sample points along input curves.
tolerance
The tolerance. When in doubt, use the document's model absolute tolerance.
Returns: >An array of tween curves. This array can be empty.
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.
obsoleteUse version that takes tolerance as input
Returns: >An array of tween curves. This array can be empty.
Evaluate the curvature vector at a curve parameter.
Remarks: No error handling.
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.
Returns: CRC of the information the defines the object.
DeleteAllUserStrings
public void DeleteAllUserStrings()
Evaluate the derivatives at the specified curve parameter.
[ConstOperation]
public Vector3d[] DerivativeAt()
t,
Curve parameter to evaluate.
derivativeCount,
Number of derivatives to evaluate, must be at least 0.
side
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.
Returns: An array of vectors that represents all the derivatives starting at zero.
Dispose
Actively reclaims unmanaged resources that this instance uses.
public void Dispose()
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.
protected override void Dispose()
disposing
true if the call comes from the Dispose() method; false if it comes from the Garbage Collector finalizer.
Overrides: GeometryBase.Dispose
Divides this curve at fixed steps along a defined contour line.
Returns: An array of points; or null on error.
Divide the curve into a number of equal-length segments.
[ConstOperation]
public double[] DivideByCount()
segmentCount,
Segment count. Note that the number of division points may differ from the segment count.
includeEnds,
If true, then the point at the start of the first division segment is returned.
points
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.
Returns: List of curve parameters at the division points on success, null on failure.
Divide the curve into specific length segments.
[ConstOperation]
public double[] DivideByLength()
segmentLength,
The length of each and every segment (except potentially the last one).
includeEnds,
If true, then the point at the start of the first division segment is returned.
reverse,
If true, then the divisions start from the end of the curve.
points
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.
[ConstOperation]
public double[] DivideByLength()
segmentLength,
The length of each and every segment (except potentially the last one).
includeEnds,
If true, then the point at the start of the first division segment is returned.
reverse
If true, then the divisions start from the end of the curve.
Returns: Array containing division curve parameters if successful, null on failure.
Divide the curve into specific length segments.
[ConstOperation]
public double[] DivideByLength()
segmentLength,
The length of each and every segment (except potentially the last one).
includeEnds,
If true, then the point at the start of the first division segment is returned.
points
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.
Returns: Array containing division curve parameters if successful, null on failure.
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.
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.
Returns: An array of equidistant points, or null on error.
Determines whether two curves travel more or less in the same direction.
Returns: true if both curves more or less point in the same direction, false if they point in the opposite directions.
Constructs an exact duplicate of this Curve.
Overrides: GeometryBase.Duplicate
See Also: DuplicateCurve()
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
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.
public void EnsurePrivateCopy()
Extends a curve until it intersects a collection of objects.
[ConstOperation]
public Curve Extend()
side,
The end of the curve to extend.
style,
The style or type of extension to use.
geometry
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.
[ConstOperation]
public Curve Extend()
side,
The end of the curve to extend.
style,
The style or type of extension to use.
endPoint
A new end point.
Returns: New extended curve result on success, null on failure.
Extends a curve by a specific length.
[ConstOperation]
public Curve Extend()
side,
Curve end to extend.
length,
Length to add to the curve end.
style
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.
[ConstOperation]
public Curve Extend()
t0,
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
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.
Returns: Extended curve on success, null on failure.
Extends a curve by an Arc until it intersects a collection of objects.
[ConstOperation]
public Curve ExtendByArc()
side,
The end of the curve to extend.
geometry
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.
[ConstOperation]
public Curve ExtendByLine()
side,
The end of the curve to extend.
geometry
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.
Returns: New extended curve result on success, null on failure.
Extends a curve on a surface.
Returns: New extended curve result on success, null on failure.
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.
Returns: The parameter values of all local extrema.
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.
[ConstOperation]
public Curve Fair()
distanceTolerance,
Maximum allowed distance the faired curve is allowed to deviate from the input.
angleTolerance,
(in radians) kinks with angles <= angleTolerance are smoothed out 0.05 is a good default.
clampStart,
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,
Same as clampStart.
iterations
The number of iterations to use in adjusting the curve.
Returns: Returns new faired Curve on success, null on failure.
Creates a constant-radius fillet surface between a surface and the curve.
public bool FilletSurfaceToCurve()
face,
the face being filleted.
t,
A parameter on the curve, indicating region of fillet.
u,
A parameter in the u direction of the face indicating which side of the curve to fillet.
v,
A parameter in the v direction of the face indicating which side of the curve to fillet.
radius,
The radius of the constant-radius fillet desired. NOTE: using arcSliders will change the shape of the arcs themselves
alignToCurve,
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,
Desired fillet degree (3 or 5) in the u-direction, along the curve
arcDegree,
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,
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,
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,
The tolerance. In in doubt, the document's absolute tolerance.
out_fillets,
he results of the fillet calculation.
fitResults
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.
Creates a surface between two surfaces, with a fixed rail curve on the first surface.
[ConstOperation]
public bool FilletSurfaceToRail()
faceWithCurve,
The first face on which the curve exists
secondFace,
The second face
u1,
A parameter in the u direction of the second face at the side you want to keep after filleting.
v1,
A parameter in the v direction of the second face at the side you want to keep after filleting.
railDegree,
Desired fillet degree (3 or 5) in the u-direction, along the rails
arcDegree,
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,
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,
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,
If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges.
split_type,
The split type
tolerance,
The tolerance. In in doubt, the document's absolute tolerance.
out_fillets,
The results of the fillet calculation.
out_breps0,
The trim or split results of the Brep owned by faceWithCurve.
out_breps1,
The trim or split results of the Brep owned by pFace1.
fitResults
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
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.
Returns: true if successful, false otherwise.
Local minimization for point on a curve with tangent perpendicular to N.
public bool FindLocalInflection()
N,
This vector and the curve tangent define a plane. In this plane, there is a vector V perpendicular to the tangent.
subDomain,
Subdomain of curve to evaluate. This must not be empty.
seed,
A seed parameter, which must be included in the subdomain.
out double
curveParameter,
The parameter on the curve if successful, RhinoMath.UnsetValue if unsuccessful.
out double
angleError
The measure, in radians, of the angle between N and V. The angle will be zero when the result is an inflection.
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.
Returns: true if the minimization succeeds, regardless of angle_error, false if unsuccessful.
Fits a new curve through an existing curve.
[ConstOperation]
public Curve Fit()
degree,
The degree of the returned Curve. Must be bigger than 1.
fitTolerance,
The fitting tolerance. If fitTolerance is RhinoMath.UnsetValue or <=0.0, the document absolute tolerance is used.
angleTolerance
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.
Returns: true on success, false on failure.
GetBoundingBox
Bounding box solver. Gets the world axis aligned bounding box for the geometry.
[ConstOperation]
public BoundingBox GetBoundingBox()
accurate
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.
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.
[ConstOperation]
public virtual BoundingBox GetBoundingBox()
xform
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.
Returns the type of conic section based on the curve's shape.
[ConstOperation]
public ConicSectionType GetConicSectionType()
out Point3d
focus1,
The first focus point, if applicable.
out Point3d
focus2,
The second focus point, if applicable.
out Point3d
center
The center point, if applicable.
Convert a NURBS curve parameter to a curve parameter.
Remarks: If HasNurbForm returns 2, this function converts the curve parameter to the NURBS curve parameter.
Returns: true on success, false on failure.
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).
public static bool GetDistancesBetweenCurves()
curveA,
A curve.
curveB,
Another curve.
tolerance,
A tolerance value.
out double
maxDistance,
The maximum distance value. This is an out reference argument.
out double
maxDistanceParameterA,
The maximum distance parameter on curve A. This is an out reference argument.
out double
maxDistanceParameterB,
The maximum distance parameter on curve B. This is an out reference argument.
out double
minDistance,
The minimum distance value. This is an out reference argument.
out double
minDistanceParameterA,
The minimum distance parameter on curve A. This is an out reference argument.
out double
minDistanceParameterB
The minimum distance parameter on curve B. This is an out reference argument.
Returns: true if the operation succeeded; otherwise false.
Finds points at which to cut a pair of curves so that a fillet of given radius can be inserted.
public static bool GetFilletPoints()
curve0,
First curve to fillet.
curve1,
Second curve to fillet.
radius,
Fillet radius.
t0Base,
Parameter value for base point on curve0.
t1Base,
Parameter value for base point on curve1.
out double
t0,
Parameter value of fillet point on curve 0.
out double
t1,
Parameter value of fillet point on curve 1.
out Plane
filletPlane
The fillet is contained in this plane with the fillet center at the plane origin.
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.
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.
Returns: The length of the sub-curve on success, or zero on failure.
Get the length of the curve.
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.
Returns: The length of the sub-curve on success, or zero on failure.
Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
Returns: True if a solution is found, false otherwise.
Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
Returns: True if a solution is found, false otherwise.
Search for a location on the curve, near seedParmameter, that is tangent to a test point.
Returns: True if a solution is found, false otherwise.
Search for a location on the curve, near seedParmameter, that is tangent to a test point.
Returns: True if a solution is found, false otherwise.
Searches for a derivative, tangent, or curvature discontinuity.
[ConstOperation]
public bool GetNextDiscontinuity()
continuityType,
Type of continuity to search for.
t0,
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,
(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,
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,
(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.
out double
t
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.
Searches for a derivative, tangent, or curvature discontinuity.
[ConstOperation]
public bool GetNextDiscontinuity()
continuityType,
Type of continuity to search for.
t0,
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,
(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.
out double
t
If a discontinuity is found, then t reports the parameter at the 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.
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.
Convert a curve parameter to a NURBS curve parameter.
Remarks: If GetNurbForm returns 2, this function converts the curve parameter to the NURBS curve parameter.
Returns: true on success, false on failure.
GetObjectData
Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData()
info,
The System.Runtime.Serialization.SerializationInfo to populate with data.
context
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.
[ConstOperation]
public Plane[] GetPerpendicularFrames()
parameters
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.
GetUserString
Gets user string from this geometry.
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.
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.
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.
Returns: true if the curve can be represented by a circle to within tolerance.
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.
[ConstOperation]
public bool IsClosable()
tolerance,
Maximum allowable distance between start and end. If start - end gap is greater than tolerance, this function will return false.
minimumAbsoluteSize,
If greater than 0.0 and none of the interior sampled points are at least minimumAbsoluteSize from start, this function will return false.
minimumRelativeSize
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.
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.
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.
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.
Returns: true if the maximum distance from the curve to the testPlane is <= tolerance.
Test a curve to see if it lies in a specific plane.
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.
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.
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.
Remarks: Faster than calling Length() and testing the result.
Returns: true if the length of the curve is <= tolerance.
Used to quickly find short curves.
Remarks: Faster than calling Length() and testing the result.
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.
Returns: true if this object is valid; false otherwise.
Joins a collection of curve segments together.
public static Curve[] JoinCurves()
inputCurves,
An array, a list or any enumerable set of curve segments to join.
joinTolerance,
Joining tolerance, i.e. the distance between segment end-points that is allowed.
preserveDirection,
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,
Set true to use the simple joining method. In general, set this parameter to false.
key
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. |
Joins a collection of curve segments together.
public static Curve[] JoinCurves()
inputCurves,
An array, a list or any enumerable set of curve segments to join.
joinTolerance,
Joining tolerance, i.e. the distance between segment end-points that is allowed.
preserveDirection,
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
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. |
Joins a collection of curve segments together.
public static Curve[] JoinCurves()
inputCurves,
An array, a list or any enumerable set of curve segments to join.
joinTolerance,
Joining tolerance, i.e. the distance between segment end-points that is allowed.
preserveDirection
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.
public static Curve[] JoinCurves()
inputCurves,
An array, a list or any enumerable set of curve segments to join.
joinTolerance
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.
Returns: An array of joined curves. This array can be empty.
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]
[EditorBrowsable(EditorBrowsableState.Never)]
public bool LcoalClosestPoint()
testPoint,
A point to test against.
seed,
The seed parameter.
out double
t
>Parameter of the curve that is closest to testPoint.
obsoleteTypo: use LocalClosestPoint
Returns: true if the search is successful, false if the search fails.
Gets the parameter along the curve which coincides with a given length along the curve.
[ConstOperation]
public bool LengthParameter()
segmentLength,
Length of segment to measure. Must be less than or equal to the length of the sub-domain.
out double
t,
Parameter such that the length of the curve from the start of the sub-domain to t is s.
fractionalTolerance,
Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance.
subdomain
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.
[ConstOperation]
public bool LengthParameter()
segmentLength,
Length of segment to measure. Must be less than or equal to the length of the curve.
out double
t,
Parameter such that the length of the curve from the curve start point to t equals s.
fractionalTolerance
Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance.
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.
[ConstOperation]
public bool LengthParameter()
segmentLength,
Length of segment to measure. Must be less than or equal to the length of the sub-domain.
out double
t,
Parameter such that the length of the curve from the start of the sub-domain to t is s.
subdomain
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.
Returns: true on success, false on failure.
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.
Returns: true if the search is successful, false if the search fails.
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.
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.
Makes adjustments to the ends of one or both input curves so that they meet at a point.
Returns: true on success.
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.
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
#For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.
protected override void NonConstOperation()
Overrides: GeometryBase.NonConstOperation
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
[ConstOperation]
public bool NormalizedLengthParameter()
s,
Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
out double
t,
Parameter such that the length of the curve from its start to t is arc_length.
fractionalTolerance,
Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance.
subdomain
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.
[ConstOperation]
public bool NormalizedLengthParameter()
s,
Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
out double
t,
Parameter such that the length of the curve from its start to t is arc_length.
fractionalTolerance
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.
[ConstOperation]
public bool NormalizedLengthParameter()
s,
Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
out double
t,
Parameter such that the length of the curve from its start to t is arc_length.
subdomain
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.
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.
[ConstOperation]
public double[] NormalizedLengthParameters()
double[]
s,
Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
absoluteTolerance,
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,
Desired fractional precision for each segment. fabs("true" length - actual length)/(actual length) <= fractionalTolerance.
subdomain
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.
[ConstOperation]
public double[] NormalizedLengthParameters()
double[]
s,
Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
absoluteTolerance,
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
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.
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,
Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
absoluteTolerance,
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
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.
[ConstOperation]
public double[] NormalizedLengthParameters()
double[]
s,
Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
absoluteTolerance
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.
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.
[ConstOperation]
public Curve[] Offset()
plane,
Offset solution plane.
distance,
The positive or negative distance to offset.
tolerance,
The offset or fitting tolerance.
cornerStyle
Corner style for offset kinks.
Returns: Offset curves on success, null on failure.
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.
[ConstOperation]
public Curve[] Offset()
directionPoint,
A point that indicates the direction of the offset.
normal,
The normal to the offset plane.
distance,
The positive or negative distance to offset.
tolerance,
The offset or fitting tolerance.
cornerStyle
Corner style for offset kinks.
Returns: Offset curves on success, null on failure.
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.
[ConstOperation]
public Curve[] Offset()
directionPoint,
A point that indicates the direction of the offset.
normal,
The normal to the offset plane.
distance,
The positive or negative distance to offset.
tolerance,
The offset or fitting tolerance.
angleTolerance,
The angle tolerance, in radians, used to decide whether to split at kinks.
loose,
If false, offset within tolerance. If true, offset by moving edit points.
cornerStyle,
Corner style for offset kinks.
endStyle
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.
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.
Offset this curve on a brep face surface. This curve must lie on the surface.
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
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.
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face, curveParameters or offsetDistances are null. |
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.
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
Offset a curve on a surface. This curve must lie on the surface.
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface is null. |
Offset this curve on a surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface, curveParameters or offsetDistances are null. |
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.
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.
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
Is called when a non-constant operation occurs.
protected override void OnSwitchToNonConst()
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.
Returns: true on success, false on failure.
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 RegionContainment PlanarClosedCurveRelationship()
curveA,
A first curve.
curveB,
A second curve.
testPlane,
A plane.
tolerance
A tolerance value.
Returns: A value indicating the relationship between the first and the second curve.
Determines if two coplanar curves collide (intersect).
Returns: true if the curves intersect, otherwise false
Evaluates point at a curve parameter.
Remarks: No error handling.
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.
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.
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.
Returns: An array of projected curves or empty array if the projection set is empty.
Projects a Curve onto a collection of Breps along a given direction.
public static Curve[] ProjectToBrep()
curve,
Curve to project.
breps,
Breps to project onto.
direction,
Direction of projection.
tolerance,
Tolerance to use for projection.
brepIndices
(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.
Projects a Curve onto a collection of Breps along a given direction.
Returns: An array of projected curves or empty array if the projection set is empty.
Projects a collection of Curves onto a collection of Breps along a given direction.
public static Curve[] ProjectToBrep()
curves,
Curves to project.
breps,
Breps to project onto.
direction,
Direction of projection.
tolerance,
Tolerance to use for projection.
loose,
If true, then project curve edit points onto Brep surfaces.
curveIndices,
Index of which curve in the input list was the source for a curve in the return array.
brepIndices
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.
Projects a collection of Curves onto a collection of Breps along a given direction.
public static Curve[] ProjectToBrep()
curves,
Curves to project.
breps,
Breps to project onto.
direction,
Direction of projection.
tolerance,
Tolerance to use for projection.
curveIndices,
Index of which curve in the input list was the source for a curve in the return array.
brepIndices
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.
Projects a collection of Curves onto a collection of Breps along a given direction.
public static Curve[] ProjectToBrep()
curves,
Curves to project.
breps,
Breps to project onto.
direction,
Direction of projection.
tolerance
Tolerance to use for projection.
Returns: An array of projected curves or empty array if the projection set is empty.
Projects a curve to a set of meshes using a direction and tolerance.
public static Curve[] ProjectToMesh()
curve,
A curve.
meshes,
A list, an array, or any enumerable of meshes.
direction,
A direction vector.
tolerance
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.
Returns: An array of curves if successful, an empty array otherwise.
Projects a curve to a set of meshes using a direction and tolerance.
public static Curve[] ProjectToMesh()
curves,
A list, an array, or any enumerable of curves.
meshes,
A list, an array, or any enumerable of meshes.
direction,
A direction vector.
tolerance,
A tolerance value.
loose
If true, then project curve edit points onto meshes.
Returns: An array of curves if successful, an empty array otherwise.
Projects a curve to a set of meshes using a direction and tolerance.
public static Curve[] ProjectToMesh()
curves,
A list, an array, or any enumerable of curves.
meshes,
A list, an array, or any enumerable of meshes.
direction,
A direction vector.
tolerance
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.
Returns: The projected curve on success; null on failure.
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.
public static Curve[] PullToBrepFace()
curve,
Curve to pull.
face,
Brep face that pulls.
tolerance,
Tolerance to use for pulling.
loose
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.
Returns: An array of pulled curves, or an empty array on failure.
Projects this curve onto a mesh.
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.
[ConstOperation]
public PolylineCurve PullToMesh()
Mesh
mesh,
Mesh to project onto.
tolerance
Input tolerance. When in doubt, the document's model absolute tolerance.
Returns: A curve if success, or null on failure.
Rebuild a curve with a specific point count.
[ConstOperation]
public NurbsCurve Rebuild()
pointCount,
Number of control points in the rebuild curve.
degree,
Degree of curve. Valid values are between and including 1 and 11.
preserveTangents
If true, the end tangents of the input curve will be preserved.
Returns: A NURBS curve on success or null on failure.
Rebuilds this curve so it takes on the degree, knot vector, and control point count of a template curve.
[ConstOperation]
public NurbsCurve RebuildToMatchTemplateCurve()
templateCurve,
The curve to match.
flipSourceDirection,
If true and this curve is open, its direction is flipped (reversed) before sampling. Set this when this curve runs opposite the template.
preserveEndTangents,
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,
If true, the result is converted to a SubD friendly curve.
out Line
maximumDeviation
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.
Returns: true if removable short segments were found. false if no removable short segments were found.
Repairs a curve.
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.
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.
public Curve RibbonOffset()
distance,
The positive distance to offset the curve.
blendRadius,
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,
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,
A vector that indicates the normal of the plane in which the offset will occur.
tolerance,
Used to determine self-intersections, not offset error.
crossSections,
Contains lines between input and the offset that might be useful as input to Brep.CreateFromSweep or some other surface creation tool.
ruledSurfaces
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.
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.
public Curve RibbonOffset()
distance,
The positive distance to offset the curve.
blendRadius,
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,
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,
A vector that indicates the normal of the plane in which the offset will occur.
tolerance,
Used to determine self-intersections, not offset error.
outputParameters,
A list of parameter, paired with curveParameters, from the output curve for creating cross sections.
curveParameters
A list of parameter, paired with outputParameters, from the input curve for creating cross sections.
Returns: The offset curve if successful.
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.
public Curve RibbonOffset()
distance,
The positive distance to offset the curve.
blendRadius,
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,
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,
A vector that indicates the normal of the plane in which the offset will occur.
tolerance
Used to determine self-intersections, not offset error.
Returns: The offset curve if successful.
Ribbon offset method to mimic RibbonOffset command
public Curve RibbonOffset()
ribbonParameters,
The ribbon offset parameters
railCurves,
on success an array of split curves representing the sweep rail segments, null on failure
crossSectionCurves,
on success an array of cross section curves used during brep creation, null on failure
brepSurfaces
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).
Returns: true if geometry successfully rotated.
Scale
Scales the object by the specified factor. The scale is centered at the origin.
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
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.
Returns: true on success, false on failure.
SetUserString
Attach a user string (key,value combination) to this geometry.
Returns: true on success.
Returns a geometrically equivalent PolyCurve.
The PolyCurve has the following properties
- 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.
[ConstOperation]
public Curve Simplify()
options,
Simplification options.
distanceTolerance,
A distance tolerance for the simplification.
angleToleranceRadians
An angle tolerance for the simplification.
Returns: New simplified curve on success, null on failure.
Same as SimplifyCurve, but simplifies only the last two segments at "side" end.
[ConstOperation]
public Curve SimplifyEnd()
end,
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,
Simplification options.
distanceTolerance,
A distance tolerance for the simplification.
angleToleranceRadians
An angle tolerance for the simplification.
Returns: New simplified curve on success, null on failure.
Smooths a curve by averaging the positions of control points in a specified region.
public Curve Smooth()
smoothFactor,
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,
When true control points move in X axis direction.
bYSmooth,
When true control points move in Y axis direction.
bZSmooth,
When true control points move in Z axis direction.
bFixBoundaries,
When true the curve ends don't move.
coordinateSystem,
The coordinates to determine the direction of the smoothing.
plane
If SmoothingCoordinateSystem.CPlane specified, then the construction plane.
Returns: The smoothed curve if successful, null otherwise.
Smooths a curve by averaging the positions of control points in a specified region.
public Curve Smooth()
smoothFactor,
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,
When true control points move in X axis direction.
bYSmooth,
When true control points move in Y axis direction.
bZSmooth,
When true control points move in Z axis direction.
bFixBoundaries,
When true the curve ends don't move.
coordinateSystem
The coordinates to determine the direction of the smoothing.
Returns: The smoothed curve if successful, null otherwise.
SortCurves
#Sorts the curves into joinable segment groups. No joining is performed, the curves are only analyzed for start/end proximity.
public static bool SortCurves()
inputCurves,
The curves to sort
tolerance,
The tolerance to bridge any gaps between curves
groups
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.
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.
Returns: An array of curves. This array can be empty.
Splits a curve into pieces using a polysurface.
obsoleteUse version that takes an angle tolerance
Returns: An array of curves. This array can be empty.
Splits (divides) the curve at the specified parameter. The parameter must be in the interior of the curve's 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.
Returns: Multiple curves on success, null on failure.
Splits a curve into pieces using a cutting plane.
Returns: An array of curves. This array can be empty.
Splits a curve into pieces using a surface.
Returns: An array of curves. This array can be empty.
Splits a curve into pieces using a surface.
obsoleteUse version that takes an angle tolerance
Returns: An array of curves. This array can be empty.
Evaluates the unit tangent vector at a curve parameter.
Remarks: No error handling.
Returns: Unit tangent vector of the curve at the parameter t.
Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straight-line segments.
[ConstOperation]
public PolyCurve ToArcsAndLines()
tolerance,
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,
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,
The minimum segment length.
maximumLength
The maximum segment length.
Returns: PolyCurve on success, null on error.
ToJSON
Create a JSON string representation of this object
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.
Returns: NURBS representation of the curve on success, null on failure.
Gets a polyline approximation of a curve.
[ConstOperation]
public PolylineCurve ToPolyline()
tolerance,
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,
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,
The minimum segment length.
maximumLength
The maximum segment length.
Returns: PolyCurve on success, null on error.
Gets a polyline approximation of a curve.
[ConstOperation]
public PolylineCurve ToPolyline()
mainSegmentCount,
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,
An amount of subsegments.
maxAngleRadians,
( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices.
maxChordLengthRatio,
Maximum permitted value of (distance chord midpoint to curve) / (length of chord).
maxAspectRatio,
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,
If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline.
minEdgeLength,
The minimum permitted edge length.
maxEdgeLength,
If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length.
keepStartPoint,
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
This sub-domain of the NURBS curve is approximated.
Returns: PolylineCurve on success, null on error.
Gets a polyline approximation of a curve.
[ConstOperation]
public PolylineCurve ToPolyline()
mainSegmentCount,
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,
An amount of subsegments.
maxAngleRadians,
( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices.
maxChordLengthRatio,
Maximum permitted value of (distance chord midpoint to curve) / (length of chord).
maxAspectRatio,
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,
If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline.
minEdgeLength,
The minimum permitted edge length.
maxEdgeLength,
If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length.
keepStartPoint
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.
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.
Returns: true if geometry successfully transformed.
Translate
Translates the object along the specified vector.
Returns: true if geometry successfully translated.
Translate
Translates the object along the specified vector.
Returns: true if geometry successfully translated.
Shortens a curve by a given length
Returns: Trimmed curve if 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.
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.
Returns: Trimmed curve if successful, null on failure.
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.
Returns: True if successful, false otherwise.
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.
Returns: True if successful, false otherwise.
Try to convert this curve into an Arc using a custom tolerance.
Returns: true if the curve could be converted into an arc.
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
Returns: true if the curve could be converted into an arc.
Try to convert this curve into an Arc using a custom tolerance.
Returns: true if the curve could be converted into an arc within the given plane.
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
Returns: true if the curve could be converted into an arc within the given plane.
Try to convert this curve into a Circle using a custom tolerance.
Returns: true if the curve could be converted into a Circle within tolerance.
Try to convert this curve into a circle using RhinoMath.ZeroTolerance.
Returns: true if the curve could be converted into a Circle.
Try to convert this curve into an Ellipse using a custom tolerance.
Returns: true if the curve could be converted into an Ellipse.
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
Returns: true if the curve could be converted into an Ellipse.
Try to convert this curve into an Ellipse using a custom tolerance.
Returns: true if the curve could be converted into an Ellipse within the given plane.
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
Returns: true if the curve could be converted into an Ellipse within the given plane.
Test a curve for planarity and return the plane.
Returns: true if there is a plane such that the maximum distance from the curve to the plane is <= tolerance.
Test a curve for planarity and return the plane.
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.
Returns: true if this curve can be represented as a polyline; otherwise, false.
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.