NLib Introduction & Installation
NLib Introduction
NLib has its origins in code developed by Wayne Tiller and Les Piegel, based on their reference work “The Nurbs Book”. NLib has an established reputation, and a long maintenance history so that it is a thoroughly tested product. The exclusive rights for maintenance, distribution and development were acquired by Solid Modeling Solutions.
SMS has updated and improved NLib over the years, without losing the logic or the rigor of the original NLib. Consequently NLib is much more user friendly. NLib is a NURBS curve and surface library delivered as “C” functions that can be linked and referenced by your application. NLib does not have topological structures and does not perform intersections. NLib remains the foundation upon which SMLib and TSNLib are built.
NLib Installation
NLib is distributed as a compiled library on Windows, Windows64, Linux, or Mac. If your application has special building requirements, source code distributions and also possible in some cases. For the purposes of this manual we will use Windows instructions as an example. After installing NLib, please refer to our documentation available for download from our FTP site. In addition, we provide examples and release notes on our web site at smlib.com. If any questions remain, please contact support@smlib.com.
Upon receiving the download instructions, unzip the distributed zip file with the given password into a folder called SMLib.
Directory Structure
 SMLib
 NLib
 inc (include files)
 src (source code distribution only)
 Project files (.sln, .vcxproj ) (source code distribution only)
 Winlibs/Winlibs64
 Release (resulting dlls and license file)
 NLib
General Usage
Representation of Various Entities
Index is used for array subscripts.
 Index starts at zero (0).
 An array index of ‘4’ means that there are ‘5’ items in the array.
 This is standard ‘C’ practice, but is also the cause of many errors by users.
Point: is always a 3D entity (x,y,z)
Control Points are always weighted. The following cases are distinguished
 2D nonrational (x, y, NL_NOZ, NL_NOW)
 2D rational (wx, wy, NL_NOZ, w)
 3D nonrational (x, y, z, NL_NOW)
 3D rational (wx, wy, wz, w)
where NL_NOZ and NL_NOW are predefined identifiers telling NLib that no z and/or no w component(s) are to be considered.
Knot Vector is always “clamped”, that is:
 U = {a(0),…,a(p), u(p+1),…,u(mp1),b(mp),…,b(m)}
where p is the degree of the curve. There are routines to clamp or unclamp knot vectors if the need so arises.
Curve is always in a Bezierlike form, i.e. with end point interpolation. Curves are mostly created by the system. However, they can be input from a file. The form of the file is explained by the following degreethree curve example:
5 <— Highest index of control points (n)
3 <— Degree (p)
1 <— Rational (1) or nonrational (0) flag
2 <— Dimension (2 or 3)
0.100000 0.300000 1.000000 <— Pw(0)
0.700000 0.600000 2.000000 <— Pw(1)
0.350000 0.600000 1.000000 <— Pw(2)
0.650000 0.600000 1.000000 <— Pw(3)
0.975000 0.450000 1.500000 <— Pw(4)
0.900000 0.300000 1.000000 <— Pw(5)
0.000000 <— u(0)
0.000000 <— u(1)
0.000000 <— u(2)
0.000000 <— u(3)
0.300000 <— u(4)
0.700000 <— u(5)
1.000000 <— u(6)
1.000000 <— u(7)
1.000000 <— u(8)
1.000000 <— u(9)
The relationship m=n+p+1 must always hold, where m is the highest index of knots (in the above example have 9 = 5 + 3 + 1).
Surface is always in a Bezierlike form, i.e. with corner point interpolation. As in the case of curves, surfaces are mostly created by the system. However, they too can be input from a file. The form of the file is explained by the following degree 3 x 2 surface example:
4 3 <— Highest indexes in u and vdirections (n, m)
3 2 <— Degrees in u and vdirections (p, q)
1 <— Rational (1) or nonrational (0) flag
8.000000 8.000000 4.000000 1.000000 <— Pw(0,0)
4.000000 8.000000 0.000000 1.000000 <— Pw(0,1)
4.000000 8.000000 0.000000 1.000000 <— Pw(0,2)
8.000000 8.000000 6.000000 1.000000 <— Pw(0,3)
8.000000 3.000000 0.000000 1.000000 <— Pw(1,0)
8.000000 6.000000 0.000000 2.000000 <— Pw(1,1)
4.000000 3.000000 0.000000 1.000000 <— Pw(1,2)
8.000000 3.000000 2.000000 1.000000 <— Pw(1,3)
8.000000 0.000000 0.000000 1.000000 <— Pw(2,0)
6.000000 0.000000 3.000000 1.500000 <— Pw(2,1)
4.000000 0.000000 2.000000 1.000000 <— Pw(2,2)
8.000000 0.000000 4.000000 1.000000 <— Pw(2,3)
8.000000 3.000000 2.000000 1.000000 <— Pw(3,0)
4.000000 3.000000 0.000000 1.000000 <— Pw(3,1)
8.000000 6.000000 0.000000 2.000000 <— Pw(3,2)
8.000000 3.000000 0.000000 1.000000 <— Pw(3,3)
8.000000 8.000000 2.000000 1.000000 <— Pw(4,0)
4.000000 8.000000 0.000000 1.000000 <— Pw(4,1)
4.000000 8.000000 2.000000 1.000000 <— Pw(4,2)
8.000000 8.000000 6.000000 1.000000 <— Pw(4,3)
0.000000 <— u(0)
0.000000 <— u(1)
0.000000 <— u(2)
0.000000 <— u(3)
0.500000 <— u(4)
1.000000 <— u(5)
1.000000 <— u(6)
1.000000 <— u(7)
1.000000 <— u(8)
0.000000 <— v(0)
0.000000 <— v(1)
0.000000 <— v(2)
0.500000 <— v(3)
1.000000 <— v(4)
1.000000 <— v(5)
1.000000 <— v(6)
The relationships r=n+p+1 and s=m+q+1 must always hold, where r and s are the highest indexes of knots in the u and vdirections, respectively (in the above example we have 8=4+3+1 and 6=3+2+1).
Program Design
We explain the major ingredients of a typical NLib application program using a simple example below. The program reads in a NURBS curve, elevates its degree by one in three different ways, and writes the last result out to a file. The names of the input and output files are command line arguments.
#include “nurbs.h”
#include “NL_Globals.h”
main( int argc, char *argv[] )
{
NL_FLAG error;
NL_INDEX n, m, s;
NL_DEGREE p;
NL_CURVE curP, curQ, curR;
NL_KNOTVECTOR *knt
NL_STACKS S;
/* Start NURBS */
N_InitNurbs(&S);
/* Input curve */
N_CrvInitArrays(&curP);
error = N_CrvReadFromFile(&curP,argv[1],NL_YES,&S);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/***************************/
/* Elevate degree call 1 */
/***************************/
N_CrvInitArrays(&curQ);
error = N_CrvElevateDegree(&curP,1,&curQ,&S,&S);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/***************************/
/* Elevate degree call 2 */
/***************************/
/* Get knot vector, highest indexes and degree */
N_CrvGetKnotVector(&curP,&knt);
N_CrvGetArraySizes(&curP,&n,&m);
N_CrvGetDegree(&curP,&p);
/* Compute highest indexes of degree elevated curve */
N_BasisGetSpanCount(knt,p,&s);
n = n+s;
p = p+1;
m = m+s+1;
/* Allocate memory for new curve */
error = N_CrvAllocArrays(&curR,n,p,m,&S);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/* Now degree elevate */
error = N_CrvElevateDegree(&curP,1,&curR,&S,&S);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/***************************/
/* Elevate degree call 3 */
/***************************/
error = N_CrvElevateDegree(&curP,1,&curP,&S,&S);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/* Output last curve */
error = N_CrvWriteToFile(&curP,argv[2]);
if ( error EQ NL_YES ) NL_PRINT_ERROR;
/* End NURBS */
N_EndNurbs(&S);
}
There are several important points:
 Each routine that calls NLib functions must include the file nurbs.h.
This header file contains all function prototypes, and includes the headers NL_Nurbsdef.h, NL_Geom.h and NL_DataStruct.h.  The top level application routine must also include NL_Globals.h.
This file contains global parameters and constants, including important tolerances (see below).  NLib functions work on predefined data types, e.g. NL_FLAG, NL_INDEX, NL_DEGREE, NL_KNOTVECTOR, NL_CURVE and NL_STACKS. These data types act like any other standard data type such as int or double. That is, when one writes NL_CURVE curP, the system allocates memory for a curve object and tags this memory with the name curP.
 NLib routines start and end with two special functions N_InitNurbs and N_EndNurbs. The first one initializes memory stacks to NULL, and the second one traverses these stacks, deallocates all dynamically allocated memory, and kills the stacks.
 The calling mechanism of each NLib function is explained in detail in the documentation and its header.
As an example, here is the explanation of how to call N_CrvElevateDegree (as extracted from its header):
A typical calling example is:
NL_CURVE curP, curQ;
NL_INDEX t;
NL_STACKS SP, SQ;
…
(define curP, get t);
…
N_CrvInitArrays(&curQ);
N_CrvElevateDegree(&curP,t,&curQ,&SP,&SQ);
N_CrvElevateDegree(&curP,t,&curP,&SP,&SP);
…
The header explains
 how to declare variables;
 how to pass them to the routine (by value or by reference).
 how to manage memory (which stack is used for input and output
We shall now walk through the sample program
Various parameters and objects are defined. Note that three curve objects are defined, however, only a knot vector pointer is needed.
The NURBS program is initialized by N_InitNurbs
curP is initialized to NULL telling the N_CrvReadFromFile routine to allocate memory, copy the curve data into curP, and place memory pointers on to the stacks.
Call 1 curQ is initialized to NULL telling the degree elevation routine to:
 find out how much memory is needed to store the output curve, and to allocate this memory;
 degree elevate curP and to place the result in curQ; and
 place memory pointers on to the stacks S.
This is the most convenient way of calling NLib routines that return a new curve or surface.
Call 2 the new degree and the highest indexes of control points and knots are computed first. Then memory is allocated by the N_CrvAllocArrays routine. When calling the degree elevation routine with curR, the routine does the following:
 Sees that curR is not NULL and checks if sufficient memory is passed in using curR’s memory stacks (the same as curP’s in this example). If yes, it continues. If not, it sets t error flag, and returns control to the calling routine.
 Degree elevates curP and places the output curve in curR,
Call 3 when calling the degree elevation routine with the same curve pointer, the routine sees that degree elevation is to be done inplace, and does the following:
 kills curP.
 allocates new memory for curP; and
 places the degree elevated curve in the new curP.
curP is saved on a file by the N_CrvWriteToFile routine.
The program is ended by N_EndNurbs that deallocates all dynamically allocated memory.
The three calls show that there is a lot of flexibility in how to create new geometric entities. For simple operations calls 1 or 3 are recommended. If degree elevation is to be done repeatedly, call 2 is recommended, i.e. allocate enough memory, only once, for all types of degree elevations, and pass this memory to the routine.
Array Arguments
In general, it is safe to say that we never have arrays of points ( ie point data laid out contiguously). What we have is an array of pointers to points…..so the points can be, for example, along either the row or column of an array. We gather the address of each successive point we are interested in and add the address into an array of pointers……
NL_POINT **Pnt
We do not have to rearrange the input if we switch from row to column. …just select the addresses differently.
Similarly with other objects, such as the curves in N_CrvDecomposeBez.
The argument ” ***CurQ ” means ” the address of an array of pointers to Curves”.
You have:
NL_CURVE *cur as a pointer to a curve
NL_CURVE **curQ as an array of curve pointers
( do not confuse this with a two dimensional array )
You call N_CrvDecomposeBez with (…….&curQ…..)
But N_CrvDecomposeBez receives it as (………NL_CURVE ***curQ……..) and internally builds a set list of curve pointers to newly allocated curves
NL_CURVE **curA; ….
build curA[i]; ……
*curQ= curA;
” take the address of the new curve list curA and put it into the location where curQ is pointing to (if there was no *curQ…but only curQ it would just locally change the address of curQ and not update the one that was sent).
After returning, the calling routine now has the address of the list of curve pointers ( NL_CURVE **CurQ).
Dynamic Memory Allocation
Memory in NLib routines is allocated by special purpose routines that can be found in the space subdirectory and have the prefix S_. These routines require a memory stack to save pointers of allocated memory. The user can work with an entire hierarchy of stacks, each one of them is local to one or global to many routines. These stacks can control when and where memory is needed. Each NURBS routine has its local stack which is killed, along with all memory residing on it, upon leaving the routine. In addition to this local stack, the routine can take, as arguments, a number of global stacks that can hold memory needed when the routine in no longer active. As an example, let us look at the structure of the degree elevation routine used above.
NL_FLAG N_CrvElevateDegree( NL_CURVE *curP, NL_INDEX t, NL_CURVE *curQ, NL_STACKS *SP, NL_STACKS *SQ )
{
NL_FLAG error = NL_NO;
…
NL_STACKS SL;
N_InitNurbs(&SL);
…
alfs = N_AllocReal1dArray(p,&SL);
if ( alfs EQ NULL ) NL_QUIT;
…
N_EndNurbs(&SL);
}
N_CrvElevateDegree is given two global stacks, SP and SQ; one for curP and one for curQ. In addition to this, it has its local stack SL. If the degree is elevated inplace, the new curve curP is placed on to SP. Otherwise, the new curve curQ is placed on to SQ. Any local memory, like alfs, is stored on the local stack SL, and is released upon leaving the routine.
Tolerances and Constants
NLib has two types of tolerances public and private. Public tolerances are declared and initialized in globals.h. Some examples follow:
 NL_MTOL models space tolerance, i.e. if two points are closer than NL_MTOL, they are considered the same. The current setting is1.0e7.
 NL_PTOL parameter space tolerance, i.e. if two parameters are closer than NL_PTOL, they are considered the same. The current setting is 1.0e12.
 NL_LTOL line tolerance, i.e. if the magnitude of the cross product of two lines’ unit direction vectors is less then NL_LTOL, the lines are considered parallel. The current setting is 1.0e12.
 NL_LUDT LUdecomposition tolerance. It will not allow the computation of LUdecomposed matrices (with or without pivoting) with huge numbers even if the divisions can be performed within the available range of the floating point processor. The current setting is 1.0e9.
Private tolerances are declared in individual routines. These tolerances are used to perform numerical computations within the scope of the individual routine. Even though they are NL_PRIVATE, they are never hard coded. They are defined on top of the routine, and adjusted in the body based on the length of the knot vector, the bounding box of the curve/surface, etc. Their initial settings are based on extensive experiments, and can be altered easily as the user sees fit.
There are a number of constants and predefined entities NLib relies on. All of them are defined in globals.h. A few examples follow:
 NL_WMIN and NL_WMAX minimum and maximum allowable weights. Current settings 1.0e2 and 10, respectively.
 NL_DMAX highest degree. Currently 28. Warning NL_DMAX cannot be modified without considering the definition of NL_INDEX and NL_INTEGER data types. The binomial coefficients are represented for efficiency reason as integers. The current definition of NL_INDEX and NL_INTEGER is long, which may have different maximum values on different systems. The ANSI standard requires long to be at least 2,147,483,647.
 NL_ITLIM iteration limit. Currently 50 (if iterations, such as Newton, do not converge within 50 steps, they probably never will).
Floating Point Operations
Floating point operations are performed in double precision. There are two types of error checks:
 Certain numbers are checked against predefined tolerances before any crucial operation, such as division, occurs. For example, if a number is to be divided by the distance between two points, then even if the division could be done, it is not done if the distance is less than the model space tolerance.
 When no specific tolerances are involved, operation checks are performed by the N_FloatOpIsBad routine. It’s calling mechanism is:
NL_REAL x, y;
…
if ( N_FloatOpIsBad(x,y,NL_ADDITION) ) NL_ERROR(NL_NUM_ERR);
if ( N_FloatOpIsBad(x,y,NL_SUBTRACTION) ) NL_ERROR(NL_NUM_ERR);
if ( N_FloatOpIsBad(x,y,MULTIPLICATION) ) NL_ERROR(NL_NUM_ERR);
if ( N_FloatOpIsBad(x,y,NL_DIVISION) ) NL_ERROR(NL_NUM_ERR);
…
Utilities
NLib has an extensive set of utilities to perform such tasks as making objects, input/output, converting objects, etc. One of the most important tasks performed by these functions is to hide the definition of various objects while providing access to their components. For example, to get the highest indexes of control points and knots of a curve object, one could write:
NL_INDEX n, m;
NL_CURVE *cur;
…
n = cur>pol>n;
m = cur>knt>m;
This requires knowledge of the NL_CURVE object. It also requires that the entire library be searched and modified if any change is made to its definition. In order to avoid this, NLib has an extensive set of utility routines to create objects from their individual components, and to break them into the many constituents. In the above example, one should write:
INDEX n, m;
NL_CURVE *cur;
…
N_CrvGetArraySizes(cur,&n,&m);
Each category of routines where objects are dealt with, e.g. NURBS, geometry and mathematics, has its own constructors and destructors. We strongly recommend that the application programmer use these routines. They have the following advantages:
 they are easier to understand;
 they are less prone to errors (the compiler catches the error if the are called incorrectly); and
 they allow changes to be made to the definitions of the objects.
Error Checking
NLib has a set of routines to check errors. They are in the error directory and have the prefix E_. We strongly recommend that these routines be used to make sure that curves and surfaces are correct before entering NURBS routines. The general philosophy is: Whenever an object is passed into a function, it is assumed that its definition is correct.
Usage Tips
Please refer to Examples/NLib for additional examples. Maybe provide FTP link.
The curve/surface evaluators use some fixed length arrays declared with dimensions NL_MAXDEG and NL_MAXDER. The current settings (in NL_Nurbsdef.h) for these evaluators are NL_MAXDEG=28 (maximum degree) and NL_MAXDER=5 (maximum derivative order). If you need to change these, you should do so before compiling NLib (you must also change NL_DMAX in NL_Globals.h to be the same as NL_MAXDEG).
“The NURBS Book” (SpringerVerlag, ISBN 3540615458), by Les Piegl and Wayne Tiller is excellent documentation for NLib. The first 12 chapters describe the underlying mathematics and algorithms, and Chapter 13 describes the system architecture (data structures, memory management, error handling, utilities, example programs, etc). We suggest you buy it.
A few tips for using NLib (see “The NURBS Book” for more detail)
 NLib requires NURBS curves/surfaces to have “clamped”, or “nonperiodic” knot vectors; i.e. end multiplicities equal to degree plus 1. Furthermore, internal knots may not have multiplicity greater than degree.
 There are functions to “clamp” curves/surfaces (specifically: N_Iges126Crv and N_Iges128Srf), and knot removal can be used where internal knots have multiplicities greater than degree.
 When importing curves/surfaces from other systems, it is advisable to use the functions N_Iges126Crv and N_Iges128Srf. These check if the NURBs definitions are compatible with NLib.
 A main program must include the files nurbs.h and NL_Globals.h (see example programs).
 Any program should start with a call to N_InitNurbs and end with a call to N_EndNurbs (see example programs).
 Generally, if an array is passed into a function, and if an integer> (say n) is also passed, then n will usually indicate the highest valid index of the array, not the number of elements in the array. Since array indices start at 0, n+1 is the actual number of array elements. This may seem unnatural for some users, but it corresponds to the notation and algorithm descriptions of “The NURBS Book“
 All angles are to be expressed in degrees, not radians.
References
The NLib products are based on solid research in NURBS technology. The publications below by Les Piegl and/or Wayne Tiller are examples of key papers providing a scientific basis for major NLib routines.
 Rational Bsplines for curve and surface representation, IEEE Computer Graphics and Applications, Vol. 3, No. 6, 1983, pp 6169.
 The NURBS Book, Second Revised Edition, SpringerVerlag, 1997.
 Curve and surface constructions using rational Bsplines, ComputerAided Design, Vol. 19, No. 9, 1987, 485498.
 A menagerie of rational Bspline circles, IEEE Computer Graphics and Applications, Vol. 9, September, 1989, pp 4856.
 Modifying the shape of rational Bsplines. Part 1: curves, ComputerAided Design, Vol. 21, No. 8, 1989, pp 509518.
 Modifying the shape of rational Bsplines. Part 2: surfaces, ComputerAided Design, Vol. 21, No. 9, 1989, pp 538546.
 Data reduction using cubic rational Bspline, IEEE Computer Graphics and Applications, May, pp 6068, 1992.
 Knotremoval algorithms for NURBS curves and surfaces, ComputerAided Design, Vol. 24, No. 8, 1992, pp 445453.
 Delaunay triangulation using a uniform grid, IEEE Computer Graphics and Applications, May, 1993, pp 3647.
 Software engineering approach to degree elevation of Bspline curves, ComputerAided Design, Vol. 26, No. 1, pp 1728 , 1994.
 Algorithm for degree reduction of Bspline curves, ComputerAided Design, Vol. 27, No. 2, pp 101110, 1995.
 Algorithm for approximate NURBS skinning, ComputerAided Design, Vol. 28, No. 9, pp 699706, 1996.
 Symbolic operators for NURBS, ComputerAided Design, Vol. 29, No. 5, pp 361368, 1997
 Algorithm for computing the product of two Bsplines, in A. Le Mehaute, C. Rabut and L. L. Schumaker (eds.) Curves and surfaces with applications in CAGD, Vanderbilt University Press, Nashville, TN, 1997, pp 337344.
 Geometrybased triangulation of trimmed NURBS surfaces, ComputerAided Design, Vol. 30, No 1, pp 1118, 1998.
 Computing the derivatives of NURBS with respect to a knot, Computer Aided Geometric Design, Vol. 15, No. 9, pp 925934, 1998.
 Approximation of offsets of NURBS curves and surfaces, ComputerAided Design, Vol. 31, No. 2, pp 147156, 1999.
 Crosssectional design with boundary constraints, Engineering with Computers, Vol. 15, 1999, pp 171180.
 Filling nsided regions with NURBS patches, The Visual Computer, Vol. 15, No. 2, pp 7789, 1999.
 Reducing control points in surface interpolation, IEEE Computer Graphics and Applications, Vol. 20, No. 5, 2000, pp 7074.
 Surface approximation to scanned data, The Visual Computer, Vol. 16, No. 7, 2000, pp 386395.
 Curve interpolation with arbitrary end derivatives, Engineering with computers, Vol. 16, 2000, pp 7379.
 Leastsquares NURBS curve approximation with arbitrary end derivatives, Engineering with computers, Vol. 16, 2000, pp 109116.
 Parametrization for surface fitting in reverse engineering, ComputerAided Design, Vol. 33, No. 8, 2001, pp 593603.
Functions
Creation of Common Curves
 Circles and circular arcs
N_CreateCircArc – Create a circle/circular arc
N_CreateQuadraticArc – Create a quadratic circle/circular arc
N_CreateQuarticArc – Create a quartic degree 4 circle/circular arc
N_CreateQuinticArc – Create a quintic circle/circular arc
N_CreateCubicSemiCircle – Create a cubic semicircle
N_CreateBoundedCircArc – Create Bezier cubic/quartic circular arc <=180 degrees
N_ApproxCircArcWithCrv – Approximate circle full or arc with nonrational curve
 Conics and conic arcs
N_CreateEllipticalArc – Create a ellipse/elliptical arc
N_CreateConicArc – Create a conic arc
 Straight line segments
N_CrvLineFromPtAndVector – Create a line as a curve
 Degenerate point curve
N_CrvDegenFromPt – Create point as a degenerate curve
Creation of Common Surfaces
 Bilinear surfaces and planes
N_CreateSrfCornerPts – Create bilinear surface
 Cones and cylinders full or patches
N_CreateCylCone – Create a cylinder/cone surface/patch
 Spheres and tori full or patches
N_CreateSphere – Create a sphere/spherical patch
N_CreateTorus – Create a torus/toroidal patch
N_FitSphereToPtsGlobal – Best fitting sphere to a set of points
N_FitSphereToPtsLocal – Best fitting sphere to a set of points
N_ApproxRevolvedSrfWithSrf – Nonrational approximation of surface of revolution
N_ApproxSphereWithSrf – Nonrational approximation of sphere
N_ApproxTorusWithSrf – Nonrational approximation of a torus
 General extruded surfaces TABCYL
N_CreateSrfExtrudeCrv – Create a generalized cylinder
 Ruled surfaces
N_CreateRuledSrf – Create a ruled surface between two arbitrary curves
N_CreateRuledSrfFromBoundaryCrvs – Ruled surface of two curves using symbolic operators
 Surfaces of revolution full or partial
N_CreateRevolvedSrf – Create surface of revolution
 Ellipsoids, elliptic paraboloids and hyperboloids of one sheet full or patches
N_CreateEllipsoid – Create a ellipsoid/patch
N_CreateHyperboloid – Create a hyperboloid of one sheet/hyperbolic patch
N_CreateParaboloid – Create a elliptic paraboloid/patch
Advanced Surface Construction Methods
 Swung surfaces
N_CreateSwungSrf – Create a swung surface
 Interpolative skinning, with or without a spine curve
N_CreateSkinSpine – General spine curvebased surface skinning
 Approximative skinning with error bound specified yields impressive data reduction
N_CreateSkinSrf – General surface skinning
N_CreateSkinSrfApproxTol – Approximative surface skinning with error bound
N_CreateSkinSrfApprox – Approximative surface skinning
N_CreateSkinSrfApproxParams – Approximate surface skinning with given knot vector
N_CreateSkinSrfParams – Surface skinning with given parameters and knot vector
 Interpolative and approximative skinning with rail curves and crossboundary continuity constraints
N_CreateSkinSrfBoundaryContinuity – Approximate skinning with boundary conditions and rails
 Translational swept surface
N_CreateTransSweepSrf – Create a translational sweep surface
 Swept surface, arbitrary trajectory curve, interpolative or approximative to within specified error bound
N_CreateSweepSrf – Create a swept surface
N_CreateSweepScale – Swept NURBS surface with boundary conditions
 Gordon surface through a compatible curve network
N_CreateGordonSrf – Gordon surface through compatible nonrational curves
 Bilinear Coons surface
N_CreateCoonsSrf – Bilinear Coons surface through four boundary curves
 Bicubic Coons surface
N_CreateCoonsBoundaryCrvs – Bicubic Coons surface through boundary and derivatives
N_CreateCoonsSrfTwist – Bicubic Coons surface through four boundary curves
 Nsided patch
N_FillNSidedHole – Nsided patch construction to boundary and derivatives
 Join surfaces
N_SrfJoin – Join two surfaces at a common boundary
Creation of Curves and Surfaces by Data Fitting
 Global curve interpolation to point data arbitrary degree
N_FitCrvInterp – Global curve interpolation with arbitrary degree
N_FitCrvInterpGivenParams – Curve interpolation with specified knot vector
 Global curve interpolation to point and end derivative data arbitrary degree
N_FitCrvDerivs – Curve interpolation with end derivatives specified
N_FitCrvTangents – Curve interpolation with end tangents specified
N_FitCrvDerivsMatrix – Curve interpolation with end derivatives and matrix
N_FitCrvDerivMatrix – Curve interpolation with end derivative and matrix
N_FitCrvFirstDeriv – Curve interpolation with first derivatives specified
N_FitCrvFirstDerivAndKnots – Curve interpolation with first derivatives & knot vector
N_FitCrvKnotsAndDerivs – Curve interpolation with end derivatives and knot vector
N_FitCrvLstSqEnds – Least Squares Curve Fit to Points, with End Conditions
N_FitCrvKnotsAndDeriv – Curve interpolation with end derivative and knot vector
 Cubic spline curve interpolation
N_FitCubicSplineInterp – Cubic spline interpolation
 Global least squares curve approximation to point data arbitrary degree
N_FitCrvWeightedLstSq – Weighted & constrained leastsquares curve approximation
N_FitCrvWeightedLstSqPeriodic – Weighted/constrained leastsquares periodic with knot vector
N_FitCrvWeightedLstSqKnots – Weighted/constrained leastsquares with knot vector
N_FitCrvApprox – Curve approximation with error bound specified
N_FitCrvApproxKnots – Curve approximation with specified knot vector
N_FitCrvCubicApprox – Data approximation with piecewise cubic segments
N_FitCrvApproxKnotsAndTangentsTol – Curve approximation with error bound & end constraints
N_ApproxConeWithSrf – Nonrational approximation of cylinder or cone
N_ApproxArcWithCrv – Nonrational approximation of a circle or arc
N_FitArcToPts – Best fitting circle or circular arc to a set of points
N_FitCrvCubicTangents – Local NL_C1 cubic curve interpolation with end tangents
N_FitHermite – Fit Hermite curve to end kth and (k+1)th derivatives
N_FitLineToPts – Best fitting line segment to a set of random points
N_FitPlaneToPts – Best fitting plane to random points
N_FitCrvLstSqEnds – Least squares curve fit to points
 Approximation of the offset of a curve
N_CrvOffset – Offset of NLib curve
N_CrvOffsetFuncVariableDir – Functional offset of NLib curve using point sampling
N_CrvOffsetApprox – Approximate offset of NLib curve with nonrational curve
N_CrvOffsetPtSampling – Offset of NLib curve using point sampling
 Offset of a connected set of curves with trimming and filleting
 Approximation of procedurally defined curves to within tolerance
N_ApproxProcCrvWithCrv – Approximate procedural curve with error bound specified
 Mapping of a uvdomain curve onto its surface
N_ApproxCrvOnSrfWithCrv – Approximate curve on surface from uvcurve
 Approximation of a curve with a nonrational curve of specified degree
N_ApproxNurbsWithNonRatCrv – Approximate curve with nonrational curve
N_ApproxG1CrvWithCrv – Approximate any NL_G1 NLib curve with nonrational curve
N_ApproxCrvWithPolyline – Piecewise linear polygonal approximation of a curve
 Global surface interpolation to point data arbitrary degrees
N_FitSrfToPts – Global surface interpolation with arbitrary degrees
N_FitSrfInterpTangents – Surface interpolation with tangent constraints
N_FitSrfToPtsKnots – Surface interpolation with given knot vectors
 Global least squares surface approximation to point data arbitrary degrees
N_FitSrfLstSqApprox – Global surface approximation with arbitrary degree
N_FitSrfApproxTol – Surface approximation with error bound specified
N_FitSrfApproxTangentsTol – Surface approximation with error bounds and tangents
N_FitSrfLstSqKnots – Surface approximation with given knot vectors
N_FitSrfLstSqBoundary – Least squares surface approximation to random points
N_FitSrfLstSqPeriodic – Periodic Least squares approximation to random points
N_fitRandomPN – Surface fit to random Points and Normals
N_FitPtsNormals – Surface fit to array of Points, Normals
 Approximation of the offset of a surface
N_SrfOffsetFunc – Functional offset Surface using point sampling
N_SrfOffset – Offset of surface using point sampling
 Approximation of a surface with a nonrational surface of specified degree
N_ApproxNurbsWithNonRatSrf – Approximate surface with nonrational surface
 Global weighted and constrained least squares curve approximation arbitrary degree
 Local NL_C1continuous nonrational cubic curve interpolation
N_FitCrvCubic – Curve interpolation with NL_C1 nonrational cubic curves
 Local NL_G1 or NL_C1continuous parabolic curve interpolation
N_FitCrvParabArcs – Curve interpolation with piecewise parabolic arcs
 Local NL_G1continuous rational quadratic curve interpolation
N_FitCrvConics – Curve interpolation with piecewise conic arcs
 NL_G1continous biarc curve interpolation
N_FitCrvArcs – Curve interpolation with piecewise circular arcs
 Local data approximation with NL_G1continuous quadratic curves
N_FitCrvConicsApprox – Data approximation with piecewise conic segments
 Local data approximation with NL_G1continuous cubic curves
 Global curve approximation / data reduction with error bound specified arbitrary degree
 Local NL_C1,1continuous nonrational bicubic surface interpolation
N_FitSrfInterpBicubic – Surface interpolation with C11 bicubic surfaces
 Global surface approximation / data reduction with error bound specified arbitrary degree
 Curve/surface interpolation and approximation functions that allow specification of boundary constraints, including tangent/derivative vectors
Evaluation of Curves and Surfaces
 Compute point and derivatives of arbitrary order on a curve
N_CrvEval – Compute a point on a curve
N_CrvDerivs – Compute derivatives of a curve
N_CrvEvalTangent – Unit tangent and point of a curve
 Compute the Frenet frame on a curve at a given point
N_CrvEvalFrenetFrame – Compute the Frenet frame of a curve at a given point
 Compute point and partial derivatives of arbitrary order on a NURBS surface
N_SrfEvalPt – Compute a point on a surface
N_SrfDerivs – Compute derivatives of a surface
 Compute the surface normal vector at a given point
N_SrfEvalPtPtDerivNormal – Compute the surface normal at given parameter values
N_SrfEvalPtNormalDeriv – Compute 1st and 2nd derivatives of UNIT surface normal
 Compute curvature on curves and surfaces
N_CrvGetCurvatureDeriv – Compute derivative of curvature of curve
N_CrvEvalCurvature – Compute curvature and osculating circle of a curve
N_SrfEvalPtCurvature – Compute Gaussian, mean and principal curvatures
N_SrfEvalPtDerivCPt – Derivative of a NURBS surface wrt a control point
 Cross boundary derivatives
N_CreateDerivField – Crossboundary derivative from surface, end twists and derivatives
N_CrossBoundaryDerivsVectorField Crossboundary derivative data from vector field
Transformations, Projections and Interactive Shaping Tools
 Translation, rotation and scaling of curves and surfaces
N_CrvTranslate – Translate a curve N_CrvFromCrvTranslation Translate a curve, but not in place
N_CrvRotateAboutAxis – Rotate a curve about a general axis
N_CrvScale – Scale a curve with respect to a point
N_CrvTransform – Transform a curve given a 4×4 matrix
N_SrfTranslate – Translate a surface
N_SrfRotateAtPt – Rotate a surface about a general axis
N_SrfScale – Scale a surface with respect to a point
N_SrfTransform – Transform a surface given a 4×4 matrix
 Parallel and perspective projection of curves and surfaces onto a plane
N_CrvProjectOntoPlane – Project a curve onto a plane
N_SrfProjectOntoPlane – Project a surface onto a plane
 Reposition curve/surface control points to obtain desired translational changes
N_CrvShapeModifyCPts – Reposition curve control points
N_SrfShapeModifyCPts – Reposition surface control points
 Modify curve/surface weights to obtain desired perspective changes
 Curve warping
N_CrvShapeWarp – Warp curve
N_CrvShapeApproxPts – Shape curve to approximate given points
N_CrvShapeApproxPtsUpdate – Shape curve to approximate given points
N_CrvShapeInterp – Shape curve to interpolate given points
N_CrvShapeDerivConstraintsOver – Constraintbased curve shaping with interp or approx
N_FitCrvShape – Interpolate points based on curve shaping
 Surface region warping and polyline warping
N_SrfShapeRegionWarp – Surface region warp
N_SrfShapePolylineWarp – Surface polyline warp
 Curve flattening
N_CrvShapeFlatten – Flatten a curve
 Surface modification
N_SrfShapeFlatten – Flatten a surface
N_SrfShapeApproxPts – Shape surface to approximate given points
N_SrfShapeDerivConstraints – Constraintbased surface shaping with interp or approx
N_SrfShapeInterp – Shape surface to interpolate given points
 Curve bending
N_CrvShapeBend – Bend a curve
 Surface axial and central bending
N_SrfShapeAxialBend – Surface axial bending
N_SrfShapeCentralBend – Surface central bending
 Curve axial deformations: pinch, taper, twist and shear
N_CrvShapeAxialDeform – Axial deformations of curves
 Surface axial deformations: pinch, taper, twist and shear
N_SrfShapeAxialDeform – Axial deformations of surfaces
N_FitSrfApproxShape – Approximatte random points based on surface shaping
N_FitSrfInterpShape – Interpolate points based on surface shaping
 Constraintbased curve modification via control point repositioning
N_CrvShapeDerivConstraints – Constraintbased curve modification
 Constraintbased surface modification via control point repositioning
Geometric Tools
 Knot insertion and knot refinement curves and surfaces
N_CrvInsertKnot – Insert a knot into a curve
N_CrvRefine – Refine a curve with a given knot vector
N_tooCrvCleanSpans – Curve remove excessive knots and control points
N_SrfInsertKnot – Insert a new knot into a surface
N_SrfReplaceKnotVector. Refine a surface with a given knot vector
N_BasisSplitLongestSpan – Add knots to knot vector
N_BasisIncreaseKnotMult – Increase multiplicity of internal knots
N_BasisInsertKnots – Refine knot vector
N_BasisSplitNLongestSpans – Refine knot interval
 Inverse knot insertion curves and surfaces
N_CrvInverseKnotInsert – Curve inverse knot insertion
N_SrfInsertKnotPt – Surface inverse knot insertion
 Decomposition into piecewise Bezier form curves and surfaces
N_CrvDecomposeBez – Decompose a curve into Bezier pieces
N_SrfDecomposeToBez – Decompose a surface into Bezier patches
 Knot removal curves and surfaces, including “cleaning” routines data reduction with boundary constraints
N_CrvRemoveKnots – Remove all removable knots from a curve
N_CrvRemoveAllKnotsConstraints – Remove all removable knots from curve with constraints
N_CrvRemoveKnot – Remove one knot multiple times from a curve
N_CrvShapeRemoveKnots – Remove all removable knots from a curve being shaped
N_SrfRemoveAllKnots – Remove all removable knots from a surface
N_SrfRemoveKnotConditional – Remove one knot from a surface multiple times
N_SrfRemoveKnotsKeepBoundaries – Remove knots from surface with boundary constraints
N_SrfShapeRemoveKnots – Remove all removable knots from a surface being shaped
 Degree elevation curves and surfaces
N_CrvElevateDegree – Elevate the degree of a curve
N_SrfElevateDegree – Elevate the degree of a surface
 Degree reduction curves and surfacesN_CrvReduceDegreeOnce – Reduce the degree of a curve
N_CrvReduceDegree – Reduce the degree of a curve as much as possible
N_SrfReduceDegree – Reduce the degree of a surface
N_SrfReduceDegreeToTol – Reduce the degree of a surface as much as possible  Subcurve and subsurface extraction
N_CrvExtractCrvSeg – Extract a curve segment from a curve
N_SrfExtractPatch – Extract a segment patch from a surface
N_SrfExtractBoundaryCrvs – Extract boundary curves from surface
 Curve and surface splitting
N_CrvSplit – Split a curve at a given parameter
N_SrfSplit – Split a surface at a given parameter
 Extraction of isoparametric curves from surfaces
N_SrfExtractIsoCrv – Extract isocurve from surface
 Reparameterize a curve
N_SrfReparamMultKnots – Reparameterize curves with respect to arc length
N_SrfReparamFunc – Reparameterize a curve with a Bspline function
N_CrvReparamRat – Curve reparameterization with linear rational function
 Make curve end weights equal
 Reparameterize a surface
N_SrfReparamArcLength – Reparameterize surfaces with respect to arc length
N_SrfReparmRat – Surface reparameterization with linear rational function
Triangular Tessellation of Trimmed Surfaces
N_TessTrimmedSrf – Tessellate a trimmed surface
ST_TessRegionOfRectangles – Triangulate a trimmed region bounded by many outer loops
Conversion between Forms
 Conversion from NURBS to piecewise Bezier or polynomial spline form
N_CrvNurbsToPiecewise – Convert curve into piecewise power basis form
N_ConvertNurbsToPowerBasis – Convert surface into piecewise power basis form
 Conversion from piecewise Bezier or polynomial form to NURBS form
N_CrvPiecewiseToNurbs – Convert a piecewise power basis curve to form
N_ConvertPiecesToNurbs – Convert a piecewise power basis surface to form
 An extensive set of routines to support the evaluation and processing of Bezier and polynomial curves and surfaces
Conversion fo NL_IGES Curves and Surfaces
 N_Iges100Arc – Create circular arc from NL_IGES Entity 100 data
N_Iges102CompositeCrv – Create composite curve from NL_IGES Entity 102 data
N_Iges104ConicArc – Create conic arc from NL_IGES Entity 104 data
N_Iges106LinearCrv – Create degree 1 curve from NL_IGES Entity 106 data
N_Iges108Plane – Create bounded plane from NL_IGES Entity 108 data
N_Iges100Line – Create bounded line from NL_IGES Entity 110 data
N_Iges112CrvNonRat – Create curve from NL_IGES Entity 112 data
N_Iges114NonRatSrf – Create surface from NL_IGES Entity 114 data
N_Iges118RuledSrf – Create ruled surface from NL_IGES Entity 118 data
N_Iges120RevolvedSrf – Create revolved surface from NL_IGES Entity 120 data
N_Iges122ExtrudedSrf – Create extruded surface from NL_IGES Entity 122 data
N_Iges124Matrix – 4×4 transformation matrix from NL_IGES Entity 124 data
N_Iges126Crv – Create curve from NL_IGES Entity 126 data
N_Iges128Srf – Create surface from NL_IGES Entity 128 data
Curve and Surface Extensions and Boundary Modifications, with continuity control
N_CrvExtendByDist – Extend a curve a given distance
N_CrvExtendToPt – Extend a curve to a point
N_SrfModifyBoundaryCrv – Modify surface to assume new boundary curve
N_SrfExtendByDist – Extend a surface a given distance
N_SrfExtendToCrv – Extend a surface to a curve
Miscellaneous Curve and Surface Routines
 Arc length of a curve segment
N_CrvArcLength – Compute arc length of segment of curve
 Project a point to a curve or surface closest point projection, given a point on a curve/surface, to determine the corresponding parameter space value
N_CrvClosestPtMultiple – Global curve point inversion/projection
N_CrvClosestPt – Curve point inversion/projection using Newton’s method
N_SrfGetClosestPt – Surface point inversion/projection using Newton’s method
 Given a tangent direction on a surface, determine the corresponding direction in parameter space
N_InvertTangentSrfCrv – Surface curve tangent vector inversion
 Reverse parameter direction of a curve or surface
N_CrvReverse – Reverse a curve
N_SrfReverse – Reverse a surface
 Unclamp a clamped curve or surface
 Scale/translate the parameter domains of a curve or surface
 Various conic utilities; e.g. determine type of conic, implicit equation of conic, and geometric characteristics of a conic vertex, radii, axes, etc
N_ConicCalcGeomDef – Compute geometric definition of conic
N_CalcConicImplicitEq – Compute the implicit equation of a conic curve
N_CalcConicShapeFactor – Compute conic shape invariance
N_ConicGetType – Determine the type of conic
 Computation of minmax box of curves and surfaces
N_CrvGetBBox – Compute minmax box of a curve
N_SrfGetBBox – Compute minmax box of a surface
 Make a set of curves or surfaces compatible same degrees and knots
N_CrvsMakeCompatible – Make curves compatible
N_CrvsMakeCompatibleAdjKnots – Make curves compatible using knot adjustment
N_CrvsMakeCompatibleApprox – Make curves compatible using approximation
N_CrvsMakeCompatibleConstraints – Make curves compatible with approximation & constraints
N_MakeSrfsCompatibleUV – Make surfaces compatible
 Analyze curves for cusps, straight line segments, and degeneracy’s.
 Curve and surface cleaning, with reparameterization for enhanced cleaning of piecewise Bezier curves and surfaces
N_CrvRemoveAllKnotsArcLen – Clean curve
N_CrvRemoveKnotsTangentConstraints – Clean curve with end tangent control
N_CrvRemoveDegenSegs – Remove degenerate segments of a curve
N_SrfRemoveAllKnotsArcLen – Clean surface
N_SrfReparmAndRemoveKnotsKeepBoundaries – Clean surface with boundary constraints
 Approximately equally spaced points on a curve
 Points on a surface
N_SrfEvalPtGrid – Compute a grid of points on a surface
N_SrfEvenSpacedPts – Compute equally spaced points on a surface
Scalarvalued Functions of One or Two Variables
 Creation of scalarvalued NURBS
 Functions of 1 or 2 parameters
 Evaluation of scalarvalued functions, including derivatives of any order
A Complete Set of Functions to Process Bezier Curves and Surfaces
Bspline and Basis Functions
Evaluation of rational and nonrational basis functions.
For curves:
N_SrfNonRatBasisDerivs, N_BasisEvalArray, N_CrvRatBasisDerivs, N_BasisDerivs, N_BasisDerivsArray, N_BasisEval, N_BasisIDerivs, N_BasisIEval, N_CrvBasisDerivs, N_CrvBasisIEval, N_CrvRatBasisIEval, N_CrvRatBasisIDerivs
For surfaces:
N_SrfRatBasisDerivs, N_SrfRatBasisIEval, N_SrfRatBasisIDerivs, N_SrfBasisDerivs, N_SrfBasisIEval
Differentiation of Curves, Surfaces, and Basis Functions with Respect to a Knot
 N_SrfDerivKnot – Compute derivatives of a surface wrt a knot
N_CrvEvalFirstDerivKnot – First derivative of a curve with respect to a knot
also see: N_BasisKnotDerivs, N_CrvRatBasisKnotDeriv, N_BiBasisKnotDeriv N_SrfRatBasisKnotDeriv, N_BasisIKnotDeriv N_CrvRatBasisIKnotDeriv, N_SrfRatBasisIKnotDeriv
Symbolic Operators
 Extract derivative curves and surfaces
 Compute maximum bounds on magnitudes of curve/surface derivatives
 Form linear combinations of curves/surfaces
 Extract the surface of normal vectors to a surface
N_ApproxNormalSrfWithSrf – Approximate unit normal surface of NLib surface  Compute various products of curves, surfaces, and functions
Basic Geometric Computations and Constructions
An extensive set of functions to perform basic geometric operations on vectors, lines, polygons, and planes; this includes distances, projections, intersections, bounding boxes, transformations, closure, and containment tests
Basic Math Routines
An extensive set of functions to perform basic mathematical and numerical operations such as matrix algebra, solution to linear systems of equations, Horner evaluation of polynomials, polynomial root finding, and computation of the binomial coefficients
Other Utilities
A very large set of lowlevel curve and surface utilities; e.g. copy a curve or surface, input/output a curve or surface from/to an ASCII or NL_IGES file, inquire curve or surface attributes closed?, rational?, etc
Curve and Surface Error Handling
An extensive set of functions to check validate object data and set error flags; e.g. validate the data defining a curve or surface object, and check if a parameter is within valid bound
Fitting to Points
Point fitting in NLib is supported with a bag of tools to be used appropriately depending on what is known about the point sets.
The components of a point fitting include the point set, the output surface, the surface properties, the constraints, and the uvmapping as described in the following.
 The point set. A collection of 3d points in to be used to define the shape of a surface. The points within the point set are called sample points.
 The output surface. The surface can be computed to either approximate or interpolate the points. In NLib fitting all output surfaces are nonrational BSplines.
 The surface properties. The output surface properties include the surface’s U and Vdirection degrees, knot vectors, and control point counts. Various functions in the NLib fitting tool allow various combinations of surface properties to be specified by the calling function or to be computed by the algorithm.
 The constraints. A set of geometric properties that must be interpolated by the output surface in addition to fitting the point set. Different fitting tools support different constraints allowing the user to select the effects desired. Constraints which are supported include:
 no constraints.
 boundary curve shape constraints.
 boundary curve crosstangent constraints
 boundary curve higherorder crosstangent curve constraints.
 internal point position constraints.
 internal point normal constraints.
 internal point crosstangent constraints.
 The uvmapping. An assignment of a surface UVpoint to every point in the input point set. This is the hard part of point fitting. A good uvmapping of a point set will yield a good fitted surface and a bad uvmapping will yield a mangled surface. There is not general algorithm that will find the best uvmapping for an arbitrary set of sample points. As such, the NLib fitting package supports several different schemes for computing uvmappings and allows uvmapping to be passed as input when the calling functions can compute a good uvmapping on their own.
Point fitting works well when enough sample points are known to characterize the desired surface and a good uvmapping is found.
Point Sets
The more known about the shape of the points set, the more likely it is to find a good uvmapping. As such, the NLib fitting functions support three different kinds of point sets.
 GridofPoints point sets. A gridofpoints point set is a set of elevation values measured on some regular sampling interval. It’s easiest to think of an array of of sample points on the XY plane each lifted in the Z axis to the height of the surface to be defined. In NLib, the gridofpoints point set does not have to be oriented on the XY plane but may be arbitrarily oriented. Since the points are ordered they can be indexed by their location in the grid as Point[i][j]. The connectivity between every sample point and it’s neighbors is known from the sample points index in the sample grid, e.g. Point[i][j] is connected in the u direction to points Point[i1][j] and Point[i+1][j] and is connected in the v direction to points Point[i][j1] and Point[i][j+1].
 RowsofPoints point sets. A columnofPoints point set is similar to the gridofpoints, but the number of points in each row of the sample grid may vary. This is useful if an original shape was measured as a sequence of crosssections sampled at regular intervals and due to the shape of the surface, the number of sample points in each crosssection varies. Points can still be index in an array but the connectivity of points is only known in one direction from the indexing, that is Point[i][j] is connected in the u direction to points Point[i1][j] and Point[i+1][j].
 CloudofPoints point sets. A cloudofpoints points set is an arbitrary collection of 3d points. The are indexed in a 1d vector as Point[0], Point[1], …, Point[n] and no information about the connectivity between points is known. Building uvmappings for cloudofpoints point sets is problematic.
Building UVMappings
Different uvmap construction techniques are used for different point sets attempting to take advantage of as much of the connectivity information as possible to make a good uvmapping.
UVMap construction for GridofPoints. Each row and column of the gridofpoints point set is mapped to a isoparameter curve. Two knot vectors are computed for the U and the V directions and the knot spacing in those knot vectors are computed from the 3d properties of the sample points.
Three methods are supported:
 Indexing: A uniform step in the u and v directions is associated with the indices of the gridofpoints arrays and each sample point uvvalue is assigned from its indes values as: Point[i][j].u = i * u_step. Point[i][j].v = i * v_step.

Chordlength: The step size for each index increment is computed as the average distance between sample points as:
u[i+1] – u[i] = Avg( Dist(Point[i+1][j], Point[i][j])) for all j values,
and v[j+1] – v[j] = Avg( Dist(Point[i][j+1], Point[i][j])) for all i values.

Centripetal: the step size for each index increment is computed as the average of the squareroot of the distance between sample points as:
u[i+1] – u[i] = Avg( SquareRootDist(Point[i+1][j], Point[i][j])) for all j values,
and v[j+1] – v[j] = Avg( SquareRootDist(Point[i][j+1], Point[i][j])) for all i values.
The method which produces the best uvmapping for the best fitsurface depends on the sample points. If little is known about the sample points it seems the most generally robust approach is the Chordlength approach.
UVMap Construction for RowsofPoints
Each row (not the columns) of a ColumnofPoints points set is mapped to an isoparameter curve. Within each row of the point set the sample points are examined to assign v values based on one of the 3 methods described above.
UVMap Construction for CloudofPoints
All uvmaps made for CloudsofPoints point sets are constructed by projecting the sample points to a target surface. The surface can be supplied by the calling function or constructed in one of the following manners.
 Project to a plane. The plane may be specified by a normal vector or can be computed from the point set by finding the best fit plane to the sample points.
 Project to a sphere. The sphere may be specified by a center point or can be computed from the point set by finding the best fit sphere to the sample points. Currently, no single function exports the project to a sphere feature.
This must be coded up as a sequence of find the sphere with
N_FitSphereToPtsGlobal(),
then project to the sphere with
N_FitCalcSrfParamsBoundarySrf().

Project to Nurbs surface. The nurbs surface can be specified by the calling function or may be computed as a blended coons patch. The surface used for projection is called the base surface.
Interpolations
Some of the fitting routines create interpolating surfaces, that is every point in the point set is interpolated exactly by the surface. The advantage of such surfaces is accuracy. The disadvantage is that the fitted surface will have large control point counts and will reflect any noise in the data set as bumpy surfaces. In addition to interpolating the position of the sample points it’s possible to force the interpolation of the crosstangents of the sample points.
Approximations
Some of the fitting routines create approximating surfaces, that is every point int the point set is approximated. The error for a sample point is the distance between the sample point and the associated surface point for the sample point’s uv value, computed from the uvmapping. Some of the approximating routines support constraints so an approximating surface can be forced to interpolate some of the sample points. Constraints support boundary curve interpolation, boundary curve crossderivative interpolation and internal point crosstangent interpolation.
There are two major types of approximation algorithms: Point fill followed by knot removal and least squares fitting.
In the point fill algorithm, a surface is created with a large number of control points that interpolate the points and then as many knots are removed as possible while maintaining the error at the sample points below a given tolerance value.
In the least squares fitting algorithm, the control point positions for a surface with specified degrees and knotvectors and a given uvmapping are computed to minimize the square root of the sum of errors at all sample points. This basic computation is placed inside a loop where a sequence of higher and higher control point count surfaces are fitted to the sample points until a surface is found whose error in the least squares sense is less than a tolerance. The least square algorithm can be made to support the same set of constraints as the point fill approach.
UVMap and Knot Vector Building
N_FitCalcSrfParamValues compute gridofpoints uvmapping using a uniform, chordlength, or centripetal rule.
N_FitSrfInterpParams compute u or v param values for gridofpoints using equal spacing, chordlength, or centripetal rule.
N_FitSrfCalcParams compute cloudofpoints uvmapping by projecting points to a bestfit or input plane.
N_FitCalcSrfParamsBoundary compute cloudofpoints uvmapping by mapping to a base surface made as a blended coons patch from given boundary curves.
N_FitCalcSrfParamsBoundarySrf compute cloudofpoints uvmapping by mapping to a base surface. Base surface can be given or computed from boundary curves.
N_FitSrfCalcKnotVectors set knot values of sized knot vectors based on a cloud of points parameter data.
Knot Removal
N_FitSrfTangentError test whether the removal of one knot will change a surface shape at specifed uv params by more than specified tolerance.
N_FitSrfRemovalBoundary removes one knot from a surface and updates error bound to a set of sample points.
N_FitSrfApproxRemoveKnots removes max number of knots from surface while keeping surface within tolerance of a given set of sample points.
N_FitSrfInterpRemoveKnots remove knots while interpolating positions at given parameter points.
N_FitSrfApproxRemoveKnotsTangents remove knots while preserving position tolerances at given parameter points and opt tangent constraints on boundaries.
Interpolate Functions
N_FitSrfToPtsKnots interpolate gridofpoints with given uvmapping to a nurbs surface with one control point for each grid point.
N_FitSrfInterpBicubic interpolate gridofpoints with a C11 bicubic nurbs fill of the data.
N_FitSrfFuncInterp interpolate gridofpoints with given uvmapping to a nurbs surface function with one control point for each grid point.
N_FitSrfInterpVariablePts interpolate rowsofpoints with nurbs surface of specified degree and a param that trades off interpolant quality with number of control points
N_FitSrfInterpBoundary interpolate cloudofpoints and boundary curves and optional uvmapping with nurbs surface.
N_FitSrfInterpShape interpolate cloudofpoints, boundary curves, and optional crosstangent boundary constraints to a tolerance with a nurbs surface algorithm finds uvmapping, knot vectors, and control points using input boundary curve properties as a start.
Approximating Functions
N_FitSrfToPts fit gridofpoints to a nurbs surface of specified degrees. The algorithm finds the uvmapping, knotVectors, and ControlPoint counts.
N_FitSrfApproxTol fit gridofpoints to given tolerance with nurb surface of specified degrees. The algorithm finds uvmapping, knotVectors, and ControlPoint counts.
N_FitSrfLstSqApprox fit gridofpoints to a nurbs surface of specified degrees and ControlPoint counts. The algorithm finds the uvmapping and knot vectors.
N_FitSrfLstSqKnots fit gridofpoints with given uvmapping to a nurbs surface of specified degrees, knotVectors, and ControlPoint counts.
N_FitSrfInterpTangents fit gridofpoints with optional boundary crosstangent direction or vector constraints (i.e. magnitude either free or fixed) with a nurbs surface. The uvmapping may be given or computed by the algorithm. The knotVectors may be given or computed by the algorithm. The ControlPoint counts are found by the algorithm.
N_FitSrfApproxTangentsTol; fit gridofpoints with optional boundary crosstangent constraints with a nurbs surface of specified degrees. The algorithm finds the uvmapping and ControlPoint counts.
N_FitSrfToPtsAndBoundary; fit gridofpoints with nurbs surface defined by given boundary curves, optionally allow extra knots to tighten fit
N_FitSrfToVariablePts fit rowsofpoints with a dense nurbs surface of specified degree followed by knot removal algorithm finds uvmapping, knotVectors, and ControlPoint counts
N_FitSrfApproxShape fit cloudofpoints, boundary curves, and optional crosstangent boundary constraints to a tolerance with a nurbs surface algorithm finds uvmapping, knot vectors, and ControlPoints using input boundary curve values as a start.
MISC
N_FitArcToEndPtsAndTangents find ControlPoint nurbs biarc positions to fit given start and end point positions and tangents
N_FitPlaneToPts; fit cloudofpoints to best fitting planar patch
N_FitSphereToPtsGlobal fit cloudofpoints to best fitting sphere or planar patch, sphere segmented globally
N_FitSphereToPtsLocal fit cloudofpoints to best fitting sphere or planar patch, sphere segmented locally
Arithmetic
 N_Combine4CPts Compute combination of four control points
 N_Combine4Pts Compute combination of four points
 N_TranslateSum2CPts Translate combination of two control points
 N_TranslateSum2Pts Translate combination of two points
 N_Combine2CPts Compute combination of two control points
 N_Combine2Pts Compute combination of two points
 N_CPtToPt Map control point to w = 0 hyperspace
 N_Cross2CPts Cross product of two control points
 N_Diff2CPts Compute the difference of two control points
 N_DiffCPtPt Compute the difference of control point and point
 N_Diff2Pts Compute the difference of two points
 N_Dot2CPts Dot product of two control points in Euclidean space
 N_Dot2CPtsIn4D Dot product of two control points in homogeneous space
 N_Dot2Pts Dot product of two points
 N_CPtToPtNow Map homogeneous control point to Euclidean control point
 N_CPtToPtEuclid Compute Euclidean point from homogeneous coordinates
 N_CPtToWxWyWz Extract coordinates of a control point
 N_CPtToXYZ Extract Euclidean coordinates of a control point
 N_PtToXYZ Extract coordinates of a point
 N_CPtGetW Extract the weight of a control point
 N_CPtGetZ Extract the z coordinate of a control point
 N_CPtFromWxWyWz Create control point object from coordinates
 N_PtFromXYZ Create point object from coordinates
 N_CopyCPt Initialize control point
 N_CopyPt Initialize point
 N_CPtMagnitude Compute magnitude of control point
 N_PtMagnitude Compute magnitude of point
 N_CPtToPtAndW Map control point to Euclidean space
 N_PtToCPt Convert point to control point
 N_CPtRatDeriv Compute rational derivative from Euclidean derivative
 N_CPtResetW Reweight control point
 N_ScaleCPtXYZ Scale first three coordinates of a control point
 N_ScaleCPt Scale control point
 N_ScalePt Scale a point
 N_ScaleCPtWithPtAndVector Scale control point with respect to a point
 N_CPtSetW Set w component of control point
 N_CPtSetX Set x component of control point
 N_CPtSetY Set y component of control point
 N_CPtSetZ Set z component of control point
 N_Sum2CPts Compute the sum of two control points
 N_SumCPtAndPt Compute the sum of control point and point
 N_Sum2Pts Compute the sum of two points
 N_TransformCPt Transform control point given a 4×4 matrix
 N_TransformPt Transform point given a 4×4 matrix
 N_TranslateCPt Translate control point by a given vector
 N_VectorBlendCPt Update control point by adding a term to it
 N_VectorBlendPt Update a point by adding a term to it
 N_VectorCombineCPts Compute vector combination of two control points
 N_VectorCombinePts Compute vector combination of two points
 N_Weight Compute weighted control point
Bezier
 N_BezEvalBasis Compute all Bernstein polynomials at a given parameter
 N_BezCalcLength Compute arc length of Bezier curve
 N_BezEvalOneBasis Evaluate a Bernstein polynomial at a given parameter
 N_BezToPowerBasis Convert Bezier curve to power basis form
 N_BezElevateDegree Elevate the degree of a Bezier curve
 N_BezReduceDegree Reduce the degree of a Bezier curve
 N_BezGetDegreeElevationMatrix Compute Bezier curve degree elevation matrix
 N_BezCrvExtend Extend Bezier curve to share same derivatives
 N_BezFuncMultiplyBezCrv4D Product of Bezier function and Bezier curve in 4D
 N_BezFuncMultiplyBezCrv Product of Bezier function and Bezier curve
 N_BezFuncEvalPt Compute a point on a Bezier curve function
 N_BezFuncMultiplyBezFunc Product of two Bezier functions
 N_BezCircArcFrom3Pts Compute weighted control points of Bezier circle
 N_BezCenterRadiusFrom3CPts Center, radius, start/end angles of 2D Bezier circle
 B_PowerBasisToBez Convert power basis curve to Bezier form
 N_BezFuncMultiplyBezCrvMatrix Compute Bezier product matrix
 N_BezReparam Reparameterize a Bezier curve with a Bezier function
 N_BezSplit Split a Bezier curve at a given parameter
 N_BezCubicFromPtsAndTangents Leastsquares cubic to end points and end tangents
 N_BezCrossProduct Cross product of two Bezier curves
 N_BezCrvEvalPt Compute a point on a Bezier curve
 N_BezCrvDotProduct Dot product of two Bezier curves
 N_BezDegreeReduceCoefs Compute Bezier degree reduction coefficients
 N_BezFuncDegreeElevate Elevate the degree of a Bezier function
 N_BezInterp4Pts Global cubic curve interpolation
 N_BezInterpNPts Global curve interpolation
 N_BezSetConicWeight Compute weight of conic arc closest to that of circle
 N_BezInversePowerMatrix Inverse of power basis conversion matrix
 N_BezInverseReparamMatrix Nonzero elements of inverse of reparameterization matrix
 N_BezCircArcFromPtsAndTangents Compute circular arc to given end points and tangents
 N_BezConicArcFromPtsAndTangents Create a Bezier conic arc
 N_BezGetPowerConversionMatrix Nonzero elements of power basis conversion matrix
 N_BezCalcArcLength Recursive procedure for Bezier arc lenth computation
 N_BezGetReparamMatrix Nonzero elements of reparameterzation matrix
 N_BezSrfToPower Convert Bezier surface to power basis form
 N_BezSrfElevateDegree Elevate the degree of a Bezier surface for a row/column
 N_BezSrfReduceDegree Reduce the degree of a Bezier surface
 N_BezSrfExtend4D Extend Bezier surface strip to share same derivatives
 N_BezSrfFuncElevateDegree Elevate the degree of a Bezier surface function
 N_BezSrfFuncEvalPt Compute a point on a Bezier surface function
 N_BezSrfFuncMultiply Product of bivariate Bezier functions
 N_BezSrfMultiplySrfFunc Product of bivariate Bezier function and Bezier surface
 N_BezConicSplit Split a Bezier conic arc
 N_BezSrfPowerToBez Convert power basis surface to Bezier form
 N_BezSrfCrossProduct Cross product of two Bezier surfaces
 N_BezSrfEvalPt Compute a point on a Bezier surface
 N_BezSrfDotProduct Dot product of two Bezier surfaces
Error Checking
 N_CrvIsFuncSized Check for sufficient storage in curve function structure
 N_ErrClear Clear error handle
 N_CheckCPtMatStorage Storage check in control point matrix structure
 N_CrvHasEqualCPts check curve control points equal
 N_CrvReplaceEqualCPts: Replace (near) equal curve control points
 N_CrvCountsAreValid Check curve definition
 N_CrvIsValid A complete curve check
 N_CrvIsNotReversed Check curve control points for direction reversal at ends
 N_CrvIsSized Check for sufficient storage in curve structure
 N_CrvWeightsAreValid Check whether curve weights are within range
 N_KnotVectorIsEndParam Check if parameter <= first knot or >= last knot
 N_ErrGetType Return type of error
 N_CheckIntMatStorage Check for sufficient storage in integer matrix structure
 N_KnotVectorIsValid Check knot vector definition
 N_KnotVectorIsParamOutOfBounds Check if parameter is out of range
 N_CheckPtMatStorage Check for sufficient storage in point matrix structure
 N_CheckRealMatStorage Check for sufficient storage in real matrix structure
 N_ErrSet Set error handle
 N_SrfIsFuncSized Check storage in surface function structure
 N_SrfCountsAreValid Check surface definition
 N_SrfIsValid A complete surface check
 N_SrfIsSized Check for sufficient storage in surface structure
 N_SrfWeightsAreValid Check whether surface weights are within range
Geometrical
 N_AreaSpherePolygon Compute Area Of Spherical polygon
 N_AreaSpherePatch Compute Area of rectangular spherical patch
 N_CPtsAreColinear Are three control points collinear?
 N_PtsAreEqual Are points the same?
 N_PtsAreColinear Are 3 points colinear
 N_VectorsAreParallel Are vectors point to the same direction?
 N_GetBBoxData Break minmax box object down to its components
 N_BBoxGetCenter Compute the center of a box
 N_BBoxDefine Define bounding box
 N_BBoxGetDiagonal Compute the diagonal of a box
 N_BBoxGetDimensions Compute the dimensions of a box
 N_BBox2dCalcOverlap Compute area of 2D box overlap
 N_CalcCircCenterAndRadius Compute center and readius of a circle given by 3 points
 N_CalcCircArcDerivs Derivatives of a circle given in trigonometric form
 N_PolygonSetIndex Set index in polgon definition
 N_DistCPolygon Compute the length of a control polygon
 N_DistCptCptHomo Compute homogeneous distance between two control points
 N_DistCptCpt Compute the distance between two control points
 N_DistCPolygonHomo Compute the length of a control polygon in 4D
 N_DistPtLineSeg Distance between point and line segment
 N_DistPtArc Distance between a point and a circular arc
 N_DistPtInfLine Compute distance of point from line
 N_DistSignedPtLine Distance of point from line given in implicit form
 N_DistSignedPtPlane Distance of point from plane given in implicit form
 N_DistPolygon Compute the length of a polygon given by the vertices
 N_DistPtPt Compute the distance between two points
 N_DistPtPt2d Compute the distance between two points in 2D
 N_DistPtPlane Compute distance of point from plane
 N_DistPerpPtLineSeg Distance between point and line segment
 N_DistSqPtPt2d Compute the squared distance between two points in 2D
 N_DistSqPtPt Compute the squared distance between two points
 N_IsectLineSegs Do line segments intersect?
 N_CPtCalcWeightColinear Get weight of one control point to ensure collinearity
 N_LineImplicitToPtVector Implicit equation of line to pointvector form
 N_PlaneImplicitToPtNormal Implicit equation of plane to pointnormal form
 N_LineIsectPolygon Intersect closed convex polygon with line segment
 N_IsectLineLine Intersect two lines
 N_IsectLinePlane Intersect line and plane
 N_IsectLineSegs Intersect two line segments
 N_IsectPlanePlane Intersect two planes
 N_ENetIsClosed Is point net closed?
 N_PtsAreInPolygonGravityField Point gridinpolygon gravity field test
 N_PtsAreInPolygon Point gridinpolygon test
 N_EPolygonIsClosed Is polygon closed?
 N_PtIsContainedByEPolygon Pointinpolygon test
 N_IntervalGetData Break interval object down to its components
 N_LineCalcBBox Compute extended bounding box of line segment
 N_LineGetData Break line object down to its components
 N_LineGetDir Get direction vector of line
 N_LineSetBoundingFlag Set bounding flag of line
 N_PtGetSideOfLine Linepoint side test
 N_LinePtVectorToImplicit Pointvector definition of 2D line to implicit form
 N_CreateCircFrom2dPts Leastsquares circle to a set of 2D points
 N_LineFitPts Best fitting line to scattered points
 N_PlaneFit3dPts Best fitting plane to scattered points
 N_LineFit2dPts Leastsquares line to a set of 2D points
 N_LineFit3dPts Leastsquares line to a set of 3D points
 N_FitPlanePts Bestfit plane to a set of 3D points
 N_SphereFit3dPts Leassquares sphere to a set of 3D points
 N_CreateInterval Make interval object
 N_CreateLinePtPt Make line object from end points
 N_CreateLineStartDirVector Make line object from start point and direction vector
 N_ENetFromPts Make point net object
 N_CreatePlanePtNormal Make plane object from point and normal vector
 N_EPolygonFromPts Make polgon object
 N_CreateRectangle Make rectangle object
 N_MaxAreaPlane3dPts Maximum area plane to grid of points
 N_ENetGetBBox Compute bounding box of point net
 N_NetGetClosestLegIndex Find index of control net leg closest to a given point
 N_ENetGetPts Break net object down to its components
 N_PlaneGetData Break plane object down to its components
 N_PlanePtNormalToImplicit Pointnormal definition of plane to implicit form
 N_PlaneGetNormal Get normal vector of plane
 N_PtGetSideOfPlane Planepoint side test
 N_Pts1dCalcBBox Compute the minmax box of a 1D point array
 N_Pts1dGetMaxExtent Compute maximum extent of 1D point array
 N_Pts2dCalcBBox Compute the minmax box of a 2D point array
 N_Pts2dGetMaxExtent Compute maximum extent of 2D point array
 N_PairSelected2dPts Find k closest points to given point in 2D point set
 N_Order3dPts Order points along a 3D curve
 N_BoundRect2dPts Bounding Rectangle of a 2D point set
 N_PolygonGetBBox Compute bounding box of polygon
 N_PolygonGetClosestLegIndex Find index of polygon leg closest to a given point
 N_PolygonOffset Compute the offset of a polygon
 N_PlaneFitOrdered3dPts Plane fit to 3D polyline points
 N_ProjectPtClosePolyPt Get parameter of point based om polygonal approximation
 N_EPolygonGetPts Break polygon object down to its components
 N_ProjectPtLineParam Project point onto line segment
 N_ProjectPtQuad Project point onto a quadrilateral
 N_ProjectPtLine Project point onto a line
 N_ProjectPtPlane Project point onto a plane
 N_PolygonGetArea Area and orientation of a closed 2D polygon
 N_RectangleGetData Break rectangle object down to its components
 N_RectToTwoIntervals Convert rectangle into two intervals
 N_CptReflect Reflect a control point through a plane
 N_SphereCenterRadius Compute center and radius of a sphere given by 4 points
 N_TetraCalcMatrix Compute 3D affine transf. matrix given 4 points and image
 N_TransformPtWithShapeFuncAndScale General axial transformations
 N_CreateRotationMatrixAboutAxis Compute general rotation matrix
 N_CreateTransformMatrixFromAxes Matrix to take one orthonormal system into another
 N_Rotate2dPts Rotate 2D point set
 N_Scale2dPts Scale 2D point set
 N_Shear2dPts Shear 2D point set
 N_Translate2dPts Translate 2D point set
 N_CreateTranslationMatrixFromPts Compute translation matrix
 N_CreateTransformMatrixFromVectors Compute matrix to take one 2D unit vector into another
 N_CreateTransformMatrixFromVector Transform general vector into one of the principal axes
 N_VectorsAngle Compute the angle between two vectors
 N_VectorCombine Compute the combination of two vectors
 N_VectorCopy Compute a copy of a given vector
 N_VectorsCosAngle Compute the cosine of the angle between two vectors
 N_VectorCross Compute cross product of two vectors
 N_VectorCrossRef Compute cross product of vectors passed in by reference
 N_VectorDirectedAngle Compute the directed angle between two 2D vectors
 N_VectorDiffCPts Difference vector between two control points in 3D
 N_VectorDiff Compute the difference of two vectors
 N_VectorDir Compute direction vector from two points
 N_VectorDotRef Compute dot product of vectors passed in by reference
 N_VectorDot Compute the dot product of two vectors
 N_VectorMagnitude Compute the magnitude of a vector
 N_VectorCreate Make NL_VECTOR data type from <x,y,z> data
 N_VectorMagnitudeRef Compute the magnitude of a vector passed in by reference
 N_VectorMixMultiply Compute the mixed product of three vectors
 N_VectorNormalizeRef Normalize a given vector passed in by reference
 N_VectorNormalize Normalize a given vector
 N_VectorPerpendicular Compute a vector perpendicular to a given 2D vector
 N_VectorPtAlongVector Compute point along a vector
 N_VectorReverse Reverse the direction of a given vector
 N_VectorReverseInPlace Reverse the direction of a given vector in place
 N_VectorReverseVectorInPlace Reverse direction of a vector wrt another vector in place
 N_VectorReverseVector Reverse direction of a vector wrt another vector
 N_VectorScale Scale a given vector
 N_VectorScaleRef Scale a given vector passed in by reference
 N_VectorSum Compute the sum of two vectors
Mathematical
 N_FloatOpIsBad Check floating point operations for under and overflow
 N_GetCPtMatrixData Get members of control point matrix object
 N_CheckMemCPtMatrix Check if memory is needed to store control point matrix
 N_GetCPtMatrixPtr Get matrix pointer of control point matrix object
 N_CPtMatrixDefine Set parameters of control point matrix
 N_GetMaxIndexCPtMatrix Get highest indexes of control point matrix object
 N_PowerBasisCrvEvalPts Evaluate polynomial curve given in power basis form
 N_SwapCPts Swap two control points
 M_CorneredTridiagonalSystem Solve corner triDiagonal system
 M_TridiagonalSystem: Solve triDiagonal system
 N_EvenSpacePtsCrv Compute equally spaced points on a curve
 N_EvenSpacePtsSrf Compute equally spaced points on a surface
 N_RandomFlipsFlops Generate a randon sequence of flips and flops
 N_RealMatrixForBack Forward elimination and backward substitution
 N_SetCPtMatrix Allocate memory to store control point matrix elements
 N_SetIntMatrix Allocate memory to store integer matrix elements
 N_SetPtMatrix Allocate memory to store point matrix elements
 N_SetRealMatrix Allocate memory to store real matrix elements
 N_MinMax1dIntArray Minimum or maximum of 1D integer array
 N_MinMax2dIntArray Minimum or maximum of 2D integer array
 N_GetIntMatrixData Get members of integer matrix object
 N_CheckMemIntMatrix Check if memory is needed to store an integer matrix
 N_IntMatrixDefine Set parameters of integer matrix
 N_GetIntMatrixPtr Get matrix pointer of integer matrix object
 N_GetMaxIndexIntMatrix Get highest indexes of integer matrix object
 N_InitCPtMatrix Initialize a control point matrix to NULL
 N_InitIntMatrix Initialize an integer matrix to NULL
 N_InitPtMatrix Initialize a point matrix to NULL
 N_InitRealMatrix Initialize a real matrix to NULL
 N_GenerateRandonNumber Generate a random number in the range of 0 to RAND_MAX
 N_InitRealHash Create hash table for reals
 N_SwapIntegers Swap two integer numbers
 N_FindElemIntArray Find element in a sorted integer array
 N_FindIntervalIntArray Find interval a given integer value is in
 N_CPtMatrixIsNULL Is control point matrix initialized to NULL?
 N_SortIndexArrayMap Sort index array using Shellsort output index array
 N_SortIndexArray Sort index array using Shellsort
 N_IntMatrixIsNULL Is integer matrix initialized to NULL?
 N_PtMatrixIsNULL Is point matrix initialized to NULL?
 N_RealMatrixIsNULL Is real matrix initialized to NULL?
 N_RealMatrixLstSqSolve Least squares solution to linear system of equations
 N_RealMatrixLuDecompose LU decompose a square matrix
 N_RealMatrixLuDecomposePivot LU decomposition with partial pivoting
 N_CreateCPtMatrix Define control point matrix
 N_CreateIntMatrix Define integer matrix
 N_CreatePtMatrix Define point matrix
 N_CreateRealMatrix Define real matrix
 N_FuncFindMinima Minimize a scalarvalued function of 1 variable
 N_PascalTriIndex Compute ith row of Pascal triangle from i1th row
 N_PascalTriRow Compute Pascal triangle
 N_GetPtMatrixData Get members of point matrix object
 N_CheckMemPtMatrix Check if memory is needed to store a point matrix
 N_PtMatrixDefine Set parameters of point matrix
 N_GetMaxIndexPtMatrix Get highest indexes of point matrix object
 N_GetPtMatrixPtr Get matrix pointer of point matrix object
 N_RealMatrixRightForBackPivot Forward/backward with partial pivoting and NL_POINT rhs
 N_PowerBasisEvalDerivs Evaluate polynomial and its derivatives
 N_PowerBasisRootNewton Polynomial root finding via Newton’s method
 N_SwapPts Swap two points
 N_PrintRealMatrix Print real matrix data to the standard output
 N_SolveQuadraticEq Solve quadratic equation
 N_MinMax1dRealArray Minimum or maximum of 1D real array
 N_MinMax2dRealArray Minimum or maximum of 2D real array
 N_RealMatrixForBackPivot Forward/backward with partial pivoting
 N_RealMatrixRightForBack Forward elimination and backward substitution for reals
 N_FindClustersRealArray Find clusters in a sorted array
 N_FindIntervalRealArray Find interval a given real value is in
 N_RetrieveRealHash Retrieve elements from hash table
 N_SwapReals Swap two real numbers
 N_SearchInsertReal Insertion search on a real array
 N_SortRealIndexArrays Sort real and integer array using Shellsort
 N_GetRealMatrixData Get members of real matrix object
 N_CheckMemRealMatrix Check if memory is needed to store a real matrix
 N_RealMatrixMultiplyCPtArray Product of real matrix and control point array
 N_RealMatrixDefine Set parameters of real matrix
 N_RealMatrixEigenValuesVectors Compute eigenvalues and eigenvectors of a matrix
 N_GetMaxIndexRealMatrix Get highest indexes of real matrix object
 N_RealMatrixInverse Compute the inverse of a real matrix
 N_RealMatrixInversePivot Inverse of a real matrix with partial pivoting
 N_RealMatrixInverseSVD Invers of a real matrix with singe value decomposition
 N_RealMatrixTransposeMultiply Product of real matrix and its transpose
 N_RealMatrixMultiplyTranspose Product of real matrix and the transpose of another
 N_RealMatrixMultiply Compute the product of two real matrices
 N_RealMatrixMultiplyPtArray Product of real matrix and point array
 N_GetRealMatrixPtr Get matrix pointer of real matrix object
 N_RealMatrixTranspose Compute the transpose of a real matrix
 N_RealMatrixMultiplyRealMatrixTranspose Product of matrix – control point – transpose of matrix
 N_SortRealRealArrays Sort real array pair using Shellsort
 N_SortRealArray Sort real array using Shellsort output index array
 N_ShellSortReal Sort real array using Shellsort
 N_PowerBasisSrfEvalPts Evaluate polynomial surface given in power basis form
 N_RealMatrixSingleValueDecompose Single Value Decomposition, decomposition, full matrix
 N_Real2dArrayInverseSVD Compute inverse of real matrix using Single Value Decomp
 N_SingleValueDecomposeSolve Single Value Decomposition, substitution, full matrix
 N_TangentVectorAkima Compute a tangent vector via the 5point Akima method
 N_TangentVectorBessel Compute a tangent vector via the 3point Bessel method
 N_UpdateRealHash Update hash table by adding an element to it
NURBS
Conics
 N_CreateConicArc Create a conic arc
 N_CreateBoundedCircArc Create Bezier cubic/quartic circular arc <= 180 degrees
 N_CreateQuadraticArc Create a quadratic circle/circular arc
 N_CreateQuarticArc Create a quartic degree 4 circle/circular arc
 N_CreateQuinticArc Create a quintic circle/circular arc
 N_CreateCircArc Create a circle/circular arc
 N_CalcCircWeights Extract circle weights
 N_CreateCubicSemiCircle Create a cubic semicircle
 N_CreateEllipticalArc Create a ellipse/elliptical arc
 N_ConicCalcGeomDef Compute geometric definition of conic
 N_CalcConicImplicitEq Compute the implicit equation of a conic curve
 N_CalcConicShapeFactor Compute conic shape invariance
 N_ConicGetType Determine the type of conic
 N_CurveGetConicData Get conic data for arc creation
Curves
 N_CrvGetBBox Compute minmax box of a curve
 N_CrvGetCurvatureDeriv Compute derivative of curvature of curve
 N_CrvIsClosedContinuity Is a curve Gn smoothly closed
 N_CrvEvalCurvature Compute curvature and osculating circle of a curve
 N_CrvDerivs Compute derivatives of a curve
 N_CrvEval Compute a point on a curve
 N_CrvGetBBoxMaxDiagDist Compute largest extent of a curve
 N_CrvEvalFrenetFrame Compute the Frenet frame of a curve at a given point
 N_CrvGetG1Segs Get NL_G1continuous segments of a curve
 N_CrvGetDegenSegs Get degenerate segments of a curve
 N_CrvGetLinearSegs Get linear and curved segments of a curve
 N_CrvGetMinPosVector Compute minimum position vector of curve control points
 N_CrvReparam Scale knot vector of a curve to given interval
 N_CrvLineFromPtAndVector Create line as a curve
 N_CrvLineFrom2Pts Create line as a curve 2 points
 N_CrvGetMaxPosVector Compute maximum position vector of curve control points
 N_CrvGetMinMaxWeightsAndPts Compute curve minmax weights and position vectors
 N_CrvDegenFromPt Create point as a degenerate curve
 N_CrvProjectOntoPlane Project a curve onto a plane
 N_CrvReverse Reverse a curve
 N_CrvRotateAboutAxis Rotate a curve about a general axis
 N_CrvScale Scale a curve with respect to a point
 N_CrvEvalTangent Unit tangent and point of a curve
 N_CrvTransform Transform a curve given a 4×4 matrix
 N_CrvTranslate Translate a curve
 N_CrvFromCrvTranslation Translate a curve, but not in place
 N_CrvGetType Determine type of curve
 N_CrvUnclamp Unclamp a curve
 N_CrvUnclampKnots Unclamp a curve with a given knot vector
 N_CrvGetAveragePosMag Compute the average position vector magnitude of a curve
 N_CrvAlign Align a curve to a given coordinate frame
 N_CrvOffsetGetMax2ndDeriv Upper bound on second derivative of offset curve
 N_CrvGetMax2ndDeriv Upper bound on second derivative of a curve
 N_CrvEvalDerivAtKnot Compute derivatives of a curve wrt a knot
 N_CrvEvalEvenSpacedPts Compute equally spaced points on a curve
 N_CrvEvalUnboundedPtsAndDerivs Compute point and derivatives on extended curve
 N_CrvEvalPt Compute a point on a curve in homogeneous space
 N_CrvOffsetGetDeriv 1st and 2nd derivatives of functional curve offset
 N_CrvModifyEndPt Modify curve so that an endpoint passes through a point
 N_CrvPlanarOffsetGetDeriv Compute 1st and 2nd derivatives of offset curves
 N_CrvDerivsAtKnot Derivatives of a curve in homogeneous space
 N_CrvScaleWeights Scale weighted control points of curve
 N_CrvExtendByDist Extend a curve a given distance
 N_CrvExtendToPt Extend a curve to a point
 N_CrvExtendByParamDist Extend a curve a given parametric distance
Curve Functions
 N_CFuncDerivs Compute derivatives of a curve function
 N_CFuncEval Compute a point on a curve function
 N_CrvFuncEvalDerivsAtKnot Compute derivatives of a curve function wrt a knot
 N_CrvFuncEvalRatBasis Evaluate rational basis function given as curve function
Curve Polynomials
 N_CrvPowerBasisEvalDerivs Compute derivatives of a power basis curve
 N_CrvPowerBasisEvalPt Compute a point on a power basis curve
 N_CrvPowerBasisReparam Reparameterize a power basis curve
Surface
 N_SrfGetBBox Compute minmax box of a surface
 N_SrfIsClosedSmooth Is a surface Gn smoothly closed
 N_SrfEvalPtCurvature Compute Gaussian, mean and principal curvatures
 N_SrfDerivs Compute derivatives of a surface
 N_SrfEvalPtCrvOnSrf Compute a point on a surface curve
 N_SrfEvalPt Compute a point on a surface
 N_SrfMaxDiagDistBBox Compute largest extent of a surface
 N_SrfFindDegenPatch Get degenerate patch strips of a surface
 N_SrfReparam Scale knot vectors of a surface to given rectangle
 N_SrfMaxMagnitudePosVectors Compute maximum position vector of surface control points
 N_SrfMinMaxWeightPosVectors Compute surface minmax weights and position vectors
 N_SrfEvalPtPtDerivNormal Compute the surface normal at given parameter values
 N_SrfEvalPtPtDerivNormalPole Compute the surface normal at a pole
 N_SrfProjectOntoPlane Project a surface onto a plane
 N_SrfReverse Reverse a surface
 N_SrfRotateAtPt Rotate a surface about a general axis
 N_SrfScale Scale a surface with respect to a point
 N_SrfTransform Transform a surface given a 4×4 matrix
 N_SrfTranslate Translate a surface
 N_SrfType Determine type of surface
 N_SrfUnclamp Unclamp a surface
 N_SrfUnclampKnotVector Unclamp a surface with given knot vectors
 N_SrfGetMaxSecondDeriv Upper bound on second derivative of unit normal
 N_SrfOffsetGetMaxDeriv Upper bound on second derivatives of offset surface
 N_SrfMaxSecondDeriv Upper bound on second derivative of a surface
 N_SrfEvalPtDerivCPt Compute derivatives of a surface wrt a control point
 N_SrfDerivKnot Compute derivatives of a surface wrt a knot
 N_SrfEvenSpacedPts Compute equally spaced points on a surface
 N_SrfEvalPtDerivsUnbounded Compute point and derivatives on extended surface
 N_SrfEvalPtGrid Compute a grid of points on a surface
 N_SrfOffsetGetFirstSecondDerivs 1st and 2nd derivatives of functional surface offset
 N_SrfModifyBoundaryCrv Modify surface to assume new boundary curve
 N_SrfEvalPtNormalDeriv Compute 1st and 2nd derivatives of UNIT surface normal
 N_SrfGetGridPtsNormals Compute points and unit normals at a grid of points
 N_SrfEvalPtDerivs Derivatives of a surface in homogeneous space
 N_SrfScaleWeights Scale weighted control points of surface
 N_SrfExtendToCrv Extend a surface to a curve
 N_SrfExtendByDist Extend a surface a given distance
 N_SrfExtendByParamDist Extend a surface a given parametric distance
Common Surfaces
 N_CreateSrfCornerPts Create bilinear surface
 N_CreateCylCone Create a cylinder/cone surface/patch
 N_CreateEllipsoid Create a ellipsoid/patch
 N_CreateSrfExtrudeCrv Create a generalized cylinder
 N_CreateRuledSrfBetweenCrvAndPt Create a generalized cone between a curve and a point
 N_CreateHyperboloid Create a hyperboloid of one sheet/hyperbolic patch
 N_CreateParaboloid Create a elliptic parabaloid/patch
 N_CreateRevolvedSrf Create surface of revolution
 N_CreateRuledSrf Create a ruled surface between two arbitrary curves
 N_CreateSphere Create a sphere/spherical patch
 N_CreateTorus Create a torus/toroidal patch
 N_CreateRuledSrfFromBoundaryCrvs Ruled surface of two curves using symbolic operators
Advanced Surface Constructions
 N_ApproxCrossBoundaryDerivs Approximate crossboundary derivative field
 N_AdjustDerivSrf Adjust derivative field
 N_CreateSkinSrfApproxTol Approximate surface skinning with error bound
 N_CreateSkinSrfApprox Approximate surface skinning
 N_CreateSkinSrfApproxParams Approximate surface skinning with given knot vector
 N_CreateCoonsBoundaryCrvs Bicubic Coons surface through boundary and derivatives
 N_CreateCoonsSrfCrossBoundaryDerivs Bicubic Coons surf given bndys, derivs and tensorsurf
 N_CreateCoonsSrfTwist Bicubic Coons surface through four boundary curves
 N_CreateCoonsSrf Bilinear Coons surface through four boundary curves
 N_CreateCrossBoundaryDerivCrv Compute crossboundary derivative field
 N_CreateBVectors Compute “B” vectors for curve alignment
 N_CrossBoundaryDerivCrv Compute crossboundary derivative field
 N_Create4CrossBoundaryDerivCrvs Compute crossboundary derivatives for Coons surface
 N_ReparmCrvsIsectPt Make intersection parameters compatible for Gordon sur
 N_CreateDerivField Crossboundary derivative from surface, end twists and derivatives
 N_CreateDataBoundaryDerivs Crossboundary derivative data from surface
 N_CreateSkinSrfBoundaryDerivs Crossboundary derivative data from vector and curve
 N_CrossBoundaryDerivsVectorField Crossboundary derivative data from vector field
 N_CreateGordonSrf Gordon surface trough compatible nonrational curves
 N_CreateSkinSrf General surface skinning
 N_CreateSkinSrfParams Surface skinning with given parameters and knot vector
 N_Get4CornerTwistVectors Compute twist vectors for bicubic Coons surface
 N_CreateTensorProductSrf Compute tensor product surface for Coons construction
 N_AdjustWeightScale Get weight and scale factor for NL_G1 continuity
 N_GetIsoCrvClosestCrv Isocurve inversion/projection using Newton’s method
 N_MergeKnotVectors Merge knot vectors to have the same internal knots
 N_FillNSidedHole Nsided patch construction to boundary and derivatives
 N_CreateSkinSrfBoundaryContinuity Approximate skinning with boundary conditions and rails
 N_CreateSkinSrfInterp Surface skinning via approximation of crosssectional curves
 N_CreateSkinSpine General spine curvebased surface skinning
 N_CreateSweepSrf Create a swept surface
 N_CreateSweepScale Swept surface with boundary conditions
 N_SweepCrossTangentCrv
 N_CreateSwungSrf Create a swung surface
 N_CreateTransSweepSrf Create a translational sweep surface
Surface Functions
 N_SFuncDerivs Compute all derivatives of a surface function
 N_SFuncEvalPt Compute a point on a surface function
 N_SrfFuncEvalRatBasis Evaluate rat basis function given as a surface function
 N_SrfFuncDerivFuncAtKnot Compute derivatives of a surface function wrt a knot
 N_SFuncEvalGrid Compute a grid of points on a surface function
Surface Polynomials
 N_SrfPowerBasisEvalDerivs Compute derivatives of a power basis surface
 N_SrfPowerBasisEvalPt Compute a point on a power basis surface
 N_SrfPowerBasisReparam Reparameterize a power basis surface
Fitting
 N_FitArcToPts Best fitting circle or circular arc to a set of points
 N_FitArcToEndPtsAndTangents Compute a biarc to given end points and end tangents
 N_FitCubicSplineInterpN_fit Cubic spline interpolation
 N_FitCrvCPtsFromSrfData Curve interpolation through row/column of surface data
 N_FitCrvInterpGivenParams Curve interpolation with specified knot vector
 N_FitCalcCrvParamValues Parameterization for global curve interpolation
 N_FitCubicSplineInterp Cubic spline interpolation
 N_FitPeriodicCubic Periodic cubic spline interpolation
 N_FitCalcFuncParamValues Parameterization for global functional interpolation
 N_FitCrvApproxLstSq Global curve approximation with arbitrary degree
 N_FitCrvApproxClosedConditions Curve interpolation to closed data with end conditions
 N_FitCrvDerivs Curve interpolation with end derivatives specified
 N_FitCrvHighDerivs Curve interpolation with given higher end derivatives
 N_FitCrvInterp Global curve interpolation with arbitrary degree
 N_FitCrvTangents Curve interpolation with end tangents specified
 N_FitFuncInterp Global function interpolation with arbitrary degree
 N_FitSrfLstSqApprox Global surface approximation with arbitrary degree
 N_FitSrfToPts Global surface interpolation with arbitrary degrees
 N_FitCalcKnotVectorCrvApprox Compute knot vector for global curve approximation
 N_FitCalcKnotVectorEndDerivs Knot vector for curve interpolation with end derivatives
 N_FitCalcKnotsHighEndDerivs Knot vector for interpolation with high end derivatives
 N_FitCrvCalcKnotVector Compute knot vector for global curve interpolation
 N_FitLineToPts Best fitting line segment to a set of random points
 N_FitPlaneToPts Best fitting plane to random points
 N_FitSrfFuncInterp Surface function interpolation with arbitrary degrees
 N_FitCalcSrfParamValues Parameterization for global surface interpolation
 N_FitArcToEndPtsAndTangents Compute a biarc to given end points and end tangents
 N_FitCrvApprox Curve approximation with error bound specified
 N_FitCrvApproxKnotsTangents Curve approximation with knots and end tangents
 N_FitCrvApproxTangents Global curve approximation with end tangents
 N_FitCrvApproxKnots Curve approximation with specified knot vector
 N_FitCrvArcApprox Data approximation with piecewise biarc segments
 N_FitCrvCubicApprox Data approximation with piecewise cubic segments
 N_FitCrvDerivsMatrix Curve interpolation with end derivatives and matrix
 N_FitCrvKnotsAndDerivs Curve interpolation with end derivatives and knot vector
 N_FitCrvApproxKnotsTol Curve approximation with error bound and knot vector
 N_FitCrvApproxKnotsAndTangentsTol Curve approximation with error bound & end constraints
 N_FitCrvFirstDeriv Curve interpolation with first derivatives specified
 N_FitCrvFirstDerivAndKnots Curve interpolation with first derivatives & knot vector
 N_FitCrvKnotsAndTangents Curve interpolation with knots and end tangents
 N_FitCrvMatrix Curve interpolation with specified matrix
 N_FitCrvArcs Curve interpolation with piecewise circular arcs
 N_FitCrvShape Interpolate points based on curve shaping
 N_FitCrvCubic Curve interpolation with NL_C1 nonrational cubic curves
 N_FitCrvCubicTangents Local NL_C1 cubic curve interpolation with end tangents
 N_FitCrvConics Curve interpolation with piecewise conic arcs
 N_FitCrvConicsApprox Data approximation with piecewise conic segments
 N_FitRemoveKnots Remove all removable knots from an approximating curve
 N_FitRemoveKnotsAndDerivs Remove all removable knots with derivative constraints
 N_FitRemoveKnotsPriorities Remove knots with derivative constraints and priorities
 N_FitCrvDerivMatrix Curve interpolation with end derivative and matrix
 N_FitCrvKnotsAndDeriv Curve interpolation with end derivative and knot vector
 N_FitCrvWeightedLstSq Weighted & constrained leastsquares curve approximation
 N_FitCrvWeightedLstSqPeriodic Weighted & constrained least squares periodic fit to points
 N_FitCrvWeightedLstSqKnots Weighted/constrained leastsquares with knot vector
 N_FitCrvApproxClosed Curve approximation to closed data with end conditions
 N_FitCrvApproxDerivs Global curve approximation with end derivatives
 N_FitFuncInterpGivenParams Function interpolation with given parameters
 N_FitCrvDerivsKnots Curve approximation with end derivatives and knots
 N_FitHermite Fit Hermite curve to end kth and (k+1)th derivatives
 N_FitCalcKnotsDerivs Knot vector for curve interpolation with all derivatives
 N_FitCalcKnotsEndDerivs Knot vector for curve approximation with end derivatives
 N_FitCalcKnotsRandom Knot vectors for random data approximation
 N_FitSrfCalcKnotVectors Compute knot vectors for surface approx to random points
 N_FitCalcKnotVectorDeriv Knot vector for curve interpolation with end derivative
 N_FitLocalCubicApprox Check scatter and compute local cubic approximant
 N_FitConicToPts Check scatter and compute local conic approximant
 N_FitCrvParabArcs Curve interpolation with piecewise parabolic arcs
 N_FitCrvLstSqEnds Least squares curve fit to points
 N_FitPtsNormals Fit surface to an array of points and normals
 N_FitRandomPN Fit surface to random set of points and normals.
 N_FitCalcMatrix Compute interpolation matrix for curve fitting
 N_FitSrfCalcParams Compute parameters for surface fit of random data
 N_FitCalcSrfParamsBoundary Compute parameters for surface fit of random data
 N_FitCalcSrfParamsBoundarySrf Parameters for surface fitting of random data
 N_FitSrfToPtsAndBoundary Surface approximation with boundary curves specified
 N_FitSrfApproxTol Surface approximation with error bound specified
 N_FitSrfToVariablePts Surface approximation to variable number of points
 N_FitSrfApproxShape Approximate random points based on surface shaping
 N_FitSrfApproxTangentsTol Surface approximation with error bounds and tangents
 N_FitSrfLstSqKnots Surface approximation with given knot vectors
 N_FitSmoothPts Smooth 3D points in preparation for curve fitting
 N_FitSrfInterpBoundary Surface interpolation to a nxm points and boundaries
 N_FitSrfInterpShape Interpolate points based on surface shaping
 N_FitSrfInterpTangents Surface interpolation with tangent constraints
 N_FitSrfToPtsKnots Surface interpolation with given knot vectors
 N_FitSrfInterpBicubic Surface interpolation with C11 bicubic surfaces
 N_FitSphereToPtsLocal Best fitting sphere to a set of points
 N_FitSrfInterpParams Parameterization for surface interpolation in u/vdis
 N_FitSphereToPtsGlobal Best fitting sphere to a set of points
 N_FitSrfLstSqBoundary Least squares surface approximation to random points
 N_FitSrfLstSqDerivs Least squares surface approximation to random points
 N_FitSrfLstSqPeriodic Periodic Least squares fit to random points
 N_FitSrfApproxRemoveKnots Remove all removable knots from an approximating surface
 N_FitSrfRemovalBoundary Update surface removal bound for surface fitting
 N_FitSrfInterpRemoveKnots Remove all removable knots from an interpolating surface
 N_FitSrfApproxRemoveKnotsTangents Remove all removable knots from an approximating surface
 N_FitSrfTangentError Tangent error for one knot removal for fitting
 N_FitSrfInterpVariablePts Surface interpolation to variable number of points
 N_FitCrvTangentsKnotsParams Curve approximation with end tangents, knots and pars
Approximations
 N_ApproxCrvWithArcs Approximate curve with circular arcs and biarcs
 N_CrvArePtsWithinTol Check error of biarc approximation
 N_ApproxCircArcWithCrv Approximate circle A full or arc with nonrational curve
 N_ApproxCrvOnSrfWithCrv Approximate curve on surface from uvcurve
 N_CalcNumCPtsToApproxArc Compute number of ctrl pts for circle approximation
 N_ApproxConeWithSrf Nonrational approximation of cylinder or cone
 N_ApproxArcWithCrv Nonrational approximation of a circle or arc
 N_ApproxCircArcWithCrvData Perform nonrational curve fit to circle data
 N_CrvApproxSpiral Cubic approximation of a spiral with error specified
 N_CrvOffsetFuncVariableDir Functional offset of curve using point sampling
 N_SrfOffsetFunc Functional offset of surface using point sampling
 N_ApproxNurbsWithNonRatCrv Approximate curve with nonrational curve
 N_ApproxNurbsWithCrvKnots Curve approximation with knot vector passed in
 N_ApproxNurbsWithNonRatSrf Approximate surface with nonrational surface
 N_ApproxG1CrvWithCrv Approximate any NL_G1 curve with nonrational curve
 N_GetPtsForCrvApprox Get points for approximation of curves
 N_CrvOffsetApprox Approximate offset of curve with nonrational curve
 N_CrvOffset Offset of curve
 N_CrvOffsetPtSampling Offset of curve using point sampling
 N_SrfOffset Offset of surface using point sampling
 N_ApproxProcCrvWithCrv Approximate procedural curve with error bound specified
 N_ApproxProcCrvWithCrvFit Fit procedural curve points with error bound specified
 N_GetPtsForCrvApproxProc Get points for approximation of procedural curve
 N_ApproxRevolvedSrfWithSrf Nonrational approaximation of surface of revolution
 N_ApproxSphereWithSrf Nonrational approximation of sphere
 N_SrfApproxSpiral Sweep a curve along a spiral ( or helix)
 N_ApproxSubSrfWithSrf Approximate subsurface bounded by 4 curves
 N_ApproxNormalSrfWithSrf Approximate unit normal of surface
 N_ApproxTorusWithSrf Nonrational approximation of a torus
Shaping
 N_CrvShapeApproxPts Shape curve to approximate given points
 N_CrvShapeApproxPtsUpdate Shape curve to approximate given points
 N_CrvShapeAxialDeform Axial deformations of curves
 N_CrvShapeBend Bend a curve
 N_CrvShapeDerivConstraintsOver Constraintbased curve shaping with interp or approx
 N_CrvShapeDerivConstraints Constraintbased curve modification
 N_CrvShapeFlatten Flatten a curve
 N_CrvShapeInterp Shape curve to interpolate given points
 N_CrvShapeModifyWeight Modify one curve weight
 N_CrvShapeRemoveKnots Remove all removable knots from a curve being shaped
 N_CrvShapeCreateBasis Make rational basis function for curve warping
 N_CrvShapeModifyCPts Reposition curve control points
 N_CrvShapeWarp Warp curve
 N_IsectCrvShapeLineCrv Linecurve intersection for bending
 N_SrfShapeAxialBend Surface axial bending
 N_SrfShapeApproxPts Shape surface to approximate given points
 N_SrfShapeAxialDeform Axial deformations of surfaces
 N_SrfShapeDerivConstraints Constraintbased surface shaping with interp or approx
 N_SrfShapeCentralBend Surface central bending
 N_SrfShapeConstraints Constraintbased surface modification
 N_SrfShapeFlatten Flatten a surface
 N_SrfShapeInterp Shape surface to interpolate given points
 N_SrfShapeModifyWeight Modify one surface weight
 N_SrfShapePolylineWarp Surface polyline warp
 N_SrfShapeRemoveKnots Remove all removable knots from a surface being shaped
 N_SrfShapeCreateRatBasis Make rational basis function for surface warping
 N_SrfShapeModifyCPts Reposition surface control points
 N_SrfShapeRegionWarp Surface region warp
Tools
 N_CrvRemoveKnotsParams Remove all removable knots from curve with constraints
 N_tooCrvCleanSpans: Curve remove excessive knots and control points
 N_CrvExtractSegClosed Extract a curve segment that crosses a curve closure
 N_CrvsMakeCompatible Make curves compatible
 N_CrvsMakeCompatibleKnotTol Make Curves compatible to a tolerance
 N_CrvDecomposeContinuity Decompose a curve into continuous pieces
 N_CrvsMakeCompatibleAdjKnots Make curves compatible using knot adjustment
 N_CrvReduceDegree Reduce the degree of a curve as much as possible
 N_CrvDecomposeBez Decompose a curve into Bezier pieces
 N_CrvElevateDegree Elevate the degree of a curve
 N_CrvReduceDegreeOnce Reduce the degree of a curve
 N_CrvInverseKnotInsert Curve inverse knot insertion
 N_CrvInsertKnot Insert a knot into a curve
 N_CrvRemoveKnots Remove all removable knots from a curve
 N_CrvRemoveKnotMaxErr Compute knot removal error bound
 N_CrvRefine Refine a curve with a given knot vector
 N_CrvRemoveKnot Remove one knot multiple times from a curve
 N_CrvExtractCrvSeg Extract a curve segment from a curve
 N_CrvSplit Split a curve at a given parameter
 N_tooCrvCleanSpans Curve remove excessive knots and control points
 N_MakeSrfsCompatible Make surfaces compatible in u,v or both
 N_SrfJoin Join two surfaces at a common boundary
 N_SrfRemoveDegenPatch Remove degenerate patch strips of a surface
 N_CrvRemoveDegenSegs Remove degenerate segments of a curve
 N_SrfExtractBoundaryCrvs Extract boundary curves from surface
 N_MakeSrfsCompatibleUV Make surfaces compatible
 N_SrfExtractIsoCrv Extract isocurve from surface
 N_SrfReduceDegreeToTol Reduce the degree of a surface as much as possible
 N_SrfDecomposeToBez Decompose a surface into Bezier patches
 N_SrfElevateDegree Elevate the degree of a surface
 N_SrfReduceDegree Reduce the degree of a surface
 N_SrfInsertKnotPt Surface inverse knot insertion
 N_SrfInsertKnot Insert a new knot into a surface
 N_SrfRemoveAllKnots Remove all removable knots from a surface
 N_SrfRemoveOneKnot Update surface removal bound
 N_SrfReplaceKnotVector Refine a surface with a given knot vector
 N_SrfRemoveKnotConditional Remove one knot from a surface multiple times
 N_SrfExtractPatch Extract a segment patch from a surface
 N_SrfSplit Split a surface at a given parameter
 N_CrvsMakeCompatibleApprox Make curves compatible using approximation
 N_CrvsMakeCompatibleKnotRemove Make curves compatible using approximation a err appr
 N_CrvsMakeCompatibleConstraints Make curves compatible with approximation & constraints
 N_CrvsMakeCompatibleFast Make curves compatible with approximation & constraint
 N_CrvRemoveAllKnotsArcLen Clean curve
 N_CrvFuncDecompose Decompose a curve function into Bezier pieces
 N_CrvFuncDegreeElevate Elevate the degree of a curve function
 N_CrvFuncInsertKnot Insert a knot into a function
 N_CrvFuncRefine Refine a curve function with a given knot vector
 N_CrvRemoveKnotsTangentConstraints Clean curve with end tangent control
 N_CrvRemoveAllKnotsConstraints Remove all removable knots from curve with constraints
 N_CrvRemoveKnotsDerivConstraints Remove all removable knots with end derivative constr
 N_CrvRefineToKnotVector Compute control points of refined curve
 N_CrvRemoveAllKnots Remove all removable knots from a curve err appr
 N_CrvMakeCompatibleWithSrf Make a curve and one direction of a surface compatible
 N_SrfRemoveAllKnotsArcLen Clean surface
 N_SrfReparmAndRemoveKnotsKeepBoundaries Clean surface with boundary constraints
 N_SrfFuncDecompose Decompose a surface function into Bezier patches
 N_SrfFuncDegreeElevate Elevate the degree of a surface function
 N_SrfFuncInsertKnot Insert a new knot into a bivariate function
 N_SrfFuncRemoveKnot Remove one knot multiple times from a surface function
 N_SrfFuncRefine Refine a surface function with a given knot vector
 N_SrfNetworkTopology Determine topology of regular network of surfaces
 N_SrfRemoveKnot Remove one knot to compute derivative change
 N_SrfRemoveKnotsConstraints Remove all removable knots with knot constraints
 N_SrfRemoveKnotMultiple Remove one knot from a surface multiple times
 N_SrfRemoveKnots Remove all removable knots from a surface err app
 N_SrfRemoveKnotsKeepBoundaries Remove knots from surface with boundary constraints
 N_SrfCrossBoundaryDerivErr Derivative error for one knot removal
Symbolic Operators
 N_CrvDiffCrvGetMaxChange Upper bound on the difference of two curves
 N_CrvGetMaxFirstDeriv Upper bound on first derivative of a curve
 N_CrvMoveKnotGetMaxChange Upper bound on curve change obtained by moving a knot
 N_MaxDiffTwoSrfs Upper bound on the difference of two surfaces
 N_SrfMaxFirstDeriv Upper bound on first derivative of a surface
 N_SrfMaxChangeMovingKnot Upper bound on surface change obtained by moving a knot
 N_SrfMax2ndDeriv Upper bound on second derivative of a surface
 N_CrossBoundDerivCrvNonRatSrf NONRATIONAL crossboundary derivative of a surface
 N_CrossBoundDerivCrvNurbsSrf Crossboundary derivative of a surface
 N_CrvGetDerivCrvsAll All derivative curves of a curve
 N_CrvMakeDerivCrv Compute kth derivative curve of a curve
 N_CrvNonRatEvalDeriv Derivative of NONRATIONAL curve with respect to a knot
 N_CrvEvalHighDerivsKnot Higher derivatives of NONRATIONAL curve wrt to a knot
 N_CrvEvalFirstDerivKnot First derivative of a curve with respect to a knot
 N_CrvCombine Combination of two curves
 N_CombineTwoSrfs Combination of two surfaces
 N_CrvNonRatGetDerivCrvsAll All derivative curves of a NONRATIONAL curve
 N_CrvNonRatGetFirstDeriv Derivative curve of a NONRATIONAL curve
 N_CrvSumDiffVector Sum/difference of a curve and a vector
 N_CrvGetMaxSecondDeriv Upper bound on second derivative of a curve
 N_CrvGetRatSecondDeriv Second derivative curve of a rational curve
 N_CrvRatGetFirstDeriv First derivative curve of a rational curve
 N_CrvFuncDeriv Derivative function of a curve function
 N_CrvFuncDerivKnot Derivative of function with respect to a knot
 N_CrvFuncHigherDerivKnot Higher derivatives of function wrt to a knot
 N_SrfFuncMultiplyConstant Product of constant and surface function
 N_MakeKnotsCompatible Merge knot vectors to have the same internal knots
 N_NormalSrfNurbsSrf_UU Normal surface of a surface
 N_CrvCrossMultiplyCrv Cross product of two curves
 N_CrvDotCrv Dot product of two curves
 N_CrossProductTwoSrfs Cross product of two surfaces
 N_CrvFuncMultiplyCrv4d Compute the product of a function and a curve in 4D
 N_CrvFuncMultiplyCrv Compute the product of a function and a curve
 N_CrvFuncMultiplyCrvFunc Compute the product of two univariate Bspline functions
 N_SrfFuncMultiplySrf Compute the product of bivariate function and surface
 N_ConstantMultiplyCrv4d Product of constant and curve in 4D
 N_ConstantMultiplyCrv Product of constant and curve
 N_CrvFuncMultiplyConstant Product of constant and curve function
 N_ConstantMultiplySrf Product of constant and surface
 N_DotProductTwoSrfs Dot product of two surfaces
 N_SrfFuncMultiplySrfFunc Compute the product of two bivariate Bspline functions
 N_CrvEvalSecondDerivKnot Second derivative curve of a rational curve wrt a knot
 N_CrvSumDiffCrv Sum/difference of two curves
 N_CrvFuncSumDiffCrvFunc Sum/difference of two curve functions
 N_AllDerivSrfNurbsSrf All derivative surfaces of a surface
 N_KDerivSrf Compute k,lth derivative surface of a surface
 N_SrfFuncDerivFunc Derivative function of bivariate Bspline function
 N_SrfFuncFuncDerivFuncAtKnot Derivative of surface function with respect to a knot
 N_DerivSrfNonRatSrfKnot Derivative of NONRATIONAL surface with respect to a knot
 N_DerivSrfRatSrfKnot First derivative of a surface with respect to a knot
 N_AllDerivSrfNonRatSrf All derivative surfaces of a NONRATIONAL surface
 N_FirstDerivSrfNonRatSrf Derivative surface of a NONRATIONAL surface
 N_SumDiffSrfVector Sum/difference of surface and vector
 N_FirstDerivSrfRatSrf First derivative surface of a rational surface
 N_SrfFuncSumDiffSrfFunc Sum/difference of two surface functions
 N_SumDiffTwoSrfs Sum/difference of two surfaces
 N_SecondDerivSrfRatSrf Second derivative surface A Suu of a rational surface
 N_MixedPartialDerivSrfRatSrf_UV Mixed partial derivative surface of a rational surface
 N_SecondDerivSrfRatSrf_VV Second derivative surface A Svv of a rational surface
Initialize and End
 N_EndNurbs Ends programming environment
 N_InitNurbs Initializes programming environment
Basis Functions
 N_SrfNonRatBasisDerivs All bivariate nonrational basis functions & derivatives
 N_CrvRatBasisDerivs All univariate rational basis functions and derivatives
 N_BasisDerivs Nonvanishing basis functions and their derivatives
 N_BasisEval Compute all nonvanishing basis functions
 N_BasisFindIndexNodeArray Compute the nodes of a given knot vector
 N_SrfRatBasisDerivs All bivariate rational basis functions and derivatives
 N_BasisIDerivs Compute one basis function and its derivatives
 N_BasisIEval Compute one basis function at a given parameter value
 N_CrvBasisDerivs All nonvanishing curve basis functions and derivatives
 N_BasisGetKnotsAndMults Return all distinct knots together with multiplicities
 N_BasisFindSpanAndMult Find knot span and multiplicity of given parameter
 N_BasisFindSpan Find knot span a given parameter value is in
 N_BasisFindGlobalMax Compute the maximum of a basis function
 N_GetCompatibleKnotArray Merge a set of knot vectors
 N_GetCompatibleKnotVector Merge internal parameters of a set of knot vectors
 N_BasisFindAllSpanMaxima Compute minmax of basis function over each span
 N_GetCompatibleKnotVectorToTol Merge a set of knot vectors using a tolerance
 N_BasisGetSpanCount Find number of nonzero spans in a knot vector
 N_CrvRatBasisIEval Evaluate univariate rational basis function
 N_CrvRatBasisIDerivs Evaluate univariate rational basis function derivatives
 N_SrfRatBasisIEval Evaluate bivariate rational basis function
 N_SrfRatBasisIDerivs Evaluate bivariate rational basis function derivatives
 N_SrfBasisDerivs All nonvanishing surface basis functions & derivatives
 N_BasisReparam Scale knot vector to a given interval
 N_BasisEvalArray All basis functions computed at an array of parameters
 N_BasisSplitLongestSpan Add knots to knot vector
 N_BasisKnotDerivs Derivatives of all nonvanishing basisf wrt to a knot
 N_BasisDerivsArray Basis functions and derivatives at various parameters
 N_CrvRatBasisKnotDeriv Derivatives of nonvanishing rat basis fs wrt to a knot
 N_BiBasisKnotDeriv Ders of all nonvanishing surface basisf wrt to a knot
 N_SrfRatBasisKnotDeriv Ders of rational bivariate basis functions wrt to a knot
 N_BasisIKnotDeriv Compute derivative of one basis function wrt to a knot
 N_CrvBasisIEval Evaluate basis function of curve
 N_BasisFindIndexNode Compute one node corresponding to a given index
 N_BasisFindKnotToTurnParamIntoNode Compute parameter to get a specified node
 N_BasisIncreaseKnotMult Increase multiplicity of internal knots
 N_GetCompatibleKnotArrayMult Merge knot vectors to have the same internal knots
 N_BasisFindNodeSpan Find node span a given parameter is in
 N_CrvRatBasisIKnotDeriv Univariate rational basis function derivative wrt a knot
 N_BasisInsertKnots Refine knot vector
 N_BasisSplitNLongestSpans Refine knot interval
 N_SrfRatBasisIKnotDeriv Bivariate rational basis function derivative wrt a knot
 N_SrfBasisIEval Evaluate basis function of surface
 N_BasisGetLongestAndShortestSpans Find smalest and largest nonzero spans in a knot vector
Geometry Processing
 N_ApproxCrvWithPolyline Piecewise linear polygonal approximation of a curve
 N_CrvArcLength Compute arc length of segment of curve
 N_CrvNurbsToPiecewise Convert curve into piecewise power basis form
 N_CrvPiecewiseToNurbs Convert a piecewise power basis curve to NURBS form
 N_CrvClosestPtMultiple Global curve point inversion/projection
 N_CrvPercentageAlongPt Compute point on the curve at given arc length
 N_CrvProjectPts Project points onto curve approximately
 N_CrvClosestPt Curve point inversion/projection using Newton’s method
 N_SrfGetClosestPt Surface point inversion/projection using Newton’s method
 N_ApproxSrfWithQuadSrf Piecewise quadrilateral approximation of surface
 N_SrfGetAverageLen Estimate surface measures lengths and area
 N_ConvertNurbsToPowerBasis Convert surface into piecewise power basis form
 N_ConvertPiecesToNurbs Convert a piecewise power basis surface to NURBS form
 N_InvertTangentSrfCrv Surface curve tangent vector inversion
 N_SrfReparamMultKnots Reparameterize curves with respect to arc length
 N_CrvReparamWeights Make curve end weights equal
 N_CrvFuncEvalInvertPt Curve function value inversion using Newton’s method
 N_SrfReparamFunc Reparameterize a curve with a Bspline function
 N_CrvReparamRat Curve reparameterization with linear rational function
 N_MapKnotsBetweenCrvFuncAndKnotVector Map knot vectors onto each other
 N_SrfProjectPts Global PointtoSurface projection
 N_SrfReparamArcLength Reparameterize surfaces with respect to arc length
 N_SrfReparamWeights Set curve end weights to given values
 N_SrfReparmRat Surface reparameterization with linear rational function
NL_IGES
 N_Iges100Arc Create circular arc from NL_IGES Entity 100 data
 N_Iges102CompositeCrv Create composite curve from NL_IGES Entity 102 data
 N_Iges104ConicArc Create conic arc from NL_IGES Entity 104 data
 N_Iges106LinearCrv Create degree 1 curve from NL_IGES Entity 106 data
 N_Iges108Plane Create bounded plane from NL_IGES Entity 108 data
 N_Iges100Line Create bounded line from NL_IGES Entity 110 data
 N_Iges112CrvNonRat Create Bspline curve from NL_IGES Entity 112 data
 N_Iges114NonRatSrf Create Bspline surface from NL_IGES Entity 114 data
 N_Iges118RuledSrf Create ruled surface from NL_IGES Entity 118 data
 N_Iges120RevolvedSrf Create revolved surface from NL_IGES Entity 120 data
 N_Iges122ExtrudedSrf Create extruded surface from NL_IGES Entity 122 data
 N_Iges124Matrix 4×4 transformation matrix from NL_IGES Entity 124 data
 N_Iges126Crv Create curve from NL_IGES Entity 126 data
 N_Iges128Srf Create surface from NL_IGES Entity 128 data
 N_IgesClampCrv Clamp an NL_IGES 126 curve to its bounds
 N_IgesCorrectCrvKnots Sanitize curve knots for NL_IGES Entity 126
 N_IgesNonPeriodicCrv Convert periodic curve to nonperiodic, unclamped curve
 N_IgesNonPeriodicCPts Convert periodic ctrl pts to unclamped, nonperiodic form
 N_IgesNonPeriodicKnots Convert periodic knots to unclamped, nonperiodic form
 N_IgesNonPeriodicSrf Convert periodic surface to nonperiodic, unclamped surf
 N_IgesClampSrf Clamp an NL_IGES 128 surface to its bounds
 N_IgesCorrectSrfKnots Sanitize surface knots for NL_IGES Entity 128
 N_IgesValidate Validate NL_IGES Entities 126 and 128 knots and bounds data
Tessellation
 N_TessGetTriangleEdges Return all edges forming edges in a triangulation
 N_TessGetTriangleVertices Return all points forming vertices in a triangulation
 N_TessGetTriangles Return all triangles in a surface triangulation
 N_TessTrimmedSrf Tessellate a trimmed surface
Storage
 N_AllocCPt1dArray Allocate memory for a control point array
 N_AllocCPtPtr1dArray Allocate memory for 1D array of control point pointers
 N_AllocCPt2dArray Allocate memory for a 2D control point array
 N_AllocCPtPtr2dArray Allocate memory for 2D array of control point pointers
 N_AllocCrvFuncArray Allocate memory to store a 1D array of curve functions
 N_AllocCrvFunc Allocate memory to store a curve function
 N_AllocCrvFuncStack Allocate memory for a curve function structure
 N_AllocCPtMatrix Allocate memory to store a control point matrix
 N_XYZToCPtArray Control point array from its wx,wy,wz,w components
 N_XYZTo2dCPtArray 2D control point array from its wx,wy,wz,w components
 N_Alloc2dArrayCrvPtrs Allocate memory for a 2D array of curve pointers
 N_AllocArrayCrvPtrsAndData Allocate array of curve pointers structures allocated
 N_Alloc1dArrayCrvs Allocate memory to store a 1D array of curves
 N_AllocArrayCrvPtrs Allocate memory to store an array of curve pointers
 N_AllocArrayRealCrvPtrs Get memory to store an array of double curve pointers
 N_AllocArrayTripleCrvPtrs Get memory to store an array of triple curve pointers
 N_AllocCrvAndArrays Allocate memory to store a curve
 N_AllocCrv Allocate memory for a curve structure
 N_AllocCValue Allocate memory for a curve value structure
 N_AllocCValueAndArray Allocate memory to store curve value object
 N_AllocFlag1dArray Allocate memory for a flag array
 N_AllocFlagPtr1dArray Allocate memory for a 1D array of flag pointers
 N_AllocFlag2dArray Allocate memory for a 2D flag array
 N_AllocInt1dArray Allocate memory for an integer array
 N_AllocIntPtr1dArray Allocate memory for a 1D array of integer pointers
 N_AllocInt2dArray Allocate memory for a 2D integer array
 N_AllocIntPtr2dArray Allocate memory for a 2D array of integer pointers
 N_AllocIntMatrix Allocate memory to store an integer matrix
 N_Alloc1dArrayKnotVectors Allocate memory to store a 1D array of knot vectors
 N_AllocKnotVector Allocate memory for a knot vector structure
 N_AllocKnotVectorAndArray Allocate memory to store a knot vector object
 N_Alloc1dArrayKnotVectPtrs Allocate memory to store knot vector pointer array
 N_AllocCNet Allocate memory for control net structure
 N_AllocCNetAndArrays Allocate memory to store a control net object
 N_AllocPt1dArray Allocate memory for a point array
 N_AllocPtPtr1dArray Allocate memory for a 1D array of point pointers
 N_AllocPt2dArray Allocate memory for a 2D point array
 N_AllocPtPtr2dArray Allocate memory for a 2D array of point pointers
 N_AllocVariable2dPtArray Allocate memory for a variable 2D point array
 N_AllocPtMatrix Allocate memory to store a point matrix
 N_XYZToPtArray Create a point array from its x,y,z components
 N_AllocCPolygonAndArray Allocate memory to store a polygon object
 N_XYZTo2dPtArray Create a 2D point array from its x,y,z components
 N_AllocCPolygon Allocate memory for a polygon structure
 N_AllocRealPtr3dArray Allocate memory for a 1D array of double pointers
 N_AllocReal1dArray Allocate memory for a real array
 N_AllocRealPtr1dArray Allocate memory for a 1D array of real pointers
 N_AllocReal2dArray Allocate memory for a 2D real array
 N_AllocRealPtr2dArray Allocate memory for a 2D array of real pointers
 N_AllocReal3dArray Allocate memory for a 3D real array
 N_AllocReal4dArray Allocate memory for a 4D real array
 N_AllocRealMatrix Allocate memory to store a real matrix
 N_Alloc2dArraySrfFunc Allocate memory for a 2D array of surface functions
 N_AllocSrfFunc Allocate memory to store a surface function
 N_AllocSrfFuncData Allocate memory for a surface function structure
 N_Alloc2dArraySrfPtrs Allocate memory for a 2D array of surface pointers
 N_AllocArraySrfPtrsInit Allocate array of surface pointers structures allocated
 N_Alloc2dArraySrfPtrsParameters Allocate memory for a 2D array of surfaces
 N_AllocArraySrfPtrs Allocate memory for an array of surface pointers
 N_AllocSrfAndArrays Allocate memory to store a surface
 N_AllocSrf Allocate memory for a surface structure
 N_AllocSValue Allocate memory for a surface value structure
 N_AllocSValueAndArray Allocate memory to store surface value object
Utilities
 N_CrvsAreCombatible Are curves compatible?
 N_CPtsAreEqual Are control points equal
 N_CrvsAreCoincident Are curves coincident?
 N_CrvAreWeightsEqual Are curve weights equal
 N_SrfsAreCoincident Are surfaces coincident?
 N_SrfAreWeightsEqual Are surface weights equal
 N_CFuncGetData Break curve function down to its components
 N_CFuncSizeArrays Check if memory is needed to store curve function
 N_CrvFuncCompact Compact curve function arrays
 N_CrvFuncCopy Copy a Bspline function
 N_CFuncGetArrayAndKnotVector Get control value and knot vector objects from function
 N_CrvFuncCntrlVal Get control values from curve function object
 N_CFuncGetDegree Get degree of curve function
 N_CrvFuncCntrlValKnotVector Get control values, knot vector and knots from function
 N_CrvFuncCntrlValKnots Get control values and knots from curve function object
 N_CFuncGetArraySizes Get highest indexes in curve function object
 N_CFuncGetKnotVector Get knot vector object from curve function
 N_CFuncGetKnots Get curve function knot vector information
 N_CrvFuncReparam Scale curve function knot vector to given interval
 N_CrvFuncSetPtrs Set control value and knot vector of curve function
 N_CreateCrvFromCoordFuncs Make curve from coordinate functions
 N_CreateSrfFromCoordFuncs Make surface from coordinate functions
 N_CrvWriteIgesCPolygon Create NL_IGES file for curve visualization
 N_Crv2dTo3d Convert a 2D curve to a 3D curve
 N_Crv3dTo2d Convert a 3D curve to a 2D curve
 N_CrvGetCPtsDegreeAndKnots Break curve down to its components
 N_CrvSizeArrays Check if memory is needed to store a curve
 N_CrvCompress Compact curve control point and knot vector arrays
 N_CrvCopy Copy a curve
 N_CrvGetCoordFuncs Extract coordinate functions from curve
 N_CrvGetDegree Get degree of curve
 N_CrvMakeNonRat Map rational curve to Euclidean space
 N_CrvGetArraySizes Get highest indexes in curve object
 N_CrvGetKnotVector Get knot vector object from curve
 N_CrvGetKnots Get knot vector info from curve object
 N_CrvReparamToInterval Scale curve knot vector to given interval
 N_CrvGetNumAndDenom Extract numerator and denominator from curve
 N_CrvNonRatToRat Convert a nonrational curve to a rational curve
 N_CrvGetParamBounds Get parameter bounds from curve object
 N_CrvClampKnot Clamp curve parameter
 N_CrvGetCPtsKnotVectorAndKnots Get control points, knot vector and knots from curve
 N_CrvGetCPts Get control polygon info from curve object
 N_CrvDetachPolygonKnot Detach polygon and knot vector objects from curve
 N_CrvGetCPtsAndKnots Get control points and knots from curve object
 N_CrvRatToNonRat Convert a rational curve to a nonrational curve
 N_CrvPruneRat Prune a curve
 N_CrvSetCPtsAndKnots Set control point and knot vector pointers of curve
 N_CrvWriteIges Create NL_IGES file containing Entity 126 curves
 N_CFuncSetSizeIndices Set parameters in curve function definition
 N_CrvSetSizeIndices Set parameters in curve definition
 N_SetKnotIndex Set index in knot vector definition
 N_SFuncSetSizeIndices Set parameters in surface function definition
 N_SrfSetSizeIndices Set parameters in surface definition
 N_SrfIsSingular Does surface have a pole?
 N_CrvGetDenomCrvFunc Extract denominator of a rational curve
 N_SrfGetDenominatorFunc Extract denominator of a rational surface
 N_AllocCrvFuncArray Allocate memory to store curve function
 N_AllocCrvAndArrays Allocate memory to store curve control points and knots
 N_AllocSrfFuncArray Get memory to store NL_SFUN control points and knots
 N_AllocSrfAndArrays Get memory to store surface control points and knots
 N_AllocCrvFunc Initialize a curve function to NULL
 N_CrvInitArrays Initialize a curve to NULL
 N_CrvProjectionInitArrays Initialize a global curve projector structure to NULL
 N_SFuncInitArrays Initialize a surface function to NULL
 N_SrfInitArrays Initialize a surface to NULL
 N_CrvArrayReadFromFile Create an array of curves from data saved in a file
 N_CrvReadFromFilePtr Read curve from file file pointer passed in
 N_CrvReadFromFile Create curve from data saved in a file
 N_Read1dPtFromFile Read in 1D NL_POINT data from file
 N_Read2dPtFromFile Read in 2D NL_POINT data from file
 N_SrfReadFromFile Read surface from file file pointer passed in
 N_CreateSrfFromDataFile Create surface from data saved in a file
 N_CrvAreFuncArraysNULL Is curve function initialized to NULL?
 N_Crv4dIsDegen Is curve degenerated to a point in 4D?
 N_CrvIs3d Is curve three dimensional?
 N_CrvIsClosed Is curve closed?
 N_CrvIsPlanar Is curve planar flat
 N_CrvIsLine Is curve a line
 N_CrvAreArraysNULL Is curve initialized to NULL?
 N_CrvIsDegen Is curve degenerate to a point?
 N_IsCrvRat Is curve rational?
 N_CrvIsInZ0Plane Does curve lie in the z=0 plane?
 N_IsPtSet1dCircular Is 1D point set cocircular
 N_1dPtSetIsClosed Is 1D point set closed?
 N_IsPtSet1dColinear Is 1D point set colinear
 N_IsPtSet1dCoplanar Is 1D point set coplanar
 N_IsPtSet1dSpherical Is 1D point set cospherical
 N_2dPtSetIsClosed Is 2D point set closed?
 N_SrfIsFlatCheap Is surface flat?
 N_SrfAreFuncArraysNULL Is surface function initialized to NULL?
 N_SrfIsClosed Is surface closed?
 N_SrfIsFlat Is surface flat?
 N_SrfAreArraysNULL Is surface initialized to NULL?
 N_SrfIsDegen Is surface degenerate to a point?
 N_IsSrfRat Is surface rational?
 N_FreeCPt1dArray Release memory that stores a control point array
 N_FreeCPt2dArray Release memory that stores a 2D control point array
 N_FreeCrvFunc Release memory that stores curve function
 N_FreeCrv Release memory that stores curve data
 N_FreeCValue Release memory that stores control value structure
 N_FreeFlag1dArray Release memory that stores a flag array
 N_FreeFlag2dArray Release memory that stores a 2D flag array
 N_FreeInt1dArray Release memory that stores an integer array
 N_FreeIntPtr1dArray Release memory that stores an array of integer pointers
 N_FreeInt2dArray Release memory that stores a 2D integer array
 N_FreeIntPtr2dArray Release memory that stores a 2D array of int pointers
 N_FreeKnotVector Release memory that stores knot vector structure
 N_FreeCNet Release memory that stores control net structure
 N_FreePt1dArray Release memory that stores a point array
 N_FreePt2dArray Release memory that stores a 2D point array
 N_FreeCPolygon Release memory that stores control polygon structure
 N_FreeReal1dArray Release memory that stores a real array
 N_FreeReal2dArray Release memory that stores a 2D real array
 N_FreeReal3dArray Release memory that stores a 3D real array
 N_FreeSrfFuncData Release memory that stores surface function data
 N_FreeSrf Release memory that stores surface data
 N_FreeSValue Release memory that stores control value structure
 N_KnotsAdd Add knots to a knot vector
 N_KnotVectorGetKnots Break knot vector object down to its components
 N_KnotsCheck Check if memory is needed to store a knot vector
 N_KnotsCopy Copy a knot vector
 N_KnotsRefine refine knot vector base on Greville spans and parameters
 N_WriteLineCrvSrfIges Create NL_IGES file containing Entities 110, 126 and 128
 N_CrvsMakeRatCompatible Make curve definitions compatible
 N_CFuncFromKnotVector Curve function structure from control value and knot vector
 N_CFuncFromKnots Make curve function from control values and knot vector
 N_CreateCrvFromPowerBasis Make curve polynomial defined in power basis form
 N_CrvFromCPolygonAndKnotVector Make curve structure from control polygon and knot vector
 N_CrvFromCPtsAndKnots Make curve structure from control points and knot vector
 N_CrvFromCPtCoordsAndKnots Make curve structure from wx,wy,wz,w and knot vector
 N_CValueFromArray Make curve function control value structure
 N_KnotVectorFromRealArray Make knot vector structure
 N_CNetFromCPts Make control net structure
 N_CNetFromCPtCoords Make control net structure from control points
 N_CPolygonFromCPts Make control polygon structure
 N_CPolygonFromCPtCoords Make polygon structure from control points
 N_MakeSrfsRatCompatible Make surface definitions compatible
 N_SFuncFromKnotVectors Surface function from contr value and knot vector objects
 N_SFuncFromKnots Surface function from control values and knot vectors
 N_CreateSplineSrf Make surface polynomial defined in power basis form
 N_SrfFromCNetAndKnotVectors Make surface structure given a net and two knot vectors
 N_SrfFromCPtsAndKnots Make surface from control points and knot vector
 N_SrfFromCPtCoordsAndKnots Make surface from wx,wy,wz,w and knot vectors
 N_SValueFromArray Make surface function control value structure
 N_SrfGetENet Map control net to Euclidean space
 N_CrvGetEPolygon Map control polygon to Euclidean space
 N_CreateCrvFromNumAndDenom Make curve from numerator and denominator
 N_CreateSrfFromNumAndDen Make surface from numerator and denominator
 N_CNetGetCPts Break control net object down to its components
 N_CrvArrayWriteToFile Create curve array file
 N_CrvWriteToFilePtr Write curve to file file pointer passed in
 N_CrvWriteToFile Create curve file
 N_Write1dPtToFile Write 1D NL_POINT data to a file
 N_Write2dPtToFile Write 2D NL_POINT data to a file
 N_SrfWriteToFile Write surface to file file pointer passed in
 N_WriteSrf Create surface file
 N_CPolygonGetCPts Break polygon object down to its components
 N_CrvFuncPrint Print curve function data out to the standard output
 N_CrvPrint Print curve data out to the standard output device
 N_KnotsPrint Print knot vector data to the standard output
 N_SrfFuncPrint Print surface function data to the standard output
 N_PrintSrfData Print surface data out to the standard output device
 N_WritePtsIges Create NL_IGES file for point set visualization
 N_Realloc1dCPtArray Reallocate memory for 1D control point array
 N_Realloc2dCPtArray Reallocate memory for 2D control point array
 N_Realloc1dFlagArray Reallocate memory for 1D flag array
 N_Realloc2dFlagArray Reallocate memory for 2D flag array
 N_Realloc1dIntArray Reallocate memory for 1D integer array
 N_Realloc1dIntPtrArray Reallocate memory for a 1D array of integer pointers
 N_Realloc2dIntArray Reallocate memory for 2D integer array
 N_Realloc2dIntPtrArray Reallocate memory for a 2D array of integer pointers
 N_Realloc1dPtArray Reallocate memory for 1D point array
 N_Realloc2dPtArray Reallocate memory for 2D point array
 N_Realloc1dRealArray Reallocate memory for 1D real array
 N_Realloc2dRealArray Reallocate memory for 2D real array
 N_SFuncGetComponents Break surface function down to its components
 N_SFuncSizeArrays Check if memory is needed to store a surface function
 N_SrfFuncCompact Compact NL_SFUN control value and knot vector arrays
 N_SrfFuncCopy Copy a surface function
 N_SFuncGetDegrees Get degree of surface function
 N_SFuncGetKnots Control values and knots from surface function object
 N_SFuncGetArraySizes Get highest indexes in surface function structure
 N_SFuncGetKnotVectors Get knot vector object from surface function
 N_SrfFuncGetKnots Get knot vectors info from surface function object
 N_SrfFuncScale Scale surface function knot vectors to given rectangle
 N_SrfFuncSetPtrs Set control value and knot vector pointers of NL_SFUN
 N_SFuncGetArrayAndKnotVectors Get control value and knot vector objects from NL_SFUN
 N_SrfFuncCntrlVal Get control values from surface function object
 N_PrintStack Show memory stack
 N_WriteSrfIges Create NL_IGES file for surface visualization
 N_SrfGetCPtsDegreesAndKnots Break surface down to its components
 N_SrfSizeArrays Check if memory is needed to store a surface
 N_SrfCompress Compact surface control point and knot vector arrays
 N_SrfCopy Copy a surface
 N_SrfGetCoordFuncs Extract coordinate functions from surface
 N_SrfGetDegrees Get degrees of surface
 N_SrfMakeNonRat Map rational surface to Euclidean space
 N_SrfGetArraySizes Get highest indexes in surface structure
 N_SrfGetKnotVectors Get knot vector objects from surface
 N_SrfGetKnots Get knot vectors info from surface object
 N_SrfReparamToInterval Scale surface knot vectors to given rectangle
 N_SrfGetNumAndDen Extract numerator and denominator from surface
 N_SrfGetCPts Get control net info from surface object
 N_SrfGetNetAndKnotVectors Detach control net and knot vector objects from surface
 N_SrfNonRatToRat Convert a nonrational surface to a rational surface
 N_SrfGetParameterBounds Get parameter bounds from surface object
 N_ClampSrfAtParams Clamp surface parameters
 N_SrfGetCPtsKnotVectorAndKnots Get control points, knot vectors and knots from surface
 N_SrfGetCPtsAndKnots Get control points and knots from surface object
 N_SrfRatToNonRat Convert a rational surface to a nonrational surface
 N_SrfPruneRat Prune a rational surface
 N_SrfSetCPtsAndKnots Set control point and knot vector pointers of surface
 N_WriteSrfToIgesFile Create NL_IGES file containing Entity 128 surfaces
 N_SwapUV Swap u and v direction in surface definition