Represents a Non Uniform Rational B-Splines (NURBS) curve.
Constructors
Constructs a new NURBS curve with a specific degree and control point count.
Constructs a new NURBS curve with knot and CV memory allocated.
public NurbsCurve(NurbsCurve other)
Initializes a NURBS curve by copying its values from another NURBS curve.
Parameters:
| other (NurbsCurve) | The other curve. This value can be null. |
NurbsCurve
#Protected constructor for internal use.
Parameters:
| info (SerializationInfo) | Serialization data. |
| context (StreamingContext) | Serialization stream. |
Properties
Degree
Gets the maximum algebraic degree of any span or a good estimate if curve spans are not algebraic.
Dimension
Gets the dimension of the object.
The dimension is typically three. For parameter space trimming curves the dimension is two. In rare cases the dimension can be one or greater than three.
Disposed
Indicates if this object has been disposed or the document it originally belonged to has been disposed.
Returns true if the NURBS curve has Bezier spans (all distinct knots have multiplicity = degree)
HasBrepForm
Returns true if the Brep.TryConvertBrep function will be successful for this object
HasUserData
Gets true if this class has any custom information attached to it through UserData.
IsClosed
Gets a value indicating whether or not this curve is a closed curve.
IsDeformable
true if object can be accurately modified with "squishy" transformations like projections, shears, and non-uniform scaling.
IsDocumentControlled
If true this object may not be modified. Any properties or functions that attempt to modify this object when it is set to "IsReadOnly" will throw a NotSupportedException.
Overrides: CommonObject.IsDocumentControlled
IsPeriodic
Gets a value indicating whether or not this curve is considered to be Periodic.
Gets a value indicating whether or not the curve is rational. Rational curves have control-points with custom weights.
IsShallowDuplicate
Is this instance a 'shallow copy'. Shallow copies are no different than regular instances with the exception that they will convert to complete independent 'deep' copies if a non const operation is perform on the instance (something that mutates the internal data)
IsSubDFriendly
Returns true if the curve is a cubic, non-rational, uniform NURBS curve that is either periodic or has natural end conditions. Otherwise, false is returned.
Remarks: A "natural" spline has zero 2nd derivatives (and hence zero curvature) at the start and end. A "periodic" spline has unclampled periodic knots and periodic control points.
Gets access to the knots (or "knot vector") of this NURBS curve.
ObjectType
Useful for switch statements that need to differentiate between basic object types like points, curves, surfaces, and so on.
Gets access to the control points of this NURBS curve.
SpanCount
Gets the number of non-empty smooth (c-infinity) spans in the curve.
TangentAtEnd
Evaluate unit tangent vector at the end of the curve.
Remarks: No error handling.
Returns: Unit tangent vector of the curve at the end point.
TangentAtStart
Evaluates the unit tangent vector at the start of the curve.
Remarks: No error handling.
Returns: Unit tangent vector of the curve at the start point.
UserData
List of custom information that is attached to this class.
UserDictionary
Dictionary of custom information attached to this class. The dictionary is actually user data provided as an easy to use shareable set of information.
Methods
Appends a NURBS curve to this curve.
Parameters:
| nurbsCurve (NurbsCurve) | The NURBS curve to append. |
ChangeClosedCurveSeam
If this curve is closed, then modify it so that the start/end point is at curve parameter t.
Parameters:
| t (double) | Curve parameter of new start/end point. The returned curves domain will start at t. |
Returns: true on success, false on failure.
Parameters:
| desiredDimension (int) | The desired dimension. |
Returns: true if the curve's dimension was already desiredDimension or if the curve's dimension was successfully changed to desiredDimension; otherwise false.
ClosedCurveOrientation
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in the world XY plane. Only works with simple (no self intersections) closed, planar curves.
Returns: The orientation of this curve with respect to world XY plane.
ClosedCurveOrientation
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in a given plane. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| plane (Plane) | The plane in which to solve the orientation. |
Returns: The orientation of this curve in the given plane.
ClosedCurveOrientation
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| xform (Transform) | Transformation to map the curve to the world XY plane. |
Returns: The orientation of this curve in the world XY-plane.
ClosedCurveOrientation
Determines the orientation (counterclockwise or clockwise) of a closed, planar curve in a given plane. Only works with simple (no self intersections) closed, planar curves.
Parameters:
| upDirection (Vector3d) | A vector that is considered "up". |
Returns: The orientation of this curve with respect to a defined up direction.
ClosestPoint
Finds the parameter of the point on a curve that is closest to testPoint. If the maximumDistance parameter is > 0, then only points whose distance to the given point is <= maximumDistance will be returned. Using a positive value of maximumDistance can substantially speed up the search.
Parameters:
| testPoint (Point3d) | Point to project. |
| t (out double) | parameter of local closest point returned here. |
| maximumDistance (double) | The maximum allowed distance. Past this distance, the search is given up and false is returned. Use 0 to turn off this parameter. |
Returns: true on success, false on failure.
ClosestPoint
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.
ClosestPoints
[ConstOperation]
public bool ClosestPoints(Curve otherCurve, out Point3d pointOnThisCurve, out Point3d pointOnOtherCurve)
Gets closest points between this and another curves.
ClosestPoints
[ConstOperation]
public bool ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry, double maximumDistance)
Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.
Parameters:
| geometry (IEnumerable<GeometryBase>) | A list, an array or any enumerable set of geometry to search. |
| pointOnCurve (out Point3d) | The point on curve. This out parameter is assigned during this call. |
| pointOnObject (out Point3d) | The point on geometry. This out parameter is assigned during this call. |
| whichGeometry (out int) | The index of the geometry. This out parameter is assigned during this call. |
| maximumDistance (double) | Maximum allowable distance. Past this distance, the research is given up and false is returned. |
Returns: true on success; false if no object was found or selected.
Exceptions:
| ArgumentNullException | If geometry is null. |
ClosestPoints
[ConstOperation]
public bool ClosestPoints(IEnumerable<GeometryBase> geometry, out Point3d pointOnCurve, out Point3d pointOnObject, out int whichGeometry)
Finds the object (and the closest point in that object) that is closest to this curve.
Breps, surfaces, curves and point clouds are examples of objects that can be passed to this function.
Parameters:
| geometry (IEnumerable<GeometryBase>) | A list, an array or any enumerable set of geometry to search. |
| pointOnCurve (out Point3d) | The point on curve. This out parameter is assigned during this call. |
| pointOnObject (out Point3d) | The point on geometry. This out parameter is assigned during this call. |
| whichGeometry (out int) | The index of the geometry. This out parameter is assigned during this call. |
Returns: true on success; false if no object was found or selected.
Exceptions:
| ArgumentNullException | If geometry is null. |
CombineShortSegments
Looks for segments that are shorter than tolerance that can be combined. For NURBS of degree greater than 1, spans are combined by removing knots. Similarly for NURBS segments of polycurves. Otherwise, RemoveShortSegments() is called. Does not change the domain, but it will change the relative parameterization.
Parameters:
| tolerance (double) |
Returns: True if short segments were combined or removed. False otherwise.
ComponentIndex
If this piece of geometry is a component in something larger, like a BrepEdge in a Brep, then this function returns the component index.
Returns: This object's component index. If this object is not a sub-piece of a larger geometric entity, then the returned index has m_type = ComponentIndex.InvalidType and m_index = -1.
ConstructConstObject
Assigns a parent object and a sub-object index to this.
Contains
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
Contains
obsoleteUse version that takes a tolerance
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset.
Contains
obsoleteUse version that takes a tolerance
Computes the relationship between a point and a closed curve region. This curve must be closed or the return value will be Unset. Both curve and point are projected to the World XY plane.
Parameters:
| testPoint (Point3d) | Point to test. |
Returns: Relationship between point and curve region.
Returns: The control polygon as a polyline if successful, null otherwise.
Converts a span of the NURBS curve into a Bezier.
Parameters:
| spanIndex (int) | The span index, where (0 <= spanIndex <= Points.Count - Order). |
Returns: Bezier curve if successful, null otherwise.
Constructs a 3D NURBS curve from a list of control points.
Parameters:
| periodic (bool) | If true, create a periodic uniform curve. If false, create a clamped uniform curve. |
| degree (int) | (>=1) degree=order-1. |
| points (IEnumerable<Point3d>) | control vertex locations. |
Returns: new NURBS curve on success null on error.
Create a uniform non-rational cubic NURBS approximation of an 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.
Parameters:
| arc (Arc) |
Returns: Curve on success, null on failure.
Create a uniform non-rational cubic NURBS approximation of a 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.
Parameters:
| circle (Circle) |
Returns: Curve on success, null on failure.
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.
Parameters:
| ellipse (Ellipse) |
Returns: A NURBS curve representation of this ellipse or null if no such representation could be made.
public static NurbsCurve CreateFromFitPoints(IEnumerable<Point3d> points, double tolerance, bool periodic)
Fits a NURBS curve to a dense, ordered set of points.
Parameters:
| points (IEnumerable<Point3d>) | An enumeration of 3D points. |
| tolerance (double) | The fitting tolerance. When in doubt, use the document's model absolute tolerance. |
| periodic (bool) | Set true to create a periodic curve. |
Returns: A NURBS curve if successful, or null on failure.
public static NurbsCurve 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.
Parameters:
| points (IEnumerable<Point3d>) | An enumeration of 3D points. |
| tolerance (double) | The fitting tolerance. When in doubt, use the document's model absolute tolerance. |
| degree (int) | The desired degree of the output curve. |
| periodic (bool) | Set true to create a periodic curve. |
| startTangent (Vector3d) | The tangent direction at the start of the curve. If unknown, set to Vector3d.Unset. |
| endTangent (Vector3d) | The tangent direction at the end of the curve. If unknown, set to Vector3d.Unset. |
Returns: A NURBS curve if successful, or null on failure.
Gets a non-rational, degree 1 NURBS curve representation of the line.
Parameters:
| line (Line) |
Returns: Curve on success, null on failure.
public static NurbsCurve 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
Parameters:
| points (IEnumerable<Point3d>) | Points to interpolate |
| startTangent (Vector3d) | Unit tangent vector or Unset |
| endTangent (Vector3d) | Unit tangent vector or Unset |
Returns: NURBS curve approximation of an arc on success
Construct an H-spline from a sequence of interpolation points
Parameters:
| points (IEnumerable<Point3d>) | Points to interpolate |
public static NurbsCurve 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
Parameters:
| degree (int) | The degree of the non-rational approximation, can be either 3, 4, or 5 |
| center (Point3d) | The arc center |
| start (Point3d) | A point in the direction of the start point of the arc |
| end (Point3d) | A point in the direction of the end point of the arc |
| radius (double) | The radius of the arc |
| tanSlider (double) | a number between zero and one which moves the tangent control point toward the mid control point of an equivalent quadratic rational arc |
| midSlider (double) | a number between zero and one which moves the mid control points toward the mid control point of an equivalent quadratic rational arc |
Returns: The approximated arc.
public static NurbsCurve CreateParabolaFromFocus(Point3d focus, Point3d startPoint, Point3d endPoint)
Creates a parabola from focus and end points.
public static NurbsCurve CreateParabolaFromPoints(Point3d startPoint, Point3d innerPoint, Point3d endPoint)
Creates a parabola from three points.
public static NurbsCurve CreateParabolaFromVertex(Point3d vertex, Point3d startPoint, Point3d endPoint)
Creates a parabola from vertex and end points.
Computes planar rail sweep frames at specified parameters.
Parameters:
| parameters (IEnumerable<double>) | A collection of curve parameters. |
| normal (Vector3d) | Unit normal to the plane. |
Returns: An array of planes if successful, or an empty array on failure.
Computes relatively parallel rail sweep frames at specified parameters.
Parameters:
| parameters (IEnumerable<double>) | A collection of curve parameters. |
Returns: An array of planes if successful, or an empty array on failure.
public static NurbsCurve 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.
Parameters:
| railCurve (Curve) | The rail curve. |
| t0 (double) | Starting portion of rail curve's domain to sweep along. |
| t1 (double) | Ending portion of rail curve's domain to sweep along. |
| radiusPoint (Point3d) | Point used only to get a vector that is perpendicular to the axis. In particular, this vector must not be (anti)parallel to the axis vector. |
| pitch (double) | The pitch. Positive values produce counter-clockwise orientation, negative values produce clockwise orientation. |
| turnCount (double) | The turn count. If != 0, then the resulting helix will have this many turns. If = 0, then pitch must be != 0 and the approximate distance between turns will be set to pitch. Positive values produce counter-clockwise orientation, negative values produce clockwise orientation. |
| radius0 (double) | The starting radius. At least one radii must be nonzero. Negative values are allowed. |
| radius1 (double) | The ending radius. At least one radii must be nonzero. Negative values are allowed. |
| pointsPerTurn (int) | Number of points to interpolate per turn. Must be greater than 4. When in doubt, use 12. |
Returns: NurbsCurve on success, null on failure.
public static NurbsCurve 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.
Parameters:
| axisStart (Point3d) | Helix's axis starting point or center of spiral. |
| axisDir (Vector3d) | Helix's axis vector or normal to spiral's plane. |
| radiusPoint (Point3d) | Point used only to get a vector that is perpendicular to the axis. In particular, this vector must not be (anti)parallel to the axis vector. |
| pitch (double) | The pitch, where a spiral has a pitch = 0, and pitch > 0 is the distance between the helix's "threads". |
| turnCount (double) | The number of turns in spiral or helix. Positive values produce counter-clockwise orientation, negative values produce clockwise orientation. Note, for a helix, turnCount * pitch = length of the helix's axis. |
| radius0 (double) | The starting radius. |
| radius1 (double) | The ending radius. |
Returns: NurbsCurve on success, null on failure.
Create a NURBS curve, that is suitable for calculations like lofting SubD objects, from an existing curve.
Parameters:
| curve (Curve) | Curve to rebuild as a SubD friendly curve. |
| pointCount (int) | Desired number of control points. If periodicClosedCurve is true, the number must be >= 6, otherwise the number must be >= 4. |
| periodicClosedCurve (bool) | True if the SubD friendly curve should be closed and periodic. False in all other cases. |
Returns: A SubD friendly NURBS curve is successful, null otherwise.
Create a NURBS curve, that is suitable for calculations like lofting SubD objects, from an existing curve.
Parameters:
| curve (Curve) | Curve to rebuild as a SubD friendly curve. |
Returns: A SubD friendly NURBS curve is successful, null otherwise.
public static NurbsCurve 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.
Parameters:
| points (IEnumerable<Point3d>) | An enumeration of points. Adjacent points must not be equal. If periodicClosedCurve is false, there must be at least two points. If periodicClosedCurve is true, there must be at least three points and it is not necessary to duplicate the first and last points. When periodicClosedCurve is true and the first and last points are equal, the duplicate last point is automatically ignored. |
| interpolatePoints (bool) | True if the curve should interpolate the points. False if points specify control point locations. In either case, the curve will begin at the first point and end at the last point. |
| periodicClosedCurve (bool) | True to create a periodic closed curve. Do not duplicate the start/end point in the point input. |
Returns: A SubD friendly NURBS curve is successful, null otherwise.
CurvatureAt
Evaluate the curvature vector at a curve parameter.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Curvature vector of the curve at the parameter t.
DataCRC
Returns a CRC calculated from the information that defines the object. This CRC can be used as a quick way to see if two objects are not identical.
Parameters:
| currentRemainder (uint) | The current remainder value. |
Returns: CRC of the information the defines the object.
DeleteAllUserStrings
public void DeleteAllUserStrings()
Parameters:
| key (string) |
DerivativeAt
[ConstOperation]
public Vector3d[] DerivativeAt(double t, int derivativeCount, CurveEvaluationSide side)
Evaluate the derivatives at the specified curve parameter.
Parameters:
| t (double) | Curve parameter to evaluate. |
| derivativeCount (int) | Number of derivatives to evaluate, must be at least 0. |
| side (CurveEvaluationSide) | Side of parameter to evaluate. If the parameter is at a kink, it makes a big difference whether the evaluation is from below or above. |
Returns: An array of vectors that represents all the derivatives starting at zero.
DerivativeAt
Evaluate the derivatives at the specified curve parameter.
Dispose
public void Dispose()
Actively reclaims unmanaged resources that this instance uses.
Dispose
For derived class implementers.
This method is called with argument true when class user calls Dispose(), while with argument false when the Garbage Collector invokes the finalizer, or Finalize() method.
You must reclaim all used unmanaged resources in both cases, and can use this chance to call Dispose on disposable fields if the argument is true.
Also, you must call the base virtual method within your overriding method.
Parameters:
| disposing (bool) | true if the call comes from the Dispose() method; false if it comes from the Garbage Collector finalizer. |
Overrides: GeometryBase.Dispose
DivideAsContour
[ConstOperation]
public Point3d[] DivideAsContour(Point3d contourStart, Point3d contourEnd, double interval)
Divides this curve at fixed steps along a defined contour line.
DivideByCount
[ConstOperation]
public double[] DivideByCount(int segmentCount, bool includeEnds, out Point3d[] points)
Divide the curve into a number of equal-length segments.
Parameters:
| segmentCount (int) | Segment count. Note that the number of division points may differ from the segment count. |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| points (out Point3d[]) | A list of division points. If the function returns successfully, this point-array will be filled in. |
Returns: Array containing division curve parameters on success, null on failure.
DivideByCount
Divide the curve into a number of equal-length segments.
Parameters:
| segmentCount (int) | Segment count. Note that the number of division points may differ from the segment count. |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
Returns: List of curve parameters at the division points on success, null on failure.
DivideByLength
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, bool reverse, out Point3d[] points)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| reverse (bool) | If true, then the divisions start from the end of the curve. |
| points (out Point3d[]) | If function is successful, points at each parameter value are returned in points. |
Returns: Array containing division curve parameters if successful, null on failure.
DivideByLength
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, bool reverse)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| reverse (bool) | If true, then the divisions start from the end of the curve. |
Returns: Array containing division curve parameters if successful, null on failure.
DivideByLength
[ConstOperation]
public double[] DivideByLength(double segmentLength, bool includeEnds, out Point3d[] points)
Divide the curve into specific length segments.
Parameters:
| segmentLength (double) | The length of each and every segment (except potentially the last one). |
| includeEnds (bool) | If true, then the point at the start of the first division segment is returned. |
| points (out Point3d[]) | If function is successful, points at each parameter value are returned in points. |
Returns: Array containing division curve parameters if successful, null on failure.
DivideByLength
Divide the curve into specific length segments.
DivideEquidistant
Calculates 3d points on a curve where the linear distance between the points is equal.
Remarks: Unlike the other divide methods, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.
Parameters:
| distance (double) | The distance between division points. |
| curveParameters (out double[]) | If successful, an array of curve parameters at the point locations. |
Returns: An array of equidistant points, or null on error.
DivideEquidistant
Calculates 3d points on a curve where the linear distance between the points is equal.
Remarks: Unlike the other divide methods, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.
Parameters:
| distance (double) | The distance between division points. |
Returns: An array of equidistant points, or null on error.
Overrides: GeometryBase.Duplicate
Returns: An exact copy 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.
Remarks: Unlike Curve.GetSubCurves(), this method produces results based on the curve's data structure.
Returns: An array of all the segments that make up this curve.
DuplicateShallow
Constructs a light copy of this object. By "light", it is meant that the same underlying data is used until something is done to attempt to change it. For example, you could have a shallow copy of a very heavy mesh object and the same underlying data will be used when doing things like inspecting the number of faces on the mesh. If you modify the location of one of the mesh vertices, the shallow copy will create a full duplicate of the underlying mesh data and the shallow copy will become a deep copy.
Returns: An object of the same type as this object.
This behavior is overridden by implementing classes.
EnsurePrivateCopy
public void EnsurePrivateCopy()
If you want to keep a copy of this class around by holding onto it in a variable after a command completes, call EnsurePrivateCopy to make sure that this class is not tied to the document. You can call this function as many times as you want.
Check that all values in other are within epsilon of the values in this
Parameters:
| other (NurbsCurve) | |
| epsilon (double) |
Implements: EpsilonEquals
Extend
[ConstOperation]
public Curve Extend(CurveEnd side, CurveExtensionStyle style, IEnumerable<GeometryBase> geometry)
Extends a curve until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| style (CurveExtensionStyle) | The style or type of extension to use. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
Extend
Extends a curve to a point.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| style (CurveExtensionStyle) | The style or type of extension to use. |
| endPoint (Point3d) | A new end point. |
Returns: New extended curve result on success, null on failure.
Extend
Extends a curve by a specific length.
Parameters:
| side (CurveEnd) | Curve end to extend. |
| length (double) | Length to add to the curve end. |
| style (CurveExtensionStyle) | Extension style. |
Returns: A curve with extended ends or null on failure.
Extend
Where possible, analytically extends curve to include the given domain. This will not work on closed curves. The original curve will be identical to the restriction of the resulting curve to the original curve domain.
Parameters:
| t0 (double) | Start of extension domain, if the start is not inside the Domain of this curve, an attempt will be made to extend the curve. |
| t1 (double) | End of extension domain, if the end is not inside the Domain of this curve, an attempt will be made to extend the curve. |
Returns: Extended curve on success, null on failure.
Extend
Where possible, analytically extends curve to include the given domain. This will not work on closed curves. The original curve will be identical to the restriction of the resulting curve to the original curve domain.
Parameters:
| domain (Interval) | Extension domain. |
Returns: Extended curve on success, null on failure.
ExtendByArc
Extends a curve by an Arc until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
ExtendByLine
Extends a curve by a line until it intersects a collection of objects.
Parameters:
| side (CurveEnd) | The end of the curve to extend. |
| geometry (IEnumerable<GeometryBase>) | A collection of objects. Allowable object types are Curve, Surface, Brep. |
Returns: New extended curve result on success, null on failure.
ExtendOnSurface
Extends a curve on a surface.
ExtendOnSurface
Extends a curve on a surface.
ExtremeParameters
Returns the parameter values of all local extrema. Parameter values are in increasing order so consecutive extrema define an interval on which each component of the curve is monotone. Note, non-periodic curves always return the end points.
Parameters:
| direction (Vector3d) | The direction in which to perform the calculation. |
Returns: The parameter values of all local extrema.
Fair
[ConstOperation]
public Curve Fair(double distanceTolerance, double angleTolerance, int clampStart, int clampEnd, int iterations)
Fairs a curve object. Fair works best on degree 3 (cubic) curves. Attempts to remove large curvature variations while limiting the geometry changes to be no more than the specified tolerance.
Parameters:
| distanceTolerance (double) | Maximum allowed distance the faired curve is allowed to deviate from the input. |
| angleTolerance (double) | (in radians) kinks with angles <= angleTolerance are smoothed out 0.05 is a good default. |
| clampStart (int) | The number of (control vertices-1) to preserve at start. 0 = preserve start point 1 = preserve start point and 1st derivative 2 = preserve start point, 1st and 2nd derivative |
| clampEnd (int) | Same as clampStart. |
| iterations (int) | The number of iterations to use in adjusting the curve. |
Returns: Returns new faired Curve on success, null on failure.
FilletSurfaceToCurve
public bool FilletSurfaceToCurve(BrepFace face, double t, double u, double v, double radius, int alignToCurve, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, double tolerance, List<Brep> out_fillets, out double[] fitResults)
Creates a constant-radius fillet surface between a surface and the curve.
Parameters:
| face (BrepFace) | the face being filleted. |
| t (double) | A parameter on the curve, indicating region of fillet. |
| u (double) | A parameter in the u direction of the face indicating which side of the curve to fillet. |
| v (double) | A parameter in the v direction of the face indicating which side of the curve to fillet. |
| radius (double) | The radius of the constant-radius fillet desired. NOTE: using arcSliders will change the shape of the arcs themselves |
| alignToCurve (int) | Does the user want the fillet to align to the curve? 0 - No, ignore the curve's b-spline structure 1 - Yes, match the curves's degree, spans, CVs as much as possible 2 - Same as 1, but iterate to fit to tolerance Note that a value of 1 or 2 will cause nBezierSrfs to be ignored |
| railDegree (int) | Desired fillet degree (3 or 5) in the u-direction, along the curve |
| arcDegree (int) | Desired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs.If 2, then the surface is rational in v |
| arcSliders (IEnumerable<double>) | Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical(1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical(1) |
| numBezierSrfs (int) | If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. |
| tolerance (double) | The tolerance. In in doubt, the document's absolute tolerance. |
| out_fillets (List<Brep>) | he results of the fillet calculation. |
| fitResults (out double[]) | array of doubles indicating fitting results: [0] max 3d point deviation along curve [1] max 3d point deviation along face [2] max angle deviation along face(in degrees) [3] max angle deviation between Bézier surfaces(in degrees) [4] max curvature difference between Bézier surfaces |
Returns: true if successful, false otherwise.
FilletSurfaceToRail
[ConstOperation]
public bool FilletSurfaceToRail(BrepFace faceWithCurve, BrepFace secondFace, double u1, double v1, int railDegree, int arcDegree, IEnumerable<double> arcSliders, int numBezierSrfs, bool extend, FilletSurfaceSplitType split_type, double tolerance, List<Brep> out_fillets, List<Brep> out_breps0, List<Brep> out_breps1, out double[] fitResults)
Creates a surface between two surfaces, with a fixed rail curve on the first surface.
Remarks: The trim or split input Breps are in OutBreps0, and OutBreps1. If the input faces are from the same Brep, nothing will be added to OutBreps1.If you specified a split type of RhinoFilletSurfaceSplitType::Nothing, then nothing will be added to either OutBreps0 or OutBreps1.
Parameters:
| faceWithCurve (BrepFace) | The first face on which the curve exists |
| secondFace (BrepFace) | The second face |
| u1 (double) | A parameter in the u direction of the second face at the side you want to keep after filleting. |
| v1 (double) | A parameter in the v direction of the second face at the side you want to keep after filleting. |
| railDegree (int) | Desired fillet degree (3 or 5) in the u-direction, along the rails |
| arcDegree (int) | esired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs.If 2, then the surface is rational in v |
| arcSliders (IEnumerable<double>) | Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical(1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical(1) |
| numBezierSrfs (int) | If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. |
| extend (bool) | If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. |
| split_type (FilletSurfaceSplitType) | The split type |
| tolerance (double) | The tolerance. In in doubt, the document's absolute tolerance. |
| out_fillets (List<Brep>) | The results of the fillet calculation. |
| out_breps0 (List<Brep>) | The trim or split results of the Brep owned by faceWithCurve. |
| out_breps1 (List<Brep>) | The trim or split results of the Brep owned by pFace1. |
| fitResults (out double[]) | array of doubles indicating fitting results: [0] max 3d point deviation along surface 0 [1] max 3d point deviation along surface 1 [2] max angle deviation along surface 0 (in degrees) [3] max angle deviation along surface 1 (in degrees) [4] max angle deviation between Bézier surfaces(in degrees) [5] max curvature difference between Bézier surfaces |
Returns: true if successful, false otherwise.
FindLocalInflection
public bool FindLocalInflection(Vector3d N, Interval subDomain, double seed, out double curveParameter, out double angleError)
Local minimization for point on a curve with tangent perpendicular to N.
Remarks: The algorithm minimizes the square of the dot product of N with the curve tangent. It is possible that the result will not be close to zero.
Parameters:
| N (Vector3d) | This vector and the curve tangent define a plane. In this plane, there is a vector V perpendicular to the tangent. |
| subDomain (Interval) | Subdomain of curve to evaluate. This must not be empty. |
| seed (double) | A seed parameter, which must be included in the subdomain. |
| curveParameter (out double) | The parameter on the curve if successful, RhinoMath.UnsetValue if unsuccessful. |
| angleError (out double) | The measure, in radians, of the angle between N and V. The angle will be zero when the result is an inflection. |
Returns: true if the minimization succeeds, regardless of angle_error, false if unsuccessful.
Fit
Fits a new curve through an existing curve.
Parameters:
| degree (int) | The degree of the returned Curve. Must be bigger than 1. |
| fitTolerance (double) | The fitting tolerance. If fitTolerance is RhinoMath.UnsetValue or <=0.0, the document absolute tolerance is used. |
| angleTolerance (double) | The kink smoothing tolerance in radians. If angleTolerance is 0.0, all kinks are smoothed If angleTolerance is >0.0, kinks smaller than angleTolerance are smoothed If angleTolerance is RhinoMath.UnsetValue or <0.0, the document angle tolerance is used for the kink smoothing |
Returns: Returns a new fitted Curve if successful, null on failure.
FrameAt
Returns a 3d frame at a parameter.
GetBoundingBox
Bounding box solver. Gets the world axis aligned bounding box for the geometry.
Parameters:
| accurate (bool) | If true, a physically accurate bounding box will be computed. If not, a bounding box estimate will be computed. For some geometry types there is no difference between the estimate and the accurate bounding box. Estimated bounding boxes can be computed much (much) faster than accurate (or "tight") bounding boxes. Estimated bounding boxes are always similar to or larger than accurate bounding boxes. |
Returns: The bounding box of the geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
GetBoundingBox
Aligned Bounding box solver. Gets the plane aligned bounding box.
Parameters:
| plane (Plane) | Orientation plane for BoundingBox. |
Returns: A BoundingBox in plane coordinates.
GetBoundingBox
Aligned Bounding box solver. Gets the world axis aligned bounding box for the transformed geometry.
Parameters:
| xform (Transform) | Transformation to apply to object prior to the BoundingBox computation. The geometry itself is not modified. |
Returns: The accurate bounding box of the transformed geometry in world coordinates or BoundingBox.Empty if not bounding box could be found.
GetConicSectionType
Returns the type of conic section based on the curve's shape.
GetConicSectionType
[ConstOperation]
public ConicSectionType GetConicSectionType(out Point3d focus1, out Point3d focus2, out Point3d center)
Returns the type of conic section based on the curve's shape.
GetCurveParameterFromNurbsFormParameter
[ConstOperation]
public bool GetCurveParameterFromNurbsFormParameter(double nurbsParameter, out double curveParameter)
Convert a NURBS curve parameter to a curve parameter.
GetLength
Gets the length of the curve with a fractional tolerance of 1.0e-8.
Returns: The length of the curve on success, or zero on failure.
GetLength
Get the length of a sub-section of the curve.
Parameters:
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve (must be non-decreasing). |
Returns: The length of the sub-curve on success, or zero on failure.
GetLength
Get the length of the curve.
Parameters:
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: The length of the curve on success, or zero on failure.
GetLength
Get the length of a sub-section of the curve with a fractional tolerance of 1e-8.
Parameters:
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve (must be non-decreasing). |
Returns: The length of the sub-curve on success, or zero on failure.
GetLocalPerpPoint
[ConstOperation]
public bool GetLocalPerpPoint(Point3d testPoint, double seedParmameter, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is perpendicular to a test point.
GetLocalTangentPoint
[ConstOperation]
public bool GetLocalTangentPoint(Point3d testPoint, double seedParmameter, out double curveParameter)
Search for a location on the curve, near seedParmameter, that is tangent to a test point.
GetNextDiscontinuity
[ConstOperation]
public bool GetNextDiscontinuity(Continuity continuityType, double t0, double t1, double cosAngleTolerance, double curvatureTolerance, out double t)
Searches for a derivative, tangent, or curvature discontinuity.
Parameters:
| continuityType (Continuity) | Type of continuity to search for. |
| t0 (double) | Search begins at t0. If there is a discontinuity at t0, it will be ignored. This makes it possible to repeatedly call GetNextDiscontinuity() and step through the discontinuities. |
| t1 (double) | (t0 != t1) If there is a discontinuity at t1 it will be ignored unless continuityType is a locus discontinuity type and t1 is at the start or end of the curve. |
| cosAngleTolerance (double) | default = cos(1 degree) Used only when continuity is G1_continuous or G2_continuous. If the cosine of the angle between two tangent vectors is <= cosAngleTolerance, then a G1 discontinuity is reported. For G2, values tighter than cos(1 degree) are treated as cos(1 degree), and angles less than about 18 degrees are doubled for the curvature direction test. With the default, a G2 discontinuity is reported if the curvature vectors differ by more than 2 degrees. |
| curvatureTolerance (double) | (default = RhinoMath.SqrtEpsilon) Used only when continuity is G2_continuous. If K0 and K1 are curvatures evaluated from above and below and |K0 - K1| <= curvatureTolerance, then the curvature is considered continuous. Otherwise, a curvature discontinuity is reported if the curvature direction test fails or ||K0| - |K1|| > 0.05 * max(|K0|, |K1|). Increasing curvatureTolerance can only loosen the test. |
| t (out double) | If a discontinuity is found, then t reports the parameter at the discontinuity. |
Returns: Parametric continuity tests c = (C0_continuous, ..., G2_continuous): true if a parametric discontinuity was found strictly between t0 and t1. Note well that all curves are parametrically continuous at the ends of their domains. Locus continuity tests c = (C0_locus_continuous, ...,G2_locus_continuous): true if a locus discontinuity was found strictly between t0 and t1 or at t1 is the at the end of a curve. Note well that all open curves (IsClosed()=false) are locus discontinuous at the ends of their domains. All closed curves (IsClosed()=true) are at least C0_locus_continuous at the ends of their domains.
GetNextDiscontinuity
[ConstOperation]
public bool GetNextDiscontinuity(Continuity continuityType, double t0, double t1, out double t)
Searches for a derivative, tangent, or curvature discontinuity.
Remarks: G1 uses a 1 degree tangent angle tolerance. G2 reports a discontinuity if the curvature vectors differ in direction by more than 2 degrees or in magnitude by more than 5%. These tolerances do not depend on the document's angle tolerance.
Parameters:
| continuityType (Continuity) | Type of continuity to search for. |
| t0 (double) | Search begins at t0. If there is a discontinuity at t0, it will be ignored. This makes it possible to repeatedly call GetNextDiscontinuity() and step through the discontinuities. |
| t1 (double) | (t0 != t1) If there is a discontinuity at t1 it will be ignored unless continuityType is a locus discontinuity type and t1 is at the start or end of the curve. |
| t (out double) | If a discontinuity is found, then t reports the parameter at the discontinuity. |
Returns: Parametric continuity tests c = (C0_continuous, ..., G2_continuous): true if a parametric discontinuity was found strictly between t0 and t1. Note well that all curves are parametrically continuous at the ends of their domains. Locus continuity tests c = (C0_locus_continuous, ...,G2_locus_continuous): true if a locus discontinuity was found strictly between t0 and t1 or at t1 is the at the end of a curve. Note well that all open curves (IsClosed()=false) are locus discontinuous at the ends of their domains. All closed curves (IsClosed()=true) are at least C0_locus_continuous at the ends of their domains.
GetNurbsFormParameterFromCurveParameter
[ConstOperation]
public bool GetNurbsFormParameterFromCurveParameter(double curveParameter, out double nurbsParameter)
Convert a curve parameter to a NURBS curve parameter.
GetObjectData
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
Populates a System.Runtime.Serialization.SerializationInfo with the data needed to serialize the target object.
Parameters:
| info (SerializationInfo) | The System.Runtime.Serialization.SerializationInfo to populate with data. |
| context (StreamingContext) | The destination (see System.Runtime.Serialization.StreamingContext) for this serialization. |
GetPerpendicularFrames
Gets a collection of perpendicular frames along the curve. Perpendicular frames are also known as 'Zero-twisting frames' and they minimize rotation from one frame to the next.
Parameters:
| parameters (IEnumerable<double>) | A collection of strictly increasing curve parameters to place perpendicular frames on. |
Returns: An array of perpendicular frames on success or null on failure.
Exceptions:
| InvalidOperationException | Thrown when the curve parameters are not increasing. |
GetSubCurves
Gets subcurves from a curve. The results will be similar to what is produced by Rhino's Explode command.
Remarks: Unlike Curve.DuplicateSegments(), this method produces results based on the curve's geometry.
Returns: An array of subcurves that make up this curve.
Parameters:
| key (string) | id used to retrieve the string. |
Returns: string associated with the key if successful. null if no key was found.
GetUserStrings
Gets a copy of all (user key string, user value string) pairs attached to this geometry.
Returns: A new collection.
Gets the greville (edit point) parameter that belongs to the control point at the specified index.
Parameters:
| index (int) | Index of Greville (Edit) point. |
Gets all Greville parameters for this curve.
Gets the Greville parameter that belongs to the control point at the specified index.
Parameters:
| index (int) | Index of Greville point. |
Gets all Greville points for this curve.
Gets Greville points for this curve.
Parameters:
| all (bool) | If true, then all Greville points are returns. If false, only edit points are returned. |
Returns: A list of points if successful, null otherwise.
HasNurbsForm
Does a NURBS curve representation of this curve exist?
Returns: 0 unable to create NURBS representation with desired accuracy. 1 success - NURBS parameterization matches the curve's to the desired accuracy 2 success - NURBS point locus matches the curve's and the domain of the NURBS curve is correct. However, This curve's parameterization and the NURBS curve parameterization may not match. This situation happens when getting NURBS representations of curves that have a transcendental parameterization like circles.
Increase the degree of this curve.
Parameters:
| desiredDegree (int) | The desired degree. Degrees should be number between and including 1 and 11. |
Returns: true on success, false on failure.
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.
Returns: An array of points if successful, null if not successful or on error.
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.
Parameters:
| curveParameters (out double[]) | An array of curve parameters at the inflection points. |
Returns: An array of points if successful, null if not successful or on error.
IsArc
Test a curve to see if it can be represented by an arc or circle within RhinoMath.ZeroTolerance.
Returns: true if the curve can be represented by an arc or a circle within tolerance.
IsArc
Test a curve to see if it can be represented by an arc or circle within the given tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if the curve can be represented by an arc or a circle within tolerance.
IsCircle
Test a curve to see if it can be represented by a circle within RhinoMath.ZeroTolerance.
Returns: true if the Curve can be represented by a circle within tolerance.
IsCircle
Test a curve to see if it can be represented by a circle within the given tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if the curve can be represented by a circle to within tolerance.
IsClosable
[ConstOperation]
public bool IsClosable(double tolerance, double minimumAbsoluteSize, double minimumRelativeSize)
Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.
Parameters:
| tolerance (double) | Maximum allowable distance between start and end. If start - end gap is greater than tolerance, this function will return false. |
| minimumAbsoluteSize (double) | If greater than 0.0 and none of the interior sampled points are at least minimumAbsoluteSize from start, this function will return false. |
| minimumRelativeSize (double) | If greater than 1.0 and chord length is less than minimumRelativeSize*gap, this function will return false. |
Returns: true if start and end points are close enough based on above conditions.
IsClosable
Decide if it makes sense to close off this curve by moving the endpoint to the start based on start-end gap size and length of curve as approximated by chord defined by 6 points.
Parameters:
| tolerance (double) | Maximum allowable distance between start and end. If start - end gap is greater than tolerance, this function will return false. |
Returns: true if start and end points are close enough based on above conditions.
IsContinuous
Test continuity at a curve parameter value.
Remarks: G1 uses a 1 degree tangent angle tolerance. G2 reports a discontinuity if the curvature vectors differ in direction by more than 2 degrees or in magnitude by more than 5%. These tolerances do not depend on the document's angle tolerance.
Parameters:
| continuityType (Continuity) | Type of continuity to test for. |
| t (double) | Parameter to test. |
Returns: true if the curve has at least the c type continuity at the parameter t.
public static bool IsDuplicate(NurbsCurve curveA, NurbsCurve curveB, bool ignoreParameterization, double tolerance)
Determines if two curves are similar.
Parameters:
| curveA (NurbsCurve) | First curve used in comparison. |
| curveB (NurbsCurve) | Second curve used in comparison. |
| ignoreParameterization (bool) | if true, parameterization and orientation are ignored. |
| tolerance (double) | tolerance to use when comparing control points. |
Returns: true if curves are similar within tolerance.
IsEllipse
Test a curve to see if it can be represented by an ellipse within RhinoMath.ZeroTolerance.
Returns: true if the Curve can be represented by an ellipse within tolerance.
IsEllipse
Test a curve to see if it can be represented by an ellipse within a given tolerance.
Parameters:
| tolerance (double) | Tolerance to use for checking. |
Returns: true if the Curve can be represented by an ellipse within tolerance.
IsInPlane
Test a curve to see if it lies in a specific plane.
Parameters:
| testPlane (Plane) | Plane to test for. |
Returns: true if the maximum distance from the curve to the testPlane is <= RhinoMath.ZeroTolerance.
IsLinear
Test a curve to see if it is linear to within RhinoMath.ZeroTolerance units (1e-12).
Returns: true if the curve is linear.
IsLinear
Test a curve to see if it is linear to within the custom tolerance.
Parameters:
| tolerance (double) | Tolerance to use when checking linearity. |
Returns: true if the ends of the curve are farther than tolerance apart and the maximum distance from any point on the curve to the line segment connecting the curve ends is <= tolerance.
Returns: true if the curve is planar (flat) to within RhinoMath.ZeroTolerance units (1e-12).
Parameters:
| tolerance (double) | Tolerance to use when checking. |
Returns: true if there is a plane such that the maximum distance from the curve to the plane is <= tolerance.
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.
Returns: true if this curve can be represented as a polyline; otherwise, false.
IsShort
Used to quickly find short curves.
Remarks: Faster than calling Length() and testing the result.
Parameters:
| tolerance (double) | Length threshold value for "shortness". |
Returns: true if the length of the curve is <= tolerance.
IsValidWithLog
Determines if an object is valid. Also provides a report on errors if this object happens not to be valid.
Parameters:
| log (out string) | A textual log. This out parameter is assigned during this call. |
Returns: true if this object is valid; false otherwise.
LcoalClosestPoint
[ConstOperation]
[EditorBrowsable(EditorBrowsableState.Never)]
public bool LcoalClosestPoint(Point3d testPoint, double seed, out double t)
obsoleteTypo: use LocalClosestPoint
Find parameter of the point on a curve that is locally closest to the testPoint. The search for a local close point starts at a seed parameter.
LengthParameter
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, double fractionalTolerance, Interval subdomain)
Gets the parameter along the curve which coincides with a given length along the curve.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the sub-domain. |
| t (out double) | Parameter such that the length of the curve from the start of the sub-domain to t is s. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve rather than the whole curve. |
Returns: true on success, false on failure.
LengthParameter
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, double fractionalTolerance)
Gets the parameter along the curve which coincides with a given length along the curve.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the curve. |
| t (out double) | Parameter such that the length of the curve from the curve start point to t equals s. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: true on success, false on failure.
LengthParameter
[ConstOperation]
public bool LengthParameter(double segmentLength, out double t, Interval subdomain)
Gets the parameter along the curve which coincides with a given length along the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| segmentLength (double) | Length of segment to measure. Must be less than or equal to the length of the sub-domain. |
| t (out double) | Parameter such that the length of the curve from the start of the sub-domain to t is s. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve rather than the whole curve. |
Returns: true on success, false on failure.
LengthParameter
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
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
If IsClosed, just return true. Otherwise, decide if curve can be closed as follows: Linear curves polylinear curves with 2 segments, NURBS with 3 or less control points cannot be made closed. Also, if tolerance > 0 and the gap between start and end is larger than tolerance, curve cannot be made closed. Adjust the curve's endpoint to match its start point.
Parameters:
| tolerance (double) | If nonzero, and the gap is more than tolerance, curve cannot be made closed. |
Returns: true on success, false on failure.
public static NurbsCurve[] 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.
Parameters:
| curves (IEnumerable<Curve>) | The input curves. |
| startPt (Point3d) | The start point. To omit, specify Point3d.Unset. |
| endPt (Point3d) | The end point. To omit, specify Point3d.Unset. |
| simplifyMethod (int) | The simplify method. |
| numPoints (int) | The number of rebuild points. |
| refitTolerance (double) | The refit tolerance. |
| angleTolerance (double) | The angle tolerance in radians. |
Returns: The output NURBS surfaces if successful.
MakeDeformable
If possible, converts the object into a form that can be accurately modified with "squishy" transformations like projections, shears, an non-uniform scaling.
Returns: false if object cannot be converted to a deformable object. true if object was already deformable or was converted into a deformable object.
Clamps ends and adds knots so the NURBS curve has Bezier spans (all distinct knots have multiplicity = degree).
Parameters:
| setEndWeightsToOne (bool) | If true and the first or last weight is not one, then the first and last spans are re-parameterized so that the end weights are one. |
Returns: true on success, false on failure.
Changes a NURBS curve so each control point affects the curve exactly the same way. This make the knot vectors uniform without changing the control point locations. This will change the object shape slightly.
Returns: True if successful, false otherwise.
public NurbsCurve 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.
Parameters:
| targetCurve (Curve) | The target curve. |
| maxEndDistance (double) | If maxEndDistance dist > 0, the curve's start must be within maxEndDistance of targetCurve start. If maxEndDistance dist > 0, the curve's end must be within maxEndDistance of targetCurve end. |
| maxInteriorDistance (double) | If maxInteriorDistance > 0, all interior Greville points of the curve must be within maxInteriorDistance of targetCurve. |
| matchTolerance (double) | The matching tolerance. |
| maxLevel (int) | If maxLevel > 0, the result will be refined up to that many times, attempting to get the result within matchTolerance. If matchTolerance <= 0, no refinement will be done. In any case, the parameters closest points on targetCurve of the Greville points of the curve must be monotonic increasing. |
Returns: Curve on success, null on failure.
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.
Returns: An array of points if successful, null if not successful or on error.
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.
Parameters:
| curveParameters (out double[]) | An array of curve parameters at the maximum curvature points. |
Returns: An array of points if successful, null if not successful or on error.
MemoryEstimate
Computes an estimate of the number of bytes that this object is using in memory.
Returns: An estimated memory footprint.
NonConstOperation
protected override void NonConstOperation()
For derived classes implementers.
Defines the necessary implementation to free the instance from being constant.
Overrides: GeometryBase.NonConstOperation
NormalizedLengthParameter
[ConstOperation]
public bool NormalizedLengthParameter(double s, out double t, double fractionalTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. |
Returns: true on success, false on failure.
NormalizedLengthParameter
[ConstOperation]
public bool NormalizedLengthParameter(double s, out double t, double fractionalTolerance)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| fractionalTolerance (double) | Desired fractional precision. fabs(("exact" length from start to t) - arc_length)/arc_length <= fractionalTolerance. |
Returns: true on success, false on failure.
NormalizedLengthParameter
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double) | Normalized arc length parameter. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| t (out double) | Parameter such that the length of the curve from its start to t is arc_length. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. |
Returns: true on success, false on failure.
NormalizedLengthParameter
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
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, double fractionalTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| fractionalTolerance (double) | Desired fractional precision for each segment. fabs("true" length - actual length)/(actual length) <= fractionalTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. A 0.0 s value corresponds to sub-domain->Min() and a 1.0 s value corresponds to sub-domain->Max(). |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
NormalizedLengthParameters
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, double fractionalTolerance)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| fractionalTolerance (double) | Desired fractional precision for each segment. fabs("true" length - actual length)/(actual length) <= fractionalTolerance. |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
NormalizedLengthParameters
[ConstOperation]
public double[] NormalizedLengthParameters(double[] s, double absoluteTolerance, Interval subdomain)
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
| subdomain (Interval) | The calculation is performed on the specified sub-domain of the curve. A 0.0 s value corresponds to sub-domain->Min() and a 1.0 s value corresponds to sub-domain->Max(). |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
NormalizedLengthParameters
Input the parameter of the point on the curve that is a prescribed arc length from the start of the curve. A fractional tolerance of 1e-8 is used in this version of the function.
Parameters:
| s (double[]) | Array of normalized arc length parameters. E.g., 0 = start of curve, 1/2 = midpoint of curve, 1 = end of curve. |
| absoluteTolerance (double) | If absoluteTolerance > 0, then the difference between (s[i+1]-s[i])*curve_length and the length of the curve segment from t[i] to t[i+1] will be <= absoluteTolerance. |
Returns: If successful, array of curve parameters such that the length of the curve from its start to t[i] is s[i]*curve_length. Null on failure.
Offset
[ConstOperation]
public Curve[] Offset(Plane plane, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| plane (Plane) | Offset solution plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
Returns: Offset curves on success, null on failure.
Offset
[ConstOperation]
public Curve[] Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, CurveOffsetCornerStyle cornerStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| directionPoint (Point3d) | A point that indicates the direction of the offset. |
| normal (Vector3d) | The normal to the offset plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
Returns: Offset curves on success, null on failure.
Offset
[ConstOperation]
public Curve[] Offset(Point3d directionPoint, Vector3d normal, double distance, double tolerance, double angleTolerance, bool loose, CurveOffsetCornerStyle cornerStyle, CurveOffsetEndStyle endStyle)
Offsets this curve. If you have a nice offset, then there will be one entry in the array. If the original curve had kinks or the offset curve had self intersections, you will get multiple segments in the output array.
Parameters:
| directionPoint (Point3d) | A point that indicates the direction of the offset. |
| normal (Vector3d) | The normal to the offset plane. |
| distance (double) | The positive or negative distance to offset. |
| tolerance (double) | The offset or fitting tolerance. |
| angleTolerance (double) | The angle tolerance, in radians, used to decide whether to split at kinks. |
| loose (bool) | If false, offset within tolerance. If true, offset by moving edit points. |
| cornerStyle (CurveOffsetCornerStyle) | Corner style for offset kinks. |
| endStyle (CurveOffsetEndStyle) | End style for non-loose, non-closed curve offsets. |
Returns: Offset curves on success, null on failure.
OffsetNormalToSurface
Finds a curve by offsetting an existing curve normal to a surface. The caller is responsible for ensuring that the curve lies on the input surface.
Parameters:
| surface (Surface) | Surface from which normals are calculated. |
| height (double) | Offset distance. |
Returns: Curve offset normal to the surface, if successful, null otherwise. The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset.
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, double distance, double fittingTolerance)
Offset this curve on a brep face surface. This curve must lie on the surface.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| distance (double) | A distance to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, double[] curveParameters, double[] offsetDistances, double fittingTolerance)
Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| curveParameters (double[]) | Curve parameters corresponding to the offset distances. |
| offsetDistances (double[]) | distances to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face, curveParameters or offsetDistances are null. |
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(BrepFace face, Point2d throughPoint, double fittingTolerance)
Offset a curve on a brep face surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.
Parameters:
| face (BrepFace) | The brep face on which to offset. |
| throughPoint (Point2d) | 2d point on the brep face to offset through. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If face is null. |
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, double distance, double fittingTolerance)
Offset a curve on a surface. This curve must lie on the surface.
Parameters:
| surface (Surface) | A surface on which to offset. |
| distance (double) | A distance to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface is null. |
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, double[] curveParameters, double[] offsetDistances, double fittingTolerance)
Offset this curve on a surface. This curve must lie on the surface.
This overload allows to specify different offsets for different curve parameters.
Parameters:
| surface (Surface) | A surface on which to offset. |
| curveParameters (double[]) | Curve parameters corresponding to the offset distances. |
| offsetDistances (double[]) | Distances to offset (+)left, (-)right. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface, curveParameters or offsetDistances are null. |
OffsetOnSurface
[ConstOperation]
public Curve[] OffsetOnSurface(Surface surface, Point2d throughPoint, double fittingTolerance)
Offset a curve on a surface. This curve must lie on the surface.
This overload allows to specify a surface point at which the offset will pass.
Parameters:
| surface (Surface) | A surface on which to offset. |
| throughPoint (Point2d) | 2d point on the brep face to offset through. |
| fittingTolerance (double) | A fitting tolerance. |
Returns: Offset curves on success, or null on failure.
Exceptions:
| ArgumentNullException | If surface is null. |
OffsetTangentToSurface
Finds a curve by offsetting an existing curve tangent to a surface. The caller is responsible for ensuring that the curve lies on the input surface.
Parameters:
| surface (Surface) | Surface from which tangents are calculated. |
| height (double) | Offset distance. |
Returns: Curve offset tangent to the surface, if successful, null otherwise. The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset.
OnSwitchToNonConst
protected override void OnSwitchToNonConst()
Is called when a non-constant operation occurs.
Overrides: CommonObject.OnSwitchToNonConst
PerpendicularFrameAt
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.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Point (location of curve at the parameter t).
PointAtLength
Gets a point at a certain length along the curve. The length must be non-negative and less than or equal to the length of the curve. Lengths will not be wrapped when the curve is closed or periodic.
Parameters:
| length (double) | Length along the curve between the start point and the returned point. |
Returns: Point on the curve at the specified length from the start point or Poin3d.Unset on failure.
PointAtNormalizedLength
Gets a point at a certain normalized length along the curve. The length must be between or including 0.0 and 1.0, where 0.0 equals the start of the curve and 1.0 equals the end of the curve.
Parameters:
| length (double) | Normalized length along the curve between the start point and the returned point. |
Returns: Point on the curve at the specified normalized length from the start point or Poin3d.Unset on failure.
PullToBrepFace
Pulls this curve to a brep face and returns the result of that operation.
Returns: An array containing the resulting curves after pulling. This array could be empty.
Exceptions:
| ArgumentNullException | If face is null. |
PullToMesh
Projects this curve onto a mesh.
Parameters:
| mesh (Mesh) | Mesh to project onto. |
| tolerance (double) | Input tolerance. When in doubt, the document's model absolute tolerance. |
| loose (bool) | If true, the curve's edit points are pulled back to the mesh. If any edit point misses the mesh, the curve will not be created. |
Returns: A curve if success, or null on failure.
PullToMesh
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
Rebuild a curve with a specific point count.
RebuildToMatchTemplateCurve
[ConstOperation]
public NurbsCurve RebuildToMatchTemplateCurve(Curve templateCurve, bool flipSourceDirection, bool preserveEndTangents, bool makeSubDFriendly, out Line maximumDeviation)
Rebuilds this curve so it takes on the degree, knot vector, and control point count of a template curve.
Parameters:
| templateCurve (Curve) | The curve to match. |
| flipSourceDirection (bool) | If true and this curve is open, its direction is flipped (reversed) before sampling. Set this when this curve runs opposite the template. |
| preserveEndTangents (bool) | If true and the result is open with at least 4 control points, the interior end control points are adjusted so the result's end tangents match this curve's. |
| makeSubDFriendly (bool) | If true, the result is converted to a SubD friendly curve. |
| maximumDeviation (out Line) | A line from this curve to the rebuilt curve at the point of maximum separation (the "from" point is on this curve, the "to" point is on the rebuilt curve), or Line.Unset if it cannot be computed. |
Returns: The rebuilt NURBS curve, or null if the template curve is unusable or the rebuild fails.
RemoveShortSegments
Looks for segments that are shorter than tolerance that can be removed. Does not change the domain, but it will change the relative parameterization.
Parameters:
| tolerance (double) | Tolerance which defines "short" segments. |
Returns: true if removable short segments were found. false if no removable short segments were found.
Parameters:
| tolerance (double) | The repair tolerance. |
Returns: true if successful, false otherwise.
Use a linear fractional transformation to re-parameterize the NURBS curve. This does not change the curve's domain.
Remarks: The CV and knot values are values are changed so that output_nurbs(t) = input_nurbs(lambda(t)).
Parameters:
| c (double) | re-parameterization constant (generally speaking, c should be > 0). The control points and knots are adjusted so that output_nurbs(t) = input_nurbs(lambda(t)), where lambda(t) = c*t/( (c-1)*t + 1 ). Note that lambda(0) = 0, lambda(1) = 1, lambda'(t) > 0, lambda'(0) = c and lambda'(1) = 1/c. |
Returns: true if successful.
Reparameterize
Reparameterizes a curve using automatic parameterization.
Remarks: Poorly parameterized objects may not intersect and trim properly when combined with other objects. "Poorly parameterized" means the curve's domain or the surface's u or v spaces are tiny or huge compared to the size of the object. When curves are parameterized with a [0,1] domain, both the accuracy and the precision of geometric calculations like intersections and closest points are reduced, sometimes dramatically. Ideally the domain of a curve is close to it's length.
Returns: The reparameterized curve if successful, null otherwise.
Remarks: If reversed, the domain changes from [a,b] to [-b,-a]
Returns: true on success, false on failure.
RibbonOffset
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out Curve[] crossSections, out Surface[] ruledSurfaces)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
| crossSections (out Curve[]) | Contains lines between input and the offset that might be useful as input to Brep.CreateFromSweep or some other surface creation tool. |
| ruledSurfaces (out Surface[]) | Contain ruled surfaces between the input and the parts of the offset that correspond exactly. Note, there will be gaps between these at blends. |
Returns: The offset curve if successful.
RibbonOffset
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance, out double[] outputParameters, out double[] curveParameters)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
| outputParameters (out double[]) | A list of parameter, paired with curveParameters, from the output curve for creating cross sections. |
| curveParameters (out double[]) | A list of parameter, paired with outputParameters, from the input curve for creating cross sections. |
Returns: The offset curve if successful.
RibbonOffset
public Curve RibbonOffset(double distance, double blendRadius, Point3d directionPoint, Vector3d normal, double tolerance)
Offsets a closed curve in the following way: pProject the curve to a plane with given normal. Then, loose Offset the projection by distance + blend_radius and trim off self-intersection. THen, Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result.
Parameters:
| distance (double) | The positive distance to offset the curve. |
| blendRadius (double) | Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius. |
| directionPoint (Point3d) | A point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. |
| normal (Vector3d) | A vector that indicates the normal of the plane in which the offset will occur. |
| tolerance (double) | Used to determine self-intersections, not offset error. |
Returns: The offset curve if successful.
RibbonOffset
public Curve RibbonOffset(RibbonOffsetParameters ribbonParameters, out Curve[] railCurves, out Curve[] crossSectionCurves, out Brep[] brepSurfaces)
Ribbon offset method to mimic RibbonOffset command
Parameters:
| ribbonParameters (RibbonOffsetParameters) | The ribbon offset parameters |
| railCurves (out Curve[]) | on success an array of split curves representing the sweep rail segments, null on failure |
| crossSectionCurves (out Curve[]) | on success an array of cross section curves used during brep creation, null on failure |
| brepSurfaces (out Brep[]) | on success and array of breps representing the ribbon surfaces, null on failure |
Returns: return an offset curve on success, null on failure
Rotate
Rotates the object about the specified axis. A positive rotation angle results in a counter-clockwise rotation about the axis (right hand rule).
Scale
Scales the object by the specified factor. The scale is centered at the origin.
Parameters:
| scaleFactor (double) | The uniform scaling factor. |
Returns: true if geometry successfully scaled.
public bool SetEndCondition(bool bSetEnd, NurbsCurveEndConditionType continuity, Point3d point, Vector3d tangent, Vector3d curvature)
Set end condition of a NURBS curve to point, tangent and curvature.
Parameters:
| bSetEnd (bool) | true: set end of curve, false: set start of curve |
| continuity (NurbsCurve.NurbsCurveEndConditionType) | Position: set start or end point, Tangency: set point and tangent, Curvature: set point, tangent and curvature |
| point (Point3d) | point to set |
| tangent (Vector3d) | tangent to set |
| curvature (Vector3d) | curvature to set |
Returns: true on success, false on failure.
public bool SetEndCondition(bool bSetEnd, NurbsCurveEndConditionType continuity, Point3d point, Vector3d tangent)
Set end condition of a NURBS curve to point, tangent and curvature.
Parameters:
| bSetEnd (bool) | true: set end of curve, false: set start of curve |
| continuity (NurbsCurve.NurbsCurveEndConditionType) | Position: set start or end point, Tangency: set point and tangent, Curvature: set point, tangent and curvature |
| point (Point3d) | point to set |
| tangent (Vector3d) | tangent to set |
Returns: true on success, false on failure.
SetEndPoint
Forces the curve to end at a specified point. Not all curve types support this operation.
Remarks: Some end points cannot be moved. Be sure to check return code
Parameters:
| point (Point3d) | New end point of curve. |
Returns: true on success, false on failure.
Sets all Greville edit points for this curve.
Parameters:
| points (IEnumerable<Point3d>) | The new point locations. The number of points should match the number of point returned by NurbsCurve.GrevillePoints(false). |
Returns: true if successful, false otherwise.
SetStartPoint
Forces the curve to start at a specified point. Not all curve types support this operation.
Remarks: Some start points cannot be moved. Be sure to check return code.
Parameters:
| point (Point3d) | New start point of curve. |
Returns: true on success, false on failure.
SetUserString
Attach a user string (key,value combination) to this geometry.
Simplify
[ConstOperation]
public Curve Simplify(CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)
Returns a geometrically equivalent PolyCurve.
The PolyCurve has the following properties
1. All the PolyCurve segments are LineCurve, PolylineCurve, ArcCurve, or NurbsCurve.
2. The NURBS Curves segments do not have fully multiple interior knots.
3. Rational NURBS curves do not have constant weights.
4. Any segment for which IsLinear() or IsArc() is true is a Line, Polyline segment, or an Arc.
5. Adjacent co-linear or co-circular segments are combined.
6. Segments that meet with G1-continuity have there ends tuned up so that they meet with G1-continuity to within machine precision.
Parameters:
| options (CurveSimplifyOptions) | Simplification options. |
| distanceTolerance (double) | A distance tolerance for the simplification. |
| angleToleranceRadians (double) | An angle tolerance for the simplification. |
Returns: New simplified curve on success, null on failure.
SimplifyEnd
[ConstOperation]
public Curve SimplifyEnd(CurveEnd end, CurveSimplifyOptions options, double distanceTolerance, double angleToleranceRadians)
Same as SimplifyCurve, but simplifies only the last two segments at "side" end.
Parameters:
| end (CurveEnd) | If CurveEnd.Start the function simplifies the last two start side segments, otherwise if CurveEnd.End the last two end side segments are simplified. |
| options (CurveSimplifyOptions) | Simplification options. |
| distanceTolerance (double) | A distance tolerance for the simplification. |
| angleToleranceRadians (double) | An angle tolerance for the simplification. |
Returns: New simplified curve on success, null on failure.
Smooth
public Curve Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem, Plane plane)
Smooths a curve by averaging the positions of control points in a specified region.
Parameters:
| smoothFactor (double) | The smoothing factor, which controls how much control points move towards the average of the neighboring control points. Note that this smoothFactor is equivalent to twice the smooth factor used in the Smooth command: on a polyline, Rhino _Smooth with a factor of 0.2 is the same as Polyline.Smooth(double) with a factor of 0.4. |
| bXSmooth (bool) | When true control points move in X axis direction. |
| bYSmooth (bool) | When true control points move in Y axis direction. |
| bZSmooth (bool) | When true control points move in Z axis direction. |
| bFixBoundaries (bool) | When true the curve ends don't move. |
| coordinateSystem (SmoothingCoordinateSystem) | The coordinates to determine the direction of the smoothing. |
| plane (Plane) | If SmoothingCoordinateSystem.CPlane specified, then the construction plane. |
Returns: The smoothed curve if successful, null otherwise.
Smooth
public Curve Smooth(double smoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, SmoothingCoordinateSystem coordinateSystem)
Smooths a curve by averaging the positions of control points in a specified region.
Parameters:
| smoothFactor (double) | The smoothing factor, which controls how much control points move towards the average of the neighboring control points. Note that this smoothFactor is equivalent to twice the smooth factor used in the Smooth command: on a polyline, Rhino _Smooth with a factor of 0.2 is the same as Polyline.Smooth(double) with a factor of 0.4. |
| bXSmooth (bool) | When true control points move in X axis direction. |
| bYSmooth (bool) | When true control points move in Y axis direction. |
| bZSmooth (bool) | When true control points move in Z axis direction. |
| bFixBoundaries (bool) | When true the curve ends don't move. |
| coordinateSystem (SmoothingCoordinateSystem) | The coordinates to determine the direction of the smoothing. |
Returns: The smoothed curve if successful, null otherwise.
SpanDomain
Get the domain of the curve span with the given index. Use the SpanCount property to test how many spans there are.
Parameters:
| spanIndex (int) | Index of span. |
Returns: Interval of the span with the given index.
SpanVector
Returns the vector of span division parameters for this curve.
Returns: An array of parameter values that mark the boundaries between spans of the curve.
Split
Splits a curve into pieces using a polysurface.
Split
obsoleteUse version that takes an angle tolerance
Splits a curve into pieces using a polysurface.
Split
Splits (divides) the curve at the specified parameter. The parameter must be in the interior of the curve's domain.
Parameters:
| t (double) | Parameter to split the curve at in the interval returned by Domain(). |
Returns: Two curves on success, null on failure.
Split
Splits (divides) the curve at a series of specified parameters. The parameter must be in the interior of the curve domain.
Parameters:
| t (IEnumerable<double>) | Parameters to split the curve at in the interval returned by Domain(). |
Returns: Multiple curves on success, null on failure.
Split
Splits a curve into pieces using a cutting plane.
Split
[ConstOperation]
public Curve[] Split(Surface cutter, double tolerance, double angleToleranceRadians)
Splits a curve into pieces using a surface.
Split
obsoleteUse version that takes an angle tolerance
Splits a curve into pieces using a surface.
TangentAt
Evaluates the unit tangent vector at a curve parameter.
Remarks: No error handling.
Parameters:
| t (double) | Evaluation parameter. |
Returns: Unit tangent vector of the curve at the parameter t.
ToArcsAndLines
[ConstOperation]
public PolyCurve ToArcsAndLines(double tolerance, double angleTolerance, double minimumLength, double maximumLength)
Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straight-line segments.
Parameters:
| tolerance (double) | The tolerance. This is the maximum deviation from arc midpoints to the curve. When in doubt, use the document's model space absolute tolerance. |
| angleTolerance (double) | The angle tolerance in radians. This is the maximum deviation of the arc end directions from the curve direction. When in doubt, use the document's model space angle tolerance. |
| minimumLength (double) | The minimum segment length. |
| maximumLength (double) | The maximum segment length. |
Returns: PolyCurve on success, null on error.
ToJSON
Create a JSON string representation of this object
Parameters:
| options (SerializationOptions) |
ToNurbsCurve
Constructs a NURBS curve representation of this curve.
Returns: NURBS representation of the curve on success, null on failure.
ToNurbsCurve
Constructs a NURBS curve representation of this curve.
Parameters:
| subdomain (Interval) | The NURBS representation for this portion of the curve is returned. |
Returns: NURBS representation of the curve on success, null on failure.
ToPolyline
[ConstOperation]
public PolylineCurve ToPolyline(double tolerance, double angleTolerance, double minimumLength, double maximumLength)
Gets a polyline approximation of a curve.
Parameters:
| tolerance (double) | The tolerance. This is the maximum deviation from line midpoints to the curve. When in doubt, use the document's model space absolute tolerance. |
| angleTolerance (double) | The angle tolerance in radians. This is the maximum deviation of the line directions. When in doubt, use the document's model space angle tolerance. |
| minimumLength (double) | The minimum segment length. |
| maximumLength (double) | The maximum segment length. |
Returns: PolyCurve on success, null on error.
ToPolyline
[ConstOperation]
public PolylineCurve ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint, Interval curveDomain)
Gets a polyline approximation of a curve.
Parameters:
| mainSegmentCount (int) | If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount sub-parts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed. |
| subSegmentCount (int) | An amount of subsegments. |
| maxAngleRadians (double) | ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices. |
| maxChordLengthRatio (double) | Maximum permitted value of (distance chord midpoint to curve) / (length of chord). |
| maxAspectRatio (double) | If maxAspectRatio < 1.0, the parameter is ignored. If 1 <= maxAspectRatio < sqrt(2), it is treated as if maxAspectRatio = sqrt(2). This parameter controls the maximum permitted value of (length of longest chord) / (length of shortest chord). |
| tolerance (double) | If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline. |
| minEdgeLength (double) | The minimum permitted edge length. |
| maxEdgeLength (double) | If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length. |
| keepStartPoint (bool) | If true the starting point of the curve is added to the polyline. If false the starting point of the curve is not added to the polyline. |
| curveDomain (Interval) | This sub-domain of the NURBS curve is approximated. |
Returns: PolylineCurve on success, null on error.
ToPolyline
[ConstOperation]
public PolylineCurve ToPolyline(int mainSegmentCount, int subSegmentCount, double maxAngleRadians, double maxChordLengthRatio, double maxAspectRatio, double tolerance, double minEdgeLength, double maxEdgeLength, bool keepStartPoint)
Gets a polyline approximation of a curve.
Parameters:
| mainSegmentCount (int) | If mainSegmentCount <= 0, then both subSegmentCount and mainSegmentCount are ignored. If mainSegmentCount > 0, then subSegmentCount must be >= 1. In this case the NURBS will be broken into mainSegmentCount equally spaced chords. If needed, each of these chords can be split into as many subSegmentCount sub-parts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if subSegmentCount = 0, then the curve is broken into mainSegmentCount pieces and no further testing is performed. |
| subSegmentCount (int) | An amount of subsegments. |
| maxAngleRadians (double) | ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices. |
| maxChordLengthRatio (double) | Maximum permitted value of (distance chord midpoint to curve) / (length of chord). |
| maxAspectRatio (double) | If maxAspectRatio < 1.0, the parameter is ignored. If 1 <= maxAspectRatio < sqrt(2), it is treated as if maxAspectRatio = sqrt(2). This parameter controls the maximum permitted value of (length of longest chord) / (length of shortest chord). |
| tolerance (double) | If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline. |
| minEdgeLength (double) | The minimum permitted edge length. |
| maxEdgeLength (double) | If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length. |
| keepStartPoint (bool) | If true the starting point of the curve is added to the polyline. If false the starting point of the curve is not added to the polyline. |
Returns: PolylineCurve on success, null on error.
TorsionAt
Evaluate the torsion of a curve at a parameter. Sometimes also called the "second curvature", torsion is the rate of change of a curve's osculating plane.
Remarks: See Barrett O'Neill, Elementary Differential Geometry, page 69.
Parameters:
| t (double) | The evaluation parameter. |
Returns: The torsion if successful.
Transform
Transforms the geometry. If the input Transform has a SimilarityType of OrientationReversing, you may want to consider flipping the transformed geometry after calling this function when it makes sense. For example, you may want to call Flip() on a Brep after transforming it.
Parameters:
| xform (Transform) | Transformation to apply to geometry. |
Returns: true if geometry successfully transformed.
Translate
Translates the object along the specified vector.
Translate
Translates the object along the specified vector.
Parameters:
| translationVector (Vector3d) | A moving vector. |
Returns: true if geometry successfully translated.
Trim
Shortens a curve by a given length
Trim
Removes portions of the curve outside the specified interval.
Remarks: If curve is open, then trimming interval must be an increasing interval. If curve is closed, and trimming interval is a decreasing interval, then the portion of the curve across the start/end is returned.
Returns: Trimmed portion of this curve is successful, null on failure.
Trim
Removes portions of the curve outside the specified interval.
Remarks: If curve is open, then trimming interval must be an increasing interval. If curve is closed, and trimming interval is a decreasing interval, then the portion of the curve across the start/end is returned.
Parameters:
| domain (Interval) | Trimming interval. |
Returns: Trimmed curve if successful, null on failure.
TrimInterval
Trims the curve in-place by removing portions of the curve outside the specified interval.
TrimInterval
Trims the curve in-place by removing portions of the curve outside the specified interval.
Remarks: Portions of the curve before curve(domain[0]) and after curve(domain[1]) are removed.
Parameters:
| domain (Interval) | Trimming interval. |
Returns: True if successful, false otherwise.
TryGetArc
Try to convert this curve into an Arc using a custom tolerance.
TryGetArc
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
Parameters:
| arc (out Arc) | On success, the Arc will be filled in. |
Returns: true if the curve could be converted into an arc.
TryGetArc
Try to convert this curve into an Arc using a custom tolerance.
TryGetArc
Try to convert this curve into an Arc using RhinoMath.ZeroTolerance.
TryGetCircle
Try to convert this curve into a Circle using a custom tolerance.
TryGetCircle
Try to convert this curve into a circle using RhinoMath.ZeroTolerance.
Parameters:
| circle (out Circle) | On success, the Circle will be filled in. |
Returns: true if the curve could be converted into a Circle.
TryGetEllipse
Try to convert this curve into an Ellipse using a custom tolerance.
TryGetEllipse
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
Parameters:
| ellipse (out Ellipse) | On success, the Ellipse will be filled in. |
Returns: true if the curve could be converted into an Ellipse.
TryGetEllipse
Try to convert this curve into an Ellipse using a custom tolerance.
TryGetEllipse
Try to convert this curve into an Ellipse within RhinoMath.ZeroTolerance.
TryGetPlane
Test a curve for planarity and return the plane.
Parameters:
| plane (out Plane) | On success, the plane parameters are filled in. |
Returns: true if there is a plane such that the maximum distance from the curve to the plane is <= RhinoMath.ZeroTolerance.
TryGetPolyline
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.
TryGetPolyline
Several types of Curve can have the form of a polyline including a degree 1 NurbsCurve, a PolylineCurve, and a PolyCurve all of whose segments are some form of polyline. IsPolyline tests a curve to see if it can be represented as a polyline.
Parameters:
| polyline (out Polyline) | If true is returned, then the polyline form is returned here. |
Returns: true if this curve can be represented as a polyline; otherwise, false.
Calculates the u, V, and N directions of a NURBS curve at a parameter similar to the method used by Rhino's MoveUVN command.