# Functions

## Creation of Common Curves

- Circles and circular arcs

N_CreateCircArc – Create a circle/circular arcN_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 semi-circle

N_CreateBoundedCircArc – Create Bezier cubic/quartic circular arc <=180 degrees

N_ApproxCircArcWithCrv – Approximate circle full or arc with non-rational curve

- Conics and conic arcs

N_CreateEllipticalArc – Create a ellipse/elliptical arcN_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 patchN_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 – Non-rational approximation of surface of revolution

N_ApproxSphereWithSrf – Non-rational approximation of sphere

N_ApproxTorusWithSrf – Non-rational 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 curvesN_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/patchN_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 curve-based surface skinning

- Approximative skinning with error bound specified yields impressive data reduction

N_CreateSkinSrf – General surface skinningN_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 cross-boundary 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 surfaceN_CreateSweepScale – Swept NURBS surface with boundary conditions

- Gordon surface through a compatible curve network

N_CreateGordonSrf – Gordon surface through compatible non-rational curves

- Bilinear Coons surface

N_CreateCoonsSrf – Bilinear Coons surface through four boundary curves

- Bicubic Coons surface

N_CreateCoonsBoundaryCrvs – Bicubic Coons surface through boundary and derivativesN_CreateCoonsSrfTwist – Bicubic Coons surface through four boundary curves

- N-sided patch

N_FillNSidedHole – N-sided 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 degreeN_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 specifiedN_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 least-squares curve approximationN_FitCrvWeightedLstSqPeriodic – Weighted/constrained least-squares periodic with knot vector

N_FitCrvWeightedLstSqKnots – Weighted/constrained least-squares 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 – Non-rational approximation of cylinder or cone

N_ApproxArcWithCrv – Non-rational 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 curveN_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 uv-domain curve onto its surface

N_ApproxCrvOnSrfWithCrv – Approximate curve on surface from uv-curve

- Approximation of a curve with a nonrational curve of specified degree

N_ApproxNurbsWithNonRatCrv – Approximate curve with non-rational curveN_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 degreesN_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 degreeN_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 samplingN_SrfOffset – Offset of surface using point sampling

- Approximation of a surface with a nonrational surface of specified degree

N_ApproxNurbsWithNonRatSrf – Approximate surface with non-rational surface

- Global weighted and constrained least squares curve approximation arbitrary degree
- Local NL_C1-continuous non-rational cubic curve interpolation

N_FitCrvCubic – Curve interpolation with NL_C1 non-rational cubic curves

- Local NL_G1- or NL_C1-continuous parabolic curve interpolation

N_FitCrvParabArcs – Curve interpolation with piecewise parabolic arcs

- Local NL_G1-continuous rational quadratic curve interpolation

N_FitCrvConics – Curve interpolation with piecewise conic arcs

- NL_G1-continous bi-arc curve interpolation

N_FitCrvArcs – Curve interpolation with piecewise circular arcs

- Local data approximation with NL_G1-continuous quadratic curves

N_FitCrvConicsApprox – Data approximation with piecewise conic segments

- Local data approximation with NL_G1-continuous cubic curves
- Global curve approximation / data reduction with error bound specified arbitrary degree
- Local NL_C1,1-continuous non-rational 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 curveN_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 surfaceN_SrfDerivs – Compute derivatives of a surface

- Compute the surface normal vector at a given point

N_SrfEvalPtPtDerivNormal – Compute the surface normal at given parameter valuesN_SrfEvalPtNormalDeriv – Compute 1st and 2nd derivatives of UNIT surface normal

- Compute curvature on curves and surfaces

N_CrvGetCurvatureDeriv – Compute derivative of curvature of curveN_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 – Cross-boundary derivative from surface, end twists and derivativesN_CrossBoundaryDerivsVectorField Cross-boundary 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 placeN_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 planeN_SrfProjectOntoPlane – Project a surface onto a plane

- Reposition curve/surface control points to obtain desired translational changes

N_CrvShapeModifyCPts – Reposition curve control pointsN_SrfShapeModifyCPts – Reposition surface control points

- Modify curve/surface weights to obtain desired perspective changes
- Curve warping

N_CrvShapeWarp – Warp curveN_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 – Constraint-based curve shaping with interp or approx

N_FitCrvShape – Interpolate points based on curve shaping

- Surface region warping and polyline warping

N_SrfShapeRegionWarp – Surface region warpN_SrfShapePolylineWarp – Surface polyline warp

- Curve flattening

N_CrvShapeFlatten – Flatten a curve

- Surface modification

N_SrfShapeFlatten – Flatten a surfaceN_SrfShapeApproxPts – Shape surface to approximate given points

N_SrfShapeDerivConstraints – Constraint-based 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 bendingN_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 surfacesN_FitSrfApproxShape – Approximatte random points based on surface shaping

N_FitSrfInterpShape – Interpolate points based on surface shaping

- Constraint-based curve modification via control point repositioning

N_CrvShapeDerivConstraints – Constraint-based curve modification

- Constraint-based surface modification via control point repositioning

### Geometric Tools

- Knot insertion and knot refinement curves and surfaces

N_CrvInsertKnot – Insert a knot into a curveN_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 insertionN_SrfInsertKnotPt – Surface inverse knot insertion

- Decomposition into piecewise Bezier form curves and surfaces

N_CrvDecomposeBez – Decompose a curve into Bezier piecesN_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 curveN_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 curveN_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 curveN_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 parameterN_SrfSplit – Split a surface at a given parameter

- Extraction of isoparametric curves from surfaces

N_SrfExtractIsoCrv – Extract iso-curve from surface

- Reparameterize a curve

N_SrfReparamMultKnots – Reparameterize curves with respect to arc lengthN_SrfReparamFunc – Reparameterize a curve with a B-spline 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 lengthN_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 formN_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 formN_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/projectionN_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 curveN_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 conicN_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 min-max box of a curveN_SrfGetBBox – Compute min-max box of a surface

- Make a set of curves or surfaces compatible same degrees and knots

N_CrvsMakeCompatible – Make curves compatibleN_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 curveN_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 surfaceN_SrfEvenSpacedPts – Compute equally spaced points on a surface

### Scalar-valued Functions of One or Two Variables

- Creation of scalar-valued NURBS
- Functions of 1 or 2 parameters
- Evaluation of scalar-valued functions, including derivatives of any order

### A Complete Set of Functions to Process Bezier Curves and Surfaces

### B-spline and Basis Functions

Evaluation of rational and non-rational 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 low-level 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 uv-mapping 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 non-rational BSplines.
- The surface properties. The output surface properties include the surface’s U and V-direction 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 cross-tangent constraints
- boundary curve higher-order cross-tangent curve constraints.
- internal point position constraints.
- internal point normal constraints.
- internal point cross-tangent constraints.

- The uv-mapping. An assignment of a surface UV-point to every point in the input point set. This is the hard part of point fitting. A good uv-mapping of a point set will yield a good fitted surface and a bad uv-mapping will yield a mangled surface. There is not general algorithm that will find the best uv-mapping for an arbitrary set of sample points. As such, the NLib fitting package supports several different schemes for computing uv-mappings and allows uv-mapping to be passed as input when the calling functions can compute a good uv-mapping on their own.

Point fitting works well when enough sample points are known to characterize the desired surface and a good uv-mapping is found.

### Point Sets

The more known about the shape of the points set, the more likely it is to find a good uv-mapping. As such, the NLib fitting functions support three different kinds of point sets.

- Grid-of-Points point sets. A grid-of-points 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 grid-of-points 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[i-1][j] and Point[i+1][j] and is connected in the v direction to points Point[i][j-1] and Point[i][j+1].
- Rows-of-Points point sets. A column-of-Points point set is similar to the grid-of-points, 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 cross-sections sampled at regular intervals and due to the shape of the surface, the number of sample points in each cross-section 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[i-1][j] and Point[i+1][j].
- Cloud-of-Points point sets. A cloud-of-points 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 uv-mappings for cloud-of-points point sets is problematic.

### Building UV-Mappings

Different uv-map 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 uv-mapping.

UV-Map construction for Grid-of-Points. Each row and column of the grid-of-points point set is mapped to a iso-parameter 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 grid-of-points arrays and each sample point uv-value 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 square-root 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 uv-mapping for the best fit-surface depends on the sample points. If little is known about the sample points it seems the most generally robust approach is the Chordlength approach.

### UV-Map Construction for Rows-of-Points

Each row (not the columns) of a Column-of-Points 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.

### UV-Map Construction for Cloud-of-Points

All uv-maps made for Clouds-of-Points 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 cross-tangents 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 uv-mapping. 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 cross-derivative interpolation and internal point cross-tangent 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 knot-vectors and a given uv-mapping 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.

### UV-Map and Knot Vector Building

N_FitCalcSrfParamValues compute grid-of-points uv-mapping using a uniform, chordlength, or centripetal rule.

N_FitSrfInterpParams compute u or v param values for grid-of-points using equal spacing, chordlength, or centripetal rule.

N_FitSrfCalcParams compute cloud-of-points uv-mapping by projecting points to a best-fit or input plane.

N_FitCalcSrfParamsBoundary compute cloud-of-points uv-mapping by mapping to a base surface made as a blended coons patch from given boundary curves.

N_FitCalcSrfParamsBoundarySrf compute cloud-of-points uv-mapping 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 grid-of-points with given uv-mapping to a nurbs surface with one control point for each grid point.

N_FitSrfInterpBicubic interpolate grid-of-points with a C11 bicubic nurbs fill of the data.

N_FitSrfFuncInterp interpolate grid-of-points with given uv-mapping to a nurbs surface function with one control point for each grid point.

N_FitSrfInterpVariablePts interpolate rows-of-points with nurbs surface of specified degree and a param that trades off interpolant quality with number of control points

N_FitSrfInterpBoundary interpolate cloud-of-points and boundary curves and optional uv-mapping with nurbs surface.

N_FitSrfInterpShape interpolate cloud-of-points, boundary curves, and optional cross-tangent boundary constraints to a tolerance with a nurbs surface algorithm finds uv-mapping, knot vectors, and control points using input boundary curve properties as a start.

### Approximating Functions

N_FitSrfToPts fit grid-of-points to a nurbs surface of specified degrees. The algorithm finds the uv-mapping, knotVectors, and ControlPoint counts.

N_FitSrfApproxTol fit grid-of-points to given tolerance with nurb surface of specified degrees. The algorithm finds uv-mapping, knotVectors, and ControlPoint counts.

N_FitSrfLstSqApprox fit grid-of-points to a nurbs surface of specified degrees and ControlPoint counts. The algorithm finds the uv-mapping and knot vectors.

N_FitSrfLstSqKnots fit grid-of-points with given uv-mapping to a nurbs surface of specified degrees, knotVectors, and ControlPoint counts.

N_FitSrfInterpTangents fit grid-of-points with optional boundary cross-tangent direction or vector constraints (i.e. magnitude either free or fixed) with a nurbs surface. The uv-mapping 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 grid-of-points with optional boundary cross-tangent constraints with a nurbs surface of specified degrees. The algorithm finds the uv-mapping and ControlPoint counts.

N_FitSrfToPtsAndBoundary; fit grid-of-points with nurbs surface defined by given boundary curves, optionally allow extra knots to tighten fit

N_FitSrfToVariablePts fit rows-of-points with a dense nurbs surface of specified degree followed by knot removal algorithm finds uv-mapping, knotVectors, and ControlPoint counts

N_FitSrfApproxShape fit cloud-of-points, boundary curves, and optional cross-tangent boundary constraints to a tolerance with a nurbs surface algorithm finds uv-mapping, 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 cloud-of-points to best fitting planar patch

N_FitSphereToPtsGlobal fit cloud-of-points to best fitting sphere or planar patch, sphere segmented globally

N_FitSphereToPtsLocal fit cloud-of-points 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 Re-weight 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 4-D
- 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 2-D 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 Least-squares 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 Non-zero 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 Non-zero elements of power basis conversion matrix
- N_BezCalcArcLength Recursive procedure for Bezier arc lenth computation
- N_BezGetReparamMatrix Non-zero 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 min-max 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 2-D 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 4-D
- 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 2-D
- 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 2-D
- 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 point-vector form
- N_PlaneImplicitToPtNormal Implicit equation of plane to point-normal 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 grid-in-polygon gravity field test
- N_PtsAreInPolygon Point grid-in-polygon test
- N_EPolygonIsClosed Is polygon closed?
- N_PtIsContainedByEPolygon Point-in-polygon 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 Line-point side test
- N_LinePtVectorToImplicit Point-vector definition of 2D line to implicit form
- N_CreateCircFrom2dPts Least-squares 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 Least-squares line to a set of 2D points
- N_LineFit3dPts Least-squares line to a set of 3D points
- N_FitPlanePts Best-fit plane to a set of 3D points
- N_SphereFit3dPts Leas-squares 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 Point-normal definition of plane to implicit form
- N_PlaneGetNormal Get normal vector of plane
- N_PtGetSideOfPlane Plane-point side test
- N_Pts1dCalcBBox Compute the min-max box of a 1-D point array
- N_Pts1dGetMaxExtent Compute maximum extent of 1-D point array
- N_Pts2dCalcBBox Compute the min-max box of a 2-D point array
- N_Pts2dGetMaxExtent Compute maximum extent of 2-D point array
- N_PairSelected2dPts Find k closest points to given point in 2-D point set
- N_Order3dPts Order points along a 3-D 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 2-D point set
- N_Scale2dPts Scale 2-D point set
- N_Shear2dPts Shear 2-D point set
- N_Translate2dPts Translate 2-D point set
- N_CreateTranslationMatrixFromPts Compute translation matrix
- N_CreateTransformMatrixFromVectors Compute matrix to take one 2-D 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 2-D vectors
- N_VectorDiffCPts Difference vector between two control points in 3-D
- 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 2-D 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 1-D integer array
- N_MinMax2dIntArray Minimum or maximum of 2-D 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 scalar-valued function of 1 variable
- N_PascalTriIndex Compute i-th row of Pascal triangle from i-1th 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 1-D real array
- N_MinMax2dRealArray Minimum or maximum of 2-D 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 5-point Akima method
- N_TangentVectorBessel Compute a tangent vector via the 3-point 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 semi-circle
- 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 min-max 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_G1-continuous 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 min-max 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 min-max 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 min-max 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 cross-boundary 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 tensor-surf
- N_CreateCoonsSrfTwist Bicubic Coons surface through four boundary curves
- N_CreateCoonsSrf Bilinear Coons surface through four boundary curves
- N_CreateCrossBoundaryDerivCrv Compute cross-boundary derivative field
- N_CreateBVectors Compute “B” vectors for curve alignment
- N_CrossBoundaryDerivCrv Compute cross-boundary derivative field
- N_Create4CrossBoundaryDerivCrvs Compute cross-boundary derivatives for Coons surface
- N_ReparmCrvsIsectPt Make intersection parameters compatible for Gordon sur
- N_CreateDerivField Cross-boundary derivative from surface, end twists and derivatives
- N_CreateDataBoundaryDerivs Cross-boundary derivative data from surface
- N_CreateSkinSrfBoundaryDerivs Cross-boundary derivative data from vector and curve
- N_CrossBoundaryDerivsVectorField Cross-boundary derivative data from vector field
- N_CreateGordonSrf Gordon surface trough compatible non-rational 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 Iso-curve inversion/projection using Newton’s method
- N_MergeKnotVectors Merge knot vectors to have the same internal knots
- N_FillNSidedHole N-sided patch construction to boundary and derivatives
- N_CreateSkinSrfBoundaryContinuity Approximate skinning with boundary conditions and rails
- N_CreateSkinSrfInterp Surface skinning via approximation of cross-sectional curves
- N_CreateSkinSpine General spine curve-based 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 non-rational 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 least-squares curve approximation
- N_FitCrvWeightedLstSqPeriodic Weighted & constrained least squares periodic fit to points
- N_FitCrvWeightedLstSqKnots Weighted/constrained least-squares 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/v-dis
- 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 non-rational curve
- N_ApproxCrvOnSrfWithCrv Approximate curve on surface from uv-curve
- N_CalcNumCPtsToApproxArc Compute number of ctrl pts for circle approximation
- N_ApproxConeWithSrf Non-rational approximation of cylinder or cone
- N_ApproxArcWithCrv Non-rational approximation of a circle or arc
- N_ApproxCircArcWithCrvData Perform non-rational 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 non-rational curve
- N_ApproxNurbsWithCrvKnots Curve approximation with knot vector passed in
- N_ApproxNurbsWithNonRatSrf Approximate surface with non-rational surface
- N_ApproxG1CrvWithCrv Approximate any NL_G1 curve with non-rational curve
- N_GetPtsForCrvApprox Get points for approximation of curves
- N_CrvOffsetApprox Approximate offset of curve with non-rational 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 Non-rational approaximation of surface of revolution
- N_ApproxSphereWithSrf Non-rational 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 Non-rational 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 Constraint-based curve shaping with interp or approx
- N_CrvShapeDerivConstraints Constraint-based 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 Line-curve intersection for bending
- N_SrfShapeAxialBend Surface axial bending
- N_SrfShapeApproxPts Shape surface to approximate given points
- N_SrfShapeAxialDeform Axial deformations of surfaces
- N_SrfShapeDerivConstraints Constraint-based surface shaping with interp or approx
- N_SrfShapeCentralBend Surface central bending
- N_SrfShapeConstraints Constraint-based 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 iso-curve 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 NON-RATIONAL cross-boundary derivative of a surface
- N_CrossBoundDerivCrvNurbsSrf Cross-boundary derivative of a surface
- N_CrvGetDerivCrvsAll All derivative curves of a curve
- N_CrvMakeDerivCrv Compute k-th derivative curve of a curve
- N_CrvNonRatEvalDeriv Derivative of NON-RATIONAL curve with respect to a knot
- N_CrvEvalHighDerivsKnot Higher derivatives of NON-RATIONAL 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 NON-RATIONAL curve
- N_CrvNonRatGetFirstDeriv Derivative curve of a NON-RATIONAL 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 4-D
- N_CrvFuncMultiplyCrv Compute the product of a function and a curve
- N_CrvFuncMultiplyCrvFunc Compute the product of two univariate B-spline functions
- N_SrfFuncMultiplySrf Compute the product of bivariate function and surface
- N_ConstantMultiplyCrv4d Product of constant and curve in 4-D
- 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 B-spline 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,l-th derivative surface of a surface
- N_SrfFuncDerivFunc Derivative function of bivariate B-spline function
- N_SrfFuncFuncDerivFuncAtKnot Derivative of surface function with respect to a knot
- N_DerivSrfNonRatSrfKnot Derivative of NON-RATIONAL 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 NON-RATIONAL surface
- N_FirstDerivSrfNonRatSrf Derivative surface of a NON-RATIONAL 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 non-rational basis functions & derivatives
- N_CrvRatBasisDerivs All univariate rational basis functions and derivatives
- N_BasisDerivs Non-vanishing basis functions and their derivatives
- N_BasisEval Compute all non-vanishing 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 non-vanishing 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 min-max of basis function over each span
- N_GetCompatibleKnotVectorToTol Merge a set of knot vectors using a tolerance
- N_BasisGetSpanCount Find number of non-zero 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 non-vanishing 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 non-vanishing basisf wrt to a knot
- N_BasisDerivsArray Basis functions and derivatives at various parameters
- N_CrvRatBasisKnotDeriv Derivatives of non-vanishing rat basis fs wrt to a knot
- N_BiBasisKnotDeriv Ders of all non-vanishing 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 non-zero 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 B-spline function
- N_CrvReparamRat Curve reparameterization with linear rational function
- N_MapKnotsBetweenCrvFuncAndKnotVector Map knot vectors onto each other
- N_SrfProjectPts Global Point-to-Surface 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 B-spline curve from NL_IGES Entity 112 data
- N_Iges114NonRatSrf Create B-spline 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 1-D array of control point pointers
- N_AllocCPt2dArray Allocate memory for a 2-D control point array
- N_AllocCPtPtr2dArray Allocate memory for 2-D array of control point pointers
- N_AllocCrvFuncArray Allocate memory to store a 1-D 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 2-D control point array from its wx,wy,wz,w components
- N_Alloc2dArrayCrvPtrs Allocate memory for a 2-D array of curve pointers
- N_AllocArrayCrvPtrsAndData Allocate array of curve pointers structures allocated
- N_Alloc1dArrayCrvs Allocate memory to store a 1-D 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 1-D array of flag pointers
- N_AllocFlag2dArray Allocate memory for a 2-D flag array
- N_AllocInt1dArray Allocate memory for an integer array
- N_AllocIntPtr1dArray Allocate memory for a 1-D array of integer pointers
- N_AllocInt2dArray Allocate memory for a 2-D integer array
- N_AllocIntPtr2dArray Allocate memory for a 2-D array of integer pointers
- N_AllocIntMatrix Allocate memory to store an integer matrix
- N_Alloc1dArrayKnotVectors Allocate memory to store a 1-D 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 1-D array of point pointers
- N_AllocPt2dArray Allocate memory for a 2-D point array
- N_AllocPtPtr2dArray Allocate memory for a 2-D array of point pointers
- N_AllocVariable2dPtArray Allocate memory for a variable 2-D 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 2-D point array from its x,y,z components
- N_AllocCPolygon Allocate memory for a polygon structure
- N_AllocRealPtr3dArray Allocate memory for a 1-D array of double pointers
- N_AllocReal1dArray Allocate memory for a real array
- N_AllocRealPtr1dArray Allocate memory for a 1-D array of real pointers
- N_AllocReal2dArray Allocate memory for a 2-D real array
- N_AllocRealPtr2dArray Allocate memory for a 2-D array of real pointers
- N_AllocReal3dArray Allocate memory for a 3-D real array
- N_AllocReal4dArray Allocate memory for a 4-D real array
- N_AllocRealMatrix Allocate memory to store a real matrix
- N_Alloc2dArraySrfFunc Allocate memory for a 2-D 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 2-D array of surface pointers
- N_AllocArraySrfPtrsInit Allocate array of surface pointers structures allocated
- N_Alloc2dArraySrfPtrsParameters Allocate memory for a 2-D 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 B-spline 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 2-D curve to a 3-D curve
- N_Crv3dTo2d Convert a 3-D curve to a 2-D 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 non-rational 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 non-rational 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 1-D NL_POINT data from file
- N_Read2dPtFromFile Read in 2-D 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 4-D?
- 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 1-D point set cocircular
- N_1dPtSetIsClosed Is 1-D point set closed?
- N_IsPtSet1dColinear Is 1-D point set colinear
- N_IsPtSet1dCoplanar Is 1-D point set coplanar
- N_IsPtSet1dSpherical Is 1-D point set cospherical
- N_2dPtSetIsClosed Is 2-D 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 2-D 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 2-D 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 2-D integer array
- N_FreeIntPtr2dArray Release memory that stores a 2-D 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 2-D 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 2-D real array
- N_FreeReal3dArray Release memory that stores a 3-D 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 1-D NL_POINT data to a file
- N_Write2dPtToFile Write 2-D 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 1-D control point array
- N_Realloc2dCPtArray Reallocate memory for 2-D control point array
- N_Realloc1dFlagArray Reallocate memory for 1-D flag array
- N_Realloc2dFlagArray Reallocate memory for 2-D flag array
- N_Realloc1dIntArray Reallocate memory for 1-D integer array
- N_Realloc1dIntPtrArray Reallocate memory for a 1-D array of integer pointers
- N_Realloc2dIntArray Reallocate memory for 2-D integer array
- N_Realloc2dIntPtrArray Reallocate memory for a 2-D array of integer pointers
- N_Realloc1dPtArray Reallocate memory for 1-D point array
- N_Realloc2dPtArray Reallocate memory for 2-D point array
- N_Realloc1dRealArray Reallocate memory for 1-D real array
- N_Realloc2dRealArray Reallocate memory for 2-D 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 non-rational 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 non-rational 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