#include
<MFnNurbsCurve.h>
List of all
members.
Detailed Description
NURBS curve function set.
This is the function set for NURBS (NonUniform Rational
BSpline) curves.
The shape of a NURBS curve is defined by an array of CVs
(control vertices), an array of knot values, a degree, and a form.
There are 3 possible "forms" for the curve: open,
closed and periodic.
The open and closed forms are quite similar, and
in fact a closed curve will become an open curve if either the
first or last CV is moved so that they are no longer coincident. To
create an open or closed curve of degree N with M spans, you must
provide M+N CVs. This implies that for a degree N curve, you must
specify at least N+1 CVs to get a curve with a single span.
The number of knots required for a curve is M + 2N  1. If you
want the curve to start exactly at the first CV and end exactly at
the last CV, then the knot vector must be structured to have degree
N "multiplicity" at the beginning and end. This means that the
first N knots must be identical, and the last N knots must be
identical.
A periodic curve is a special case of a closed curve.
Instead of having just the first and last CVs coincident, the last
N CVs in the curve must overlap the first N CVs. This results in a
curve with no tangent break at the seam where the ends meet. The
last N CVs in a periodic curve are permanently bound to the first N
CVs, and Maya will not allow those last N CVs to be repositioned.
If one or more of the first N CVs of the curve are repositioned,
the overlapping CV's will remain bound, and will also be moved.
In order to create a periodic curve, you must specify at least
2N+1 CVs, so that that last N can overlap the first N and you still
have 1 nonoverlapping CV left. The number of CVs required to
create a periodic curve is still N+M (with a lower limit of 2N+1),
but you must ensure that the positions of the last N CVs are
identical to the positions of the first N.
You still need M + 2N  1 knots for a periodic curve, but the
knot values required are more restrictive than for open or closed
curves because of the overlap at the ends, The difference between
the first N pairs of knots values should be equal to the difference
between the last N pairs. Additionally there can be no knot
multiplicity at the ends of the curve, because that would
compromise the tangent continuity property. So an example knot
sequence could begin with knots at { (N2), (N1), ... , 0}.
Managing different knot representations in external
applications
Note that some third party applications use a different format
for knots, where the number of knots required for a curve is M+2N+1
rather than M+2N1 as used in Maya. Both knot representations are
equivalent mathematically. To convert from one of these external
representations into the Maya representation, simply omit the first
and last knots from the external representation when creating the
Maya representation. To convert from the Maya representation into
the external representation, add two new knots at the beginning and
end of the Maya knot sequence. The value of these new knots depends
on the existing knot sequence. For a knot sequence with multiple
end knots, simply duplicate the existing first and last knots once
more, for example:
Maya representation: {0,0,0,...,N,N,N}
External representation: {0,0,0,0,...,N,N,N,N}
For a knot sequence with uniform end knots, create the new knots
offset at an interval equal to the existing first and last knot
intervals, for example:
Maya representation: {0,1,2,...,N,N+1,N+2}
External representation: {1,0,1,2,...,N,N+1,N+2,N+3}

arcLenNode.cpp, closestTangentUAndDistance.cpp,
fullLoftNode.cpp,
helix2Cmd.cpp, helixCmd.cpp,
helixTool.cpp, instanceCallbackCmd.cpp,
motionTraceCmd.cpp,
multiCurveNode.cpp,
particlePathsCmd.cpp,
and simpleLoftNode.cpp.

Public Types

enum 
Form
{
kInvalid = 0,
kOpen,
kClosed,
kPeriodic,
kLast
} 

Forms that a curve may take. More...

Public Member Functions

virtual MFn::Type 
type
() const 

Function set type.

virtual 
~MFnNurbsCurve
() 

Destructor.


MFnNurbsCurve
() 

Default constructor.


MFnNurbsCurve
(MObject &object,
MStatus
*ReturnStatus=NULL) 

Constructor.


MFnNurbsCurve
(const MDagPath
&object, MStatus
*ret=NULL) 

Constructor.

MObject 
create
(const MPointArray &controlVertices,
const MDoubleArray &knotSequences,
unsigned int degree, Form
agForm, bool create2D, bool createRational, MObject &parentOrOwner=MObject::kNullObj,
MStatus
*ReturnStatus=NULL) 
MObject 
createWithEditPoints
(const MPointArray &editPoints,
unsigned int degree, Form
agForm, bool create2D, bool createRational, bool uniformParam,
MObject
&parentOrOwner=MObject::kNullObj,
MStatus
*ReturnStatus=NULL) 
MObject 
create
(const MObjectArray &sources,
MObject
&parentOrOwner=MObject::kNullObj,
MStatus
*ReturnStatus=NULL) 
MObject 
copy
(const MObject
&source, MObject
&parentOrOwner=MObject::kNullObj,
MStatus
*ReturnStatus=NULL) 
MStatus 
reverse
(bool constructionHistory=false) 
MStatus 
makeMultipleEndKnots
() 
MObject 
cv
(unsigned int index, MStatus *ReturnStatus=NULL) const 
MStatus 
getCV
(unsigned int index, MPoint &pt, MSpace::Space
space=MSpace::kObject) const 
MStatus 
setCV
(unsigned int index, const MPoint &pt, MSpace::Space
space=MSpace::kObject) 
Form 
form
(MStatus
*ReturnStatus=NULL) const 
int 
degree
(MStatus
*ReturnStatus=NULL) const 
int 
numCVs
(MStatus
*ReturnStatus=NULL) const 
int 
numSpans
(MStatus
*ReturnStatus=NULL) const 
int 
numKnots
(MStatus
*ReturnStatus=NULL) const 
MStatus 
getKnotDomain
(double &start, double &end) const 
MStatus 
getKnots
(MDoubleArray
&array) const 
MStatus 
setKnots
(const MDoubleArray &array, unsigned
int startIndex, unsigned int endIndex) 
MStatus 
setKnot
(unsigned int index, double param) 
MObject 
cvs
(unsigned int startIndex, unsigned int endIndex, MStatus *ReturnStatus=NULL)
const 
MStatus 
getCVs
(MPointArray
&array, MSpace::Space
space=MSpace::kObject) const 
MStatus 
setCVs
(const MPointArray &array, MSpace::Space
space=MSpace::kObject) 
double 
knot
(unsigned int index, MStatus *ReturnStatus=NULL) const 
MStatus 
removeKnot
(double atThisParam, bool removeAll=false) 
bool 
isPointOnCurve
(const MPoint
&point, double tolerance=1.0e3, MSpace::Space
space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MStatus 
getPointAtParam
(double param, MPoint
&point, MSpace::Space
space=MSpace::kObject) const 
MStatus 
getParamAtPoint
(const MPoint
&atThisPoint, double ¶m, MSpace::Space
space=MSpace::kObject) const 
MStatus 
getParamAtPoint
(const MPoint
&atThisPoint, double ¶m, double tolerance, MSpace::Space
space=MSpace::kObject) const 
bool 
isParamOnCurve
(double param, MStatus
*ReturnStatus=NULL) const 
MVector 
normal
(double param, MSpace::Space
space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MVector 
tangent
(double param, MSpace::Space
space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MStatus 
getDerivativesAtParm
(double param, MPoint
&pos, MVector
&dU, MSpace::Space
space, MVector
*dUU=NULL) const 
bool 
isPlanar
(MVector
*planeNormal=NULL, MStatus *ReturnStatus=NULL) const 
MPoint 
closestPoint
(const MPoint
&toThisPoint, double *param=NULL, double tolerance=1.0e3,
MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL)
const 
MPoint 
closestPoint
(const MPoint
&toThisPoint, bool paramAsStart, double *param=NULL, double
tolerance=1.0e3, MSpace::Space space=MSpace::kObject, MStatus
*ReturnStatus=NULL) const 
double 
distanceToPoint
(const MPoint &pt,
MSpace::Space
space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
double 
area
(double tolerance=1.0e3, MStatus *ReturnStatus=NULL) const 
double 
length
(double tolerance=1.0e3, MStatus *ReturnStatus=NULL) const 
double 
findParamFromLength
(double partLength, MStatus *ReturnStatus=NULL) const 
bool 
hasHistoryOnCreate
(MStatus
*ReturnStatus=NULL) 
MStatus 
updateCurve
() 

MFnNurbsCurve
(const MObject
&object, MStatus
*ret=NULL) 

Constructor.

Protected Member Functions

virtual const char * 
className
() const 

Class name.

Member Enumeration Documentation
Forms that a curve may take.
 Enumerator:

kInvalid 

kOpen 
Ends are independent. 
kClosed 
Endpoints are coincident. 
kPeriodic 
Ends overlap such that there is no break in tangency. 
kLast 

Constructor & Destructor Documentation
MFnNurbsCurve::~MFnNurbsCurve 
( 

) 
[virtual] 
Destructor.
Class desctructor.
MFnNurbsCurve::MFnNurbsCurve 
( 
MObject & 
object, 


MStatus * 
ReturnStatus =
NULL 


) 



Constructor.
Class constructor that initializes the function set to the given
MObject.
 Parameters:

[in] 
object 
The MObject to
attach the function set to 
[out] 
ReturnStatus 
the return status 
 Status Codes:

MFnNurbsCurve::MFnNurbsCurve 
( 
const MDagPath & 
object, 


MStatus * 
ReturnStatus =
NULL 


) 



Constructor.
Class constructor that initializes the function set to the given
constant MDagPath object.
 Parameters:

[in] 
object 
The const MDagPath to attach the function set to 
[out] 
ReturnStatus 
The return status 
 Status Codes:

MFnNurbsCurve::MFnNurbsCurve 
( 
const MObject & 
object, 


MStatus * 
ReturnStatus =
NULL 


) 



Constructor.
Class constructor that initializes the function set to the given
MObject.
 Parameters:

[in] 
object 
The MObject to
attach the function set to 
[out] 
ReturnStatus 
the return status 
 Status Codes:

Member Function Documentation
MFn::Type
MFnNurbsCurve::type 
( 

) 
const [virtual] 
const char * MFnNurbsCurve::className 
( 

) 
const [protected, virtual] 
Class name.
Return the class name : "MFnNurbsCurve"
Reimplemented from MFnDagNode.
This method creates a nurbs curve from the given control
vertices and knot vector and sets this function set to operate on
the new curve.
The parentOrOwner argument is used to specify the owner of the
new curve.
If the parentOrOwner is kNurbsCurveData then the created curve
will be of type kNurbsCurveGeom and will be returned. The
parentOrOwner will become the owner of the new curve.
If parentOrOwner is NULL then a new transform will be created
and returned which will be the parent for the curve. The new
transform will be added to the DAG.
If parentOrOwner is a DAG node then the new curve will be
returned and the parentOrOwner will become its parent.
The knot vector is valid if it is nondecreasing and of length
spans + 2 * degree  1. The cvs are assumed to be in rational form
(as opposed to homogeneous)
If the form specified is kClosed and the endpoints are
not close then a new span will be created inorder to close the
curve.
 Parameters:

[in] 
controlVertices 
an array of control vertices 
[in] 
knots 
an array of knots 
[in] 
degree 
the degree to create the curve with 
[in] 
form 
either kOpen, kClosed, kPeriodic 
[in] 
create2D 
indictates whether to create 2D or 3D curve 
[in] 
createRational 
true means curve being created will be rational 
[in] 
parentOrOwner 
the DAG parent or kNurbsCurveData the new curve will belong
to 
[out] 
ReturnStatus 
Status code 
 Returns:

 If parentOrOwner is NULL then the transform for this curve is
returned
 If parentOrOwner is a DAG object then the curve shape is
returned
 The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData
 Status Codes:

This method creates a nurbs curve from the given edit points and
sets this function set to operate on the new curve.
The parentOrOwner argument is used to specify the owner of the
new curve.
If the parentOrOwner is kNurbsCurveData then the created curve
will be of type kNurbsCurveGeom and will be returned. The
parentOrOwner will become the owner of the new curve.
If parentOrOwner is NULL then a new transform will be created
and returned which will be the parent for the curve. The new
transform will be added to the DAG.
If parentOrOwner is a DAG node then the new curve will be
returned and the parentOrOwner will become its parent.
If the form specified is kClosed and the endpoints are
not close then a new span will be created inorder to close the
curve.
 Parameters:

[in] 
editPoints 
an array of edit points 
[in] 
degree 
the degree to create the curve with 
[in] 
form 
either kOpen, kClosed, kPeriodic 
[in] 
create2D 
indictates whether to create 2D or 3D curve 
[in] 
createRational 
true means curve being created will be rational 
[in] 
uniformParam 
true means curve being created will have uniform
parameterization, false means chord length 
[in] 
parentOrOwner 
the DAG parent or kNurbsCurveData the new curve will belong
to 
[out] 
ReturnStatus 
Status code 
 Returns:

 If parentOrOwner is NULL then the transform for this curve is
returned
 If parentOrOwner is a DAG object then the curve shape is
returned
 The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData
 Status Codes:

This method creates a single curve that represents all the
curves in the MObjectArray. The method assumes
the curves in the sources are good for building a single curve:
 they are in the same direction,
 they are not intersective to themselvies or eath other,
 there are no gaps between the points at the ends.
 the order of the curves in the array are followed, i.e. the
result curve starts from sources[0].
It is good enough to be C0 continouns (tangent breaks are okay).
 Parameters:

[in] 
sources 
Input array of souce curves. 
[in] 
parentOrOwner 
the DAG parent or kNurbsCurveData the new curve will belong
to 
[out] 
ReturnStatus 
Status code 
 Returns:

 If parentOrOwner is NULL then the transform for this curve is
returned
 If parentOrOwner is a DAG object then the curve shape is
returned
 The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData
 Status Codes:

This method creates a copy of a nurbs curve.
The parentOrOwner argument is used to specify the owner of the
new curve.
If the parentOrOwner is kNurbsCurveData then the created curve
will be of type kNurbsCurveGeom and will be returned. The
parentOrOwner will become the owner of the new curve.
If parentOrOwner is NULL then a new transform will be created
and returned which will be the parent for the curve. The new
transform will be added to the DAG.
If parentOrOwner is a DAG node then the new curve will be
returned and the parentOrOwner will become its parent.
 Parameters:

[in] 
source 
the curve to be copied 
[in] 
parentOrOwner 
the DAG parent or kNurbsCurveData the new curve will belong
to 
[out] 
ReturnStatus 
Status code 
 Returns:

 If parentOrOwner is NULL then the transform for this curve is
returned
 If parentOrOwner is a DAG object then the curve shape is
returned
 The curve geometry is returned if parentOrOwner is of type
kNurbsCurveData
 Status Codes:

MStatus MFnNurbsCurve::reverse 
( 
bool 
constructionHistory =
false 
) 

This method reverse the curve direction.
 Returns:
 Status code
 Status Codes:

MStatus
MFnNurbsCurve::makeMultipleEndKnots 
( 

) 

This method gives end knots full multiplicity. This ensures the
end points of the curve interpolate the first and last CVs. It can
also be used to convert a periodic curve to a closed curve.
 Returns:
 Status code
 Status Codes:

MObject MFnNurbsCurve::cv 
( 
unsigned int 
index, 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Get a direct access handle to the CV at the specified index. The
CV iterator class MItCurveCV must be
used to access the returned CV.
 Parameters:

[out] 
index 
Index of the CV 
[out] 
ReturnStatus 
Status code 
 Returns:
 A handle to the CVs requested
 Status Codes:

Get the CV at the given index.
 Parameters:

[in] 
index 
The index of the CV that will be retrieved 
[out] 
pt 
Storage for the CV 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:
 Status code
 Status Codes:

Set the CV at the given index to the given point. The method
updateCurve should be called to trigger changes in the
curve.
 Parameters:

[in] 
index 
The index of the CV that will be changed 
[in] 
pt 
The new value that the CV will take 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:
 Status code
 Status Codes:

This method returns the form of the curve. The curve can be
open, closed, or periodic.
 Parameters:

[out] 
ReturnStatus 
Status code 
 Returns:

 Status Codes:

int MFnNurbsCurve::degree 
( 
MStatus * 
ReturnStatus =
NULL 
) 
const 
Return the degree of this curve. If the degree cannot be
determined then 0 is returned.
 Parameters:

[out] 
ReturnStatus 
Status code 
 Returns:
 The degree of this curve.
 Status Codes:

int MFnNurbsCurve::numCVs 
( 
MStatus * 
ReturnStatus =
NULL 
) 
const 
Return the number of CVs for this curve. If the number of CVs
cannot be determined then 0 is returned.
 Parameters:

[out] 
ReturnStatus 
Status code 
 Returns:
 The number of CVs for this curve.
 Status Codes:

int MFnNurbsCurve::numSpans 
( 
MStatus * 
ReturnStatus =
NULL 
) 
const 
Return the number of spans for this curve. If the number of
spans cannot be determined then 0 is returned.
 Parameters:

[out] 
ReturnStatus 
Status code 
 Returns:
 The number of spans for this curve.
 Status Codes:

int MFnNurbsCurve::numKnots 
( 
MStatus * 
ReturnStatus =
NULL 
) 
const 
Return the number of knots for this curve. If the number of
knots cannot be determined then 0 is returned.
 Parameters:

[out] 
ReturnStatus 
Status code 
 Returns:
 The number of knots for this curve.
 Status Codes:

MStatus MFnNurbsCurve::getKnotDomain 
( 
double & 
start, 


double & 
end 


) 


const 
Return the range corresponding to the maximum and minimum
parameter values for this curve.
 Parameters:

[out] 
start 
storage for the max parameter value 
[out] 
end 
storage for the min parameter value 
 Returns:
 Status code
 Status Codes:

This method retrieves a copy of the knot array for this
curve.
 Parameters:

[out] 
array 
storage where the parameter values of the knots for this curve
will be copied 
 Returns:
 Status code
 Status Codes:

MStatus MFnNurbsCurve::setKnots 
( 
const MDoubleArray & 
array, 


unsigned int 
startIndex, 


unsigned int 
endIndex 


) 



This method is used to set the values of a contiguous group of
knots of the curve. The range of knots to set is specified using
the start and end index. The knots of index startIndex to endIndex
inclusive will be set using the value in the double array.
Knot indices range from 0 to numKnots()
 1
 Parameters:

[in] 
array 
a double array of knot points 
[in] 
startIndex 
the starting index of the knots to be altered. 
[in] 
endIndex 
the ending index of the knots to be altered. 
 Returns:
 Status code
 Status Codes:

 MS::kSuccess The
method was successful
 MS::kInvalidParameter
Invalid start or end indices, or the length of the array is not
sufficient to fill the range given, or the knots are in decreasing
order.
 MS::kFailure An object error
has occurred
MStatus MFnNurbsCurve::setKnot 
( 
unsigned int 
index, 


double 
param 


) 



Set the given knot's parameter value. Knot indices range from
0 to numKnots()
 1.
If a knot value is set that breaks the nondecreasing
requirement for the knot array, the knot value will be changed and
a kInvalidParameter error will be returned.
 Parameters:

[in] 
index 
Index of the knot to be set 
[in] 
param 
The parameter value that the knot will take 
 Returns:
 Status code
 Status Codes:

MObject MFnNurbsCurve::cvs 
( 
unsigned int 
startIndex, 


unsigned int 
endIndex, 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method is used to directly access a contiguous group of
CVs. The returned group can be accessed via the MItCurveCV class. Any
modifications to these CVs will affect this curve.
updateCurve should be called to cause the curve to redraw
itself.
 Parameters:

[in] 
startIndex 
the start index for the CVs to return 
[in] 
endIndex 
the end index for the CVs to return 
[out] 
ReturnStatus 
Status code 
 Returns:
 An MObject
providing directaccess to the specified CVs
 Status Codes:

Get the positions of the CVs of this curve. The returned group
can be accessed via the MPointArray class. Any
modifications to these CVs will not affect this curve.
setCVs should be called to modify the original curve.
updateCurve should be called to cause the curve to redraw
itself.
 Parameters:

[out] 
array 
The array of point values for the CVs 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:
 Status code
 Status Codes:

Set the CVs for this curve to the given points.
 Parameters:

[in] 
array 
The array of point values for the CVs 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:
 Status code
 Status Codes:

double MFnNurbsCurve::knot 
( 
unsigned int 
index, 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Get the parameter value of the specified knot for this curve.
Knot indices range from 0 to numKnots()
 1
 Parameters:

[in] 
index 
The knot index 
[out] 
ReturnStatus 
Status code 
 Returns:
 The parameter value for the knot at index.
 Status Codes:

MStatus MFnNurbsCurve::removeKnot 
( 
double 
atThisParam, 


bool 
removeAll = false 


) 



Remove knot(s) from this curve. If removeAll is
true then all of the knots except for the knot at the given
parameter value will be removed. If removeAll is
false then only the knot at the given parameter value will
be removed.
 Parameters:

[in] 
atThisParam 
Status code 
[in] 
removeAll 
Determines whether we remove all knots, or all but one 
 Returns:
 Status code
 Status Codes:

bool MFnNurbsCurve::isPointOnCurve 
( 
const MPoint & 
point, 


double 
tolerance =
1.0e3 , 


MSpace::Space 
space =
MSpace::kObject , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Determines whether the given point is on this curve.
 Parameters:

[in] 
point 
The point to test 
[in] 
tolerance 
The amount of error (epsilon value) in the calculation 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 true if the given point is on the curve, false
otherwise.
 Status Codes:

Returns the point in space that is at the given parameter value
of the curve. If the parameter value does not give a valid point on
the curve, then MS::kInvalidParameter
is returned.
 Parameters:

[in] 
param 
The parameter value that we are examining 
[out] 
point 
Storage for the point being returned 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:
 Status code
 Status Codes:

MStatus
MFnNurbsCurve::getParamAtPoint 
( 
const MPoint & 
atThisPoint, 


double & 
param, 


MSpace::Space 
space =
MSpace::kObject 


) 


const 
This method retrieves the parameter value corresponding to the
given point on the curve.
 Parameters:

[in] 
atThisPoint 
Point to check 
[out] 
param 
storage for the parameter value 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:

MStatus
MFnNurbsCurve::getParamAtPoint 
( 
const MPoint & 
atThisPoint, 


double & 
param, 


double 
tolerance, 


MSpace::Space 
space =
MSpace::kObject 


) 


const 
This method retrieves the parameter value corresponding to the
given point on the curve.
 Parameters:

[in] 
atThisPoint 
Point to check 
[out] 
param 
storage for the parameter value 
[in] 
tolerance 
tolerance used for operation 
[in] 
space 
Specifies the coordinate system for this operation 
 Returns:

bool MFnNurbsCurve::isParamOnCurve 
( 
double 
param, 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Determines whether the specified parameter value is within the
bounds of the knot vector of this curve
 Parameters:

[in] 
param 
The parameter value to check 
[out] 
ReturnStatus 
Status code 
 Returns:

 true The parameter is on this curve.
 false Parameter is NOT on this curve.
 Status Codes:

This method returns the normal at the given parameter value on
the curve. For degree 1 curves the normal is the vector at right
angles to the curve that lies in the average plane of the curve.
For higher degrees the normal is defined by the local curvature at
param.
 Parameters:

[in] 
param 
The parameter of the point on the curve from which to get the
normal 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 The normal vector for the given parameter
 Status Codes:

This method returns the tangent at the given parameter value on
the curve. The resulting tangent vector is normalized.
 Parameters:

[in] 
param 
The parameter of the point on the curve from which to get the
tangent 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 The tangent vector for the given parameter
 Status Codes:

Evaluate the surface at the given parameter returning the
position, first derivative and optionally the seecond derivative.
Derivatives are not normalized.
 Parameters:

[in] 
param 
U parameter value to evaluate 
[out] 
pos 
Storage for the XYZ position of the curve 
[out] 
dU 
Storage for the first order partial derivative with respect to
u 
[in] 
space 
Coordinate space for the returned vectors 
[out] 
dUU 
Pointer to storage for the second order partial derivative with
respect to u 
 Returns:
 Status Code
 Status Codes:

bool MFnNurbsCurve::isPlanar 
( 
MVector * 
planeNormal =
NULL , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method determines if this curve is a planar curve. If
planeNormal is nonNULL then the normal to the plane containing
this curve is returned in this location.
 Parameters:

[in] 
planeNormal 
Normal to the plane containing this curve 
[out] 
ReturnStatus 
Status code 
 Returns:
 Status code
 Status Codes:

MPoint MFnNurbsCurve::closestPoint 
( 
const MPoint & 
toThisPoint, 


double * 
param = NULL , 


double 
tolerance =
1.0e3 , 


MSpace::Space 
space =
MSpace::kObject , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method determines the closest point on the curve to the
given point.
 Parameters:

[in] 
toThisPoint 
The point to test 
[in] 
param 
pointer to a double. If nonnull, on successful returns this
will contain the parameter value of the returned point. 
[in] 
tolerance 
The amount of error (epsilon value) in the calculation 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 The point on the curve closest to the given point.
 Status Codes:

MPoint MFnNurbsCurve::closestPoint 
( 
const MPoint & 
toThisPoint, 


bool 
paramAsStart, 


double * 
param = NULL , 


double 
tolerance =
1.0e3 , 


MSpace::Space 
space =
MSpace::kObject , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method determines the closest point on the curve to the
given point. Performance can be greatly increased by supplying a
starting parameter value that is reasonably close to the final
point.
 Parameters:

[in] 
toThisPoint 
The point to test 
[in] 
paramAsStart 
If true use the value pointed to by param as a starting point
for the search. 
[in] 
param 
pointer to a double. If nonnull, on successful returns this
will contain the parameter value of the returned point. 
[in] 
tolerance 
The amount of error (epsilon value) in the calculation 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 The point on the curve closest to the given point.
 Status Codes:

double MFnNurbsCurve::distanceToPoint 
( 
const MPoint & 
pt, 


MSpace::Space 
space =
MSpace::kObject , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method determines the distance from the given point to
closest point on the curve.
 Parameters:

[in] 
pt 
The point to calculate the distance to 
[in] 
space 
Specifies the coordinate system for this operation 
[out] 
ReturnStatus 
Status code 
 Returns:
 Status code
 Status Codes:

double MFnNurbsCurve::area 
( 
double 
tolerance =
1.0e3 , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
This method returns the area bounded by this curve. The curve
must be closed and planar.
A value of 0.0 will be returned if area cannot be
determined.
 Parameters:

[in] 
tolerance 
The amount of error (epsilon value) in the calculation 
[out] 
ReturnStatus 
Status code 
 Returns:
 Status code
 Status Codes:

double MFnNurbsCurve::length 
( 
double 
tolerance =
1.0e3 , 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Return the arc length of this curve or 0.0 if it cannot be
computed.
 Parameters:

[in] 
tolerance 
The amount of error (epsilon value) in the calculation 
[out] 
ReturnStatus 
Status code 
 Returns:
 Status code
 Status Codes:

double MFnNurbsCurve::findParamFromLength 
( 
double 
partLength, 


MStatus * 
ReturnStatus =
NULL 


) 


const 
Given the length along the curve, find the parameter value that
corresponds to it. If the parameter value cannot be found for the
given length then ReturnStatus is set to kInvalidParameter and the
parameter for the end point of the curve is returned.
 Parameters:

[in] 
partLength 
Length along the curve to find parameter value at 
[out] 
ReturnStatus 
Status code 
 Returns:
 The parameter value corrisponding to the given length. If a
parameter cannot be found for the given length then the parameter
for the end point of the curve is returned.
 Status Codes:

bool MFnNurbsCurve::hasHistoryOnCreate 
( 
MStatus * 
ReturnStatus =
NULL 
) 

This method determines if the shape was created with
history.
If the object that this function set is attached to is not a
shape then this method will fail.
 Parameters:

 Returns:

 true shape has history
 false shape does not have history
 Status Codes:

MStatus MFnNurbsCurve::updateCurve 
( 

) 

This method signals that this curve has changed and needs to be
recalculated.
This method is useful when a large number of CVs for the curve
are being modified. Instead of updating the curve every time a CV
is changed it is more efficient to call this method once after
updating all of the CVs.
 Returns:
 Status code
 Status Codes:
