ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry, double maximumDistance)

Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.

ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry)

Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.

CombineShortSegments(double tolerance)

Looks for segments that are shorter than tolerance that can be combined. For NURBS of degree greater than 1, spans are combined by removing knots. Similarly for NURBS segments of polycurves. Otherwise, RemoveShortSegments() is called. Does not change the domain, but it will change the relative parameterization.

ComponentIndex()

If this piece of geometry is a component in something larger, like a BrepEdge in a Brep, then this function returns the component index.

ConstructConstObject(object parentObject, int subobjectIndex)

Assigns a parent object and a sub-object index to this.

Contains(Point3d testPoint, Plane plane, double tolerance)

Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.

Contains(Point3d testPoint, Plane plane)

Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.

Contains(Point3d testPoint)

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.

ControlPolygon()

Gets the curve's control polygon.

ConvertSpanToBezier(int spanIndex)

Converts a span of the NURBS curve into a Bezier.

Create(bool periodic, int degree, IEnumerable<Point3d> points)

Constructs a 3D NURBS curve from a list of control points.

CreateArcBlend(Point3d startPt, Vector3d startDir, Point3d endPt, Vector3d endDir, double controlPointLengthRatio)

Creates a polycurve consisting of two tangent arc segments that connect two points and two directions.

CreateArcCornerRectangle(Rectangle3d rectangle, double radius)

Creates an arc-cornered (rounded) rectangular curve.

CreateArcLineArcBlend(Point3d startPt, Vector3d startDir, Point3d endPt, Vector3d endDir, double radius)

Creates an arc-line-arc blend curve between two curves. The output is generally a PolyCurve with three segments: arc, line, arc. In some cases, one or more of those segments will be absent because they would have 0 length. If there is only a single segment, the result will either be an ArcCurve or a LineCurve.

CreateBlendCurve(Curve curve0, double t0, bool reverse0, BlendContinuity continuity0, Curve curve1, double t1, bool reverse1, BlendContinuity continuity1)

Makes a curve blend between 2 curves at the parameters specified with the directions and continuities specified

CreateBlendCurve(Curve curveA, Curve curveB, BlendContinuity continuity, double bulgeA, double bulgeB)

Create a Blend curve between two existing curves.

CreateBlendCurve(Curve curveA, Curve curveB, BlendContinuity continuity)

Create a Blend curve between two existing curves.

CreateBooleanDifference(Curve curveA, Curve curveB, double tolerance)

Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar.

CreateBooleanDifference(Curve curveA, Curve curveB)

Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar.

CreateBooleanDifference(Curve curveA, IEnumerable<Curve> subtractors, double tolerance)

Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.

CreateBooleanDifference(Curve curveA, IEnumerable<Curve> subtractors)

Calculates the boolean difference between a closed planar curve, and a list of closed planar curves. Note, curves must be co-planar.

CreateBooleanIntersection(Curve curveA, Curve curveB, double tolerance)

Calculates the boolean intersection of two closed, planar curves. Note, curves must be co-planar.

CreateBooleanIntersection(Curve curveA, Curve curveB)

Calculates the boolean intersection of two closed, planar curves. Note, curves must be co-planar.

CreateBooleanRegions(IEnumerable<Curve> curves, Plane plane, bool combineRegions, double tolerance)

Calculates curve Boolean regions, which trims and splits curves based on their overlapping regions.

CreateBooleanRegions(IEnumerable<Curve> curves, Plane plane, IEnumerable<Point3d> points, bool combineRegions, double tolerance)

Curve Boolean method, which trims and splits curves based on their overlapping regions.

CreateBooleanUnion(IEnumerable<Curve> curves, double tolerance)

Calculates the boolean union of two or more closed, planar curves. Note, curves must be co-planar.

CreateBooleanUnion(IEnumerable<Curve> curves)

Calculates the boolean union of two or more closed, planar curves. Note, curves must be co-planar.

CreateConicCornerRectangle(Rectangle3d rectangle, double rho)

Creates a conic-corned (rounded) rectangular curve.

CreateControlPointCurve(IEnumerable<Point3d> points, int degree)

Constructs a curve from a set of control-point locations.

CreateControlPointCurve(IEnumerable<Point3d> points)

Constructs a control-point of degree=3 (or less).

CreateCurve2View(Curve curveA, Curve curveB, Vector3d vectorA, Vector3d vectorB, double tolerance, double angleTolerance)

Creates a third curve from two curves that are planar in different construction planes. The new curve looks the same as each of the original curves when viewed in each plane.

CreateFillet(Curve curve0, Curve curve1, double radius, double t0Base, double t1Base)

Computes the fillet arc for a curve filleting operation.

CreateFilletCornersCurve(Curve curve, double radius, double tolerance, double angleTolerance)

Rounds the corners of a kinked curve with arcs of a single, specified radius.

CreateFilletCurves(Curve curve0, Point3d point0, Curve curve1, Point3d point1, double radius, bool join, bool trim, bool arcExtension, double tolerance, double angleTolerance)

Creates a tangent arc between two curves and trims or extends the curves to the arc.

CreateFromArc(Arc arc, int degree, int cvCount)

Create a uniform non-rational cubic NURBS approximation of an arc.

CreateFromArc(Arc arc)

Gets a rational degree 2 NURBS curve representation of the arc. Note that the parameterization of NURBS curve does not match arc's transcendental parameterization.

CreateFromCircle(Circle circle, int degree, int cvCount)

Create a uniform non-rational cubic NURBS approximation of a circle.

CreateFromCircle(Circle circle)

Gets a rational degree 2 NURBS curve representation of the circle. Note that the parameterization of NURBS curve does not match circle's transcendental parameterization. Use GetRadianFromNurbFormParameter() and GetParameterFromRadian() to convert between the NURBS curve parameter and the transcendental parameter.

CreateFromEllipse(Ellipse ellipse)

Gets a rational degree 2 NURBS curve representation of the ellipse.
Note that the parameterization of the NURBS curve does not match with the transcendental parameterization of the ellipsis.

CreateFromFitPoints(IEnumerable<Point3d> points, double tolerance, bool periodic)

Fits a NURBS curve to a dense, ordered set of points.

CreateFromFitPoints(IEnumerable<Point3d> points, double tolerance, int degree, bool periodic, Vector3d startTangent, Vector3d endTangent)

Fits a NURBS curve to a dense, ordered set of points.

CreateFromLine(Line line)

Gets a non-rational, degree 1 NURBS curve representation of the line.

CreateHSpline(IEnumerable<Point3d> points, Vector3d startTangent, Vector3d endTangent)

Construct an H-spline from a sequence of interpolation points and optional start and end derivative information

CreateHSpline(IEnumerable<Point3d> points)

Construct an H-spline from a sequence of interpolation points

CreateInterpolatedCurve(IEnumerable<Point3d> points, int degree, CurveKnotStyle knots, Vector3d startTangent, Vector3d endTangent)

Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.

CreateInterpolatedCurve(IEnumerable<Point3d> points, int degree, CurveKnotStyle knots)

Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.

CreateInterpolatedCurve(IEnumerable<Point3d> points, int degree)

Interpolates a sequence of points. Used by InterpCurve Command This routine works best when degree=3.

CreateMatchCurve(Curve curve0, bool reverse0, BlendContinuity continuity, Curve curve1, bool reverse1, PreserveEnd preserve, bool average)

Changes a curve end to meet a specified curve with a specified continuity.

CreateMeanCurve(Curve curveA, Curve curveB, double angleToleranceRadians)

Constructs a mean, or average, curve from two curves.

CreateMeanCurve(Curve curveA, Curve curveB)

Constructs a mean, or average, curve from two curves.

CreateNonRationalArcBezier(int degree, Point3d center, Point3d start, Point3d end, double radius, double tanSlider, double midSlider)

Creates a non-rational approximation of a rational arc as a single bezier segment

CreateParabolaFromFocus(Point3d focus, Point3d startPoint, Point3d endPoint)

Creates a parabola from focus and end points.

CreateParabolaFromPoints(Point3d startPoint, Point3d innerPoint, Point3d endPoint)

Creates a parabola from three points.

CreateParabolaFromVertex(Point3d vertex, Point3d startPoint, Point3d endPoint)

Creates a parabola from vertex and end points.

CreatePeriodicCurve(Curve curve, bool smooth)

Removes kinks from a curve. Periodic curves deform smoothly without kinks.

CreatePeriodicCurve(Curve curve)

Removes kinks from a curve. Periodic curves deform smoothly without kinks.

CreatePlanarRailFrames(IEnumerable<double> parameters, Vector3d normal)

Computes planar rail sweep frames at specified parameters.

CreateRailFrames(IEnumerable<double> parameters)

Computes relatively parallel rail sweep frames at specified parameters.

CreateSoftEditCurve(Curve curve, double t, Vector3d delta, double length, bool fixEnds)

Creates a soft edited curve from an existing curve using a smooth field of influence.

CreateSpiral(Curve railCurve, double t0, double t1, Point3d radiusPoint, double pitch, double turnCount, double radius0, double radius1, int pointsPerTurn)

Create a C2 non-rational uniform cubic NURBS approximation of a swept helix or spiral.

CreateSpiral(Point3d axisStart, Vector3d axisDir, Point3d radiusPoint, double pitch, double turnCount, double radius0, double radius1)

Creates a C1 cubic NURBS approximation of a helix or spiral. For a helix, you may have radius0 == radius1. For a spiral radius0 == radius1 produces a circle. Zero and negative radii are permissible.

CreateSubDFriendly(Curve curve, int pointCount, bool periodicClosedCurve)

Create a NURBS curve, that is suitable for calculations like lofting SubD objects, from an existing curve.

CreateSubDFriendly(Curve curve)

Create a NURBS curve, that is suitable for calculations like lofting SubD objects, from an existing curve.

CreateSubDFriendly(IEnumerable<Point3d> points, bool interpolatePoints, bool periodicClosedCurve)

Create a NURBS curve, that is suitable for calculations like lofting SubD objects, through a sequence of curves.

CreateTextOutlines(string text, string font, double textHeight, int textStyle, bool closeLoops, Plane plane, double smallCapsScale, double tolerance)

Creates outline curves created from a text string. The functionality is similar to what you find in Rhino's TextObject command or TextEntity.Explode() in RhinoCommon.

CreateTweenCurves(Curve curve0, Curve curve1, int numCurves, double tolerance)

Creates curves between two open or closed input curves. Uses the control points of the curves for finding tween curves. That means the first control point of first curve is matched to first control point of the second curve and so on. There is no matching of curves direction. Caller must match input curves direction before calling the function.

CreateTweenCurves(Curve curve0, Curve curve1, int numCurves)

CreateTweenCurvesWithMatching(Curve curve0, Curve curve1, int numCurves, double tolerance)

Creates curves between two open or closed input curves. Make the structure of input curves compatible if needed. Refits the input curves to have the same structure. The resulting curves are usually more complex than input unless input curves are compatible and no refit is needed. There is no matching of curves direction. Caller must match input curves direction before calling the function.

CreateTweenCurvesWithMatching(Curve curve0, Curve curve1, int numCurves)

CreateTweenCurvesWithSampling(Curve curve0, Curve curve1, int numCurves, int numSamples, double tolerance)

Creates curves between two open or closed input curves. Use sample points method to make curves compatible. This is how the algorithm works: Divides the two curves into an equal number of points, finds the midpoint between the corresponding points on the curves and interpolates the tween curve through those points. There is no matching of curves direction. Caller must match input curves direction before calling the function.

CreateTweenCurvesWithSampling(Curve curve0, Curve curve1, int numCurves, int numSamples)

CurvatureAt(double t)

Evaluate the curvature vector at a curve parameter.

DataCRC(uint currentRemainder)

Returns a CRC calculated from the information that defines the object. This CRC can be used as a quick way to see if two objects are not identical.

DeleteAllUserStrings()

DeleteUserString(string key)

DerivativeAt(double t, int derivativeCount, CurveEvaluationSide side)

Evaluate the derivatives at the specified curve parameter.

DerivativeAt(double t, int derivativeCount)

Evaluate the derivatives at the specified curve parameter.

Dispose()

Actively reclaims unmanaged resources that this instance uses.

Dispose(bool disposing)

For derived class implementers.
This method is called with argument True when class user calls Dispose(), while with argument False when the Garbage Collector invokes the finalizer, or Finalize() method.
You must reclaim all used unmanaged resources in both cases, and can use this chance to call Dispose on disposable fields if the argument is true.
Also, you must call the base virtual method within your overriding method.

Dispose(bool disposing)

Overridden in order to destroy local display cache information

Dispose(bool disposing)

DivideAsContour(Point3d contourStart, Point3d contourEnd, double interval)

Divides this curve at fixed steps along a defined contour line.

DivideByCount(int segmentCount, bool includeEnds, out Point3d[] points)

Divide the curve into a number of equal-length segments.

DivideByCount(int segmentCount, bool includeEnds)

Divide the curve into a number of equal-length segments.

DivideByLength(double segmentLength, bool includeEnds, bool reverse, out Point3d[] points)

Divide the curve into specific length segments.

DivideByLength(double segmentLength, bool includeEnds, bool reverse)

Divide the curve into specific length segments.

DivideByLength(double segmentLength, bool includeEnds, out Point3d[] points)

Divide the curve into specific length segments.

DivideByLength(double segmentLength, bool includeEnds)

Divide the curve into specific length segments.

DivideEquidistant(double distance)

Calculates 3d points on a curve where the linear distance between the points is equal.

DoDirectionsMatch(Curve curveA, Curve curveB)

Determines whether two curves travel more or less in the same direction.

Duplicate()

Constructs a deep (full) copy of this object.

Duplicate()

Constructs an exact duplicate of this Curve.

DuplicateCurve()

Constructs an exact duplicate of this curve.

DuplicateSegments()

Duplicates curve segments. Explodes polylines, polycurves and G1 discontinuous NURBS curves. Single segment curves, such as lines, arcs, unkinked NURBS curves, are duplicated.

DuplicateShallow()

Constructs a light copy of this object. By "light", it is meant that the same underlying data is used until something is done to attempt to change it. For example, you could have a shallow copy of a very heavy mesh object and the same underlying data will be used when doing things like inspecting the number of faces on the mesh. If you modify the location of one of the mesh vertices, the shallow copy will create a full duplicate of the underlying mesh data and the shallow copy will become a deep copy.

EnsurePrivateCopy()

If you want to keep a copy of this class around by holding onto it in a variable after a command completes, call EnsurePrivateCopy to make sure that this class is not tied to the document. You can call this function as many times as you want.

EpsilonEquals(NurbsCurve other, double epsilon)

Check that all values in other are within epsilon of the values in this

Extend(CurveEnd side, CurveExtensionStyle style, IEnumerable<GeometryBase> geometry)

Extends a curve until it intersects a collection of objects.

Extend(CurveEnd side, CurveExtensionStyle style, Point3d endPoint)

Extends a curve to a point.

Extend(CurveEnd side, double length, CurveExtensionStyle style)

Extends a curve by a specific length.

Extend(double t0, double t1)

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.

Extend(Interval domain)

ExtendByArc(CurveEnd side, IEnumerable<GeometryBase> geometry)

Extends a curve by an Arc until it intersects a collection of objects.

ExtendByLine(CurveEnd side, IEnumerable<GeometryBase> geometry)

Extends a curve by a line until it intersects a collection of objects.

ExtendOnSurface(CurveEnd side, BrepFace face)

Extends a curve on a surface.

ExtendOnSurface(CurveEnd side, Surface surface)

Extends a curve on a surface.

ExtremeParameters(Vector3d direction)

Returns the parameter values of all local extrema. Parameter values are in increasing order so consecutive extrema define an interval on which each component of the curve is monotone. Note, non-periodic curves always return the end points.

Fair(double distanceTolerance, double angleTolerance, int clampStart, int clampEnd, int iterations)

Fairs a curve object. Fair works best on degree 3 (cubic) curves. Attempts to remove large curvature variations while limiting the geometry changes to be no more than the specified tolerance.

FilletSurfaceToCurve(BrepFace face, double t, double u, double v, double radius, int alignToCurve, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, double tolerance, List<Brep> out_fillets, out double fitResults)

Creates a constant-radius fillet surface between a surface and the curve.

FilletSurfaceToRail(BrepFace faceWithCurve, BrepFace secondFace, double u1, double v1, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, bool extend, FilletSurfaceSplitType split_type, double tolerance, List<Brep> out_fillets, List<Brep> out_breps0, List<Brep> out_breps1, out double fitResults)

Creates a surface between two surfaces, with a fixed rail curve on the first surface.

FindLocalInflection(Vector3d N, Interval subDomain, double seed, out double curveParameter, out double angleError)

Local minimization for point on a curve with tangent perpendicular to N.

Fit(int degree, double fitTolerance, double angleTolerance)

Fits a new curve through an existing curve.

FrameAt(double t, out Plane plane)

Returns a 3d frame at a parameter.

FromBase64String(int archive3dm, int opennurbs, string base64Data)

Create a CommonObject instance from a Base64 encoded string. This is typically the values used when passing common objects around as JSON data

FromJSON(Dictionary<string, string> jsonDictionary)

Create a CommonObject instance from a JSON dictionary

FromJSON(string json)

Create a CommonObject instance from a JSON string

GeometryEquals(GeometryBase first, GeometryBase second)

Determines if two geometries equal one another, in pure geometrical shape. This version only compares the geometry itself and does not include any user data comparisons. This is a comparison by value: for two identical items it will be true, no matter where in memory they may be stored.

GeometryReferenceEquals(GeometryBase one, GeometryBase other)

Determines if two objects are respectively shallow copies, new managed instantiations of the same geometry, or similar internal references to the exact same geometry, both in managed and in unmanaged code.

GetBoundingBox(bool accurate)

Bounding box solver. Gets the world axis aligned bounding box for the geometry.

GetBoundingBox(Plane plane, out Box worldBox)

Aligned Bounding box solver. Gets the plane aligned bounding box.

GetBoundingBox(Plane plane)

Aligned Bounding box solver. Gets the plane aligned bounding box.

GetBoundingBox(Transform xform)

Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.

GetConicSectionType()

Returns the type of conic section based on the curve's shape.

GetConicSectionType(out Point3d focus1, out Point3d focus2, out Point3d center)

Returns the type of conic section based on the curve's shape.

GetCurveParameterFromNurbsFormParameter(double nurbsParameter, out double curveParameter)

Convert a NURBS curve parameter to a curve parameter.

GetDistancesBetweenCurves(Curve curveA, Curve curveB, double tolerance, out double maxDistance, out double maxDistanceParameterA, out double maxDistanceParameterB, out double minDistance, out double minDistanceParameterA, out double minDistanceParameterB)

Calculates the minimum and maximum distances between two curves. This function is useful for computing curve deviation. If you are not computing curve deviation, use <b>ClosestPoints(Curve, out Point3d, out Point3d)</b> .

GetFilletPoints(Curve curve0, Curve curve1, double radius, double t0Base, double t1Base, out double t0, out double t1, out Plane filletPlane)

Finds points at which to cut a pair of curves so that a fillet of given radius can be inserted.

GetLength()

Gets the length of the curve with a fractional tolerance of 1.0e-8.

GetLength(double fractionalTolerance, Interval subdomain)

Get the length of a sub-section of the curve.

GetLength(double fractionalTolerance)

Get the length of the curve.

GetLength(Interval subdomain)

Get the length of a sub-section of the curve with a fractional tolerance of 1e-8.

GetLocalPerpPoint(Point3d testPoint, double seedParmameter, Interval subDomain, out double curveParameter)

Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.

GetLocalPerpPoint(Point3d testPoint, double seedParmameter, out double curveParameter)

Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.

GetLocalTangentPoint(Point3d testPoint, double seedParmameter, Interval subDomain, out double curveParameter)

Search for a location on the curve, near seedParmameter, that is tangent to a test point.

GetLocalTangentPoint(Point3d testPoint, double seedParmameter, out double curveParameter)

Search for a location on the curve, near seedParmameter, that is tangent to a test point.

GetNextDiscontinuity(Continuity continuityType, double t0, double t1, double cosAngleTolerance, double curvatureTolerance, out double t)

Searches for a derivative, tangent, or curvature discontinuity.

GetNextDiscontinuity(Continuity continuityType, double t0, double t1, out double t)

Searches for a derivative, tangent, or curvature discontinuity.

GetNurbsFormParameterFromCurveParameter(double curveParameter, out double nurbsParameter)

Convert a curve parameter to a NURBS curve parameter.

GetObjectData(SerializationInfo info,StreamingContext context)

Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.

GetPerpendicularFrames(IEnumerable<double> parameters)

Gets a collection of perpendicular frames along the curve. Perpendicular frames are also known as 'Zero-twisting frames' and they minimize rotation from one frame to the next.

GetSubCurves()

Gets subcurves from a curve. The results will be similar to what is produced by Rhino's Explode command.

GetUserString(string key)

Gets user string from this geometry.

GetUserStrings()

Gets a copy of all (user key string, user value string) pairs attached to this geometry.

GrevilleParameter(int index)

Gets the greville (edit point) parameter that belongs to the control point at the specified index.

GrevilleParameters()

Gets all Greville parameters for this curve.

GrevillePoint(int index)

Gets the Greville parameter that belongs to the control point at the specified index.

GrevillePoints()

Gets all Greville points for this curve.

GrevillePoints(bool all)

Gets Greville points for this curve.

HasNurbsForm()

Does a NURBS curve representation of this curve exist?

IncreaseDegree(int desiredDegree)

Increase the degree of this curve.

InflectionPoints()

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.

InflectionPoints(out double curveParameters)

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.

IsArc()

Test a curve to see if it can be represented by an arc or circle within RhinoMath.ZeroTolerance.

IsArc(double tolerance)

Test a curve to see if it can be represented by an arc or circle within the given tolerance.

IsCircle()

Test a curve to see if it can be represented by a circle within RhinoMath.ZeroTolerance.

IsCircle(double tolerance)

Test a curve to see if it can be represented by a circle within the given tolerance.

IsClosable(double tolerance, double minimumAbsoluteSize, double minimumRelativeSize)

Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.

IsClosable(double tolerance)

Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.

IsContinuous(Continuity continuityType, double t)

Test continuity at a curve parameter value.

IsDuplicate(NurbsCurve curveA, NurbsCurve curveB, bool ignoreParameterization, double tolerance)

Determines if two curves are similar.

IsEllipse()

Test a curve to see if it can be represented by an ellipse within RhinoMath.ZeroTolerance.

IsEllipse(double tolerance)

Test a curve to see if it can be represented by an ellipse within a given tolerance.

IsInPlane(Plane testPlane, double tolerance)

Test a curve to see if it lies in a specific plane.

IsInPlane(Plane testPlane)

Test a curve to see if it lies in a specific plane.

IsLinear()

Test a curve to see if it is linear to within RhinoMath.ZeroTolerance units (1e-12).

IsLinear(double tolerance)

Test a curve to see if it is linear to within the custom tolerance.

IsPlanar()

Test a curve for planarity.

IsPlanar(double tolerance)

Test a curve for planarity.

IsPolyline()

Several types of Curve can have the form of a polyline including a degree 1 NurbsCurve, a PolylineCurve, and a PolyCurve all of whose segments are some form of polyline. IsPolyline tests a curve to see if it can be represented as a polyline.

IsShort(double tolerance, Interval subdomain)

Used to quickly find short curves.

IsShort(double tolerance)

Used to quickly find short curves.

IsValidWithLog(out string log)

Determines if an object is valid. Also provides a report on errors if this object happens not to be valid.

JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection, bool simpleJoin, out int key)

Joins a collection of curve segments together.

JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection, out int key)

Joins a collection of curve segments together.

JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance, bool preserveDirection)

Joins a collection of curve segments together.

JoinCurves(IEnumerable<Curve> inputCurves, double joinTolerance)

Joins a collection of curve segments together.

JoinCurves(IEnumerable<Curve> inputCurves)

Joins a collection of curve segments together.

LcoalClosestPoint(Point3d testPoint, double seed, out double t)

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.

LengthParameter(double segmentLength, out double t, double fractionalTolerance, Interval subdomain)

Gets the parameter along the curve which coincides with a given length along the curve.

LengthParameter(double segmentLength, out double t, double fractionalTolerance)

Gets the parameter along the curve which coincides with a given length along the curve.

LengthParameter(double segmentLength, out double t, Interval subdomain)

Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e-8 is used in this version of the function.

LengthParameter(double segmentLength, out double t)

Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e-8 is used in this version of the function.

LocalClosestPoint(Point3d testPoint, double seed, out double t)

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.

MakeClosed(double tolerance)

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.

MakeCompatible(IEnumerable<Curve> curves, Point3d startPt, Point3d endPt, int simplifyMethod, int numPoints, double refitTolerance, double angleTolerance)

For expert use only. From the input curves, make an array of compatible NURBS curves.

MakeDeformable()

If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.

MakeEndsMeet(Curve curveA, bool adjustStartCurveA, Curve curveB, bool adjustStartCurveB)

Makes adjustments to the ends of one or both input curves so that they meet at a point.

MakePiecewiseBezier(bool setEndWeightsToOne)

Clamps ends and adds knots so the NURBS curve has Bezier spans (all distinct knots have multiplicity = degree).

MatchToCurve(Curve targetCurve, double maxEndDistance, double maxInteriorDistance, double matchTolerance, int maxLevel)

Constructs a NURBS curve with the start and end matching the start and end of targetCurve, and Greville points on targetCurve.

MaxCurvaturePoints()

Returns a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points.

MaxCurvaturePoints(out double curveParameters)

Returns a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points.

MemoryEstimate()

Computes an estimate of the number of bytes that this object is using in memory.

NonConstOperation()

For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.

NonConstOperation()

Destroy cache handle

NonConstOperation()

For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.

NormalizedLengthParameter(double s, out double t, double fractionalTolerance, Interval subdomain)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.

NormalizedLengthParameter(double s, out double t, double fractionalTolerance)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.

NormalizedLengthParameter(double s, out double t, Interval subdomain)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.

NormalizedLengthParameter(double s, out double t)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.

NormalizedLengthParameters(double s, double absoluteTolerance, double fractionalTolerance, Interval subdomain)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.

NormalizedLengthParameters(double s, double absoluteTolerance, double fractionalTolerance)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.

NormalizedLengthParameters(double s, double absoluteTolerance, Interval subdomain)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.

NormalizedLengthParameters(double s, double absoluteTolerance)

Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.

Offset(Plane plane, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)

Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.

Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)

Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, double angleTolerance, bool loose, CurveOffsetCornerStyle cornerStyle, CurveOffsetEndStyle endStyle)

OffsetNormalToSurface(Surface surface, double height)

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.

OffsetOnSurface(BrepFace face, double curveParameters, double offsetDistances, double fittingTolerance)

Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.

OffsetOnSurface(BrepFace face, double distance, double fittingTolerance)

Offset this curve on a brep face surface. This curve must lie on the surface.

OffsetOnSurface(BrepFace face, Point2d throughPoint, double fittingTolerance)

Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.

OffsetOnSurface(Surface surface, double curveParameters, double offsetDistances, double fittingTolerance)

Offset this curve on a surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.

OffsetOnSurface(Surface surface, double distance, double fittingTolerance)

Offset a curve on a surface. This curve must lie on the surface.

OffsetOnSurface(Surface surface, Point2d throughPoint, double fittingTolerance)

Offset a curve on a surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.

OffsetTangentToSurface(Surface surface, double height)

Finds a curve by offsetting an existing curve tangent to a surface. The caller is responsible for ensuring that the curve lies on the input surface.

OnSwitchToNonConst()

Is called when a non-constant operation first occurs.

OnSwitchToNonConst()

Is called when a non-constant operation occurs.

PerpendicularFrameAt(double t, out Plane plane)

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.

PlanarClosedCurveRelationship(Curve curveA, Curve curveB, Plane testPlane, double tolerance)

Determines whether two coplanar simple closed curves are disjoint or intersect; otherwise, if the regions have a containment relationship, discovers which curve encloses the other.

PlanarCurveCollision(Curve curveA, Curve curveB, Plane testPlane, double tolerance)

Determines if two coplanar curves collide (intersect).

PointAt(double t)

Evaluates point at a curve parameter.

PointAtLength(double length)

Gets a point at a certain length along the curve. The length must be non-negative and less than or equal to the length of the curve. Lengths will not be wrapped when the curve is closed or periodic.

PointAtNormalizedLength(double length)

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.

ProjectToBrep(Curve curve, Brep brep, Vector3d direction, double tolerance)

Projects a Curve onto a Brep along a given direction.

ProjectToBrep(Curve curve, IEnumerable<Brep> breps, Vector3d direction, double tolerance, out int brepIndices)

Projects a Curve onto a collection of Breps along a given direction.

ProjectToBrep(Curve curve, IEnumerable<Brep> breps, Vector3d direction, double tolerance)

Projects a Curve onto a collection of Breps along a given direction.

ProjectToBrep(IEnumerable<Curve> curves, IEnumerable<Brep> breps, Vector3d direction, double tolerance, out int curveIndices, out int brepIndices)

Projects a collection of Curves onto a collection of Breps along a given direction.

ProjectToBrep(IEnumerable<Curve> curves, IEnumerable<Brep> breps, Vector3d direction, double tolerance)

Projects a collection of Curves onto a collection of Breps along a given direction.

ProjectToMesh(Curve curve, IEnumerable<Mesh> meshes, Vector3d direction, double tolerance)

Projects a curve to a set of meshes using a direction and tolerance.

ProjectToMesh(Curve curve, Mesh mesh, Vector3d direction, double tolerance)

Projects a curve to a mesh using a direction and tolerance.

ProjectToMesh(IEnumerable<Curve> curves, IEnumerable<Mesh> meshes, Vector3d direction, double tolerance)

Projects a curve to a set of meshes using a direction and tolerance.

ProjectToPlane(Curve curve, Plane plane)

Constructs a curve by projecting an existing curve to a plane.

PullToBrepFace(BrepFace face, double tolerance)

Pulls this curve to a brep face and returns the result of that operation.

PullToBrepFace(Curve curve, BrepFace face, double tolerance)

Pull a curve to a BrepFace using closest point projection.

PullToMesh(Mesh mesh, double tolerance)

Makes a polyline approximation of the curve and gets the closest point on the mesh for each point on the curve. Then it "connects the points" so that you have a polyline on the mesh.

Rebuild(int pointCount, int degree, bool preserveTangents)

Rebuild a curve with a specific point count.

RemoveShortSegments(double tolerance)

Looks for segments that are shorter than tolerance that can be removed. Does not change the domain, but it will change the relative parameterization.

Repair(double tolerance)

Repairs a curve.

Reparameterize(double c)

Use a linear fractional transformation to re-parameterize the NURBS curve. This does not change the curve's domain.

Reverse()

Reverses the direction of the curve.

RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out Curve[] crossSections, out Surface[] ruledSurfaces)

Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.

RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out double outputParameters, out double curveParameters)

RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance)

RibbonOffset(RibbonOffsetParameters ribbonParameters, out Curve[] railCurves, out Curve[] crossSectionCurves, out Brep[] brepSurfaces)

Ribbon offset method to mimic RibbonOffset command

Rotate(double angleRadians, Vector3d rotationAxis, Point3d rotationCenter)

Rotates the object about the specified axis. A positive rotation angle results in a counter-clockwise rotation about the axis (right hand rule).

Scale(double scaleFactor)

Scales the object by the specified factor. The scale is centered at the origin.

SetEndCondition(bool bSetEnd, NurbsCurveEndConditionType continuity, Point3d point, Vector3d tangent, Vector3d curvature)

Set end condition of a NURBS curve to point, tangent and curvature.

SetEndCondition(bool bSetEnd, NurbsCurveEndConditionType continuity, Point3d point, Vector3d tangent)

Set end condition of a NURBS curve to point, tangent and curvature.

SetEndPoint(Point3d point)

Forces the curve to end at a specified point. Not all curve types support this operation.

SetGrevillePoints(IEnumerable<Point3d> points)

Sets all Greville edit points for this curve.

SetStartPoint(Point3d point)

Forces the curve to start at a specified point. Not all curve types support this operation.

SetUserString(string key, string value)

Attach a user string (key,value combination) to this geometry.

Simplify(CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)

Returns a geometrically equivalent PolyCurve.
The PolyCurve has the following properties
1. All the PolyCurve segments are LineCurve, PolylineCurve, ArcCurve, or NurbsCurve.
2. The NURBS Curves segments do not have fully multiple interior knots.
3. Rational NURBS curves do not have constant weights.
4. Any segment for which IsLinear() or IsArc() is True is a Line, Polyline segment, or an Arc.
5. Adjacent co-linear or co-circular segments are combined.
6. Segments that meet with G1-continuity have there ends tuned up so that they meet with G1-continuity to within machine precision.

SimplifyEnd(CurveEnd end, CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)

Same as SimplifyCurve, but simplifies only the last two segments at "side" end.

Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem, Plane plane)

Smooths a curve by averaging the positions of control points in a specified region.

Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem)

Smooths a curve by averaging the positions of control points in a specified region.

SpanDomain(int spanIndex)

Get the domain of the curve span with the given index. Use the SpanCount property to test how many spans there are.

SpanVector()

Split(Brep cutter, double tolerance, double angleToleranceRadians)

Splits a curve into pieces using a polysurface.

Split(Brep cutter, double tolerance)

Splits a curve into pieces using a polysurface.

Split(double t)

Splits (divides) the curve at the specified parameter. The parameter must be in the interior of the curve's domain.

Split(IEnumerable<double> t)

Splits (divides) the curve at a series of specified parameters. The parameter must be in the interior of the curve domain.

Split(Surface cutter, double tolerance, double angleToleranceRadians)

Splits a curve into pieces using a surface.

Split(Surface cutter, double tolerance)

Splits a curve into pieces using a surface.

TangentAt(double t)

Evaluates the unit tangent vector at a curve parameter.

ToArcsAndLines(double tolerance, double angleTolerance, double minimumLength, double maximumLength)

Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straight-line segments.

ToJSON(SerializationOptions options)

Create a JSON string representation of this object

ToNurbsCurve()

Constructs a NURBS curve representation of this curve.

ToNurbsCurve(Interval subdomain)

Constructs a NURBS curve representation of this curve.

ToPolyline(double tolerance, double angleTolerance, double minimumLength, double maximumLength)

Gets a polyline approximation of a curve.

ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint, Interval curveDomain)

Gets a polyline approximation of a curve.

TorsionAt(double t)

Evaluate the torsion of a curve at a parameter. Sometimes also called the "second curvature", torsion is the rate of change of a curve's osculating plane.

Transform(Transform xform)

Transforms the geometry. If the input Transform has a SimilarityType of OrientationReversing, you may want to consider flipping the transformed geometry after calling this function when it makes sense. For example, you may want to call Flip() on a Brep after transforming it.

Translate(double x, double y, double z)

Translates the object along the specified vector.

Translate(Vector3d translationVector)

Translates the object along the specified vector.

Trim(CurveEnd side, double length)

Shortens a curve by a given length

Trim(double t0, double t1)