RhinoCompute.Curve¶

RhinoCompute.Curve.
getConicSectionType
(thisCurve, multiple=false)¶ Returns the type of conic section based on the curve’s shape.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Return type: ConicSectionType

RhinoCompute.Curve.
createInterpolatedCurve
(points, degree, multiple=false)¶ Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Arguments:  degree (int) – The degree of the curve >=1. Degree must be odd.
 points (list[rhino3dm.Point3d]) – Points to interpolate (Count must be >= 2)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: interpolated curve on success. None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createInterpolatedCurve1
(points, degree, knots, multiple=false)¶ Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Arguments:  degree (int) – The degree of the curve >=1. Degree must be odd.
 points (list[rhino3dm.Point3d]) – Points to interpolate. For periodic curves if the final point is a duplicate of the initial point it is ignored. (Count must be >=2)
 knots (CurveKnotStyle) – Knotstyle to use and specifies if the curve should be periodic.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: interpolated curve on success. None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createInterpolatedCurve2
(points, degree, knots, startTangent, endTangent, multiple=false)¶ Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.
Arguments:  degree (int) – The degree of the curve >=1. Degree must be odd.
 points (list[rhino3dm.Point3d]) – Points to interpolate. For periodic curves if the final point is a duplicate of the initial point it is ignored. (Count must be >=2)
 knots (CurveKnotStyle) – Knotstyle to use and specifies if the curve should be periodic.
 startTangent (rhino3dm.Vector3d) – A starting tangent.
 endTangent (rhino3dm.Vector3d) – An ending tangent.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: interpolated curve on success. None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createSoftEditCurve
(curve, t, delta, length, fixEnds, multiple=false)¶ Creates a soft edited curve from an existing curve using a smooth field of influence.
Arguments:  curve (rhino3dm.Curve) – The curve to soft edit.
 t (float) – 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 (rhino3dm.Vector3d) – The direction and magnitude, or maximum distance, of the move.
 length (float) – The distance along the curve from the editing point over which the strength of the editing falls off smoothly.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The soft edited curve if successful. None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createFilletCornersCurve
(curve, radius, tolerance, angleTolerance, multiple=false)¶ Rounds the corners of a kinked curve with arcs of a single, specified radius.
Arguments:  curve (rhino3dm.Curve) – The curve to fillet.
 radius (float) – The fillet radius.
 tolerance (float) – The tolerance. When in doubt, use the document’s model space absolute tolerance.
 angleTolerance (float) – The angle tolerance in radians. When in doubt, use the document’s model space angle tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The filleted curve if successful. None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createArcBlend
(startPt, startDir, endPt, endDir, controlPointLengthRatio, multiple=false)¶ Creates a polycurve consisting of two tangent arc segments that connect two points and two directions.
Arguments:  startPt (rhino3dm.Point3d) – Start of the arc blend curve.
 startDir (rhino3dm.Vector3d) – Start direction of the arc blend curve.
 endPt (rhino3dm.Point3d) – End of the arc blend curve.
 endDir (rhino3dm.Vector3d) – End direction of the arc blend curve.
 controlPointLengthRatio (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The arc blend curve, or None on error.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createMeanCurve
(curveA, curveB, angleToleranceRadians, multiple=false)¶ Constructs a mean, or average, curve from two curves.
Arguments:  curveA (rhino3dm.Curve) – A first curve.
 curveB (rhino3dm.Curve) – A second curve.
 angleToleranceRadians (float) – 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)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The average curve, or None on error.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createMeanCurve1
(curveA, curveB, multiple=false)¶ Constructs a mean, or average, curve from two curves.
Arguments:  curveA (rhino3dm.Curve) – A first curve.
 curveB (rhino3dm.Curve) – A second curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The average curve, or None on error.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createBlendCurve
(curveA, curveB, continuity, multiple=false)¶ Create a Blend curve between two existing curves.
Arguments:  curveA (rhino3dm.Curve) – Curve to blend from (blending will occur at curve end point).
 curveB (rhino3dm.Curve) – Curve to blend to (blending will occur at curve start point).
 continuity (BlendContinuity) – Continuity of blend.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve representing the blend between A and B or None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createBlendCurve1
(curveA, curveB, continuity, bulgeA, bulgeB, multiple=false)¶ Create a Blend curve between two existing curves.
Arguments:  curveA (rhino3dm.Curve) – Curve to blend from (blending will occur at curve end point).
 curveB (rhino3dm.Curve) – Curve to blend to (blending will occur at curve start point).
 continuity (BlendContinuity) – Continuity of blend.
 bulgeA (float) – Bulge factor at curveA end of blend. Values near 1.0 work best.
 bulgeB (float) – Bulge factor at curveB end of blend. Values near 1.0 work best.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve representing the blend between A and B or None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createBlendCurve2
(curve0, t0, reverse0, continuity0, curve1, t1, reverse1, continuity1, multiple=false)¶ Makes a curve blend between 2 curves at the parameters specified with the directions and continuities specified
Arguments:  curve0 (rhino3dm.Curve) – First curve to blend from
 t0 (float) – Parameter on first curve for blend endpoint
 reverse0 (bool) – If false, the blend will go in the natural direction of the curve. If true, the blend will go in the opposite direction to the curve
 continuity0 (BlendContinuity) – Continuity for the blend at the start
 curve1 (rhino3dm.Curve) – Second curve to blend from
 t1 (float) – Parameter on second curve for blend endpoint
 reverse1 (bool) – If false, the blend will go in the natural direction of the curve. If true, the blend will go in the opposite direction to the curve
 continuity1 (BlendContinuity) – Continuity for the blend at the end
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The blend curve on success. None on failure
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createTweenCurves
(curve0, curve1, numCurves, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createTweenCurves1
(curve0, curve1, numCurves, tolerance, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createTweenCurvesWithMatching
(curve0, curve1, numCurves, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createTweenCurvesWithMatching1
(curve0, curve1, numCurves, tolerance, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createTweenCurvesWithSampling
(curve0, curve1, numCurves, numSamples, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 numSamples (int) – Number of sample points along input curves.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: >An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createTweenCurvesWithSampling1
(curve0, curve1, numCurves, numSamples, tolerance, multiple=false)¶ 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.
Arguments:  curve0 (rhino3dm.Curve) – The first, or starting, curve.
 curve1 (rhino3dm.Curve) – The second, or ending, curve.
 numCurves (int) – Number of tween curves to create.
 numSamples (int) – Number of sample points along input curves.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: >An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
joinCurves
(inputCurves, multiple=false)¶ Joins a collection of curve segments together.
Arguments:  inputCurves (list[rhino3dm.Curve]) – Curve segments to join.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of curves which contains.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
joinCurves1
(inputCurves, joinTolerance, multiple=false)¶ Joins a collection of curve segments together.
Arguments:  inputCurves (list[rhino3dm.Curve]) – An array, a list or any enumerable set of curve segments to join.
 joinTolerance (float) – Joining tolerance, i.e. the distance between segment endpoints that is allowed.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
joinCurves2
(inputCurves, joinTolerance, preserveDirection, multiple=false)¶ Joins a collection of curve segments together.
Arguments:  inputCurves (list[rhino3dm.Curve]) – An array, a list or any enumerable set of curve segments to join.
 joinTolerance (float) – Joining tolerance, i.e. the distance between segment endpoints that is allowed.
 preserveDirection (bool) – If true, curve endpoints will be compared to curve start points.If false, all start and endpoints will be compared and copies of input curves may be reversed in output.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of joint curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
makeEndsMeet
(curveA, adjustStartCurveA, curveB, adjustStartCurveB, multiple=false)¶ Makes adjustments to the ends of one or both input curves so that they meet at a point.
Arguments:  curveA (rhino3dm.Curve) – 1st curve to adjust.
 adjustStartCurveA (bool) – Which end of the 1st curve to adjust: True is start, False is end.
 curveB (rhino3dm.Curve) – 2nd curve to adjust.
 adjustStartCurveB (bool) – which end of the 2nd curve to adjust true==start, false==end.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success.
Return type: bool

RhinoCompute.Curve.
createFillet
(curve0, curve1, radius, t0Base, t1Base, multiple=false)¶ Computes the fillet arc for a curve filleting operation.
Arguments:  curve0 (rhino3dm.Curve) – First curve to fillet.
 curve1 (rhino3dm.Curve) – Second curve to fillet.
 radius (float) – Fillet radius.
 t0Base (float) – Parameter on curve0 where the fillet ought to start (approximately).
 t1Base (float) – Parameter on curve1 where the fillet ought to end (approximately).
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The fillet arc on success, or Arc.Unset on failure.
Return type: Arc

RhinoCompute.Curve.
createFilletCurves
(curve0, point0, curve1, point1, radius, join, trim, arcExtension, tolerance, angleTolerance, multiple=false)¶ Creates a tangent arc between two curves and trims or extends the curves to the arc.
Arguments:  curve0 (rhino3dm.Curve) – The first curve to fillet.
 point0 (rhino3dm.Point3d) – A point on the first curve that is near the end where the fillet will be created.
 curve1 (rhino3dm.Curve) – The second curve to fillet.
 point1 (rhino3dm.Point3d) – A point on the second curve that is near the end where the fillet will be created.
 radius (float) – The radius of the fillet.
 join (bool) – Join the output curves.
 trim (bool) – Trim copies of the input curves to the output fillet curve.
 arcExtension (bool) – Applies when arcs are filleted but need to be extended to meet the fillet curve or chamfer line. If true, then the arc is extended maintaining its validity. If false, then the arc is extended with a line segment, which is joined to the arc converting it to a polycurve.
 tolerance (float) – The tolerance, generally the document’s absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanUnion
(curves, multiple=false)¶ Calculates the boolean union of two or more closed, planar curves. Note, curves must be coplanar.
Arguments:  curves (list[rhino3dm.Curve]) – The coplanar curves to union.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no union could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanUnion1
(curves, tolerance, multiple=false)¶ Calculates the boolean union of two or more closed, planar curves. Note, curves must be coplanar.
Arguments:  curves (list[rhino3dm.Curve]) – The coplanar curves to union.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no union could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanIntersection
(curveA, curveB, multiple=false)¶ Calculates the boolean intersection of two closed, planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 curveB (rhino3dm.Curve) – The second closed, planar curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no intersection could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanIntersection1
(curveA, curveB, tolerance, multiple=false)¶ Calculates the boolean intersection of two closed, planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 curveB (rhino3dm.Curve) – The second closed, planar curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no intersection could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanDifference
(curveA, curveB, multiple=false)¶ Calculates the boolean difference between two closed, planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 curveB (rhino3dm.Curve) – The second closed, planar curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no difference could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanDifference1
(curveA, curveB, tolerance, multiple=false)¶ Calculates the boolean difference between two closed, planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 curveB (rhino3dm.Curve) – The second closed, planar curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no difference could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanDifference2
(curveA, subtractors, multiple=false)¶ Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 subtractors (list[rhino3dm.Curve]) – curves to subtract from the first closed curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no difference could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanDifference3
(curveA, subtractors, tolerance, multiple=false)¶ Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be coplanar.
Arguments:  curveA (rhino3dm.Curve) – The first closed, planar curve.
 subtractors (list[rhino3dm.Curve]) – curves to subtract from the first closed curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Result curves on success, empty array if no difference could be calculated.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createBooleanRegions
(curves, plane, points, combineRegions, tolerance, multiple=false)¶ Curve Boolean method, which trims and splits curves based on their overlapping regions.
Arguments:  curves (list[rhino3dm.Curve]) – The input curves.
 plane (rhino3dm.Plane) – Regions will be found in the projection of the curves to this plane.
 points (list[rhino3dm.Point3d]) – These points will be projected to plane. All regions that contain at least one of these points will be found.
 combineRegions (bool) – If true, then adjacent regions will be combined.
 tolerance (float) – Function tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The curve Boolean regions if successful, None of no successful.
Return type: CurveBooleanRegions

RhinoCompute.Curve.
createBooleanRegions1
(curves, plane, combineRegions, tolerance, multiple=false)¶ Calculates curve Boolean regions, which trims and splits curves based on their overlapping regions.
Arguments:  curves (list[rhino3dm.Curve]) – The input curves.
 plane (rhino3dm.Plane) – Regions will be found in the projection of the curves to this plane.
 combineRegions (bool) – If true, then adjacent regions will be combined.
 tolerance (float) – Function tolerance. When in doubt, use the document’s model absolute tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The curve Boolean regions if successful, None of no successful.
Return type: CurveBooleanRegions

RhinoCompute.Curve.
createTextOutlines
(text, font, textHeight, textStyle, closeLoops, plane, smallCapsScale, tolerance, multiple=false)¶ 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.
Arguments:  text (str) – The text from which to create outline curves.
 font (str) – The text font.
 textHeight (float) – The text height.
 textStyle (int) – The font style. The font style can be any number of the following: 0  Normal, 1  Bold, 2  Italic
 closeLoops (bool) – Set this value to True when dealing with normal fonts and when you expect closed loops. You may want to set this to False when specifying a singlestroke font where you don’t want closed loops.
 plane (rhino3dm.Plane) – The plane on which the outline curves will lie.
 smallCapsScale (float) – Displays lowercase letters as small caps. Set the relative text size to a percentage of the normal text.
 tolerance (float) – The tolerance for the operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array containing one or more curves if successful.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
createCurve2View
(curveA, curveB, vectorA, vectorB, tolerance, angleTolerance, multiple=false)¶ 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.
Arguments:  curveA (rhino3dm.Curve) – The first curve.
 curveB (rhino3dm.Curve) – The second curve.
 vectorA (rhino3dm.Vector3d) – A vector defining the normal direction of the plane which the first curve is drawn upon.
 vectorB (rhino3dm.Vector3d) – A vector defining the normal direction of the plane which the second curve is drawn upon.
 tolerance (float) – The tolerance for the operation.
 angleTolerance (float) – The angle tolerance for the operation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array containing one or more curves if successful.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
doDirectionsMatch
(curveA, curveB, multiple=false)¶ Determines whether two curves travel more or less in the same direction.
Arguments:  curveA (rhino3dm.Curve) – First curve to test.
 curveB (rhino3dm.Curve) – Second curve to test.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if both curves more or less point in the same direction, False if they point in the opposite directions.
Return type: bool

RhinoCompute.Curve.
projectToMesh
(curve, mesh, direction, tolerance, multiple=false)¶ Projects a curve to a mesh using a direction and tolerance.
Arguments:  curve (rhino3dm.Curve) – A curve.
 mesh (rhino3dm.Mesh) – A mesh.
 direction (rhino3dm.Vector3d) – A direction vector.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve array.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToMesh1
(curve, meshes, direction, tolerance, multiple=false)¶ Projects a curve to a set of meshes using a direction and tolerance.
Arguments:  curve (rhino3dm.Curve) – A curve.
 meshes (list[rhino3dm.Mesh]) – A list, an array or any enumerable of meshes.
 direction (rhino3dm.Vector3d) – A direction vector.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve array.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToMesh2
(curves, meshes, direction, tolerance, multiple=false)¶ Projects a curve to a set of meshes using a direction and tolerance.
Arguments:  curves (list[rhino3dm.Curve]) – A list, an array or any enumerable of curves.
 meshes (list[rhino3dm.Mesh]) – A list, an array or any enumerable of meshes.
 direction (rhino3dm.Vector3d) – A direction vector.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve array.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToBrep
(curve, brep, direction, tolerance, multiple=false)¶ Projects a Curve onto a Brep along a given direction.
Arguments:  curve (rhino3dm.Curve) – Curve to project.
 brep (rhino3dm.Brep) – Brep to project onto.
 direction (rhino3dm.Vector3d) – Direction of projection.
 tolerance (float) – Tolerance to use for projection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of projected curves or empty array if the projection set is empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToBrep1
(curve, breps, direction, tolerance, multiple=false)¶ Projects a Curve onto a collection of Breps along a given direction.
Arguments:  curve (rhino3dm.Curve) – Curve to project.
 breps (list[rhino3dm.Brep]) – Breps to project onto.
 direction (rhino3dm.Vector3d) – Direction of projection.
 tolerance (float) – Tolerance to use for projection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of projected curves or empty array if the projection set is empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToBrep2
(curve, breps, direction, tolerance, multiple=false)¶ Projects a Curve onto a collection of Breps along a given direction.
Arguments:  curve (rhino3dm.Curve) – Curve to project.
 breps (list[rhino3dm.Brep]) – Breps to project onto.
 direction (rhino3dm.Vector3d) – Direction of projection.
 tolerance (float) – Tolerance to use for projection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of projected curves or None if the projection set is empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToBrep3
(curves, breps, direction, tolerance, multiple=false)¶ Projects a collection of Curves onto a collection of Breps along a given direction.
Arguments:  curves (list[rhino3dm.Curve]) – Curves to project.
 breps (list[rhino3dm.Brep]) – Breps to project onto.
 direction (rhino3dm.Vector3d) – Direction of projection.
 tolerance (float) – Tolerance to use for projection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of projected curves or empty array if the projection set is empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToBrep4
(curves, breps, direction, tolerance, multiple=false)¶ Projects a collection of Curves onto a collection of Breps along a given direction.
Arguments:  curves (list[rhino3dm.Curve]) – Curves to project.
 breps (list[rhino3dm.Brep]) – Breps to project onto.
 direction (rhino3dm.Vector3d) – Direction of projection.
 tolerance (float) – Tolerance to use for projection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of projected curves. Array is empty if the projection set is empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
projectToPlane
(curve, plane, multiple=false)¶ Constructs a curve by projecting an existing curve to a plane.
Arguments:  curve (rhino3dm.Curve) – A curve.
 plane (rhino3dm.Plane) – A plane.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The projected curve on success; None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
pullToBrepFace
(curve, face, tolerance, multiple=false)¶ Pull a curve to a BrepFace using closest point projection.
Arguments:  curve (rhino3dm.Curve) – Curve to pull.
 face (rhino3dm.BrepFace) – Brep face that pulls.
 tolerance (float) – Tolerance to use for pulling.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of pulled curves, or an empty array on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
planarClosedCurveRelationship
(curveA, curveB, testPlane, tolerance, multiple=false)¶ 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.
Arguments:  curveA (rhino3dm.Curve) – A first curve.
 curveB (rhino3dm.Curve) – A second curve.
 testPlane (rhino3dm.Plane) – A plane.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A value indicating the relationship between the first and the second curve.
Return type: RegionContainment

RhinoCompute.Curve.
planarCurveCollision
(curveA, curveB, testPlane, tolerance, multiple=false)¶ Determines if two coplanar curves collide (intersect).
Arguments:  curveA (rhino3dm.Curve) – A curve.
 curveB (rhino3dm.Curve) – Another curve.
 testPlane (rhino3dm.Plane) – A valid plane containing the curves.
 tolerance (float) – A tolerance value for intersection.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if the curves intersect, otherwise false
Return type: bool

RhinoCompute.Curve.
duplicateSegments
(thisCurve, multiple=false)¶ Polylines will be exploded into line segments. ExplodeCurves will return the curves in topological order.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of all the segments that make up this curve.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
smooth
(thisCurve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, multiple=false)¶ Smooths a curve by averaging the positions of control points in a specified region.
Arguments:  smoothFactor (float) – The smoothing factor, which controls how much control points move towards the average of the neighboring control points.
 bXSmooth (bool) – When True control points move in X axis direction.
 bYSmooth (bool) – When True control points move in Y axis direction.
 bZSmooth (bool) – When True control points move in Z axis direction.
 bFixBoundaries (bool) – When True the curve ends don’t move.
 coordinateSystem (SmoothingCoordinateSystem) – The coordinates to determine the direction of the smoothing.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The smoothed curve if successful, None otherwise.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
smooth1
(thisCurve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, plane, multiple=false)¶ Smooths a curve by averaging the positions of control points in a specified region.
Arguments:  smoothFactor (float) – The smoothing factor, which controls how much control points move towards the average of the neighboring control points.
 bXSmooth (bool) – When True control points move in X axis direction.
 bYSmooth (bool) – When True control points move in Y axis direction.
 bZSmooth (bool) – When True control points move in Z axis direction.
 bFixBoundaries (bool) – When True the curve ends don’t move.
 coordinateSystem (SmoothingCoordinateSystem) – The coordinates to determine the direction of the smoothing.
 plane (rhino3dm.Plane) – If SmoothingCoordinateSystem.CPlane specified, then the construction plane.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The smoothed curve if successful, None otherwise.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
getLocalPerpPoint
(thisCurve, testPoint, seedParmameter, multiple=false)¶ Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
Arguments:  testPoint (rhino3dm.Point3d) – The test point.
 seedParmameter (float) – A “seed” parameter on the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if a solution is found, False otherwise.
Return type: bool

RhinoCompute.Curve.
getLocalPerpPoint1
(thisCurve, testPoint, seedParmameter, subDomain, multiple=false)¶ Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
Arguments:  testPoint (rhino3dm.Point3d) – The test point.
 seedParmameter (float) – A “seed” parameter on the curve.
 subDomain (rhino3dm.Interval) – The subdomain of the curve to search.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if a solution is found, False otherwise.
Return type: bool

RhinoCompute.Curve.
getLocalTangentPoint
(thisCurve, testPoint, seedParmameter, multiple=false)¶ Search for a location on the curve, near seedParmameter, that is tangent to a test point.
Arguments:  testPoint (rhino3dm.Point3d) – The test point.
 seedParmameter (float) – A “seed” parameter on the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if a solution is found, False otherwise.
Return type: bool

RhinoCompute.Curve.
getLocalTangentPoint1
(thisCurve, testPoint, seedParmameter, subDomain, multiple=false)¶ Search for a location on the curve, near seedParmameter, that is tangent to a test point.
Arguments:  testPoint (rhino3dm.Point3d) – The test point.
 seedParmameter (float) – A “seed” parameter on the curve.
 subDomain (rhino3dm.Interval) – The subdomain of the curve to search.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if a solution is found, False otherwise.
Return type: bool

RhinoCompute.Curve.
inflectionPoints
(thisCurve, multiple=false)¶ 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.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of points if successful, None if not successful or on error.
Return type: rhino3dm.Point3d[]

RhinoCompute.Curve.
maxCurvaturePoints
(thisCurve, multiple=false)¶ Returns a curve’s maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of points if successful, None if not successful or on error.
Return type: rhino3dm.Point3d[]

RhinoCompute.Curve.
makeClosed
(thisCurve, tolerance, multiple=false)¶ 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.
Arguments:  tolerance (float) – If nonzero, and the gap is more than tolerance, curve cannot be made closed.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
lcoalClosestPoint
(thisCurve, testPoint, seed, multiple=false)¶ 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.
Arguments:  testPoint (rhino3dm.Point3d) – A point to test against.
 seed (float) – The seed parameter.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if the search is successful, False if the search fails.
Return type: bool

RhinoCompute.Curve.
localClosestPoint
(thisCurve, testPoint, seed, multiple=false)¶ 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.
Arguments:  testPoint (rhino3dm.Point3d) – A point to test against.
 seed (float) – The seed parameter.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if the search is successful, False if the search fails.
Return type: bool

RhinoCompute.Curve.
closestPoint
(thisCurve, testPoint, multiple=false)¶ 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.
Arguments:  testPoint (rhino3dm.Point3d) – Point to search from.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
closestPoint1
(thisCurve, testPoint, maximumDistance, multiple=false)¶ 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.
Arguments:  testPoint (rhino3dm.Point3d) – Point to project.
 maximumDistance (float) – The maximum allowed distance. Past this distance, the search is given up and False is returned.Use 0 to turn off this parameter.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
closestPoints
(thisCurve, otherCurve, multiple=false)¶ Gets closest points between this and another curves.
Arguments:  otherCurve (rhino3dm.Curve) – The other curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success; False on error.
Return type: bool

RhinoCompute.Curve.
contains
(thisCurve, testPoint, multiple=false)¶ 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.
Arguments:  testPoint (rhino3dm.Point3d) – Point to test.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Relationship between point and curve region.
Return type: PointContainment

RhinoCompute.Curve.
contains1
(thisCurve, testPoint, plane, multiple=false)¶ Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
Arguments:  testPoint (rhino3dm.Point3d) – Point to test.
 plane (rhino3dm.Plane) – Plane in which to compare point and region.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Relationship between point and curve region.
Return type: PointContainment

RhinoCompute.Curve.
contains2
(thisCurve, testPoint, plane, tolerance, multiple=false)¶ Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
Arguments:  testPoint (rhino3dm.Point3d) – Point to test.
 plane (rhino3dm.Plane) – Plane in which to compare point and region.
 tolerance (float) – Tolerance to use during comparison.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Relationship between point and curve region.
Return type: PointContainment

RhinoCompute.Curve.
extremeParameters
(thisCurve, direction, multiple=false)¶ 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, nonperiodic curves always return the end points.
Arguments:  direction (rhino3dm.Vector3d) – The direction in which to perform the calculation.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The parameter values of all local extrema.
Return type: float[]

RhinoCompute.Curve.
createPeriodicCurve
(curve, multiple=false)¶ Removes kinks from a curve. Periodic curves deform smoothly without kinks.
Arguments:  curve (rhino3dm.Curve) – The curve to make periodic. Curve must have degree >= 2.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The resulting curve if successful, None otherwise.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
createPeriodicCurve1
(curve, smooth, multiple=false)¶ Removes kinks from a curve. Periodic curves deform smoothly without kinks.
Arguments:  curve (rhino3dm.Curve) – The curve to make periodic. Curve must have degree >= 2.
 smooth (bool) – If true, smooths any kinks in the curve and moves control points to make a smooth curve. If false, control point locations are not changed or changed minimally (only one point may move) and only the knot vector is altered.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The resulting curve if successful, None otherwise.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
pointAtLength
(thisCurve, length, multiple=false)¶ Gets a point at a certain length along the curve. The length must be nonnegative and less than or equal to the length of the curve. Lengths will not be wrapped when the curve is closed or periodic.
Arguments:  length (float) – Length along the curve between the start point and the returned point.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Point on the curve at the specified length from the start point or Poin3d.Unset on failure.
Return type: rhino3dm.Point3d

RhinoCompute.Curve.
pointAtNormalizedLength
(thisCurve, length, multiple=false)¶ 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.
Arguments:  length (float) – Normalized length along the curve between the start point and the returned point.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Point on the curve at the specified normalized length from the start point or Poin3d.Unset on failure.
Return type: rhino3dm.Point3d

RhinoCompute.Curve.
perpendicularFrameAt
(thisCurve, t, multiple=false)¶ 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.
Arguments:  t (float) – Evaluation parameter.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
getPerpendicularFrames
(thisCurve, parameters, multiple=false)¶ Gets a collection of perpendicular frames along the curve. Perpendicular frames are also known as ‘Zerotwisting frames’ and they minimize rotation from one frame to the next.
Arguments:  parameters (list[float]) – A collection of strictly increasing curve parameters to place perpendicular frames on.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of perpendicular frames on success or None on failure.
Return type: rhino3dm.Plane[]

RhinoCompute.Curve.
getLength
(thisCurve, multiple=false)¶ Gets the length of the curve with a fractional tolerance of 1.0e8.
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The length of the curve on success, or zero on failure.
Return type: float

RhinoCompute.Curve.
getLength1
(thisCurve, fractionalTolerance, multiple=false)¶ Get the length of the curve.
Arguments:  fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The length of the curve on success, or zero on failure.
Return type: float

RhinoCompute.Curve.
getLength2
(thisCurve, subdomain, multiple=false)¶ Get the length of a subsection of the curve with a fractional tolerance of 1e8.
Arguments:  subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve (must be nondecreasing).
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The length of the subcurve on success, or zero on failure.
Return type: float

RhinoCompute.Curve.
getLength3
(thisCurve, fractionalTolerance, subdomain, multiple=false)¶ Get the length of a subsection of the curve.
Arguments:  fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve (must be nondecreasing).
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The length of the subcurve on success, or zero on failure.
Return type: float

RhinoCompute.Curve.
isShort
(thisCurve, tolerance, multiple=false)¶ Used to quickly find short curves.
Arguments:  tolerance (float) – Length threshold value for “shortness”.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if the length of the curve is <= tolerance.
Return type: bool

RhinoCompute.Curve.
isShort1
(thisCurve, tolerance, subdomain, multiple=false)¶ Used to quickly find short curves.
Arguments:  tolerance (float) – Length threshold value for “shortness”.
 subdomain (rhino3dm.Interval) – The test is performed on the interval that is the intersection of subdomain with Domain()
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if the length of the curve is <= tolerance.
Return type: bool

RhinoCompute.Curve.
removeShortSegments
(thisCurve, tolerance, multiple=false)¶ Looks for segments that are shorter than tolerance that can be removed. Does not change the domain, but it will change the relative parameterization.
Arguments:  tolerance (float) – Tolerance which defines “short” segments.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True if removable short segments were found. False if no removable short segments were found.
Return type: bool

RhinoCompute.Curve.
lengthParameter
(thisCurve, segmentLength, multiple=false)¶ Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e8 is used in this version of the function.
Arguments:  segmentLength (float) – Length of segment to measure. Must be less than or equal to the length of the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
lengthParameter1
(thisCurve, segmentLength, fractionalTolerance, multiple=false)¶ Gets the parameter along the curve which coincides with a given length along the curve.
Arguments:  segmentLength (float) – Length of segment to measure. Must be less than or equal to the length of the curve.
 fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
lengthParameter2
(thisCurve, segmentLength, subdomain, multiple=false)¶ Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e8 is used in this version of the function.
Arguments:  segmentLength (float) – Length of segment to measure. Must be less than or equal to the length of the subdomain.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve rather than the whole curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
lengthParameter3
(thisCurve, segmentLength, fractionalTolerance, subdomain, multiple=false)¶ Gets the parameter along the curve which coincides with a given length along the curve.
Arguments:  segmentLength (float) – Length of segment to measure. Must be less than or equal to the length of the subdomain.
 fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve rather than the whole curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
normalizedLengthParameter
(thisCurve, s, multiple=false)¶ 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 1e8 is used in this version of the function.
Arguments:  s (float) – Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
normalizedLengthParameter1
(thisCurve, s, fractionalTolerance, multiple=false)¶ Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Arguments:  s (float) – Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
normalizedLengthParameter2
(thisCurve, s, subdomain, multiple=false)¶ 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 1e8 is used in this version of the function.
Arguments:  s (float) – Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
normalizedLengthParameter3
(thisCurve, s, fractionalTolerance, subdomain, multiple=false)¶ Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Arguments:  s (float) – Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 fractionalTolerance (float) – Desired fractional precision. fabs((“exact” length from start to t)  arc_length)/arc_length <= fractionalTolerance.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: True on success, False on failure.
Return type: bool

RhinoCompute.Curve.
normalizedLengthParameters
(thisCurve, s, absoluteTolerance, multiple=false)¶ 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 1e8 is used in this version of the function.
Arguments:  s (float[]) – Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 absoluteTolerance (float) – 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.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: float[]

RhinoCompute.Curve.
normalizedLengthParameters1
(thisCurve, s, absoluteTolerance, fractionalTolerance, multiple=false)¶ Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Arguments:  s (float[]) – Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 absoluteTolerance (float) – 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 (float) – Desired fractional precision for each segment. fabs(“true” length  actual length)/(actual length) <= fractionalTolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: float[]

RhinoCompute.Curve.
normalizedLengthParameters2
(thisCurve, s, absoluteTolerance, subdomain, multiple=false)¶ 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 1e8 is used in this version of the function.
Arguments:  s (float[]) – Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 absoluteTolerance (float) – 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 (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve. A 0.0 s value corresponds to subdomain>Min() and a 1.0 s value corresponds to subdomain>Max().
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: float[]

RhinoCompute.Curve.
normalizedLengthParameters3
(thisCurve, s, absoluteTolerance, fractionalTolerance, subdomain, multiple=false)¶ Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Arguments:  s (float[]) – Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve.
 absoluteTolerance (float) – 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 (float) – Desired fractional precision for each segment. fabs(“true” length  actual length)/(actual length) <= fractionalTolerance.
 subdomain (rhino3dm.Interval) – The calculation is performed on the specified subdomain of the curve. A 0.0 s value corresponds to subdomain>Min() and a 1.0 s value corresponds to subdomain>Max().
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
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.
Return type: float[]

RhinoCompute.Curve.
divideByCount
(thisCurve, segmentCount, includeEnds, multiple=false)¶ Divide the curve into a number of equallength segments.
Arguments:  segmentCount (int) – Segment count. Note that the number of division points may differ from the segment count.
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: List of curve parameters at the division points on success, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideByCount1
(thisCurve, segmentCount, includeEnds, multiple=false)¶ Divide the curve into a number of equallength segments.
Arguments:  segmentCount (int) – Segment count. Note that the number of division points may differ from the segment count.
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array containing division curve parameters on success, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideByLength
(thisCurve, segmentLength, includeEnds, multiple=false)¶ Divide the curve into specific length segments.
Arguments:  segmentLength (float) – The length of each and every segment (except potentially the last one).
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array containing division curve parameters if successful, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideByLength1
(thisCurve, segmentLength, includeEnds, reverse, multiple=false)¶ Divide the curve into specific length segments.
Arguments:  segmentLength (float) – The length of each and every segment (except potentially the last one).
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 reverse (bool) – If true, then the divisions start from the end of the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array containing division curve parameters if successful, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideByLength2
(thisCurve, segmentLength, includeEnds, multiple=false)¶ Divide the curve into specific length segments.
Arguments:  segmentLength (float) – The length of each and every segment (except potentially the last one).
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array containing division curve parameters if successful, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideByLength3
(thisCurve, segmentLength, includeEnds, reverse, multiple=false)¶ Divide the curve into specific length segments.
Arguments:  segmentLength (float) – The length of each and every segment (except potentially the last one).
 includeEnds (bool) – If true, then the point at the start of the first division segment is returned.
 reverse (bool) – If true, then the divisions start from the end of the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Array containing division curve parameters if successful, None on failure.
Return type: float[]

RhinoCompute.Curve.
divideEquidistant
(thisCurve, distance, multiple=false)¶ Calculates 3d points on a curve where the linear distance between the points is equal.
Arguments:  distance (float) – The distance between division points.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of equidistant points, or None on error.
Return type: rhino3dm.Point3d[]

RhinoCompute.Curve.
divideAsContour
(thisCurve, contourStart, contourEnd, interval, multiple=false)¶ Divides this curve at fixed steps along a defined contour line.
Arguments:  contourStart (rhino3dm.Point3d) – The start of the contouring line.
 contourEnd (rhino3dm.Point3d) – The end of the contouring line.
 interval (float) – A distance to measure on the contouring axis.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of points; or None on error.
Return type: rhino3dm.Point3d[]

RhinoCompute.Curve.
trim
(thisCurve, side, length, multiple=false)¶ Shortens a curve by a given length
Arguments:  multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Trimmed curve if successful, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
split
(thisCurve, cutter, tolerance, multiple=false)¶ Splits a curve into pieces using a polysurface.
Arguments:  cutter (rhino3dm.Brep) – A cutting surface or polysurface.
 tolerance (float) – A tolerance for computing intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
split1
(thisCurve, cutter, tolerance, angleToleranceRadians, multiple=false)¶ Splits a curve into pieces using a polysurface.
Arguments:  cutter (rhino3dm.Brep) – A cutting surface or polysurface.
 tolerance (float) – A tolerance for computing intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
split2
(thisCurve, cutter, tolerance, multiple=false)¶ Splits a curve into pieces using a surface.
Arguments:  cutter (rhino3dm.Surface) – A cutting surface or polysurface.
 tolerance (float) – A tolerance for computing intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
split3
(thisCurve, cutter, tolerance, angleToleranceRadians, multiple=false)¶ Splits a curve into pieces using a surface.
Arguments:  cutter (rhino3dm.Surface) – A cutting surface or polysurface.
 tolerance (float) – A tolerance for computing intersections.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array of curves. This array can be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
extend
(thisCurve, t0, t1, multiple=false)¶ 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.
Arguments:  t0 (float) – 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 (float) – End of extension domain, if the end is not inside the Domain of this curve, an attempt will be made to extend the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Extended curve on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extend1
(thisCurve, domain, multiple=false)¶ 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.
Arguments:  domain (rhino3dm.Interval) – Extension domain.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Extended curve on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extend2
(thisCurve, side, length, style, multiple=false)¶ Extends a curve by a specific length.
Arguments:  side (CurveEnd) – Curve end to extend.
 length (float) – Length to add to the curve end.
 style (CurveExtensionStyle) – Extension style.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A curve with extended ends or None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extend3
(thisCurve, side, style, geometry, multiple=false)¶ Extends a curve until it intersects a collection of objects.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 style (CurveExtensionStyle) – The style or type of extension to use.
 geometry (System.Collections.Generic.IEnumerable<GeometryBase>) – A collection of objects. Allowable object types are Curve, Surface, Brep.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extend4
(thisCurve, side, style, endPoint, multiple=false)¶ Extends a curve to a point.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 style (CurveExtensionStyle) – The style or type of extension to use.
 endPoint (rhino3dm.Point3d) – A new end point.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extendOnSurface
(thisCurve, side, surface, multiple=false)¶ Extends a curve on a surface.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 surface (rhino3dm.Surface) – Surface that contains the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extendOnSurface1
(thisCurve, side, face, multiple=false)¶ Extends a curve on a surface.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 face (rhino3dm.BrepFace) – BrepFace that contains the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extendByLine
(thisCurve, side, geometry, multiple=false)¶ Extends a curve by a line until it intersects a collection of objects.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 geometry (System.Collections.Generic.IEnumerable<GeometryBase>) – A collection of objects. Allowable object types are Curve, Surface, Brep.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
extendByArc
(thisCurve, side, geometry, multiple=false)¶ Extends a curve by an Arc until it intersects a collection of objects.
Arguments:  side (CurveEnd) – The end of the curve to extend.
 geometry (System.Collections.Generic.IEnumerable<GeometryBase>) – A collection of objects. Allowable object types are Curve, Surface, Brep.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New extended curve result on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
simplify
(thisCurve, options, distanceTolerance, angleToleranceRadians, multiple=false)¶ Returns a geometrically equivalent PolyCurve. The PolyCurve has the following properties 1. All the PolyCurve segments are LineCurve, PolylineCurve, ArcCurve, or NurbsCurve. 2. The NURBS Curves segments do not have fully multiple interior knots. 3. Rational NURBS curves do not have constant weights. 4. Any segment for which IsLinear() or IsArc() is True is a Line, Polyline segment, or an Arc. 5. Adjacent colinear or cocircular segments are combined. 6. Segments that meet with G1continuity have there ends tuned up so that they meet with G1continuity to within machine precision.
Arguments:  options (CurveSimplifyOptions) – Simplification options.
 distanceTolerance (float) – A distance tolerance for the simplification.
 angleToleranceRadians (float) – An angle tolerance for the simplification.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New simplified curve on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
simplifyEnd
(thisCurve, end, options, distanceTolerance, angleToleranceRadians, multiple=false)¶ Same as SimplifyCurve, but simplifies only the last two segments at “side” end.
Arguments:  end (CurveEnd) – If CurveEnd.Start the function simplifies the last two start side segments, otherwise if CurveEnd.End the last two end side segments are simplified.
 options (CurveSimplifyOptions) – Simplification options.
 distanceTolerance (float) – A distance tolerance for the simplification.
 angleToleranceRadians (float) – An angle tolerance for the simplification.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: New simplified curve on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
fair
(thisCurve, distanceTolerance, angleTolerance, clampStart, clampEnd, iterations, multiple=false)¶ 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.
Arguments:  distanceTolerance (float) – Maximum allowed distance the faired curve is allowed to deviate from the input.
 angleTolerance (float) – (in radians) kinks with angles <= angleTolerance are smoothed out 0.05 is a good default.
 clampStart (int) – The number of (control vertices1) to preserve at start. 0 = preserve start point1 = preserve start point and 1st derivative2 = preserve start point, 1st and 2nd derivative
 clampEnd (int) – Same as clampStart.
 iterations (int) – The number of iterations to use in adjusting the curve.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns new faired Curve on success, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
fit
(thisCurve, degree, fitTolerance, angleTolerance, multiple=false)¶ Fits a new curve through an existing curve.
Arguments:  degree (int) – The degree of the returned Curve. Must be bigger than 1.
 fitTolerance (float) – The fitting tolerance. If fitTolerance is RhinoMath.UnsetValue or <=0.0, the document absolute tolerance is used.
 angleTolerance (float) – The kink smoothing tolerance in radians. If angleTolerance is 0.0, all kinks are smoothedIf angleTolerance is >0.0, kinks smaller than angleTolerance are smoothedIf angleTolerance is RhinoMath.UnsetValue or <0.0, the document angle tolerance is used for the kink smoothing
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Returns a new fitted Curve if successful, None on failure.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
rebuild
(thisCurve, pointCount, degree, preserveTangents, multiple=false)¶ Rebuild a curve with a specific point count.
Arguments:  pointCount (int) – Number of control points in the rebuild curve.
 degree (int) – Degree of curve. Valid values are between and including 1 and 11.
 preserveTangents (bool) – If true, the end tangents of the input curve will be preserved.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A NURBS curve on success or None on failure.
Return type: rhino3dm.NurbsCurve

RhinoCompute.Curve.
toPolyline
(thisCurve, mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint, multiple=false)¶ Gets a polyline approximation of a curve.
Arguments:  mainSegmentCount (int) – If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount subparts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed.
 subSegmentCount (int) – An amount of subsegments.
 maxAngleRadians (float) – ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices.
 maxChordLengthRatio (float) – Maximum permitted value of (distance chord midpoint to curve) / (length of chord).
 maxAspectRatio (float) – 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 (float) – If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline.
 minEdgeLength (float) – The minimum permitted edge length.
 maxEdgeLength (float) – If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length.
 keepStartPoint (bool) – If True the starting point of the curve is added to the polyline. If False the starting point of the curve is not added to the polyline.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: PolylineCurve on success, None on error.
Return type: PolylineCurve

RhinoCompute.Curve.
toPolyline1
(thisCurve, mainSegmentCount, subSegmentCount, maxAngleRadians, maxChordLengthRatio, maxAspectRatio, tolerance, minEdgeLength, maxEdgeLength, keepStartPoint, curveDomain, multiple=false)¶ Gets a polyline approximation of a curve.
Arguments:  mainSegmentCount (int) – If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount subparts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed.
 subSegmentCount (int) – An amount of subsegments.
 maxAngleRadians (float) – ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices.
 maxChordLengthRatio (float) – Maximum permitted value of (distance chord midpoint to curve) / (length of chord).
 maxAspectRatio (float) – 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 (float) – If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline.
 minEdgeLength (float) – The minimum permitted edge length.
 maxEdgeLength (float) – If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length.
 keepStartPoint (bool) – If True the starting point of the curve is added to the polyline. If False the starting point of the curve is not added to the polyline.
 curveDomain (rhino3dm.Interval) – This subdomain of the NURBS curve is approximated.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: PolylineCurve on success, None on error.
Return type: PolylineCurve

RhinoCompute.Curve.
toPolyline2
(thisCurve, tolerance, angleTolerance, minimumLength, maximumLength, multiple=false)¶ Gets a polyline approximation of a curve.
Arguments:  tolerance (float) – 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 (float) – 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 (float) – The minimum segment length.
 maximumLength (float) – The maximum segment length.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: PolyCurve on success, None on error.
Return type: PolylineCurve

RhinoCompute.Curve.
toArcsAndLines
(thisCurve, tolerance, angleTolerance, minimumLength, maximumLength, multiple=false)¶ Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straightline segments.
Arguments:  tolerance (float) – 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 (float) – 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 (float) – The minimum segment length.
 maximumLength (float) – The maximum segment length.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: PolyCurve on success, None on error.
Return type: PolyCurve

RhinoCompute.Curve.
pullToMesh
(thisCurve, mesh, tolerance, multiple=false)¶ 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.
Arguments:  mesh (rhino3dm.Mesh) – Mesh to project onto.
 tolerance (float) – Input tolerance (RhinoDoc.ModelAbsoluteTolerance is a good default)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: A polyline curve on success, None on failure.
Return type: PolylineCurve

RhinoCompute.Curve.
offset
(thisCurve, plane, distance, tolerance, cornerStyle, multiple=false)¶ 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.
Arguments:  plane (rhino3dm.Plane) – Offset solution plane.
 distance (float) – The positive or negative distance to offset.
 tolerance (float) – The offset or fitting tolerance.
 cornerStyle (CurveOffsetCornerStyle) – Corner style for offset kinks.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offset1
(thisCurve, directionPoint, normal, distance, tolerance, cornerStyle, multiple=false)¶ 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.
Arguments:  directionPoint (rhino3dm.Point3d) – A point that indicates the direction of the offset.
 normal (rhino3dm.Vector3d) – The normal to the offset plane.
 distance (float) – The positive or negative distance to offset.
 tolerance (float) – The offset or fitting tolerance.
 cornerStyle (CurveOffsetCornerStyle) – Corner style for offset kinks.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offset2
(thisCurve, directionPoint, normal, distance, tolerance, angleTolerance, loose, cornerStyle, endStyle, multiple=false)¶ 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.
Arguments:  directionPoint (rhino3dm.Point3d) – A point that indicates the direction of the offset.
 normal (rhino3dm.Vector3d) – The normal to the offset plane.
 distance (float) – The positive or negative distance to offset.
 tolerance (float) – The offset or fitting tolerance.
 angleTolerance (float) – The angle tolerance, in radians, used to decide whether to split at kinks.
 loose (bool) – If false, offset within tolerance. If true, offset by moving edit points.
 cornerStyle (CurveOffsetCornerStyle) – Corner style for offset kinks.
 endStyle (CurveOffsetEndStyle) – End style for nonloose, nonclosed curve offsets.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
ribbonOffset
(thisCurve, distance, blendRadius, directionPoint, normal, tolerance, multiple=false)¶ 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 selfintersection. 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.
Arguments:  distance (float) – The positive distance to offset the curve.
 blendRadius (float) – Positive, typically the same as distance. When the offset results in a selfintersection that gets trimmed off at a kink, the kink will be blended out using this radius.
 directionPoint (rhino3dm.Point3d) – A point that indicates the direction of the offset. If the offset is inward, the point’s projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are selfintersections.
 normal (rhino3dm.Vector3d) – A vector that indicates the normal of the plane in which the offset will occur.
 tolerance (float) – Used to determine selfintersections, not offset error.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: The offset curve if successful.
Return type: rhino3dm.Curve

RhinoCompute.Curve.
offsetOnSurface
(thisCurve, face, distance, fittingTolerance, multiple=false)¶ Offset this curve on a brep face surface. This curve must lie on the surface.
Arguments:  face (rhino3dm.BrepFace) – The brep face on which to offset.
 distance (float) – A distance to offset (+)left, ()right.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetOnSurface1
(thisCurve, face, throughPoint, fittingTolerance, multiple=false)¶ 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.
Arguments:  face (rhino3dm.BrepFace) – The brep face on which to offset.
 throughPoint (rhino3dm.Point2d) – 2d point on the brep face to offset through.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetOnSurface2
(thisCurve, face, curveParameters, offsetDistances, fittingTolerance, multiple=false)¶ 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.
Arguments:  face (rhino3dm.BrepFace) – The brep face on which to offset.
 curveParameters (float[]) – Curve parameters corresponding to the offset distances.
 offsetDistances (float[]) – distances to offset (+)left, ()right.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetOnSurface3
(thisCurve, surface, distance, fittingTolerance, multiple=false)¶ Offset a curve on a surface. This curve must lie on the surface.
Arguments:  surface (rhino3dm.Surface) – A surface on which to offset.
 distance (float) – A distance to offset (+)left, ()right.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetOnSurface4
(thisCurve, surface, throughPoint, fittingTolerance, multiple=false)¶ 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.
Arguments:  surface (rhino3dm.Surface) – A surface on which to offset.
 throughPoint (rhino3dm.Point2d) – 2d point on the brep face to offset through.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetOnSurface5
(thisCurve, surface, curveParameters, offsetDistances, fittingTolerance, multiple=false)¶ Offset this curve on a surface. This curve must lie on the surface. This overload allows to specify different offsets for different curve parameters.
Arguments:  surface (rhino3dm.Surface) – A surface on which to offset.
 curveParameters (float[]) – Curve parameters corresponding to the offset distances.
 offsetDistances (float[]) – Distances to offset (+)left, ()right.
 fittingTolerance (float) – A fitting tolerance.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curves on success, or None on failure.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
pullToBrepFace1
(thisCurve, face, tolerance, multiple=false)¶ Pulls this curve to a brep face and returns the result of that operation.
Arguments:  face (rhino3dm.BrepFace) – A brep face.
 tolerance (float) – A tolerance value.
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: An array containing the resulting curves after pulling. This array could be empty.
Return type: rhino3dm.Curve[]

RhinoCompute.Curve.
offsetNormalToSurface
(thisCurve, surface, height, multiple=false)¶ 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.
Arguments:  surface (rhino3dm.Surface) – Surface from which normals are calculated.
 height (float) – offset distance (distance from surface to result curve)
 multiple (bool) – (default False) If True, all parameters are expected as lists of equal length and input will be batch processed
Returns: Offset curve at distance height from the surface. 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.
Return type: rhino3dm.Curve