MVHyperConeFromNPoints

(mvcones.c:697)

Prototype:

int MVHyperConeFromNPoints(MvarNormalConeStruct *MVCone, MvarVecStruct * const *Vecs, int n)

Description:

Consturcts a hyper cone in R^n through n vectors specified by Vecs.

Parameters:

MVCone:	The result is to be placed here.
Vecs:	Input vectors, prescribing n locations in R^n.
n:	Size of array Vecs.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MVHyperPlaneFromNPoints MVHyperConeFromNPoints2 MVHyperConeFromNPoints3

Keywords:

MVHyperConeFromNPoints2

(mvcones.c:745)

Prototype:

int MVHyperConeFromNPoints2(MvarNormalConeStruct *MVCone, MvarVecStruct * const *Vecs, int m)

Description:

Consturcts a hyper cone in R^n through m (m < n) vectors specified by Vecs.

Parameters:

MVCone:	The result is to be placed here.
Vecs:	Input vectors, prescribing m locations in R^n.
m:	Size of array Vecs, m < n.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MVHyperPlaneFromNPoints MVHyperConeFromNPoints MVHyperConeFromNPoints3

Keywords:

MVHyperConeFromNPoints3

(mvcones.c:842)

Prototype:

int MVHyperConeFromNPoints3(MvarNormalConeStruct *MVCone, MvarVecStruct * const *Vecs, int m)

Description:

Consturcts a hyper cone in R^n through m (m < n) vectors specified by Vecs. Same functionality of MVHyperConeFromNPoints2 but more efficient, by solving for A A^T x = e, were e is [1, 1,..., 1], and having x being the linear combination of A's rows defining the cone axis.

Parameters:

MVCone:	The result is to be placed here.
Vecs:	Input vectors, prescribing m locations in R^n.
m:	Size of array Vecs, m < n.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MVHyperPlaneFromNPoints MVHyperConeFromNPoints MVHyperConeFromNPoints2

Keywords:

MVHyperPlaneFromNPoints

(mvcones.c:643)

Prototype:

int MVHyperPlaneFromNPoints(MvarPlaneStruct *MVPlane, MvarVecStruct * const *Vecs, int n)

Description:

Constructs a hyper plane in R^n through n locations specified by Vecs.

Parameters:

MVPlane:	The result is to be placed here.
Vecs:	Input vectors, prescribing n locations in R^n.
n:	Size of array Vecs.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MVHyperConeFromNPoints

Keywords:

MVarBzrMVDivide

(mvbzrsym.c:38)

Prototype:

void MVarBzrMVDivide(const MvarMVStruct *MV1, const MvarMVStruct *MV2, MvarMVStruct **Q, MvarMVStruct **R)

Description:

Given two scalar Bezier multivariates, MV1, MV2, calculates a quotient Bezier multivariate, Q, and a remainder Bezier multivarite, R, such that, MV1 = Q*MV2 + R. MV1 and MV2 are assumed to have the same dimension.

Parameters:

MV1, MV2:	The two multivariates to divide.
Q, R:	Where to allocate the computed quotient and remainder.

Returned Value:

void

Keywords:

product

MVarExprTreeNormalCone

(mvcones.c:2074)

Prototype:

MvarNormalConeStruct *MVarExprTreeNormalCone(MvarExprTreeStruct *Eqn)

Description:

Constructs a normal cone to a scalar multivariate expression tree. If the input multivariate is not scalar it is assumed to be of point type E(1+Dim), where Dim is the dimension of the MV. This scalar holds the gradient already in the Dim locations of the Points array in MV, in slots Points[2] to Points[Dim + 1], with Points[1] still holding the scalar field.

Parameters:

Eqn:	Multivariate to derive a cone bounding its normal space.

Returned Value:

MvarNormalConeStruct *: The resulting normal cone.

See Also:

MvarExprTreeConesOverlap

Keywords:

MVarIsCrvInsideCirc

(ms_circ.c:448)

Prototype:

int MVarIsCrvInsideCirc(const CagdCrvStruct *Crv, CagdRType Center[2], CagdRType Radius, CagdRType Tolerance)

Description:

Tests if a Crv is contained in the given prescribed circle. Computes the maximal distance of the curve from the circle center and compares that distance with circle radius.

Parameters:

Crv:	Curve to test for containment in the circle.
Center:	Center of the circle to test against.
Radius:	Radius of the circle to test against.
Tolerance:	Of computation.

Returned Value:

int: TRUE if Crv is indeed inside the circle, FALSE otherwise.

See Also:

MvarMSCircOfThreeCurves MvarMSCircOfThreeCurves MvarMinSpanCirc

Keywords:

MVarMVNormalCone

(mvcones.c:1150)

Prototype:

MvarNormalConeStruct *MVarMVNormalCone(const MvarMVStruct *MV)

Description:

Constructs a normal cone to a scalar multivariate MV. Note the normal space of the trivariate is assumed of dimension one, and the gradient of the multivariate is assumed to span the normal space. If the input multivariate is not scalar it is assumed to be of point type E(1+Dim), where Dim is the dimension of the MV. This scalar holds the gradient already in the Dim locations of the Points array in MV, in slots Points[2] to Points[Dim + 1], with Points[1] still holding the scalar field.

Parameters:

MV:	Multivariate to derive a cone bounding its normal space.

Returned Value:

MvarNormalConeStruct *: A cone bounding the normal space of MV, or NULL if failed (i.e. angular span of normal space too large).

See Also:

MVarMVNormalCone2 MvarMVConesOverlap

Keywords:

MVarMVNormalCone2

(mvcones.c:1219)

Prototype:

MvarNormalConeStruct *MVarMVNormalCone2(const MvarMVStruct *MV, CagdRType * const *GradPoints, int TotalLength, int *MaxDevIndex)

Description:

A second version of MVarMVNormalCone in which the control vectors are given directly. Note the normal space of the trivariate is assumed of dimension one, and the gradient of the multivariate is assumed to span the normal space. If the input multivariate is not scalar it is assumed to be of point type E(1+Dim), where Dim is the dimension of the MV. This scalar holds the gradient already in the Dim locations of the Points array in MV, in slots Points[2] to Points[Dim + 1], with Points[1] still holding the scalar field.

Parameters:

MV:	Multivariate to derive a cone bounding its normal space.
GradPoints:	Control vectors of gradient field.
TotalLength:	Number of control vectors in gradient field.
MaxDevIndex:	The index in GradPoints where maximal deviation occur will be kept here.

Returned Value:

MvarNormalConeStruct *: A cone bounding the normal space of MV, or NULL if failed (i.e. angular span of normal space too large).

See Also:

MVarMVNormalCone MvarMVConesOverlap

Keywords:

MVarMVNormalConeMainAxis

(mvcones.c:1294)

Prototype:

MvarNormalConeStruct *MVarMVNormalConeMainAxis(const MvarMVStruct *MV, MvarVecStruct **MainAxis)

Description:

Constructs a normal cone to a scalar multivariate MV. Note the normal space of the trivariate is assumed of dimension one, and the gradient of the multivariate is assumed to span the normal space. If the input multivariate is not scalar it is assumed to be of point type E(1+Dim), where Dim is the dimension of the MV. This scalar holds the gradient already in the Dim locations of the Points array in MV, in slots Points[2] to Points[Dim + 1], with Points[1] still holding the scalar field.

Parameters:

MV:	Multivariate to derive a cone bounding its normal space.
MainAxis:	Main axis (principal component) of the normal cone's vectors distribution. Valid only if success.

Returned Value:

MvarNormalConeStruct *: A cone bounding the normal space of MV, or NULL if failed (i.e. angular span of normal space too large).

See Also:

MVarMVNormalConeMainAxis2 MVarMVNormalCone MvarMVConesOverlap

Keywords:

MVarMVNormalConeMainAxis2

(mvcones.c:1352)

Prototype:

MvarNormalConeStruct *MVarMVNormalConeMainAxis2(const MvarMVStruct *MV, CagdRType * const *GradPoints, int TotalLength, MvarVecStruct **MainAxis)

Description:

A second version of MVarMVNormalConeMainAxis in which the control points are given directly.

Parameters:

MV:	Multivariate to derive a cone bounding its normal space.
GradPoints:	Control vectors of gradient field.
TotalLength:	Number of control vectors in gradient field.
MainAxis:	Main axis (principal component) of the normal cone's vectors distribution. Allocated and valid only if success. Can be NULL in which case it is ignored.

Returned Value:

MvarNormalConeStruct *: A cone bounding the normal space of MV, or NULL if failed (i.e. angular span of normal space too large).

See Also:

MVarMVNormalConeMainAxis MVarMVNormalCone MvarMVConesOverlap

Keywords:

MVarProjNrmlPrmt2MVScl

(mvaccess.c:418)

Prototype:

MvarMVStruct *MVarProjNrmlPrmt2MVScl(const CagdSrfStruct *Srf, const CagdSrfStruct *NrmlSrf, const MvarMVStruct *MVScl)

Description:

Performs the following steps in order: 1. Project Srf onto NrmlSrf by computing their inner product. 2. Promote the surface to a 4-variate with the surface the first 2 vars. 3. Scale the new 4-variate by a scalar product with MVScl.

Parameters:

Srf:	Surface to project promote and scale.
NrmlSrf:	ormal field to project along.
MVScl:	Scale field to scale with.

Returned Value:

MvarMVStruct : Resulting multivariate.

Keywords:

MVarSmallestPrincipalDirection

(mvcones.c:1028)

Prototype:

void MVarSmallestPrincipalDirection(MvarVecStruct *SPDVec, MvarVecStruct *ConeAxis, CagdRType * const *GradPoints, int TotalLength, int Dim)

Description:

Computes the smallest principal direction of a set of normal vectors.

Parameters:

SPDVec:	Vector to be updated with the smallest principla component.
ConeAxis:	xis of cone bounding all the normal vectors in GradPoints. Assumed unit length.
GradPoints:	The normal (Gradient) vectors to handle.
TotalLength:	Number of normal vectors in GradPoints.
Dim:	Dimension of Normal vectors. N

Returned Value:

void

See Also:

MVarMVMaximalDeviation

Keywords:

Mvar2CntctCompute2CntctMotion

(mv2cntct.c:3502)

Prototype:

MvarPolylineStruct *Mvar2CntctCompute2CntctMotion(const CagdCrvStruct *CCrvA, const CagdCrvStruct *CCrvB, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes the 2 Contact motion between two C^1 cont curves, CCrvA and CCrvB. The curves are assumed to be C1 periodic curve with open end condition. The algebraic conditions for 2contact are following (please refer the paper,"Precise Continuous Contact Motion for Planar Freeform Geometric Curves" for the details): [CrvB(v1) -Rot(theta) * CrvA(u1)]_x = [CrvB(v2) - Rot(theta) * CrvA(u2)]_x [CrvB(v1) -Rot(theta) * CrvA(u1)]_y = [CrvB(v2) - Rot(theta) * CrvA(u2)]_y

    det (Rot(theta) * CrvA'(u1), CrvB'(v1) = 0,
    det (Rot(theta) * CrvA'(u2), CrvB'(v2) = 0.


Parameters:


 CCrvA:     Moving curve.
 CCrvB:     Obstacle Curves.
 Step:      Step size to use in the numeric tracing.
 SubdivTol:    Subdivision tolerance of Computation.
 NumericTol:   Numerical tolerance of computation.



Returned Value:


  MvarPolylineStruct *: Linked list of the solutions holding parameter
                        value of two contact points and rotation in
                        radian (u1, v1, u2, v2, theta).



See Also:



Keywords:

  2Contact Trace


 Mvar2CtBuildBVH 
  (mv2ctbvh.c:778)

Prototype:

  Mvar2CtBVHStruct *Mvar2CtBuildBVH(CagdCrvStruct *Crv,
                                    CagdRType SubdivTol,
                                    CagdRType BvTol)


Description:

CCrvA:	Moving curve.
CCrvB:	Obstacle Curves.
Step:	Step size to use in the numeric tracing.
SubdivTol:	Subdivision tolerance of Computation.
NumericTol:	Numerical tolerance of computation.

Build a bounding volume hierarchy for a curve.

Parameters:

Crv:	rv to build a BVH.
SubdivTol:	ubdivision tolerance for the construction.
BvTol:	ounding volume error tolerance for the construction.

Returned Value:

Mvar2CtBVHStruct *: Bounding volume hierarchy for a curve

See Also:

Keywords:

Mvar2CtBuildCParamHierarchy

(mv2ctaux.c:147)

Prototype:

void Mvar2CtBuildCParamHierarchy(CagdCrvStruct *Circle, Mvar2CtCParamStruct **Node, CagdRType Min, CagdRType Max, CagdRType Tol)

Description:

Build a hierarchy for rotation data structure.

Parameters:

Circle:	nit circle.
Node:	ew node will be allocated herein.
Min, Max:	omain for the node.
Tol:	olerance for building hierarchy.

Returned Value:

void

See Also:

Keywords:

Mvar2CtCheck2CtTrace

(mv2ctaux.c:1056)

Prototype:

CagdBType Mvar2CtCheck2CtTrace(Mvar2CtBVNodeStruct *Nodes[4], Mvar2CtCParamStruct *Cparam, CagdRType Tol)

Description:

Check if there exists 2 contact trace in the domain using BVH.

Parameters:

Nodes:	Bounding volumes for curves.
Cparam:	data structure for rotation.
Tol:	Subdivision tolerance of checking.

Returned Value:

CagdBType: FALSE if there is no solution in the domain, TRUE otherwise.

See Also:

Keywords:

Mvar2CtConnectPeriodic

(mv2ctaux.c:2292)

Prototype:

MvarPolylineStruct *Mvar2CtConnectPeriodic(MvarPolylineStruct *Polys, CagdRType Tol)

Description:

Connect 2Contact traces that are not connected due to the parametrization of the periodic curve.

Parameters:

Polys:	2contact traces.
Tol:	tolerance for the connection.

Returned Value:

MvarPolylineStruct *: connected 2contact motion curves.

See Also:

Keywords:

Mvar2CtCurvatureOverlap

(mv2ctaux.c:90)

Prototype:

CagdBType Mvar2CtCurvatureOverlap(Mvar2CtBVNodeStruct *ANode, Mvar2CtBVNodeStruct *BNode, Mvar2CtCParamStruct *Cparam)

Description:

Check if two curves can have a same curvature by using BVH.

Parameters:

ANode:	Bounding volume for a moving curve.
BNode:	Bounding volume for a obstacle curve.
Cparam:	Data structure for rotation.

Returned Value:

CagdBType: FALSE if there is no curvature overlap TRUE otherwise.

See Also:

Keywords:

Mvar2CtExtractMVRegion

(mv2ctaux.c:1507)

Prototype:

MvarMVStruct **Mvar2CtExtractMVRegion(MvarMVStruct **MVs, int MVNum, CagdRType *Min, CagdRType *Max)

Description:

Extract sub-region of multivariate correspond to a given sub domain.

Parameters:

MVs:	Array of multivariates.
MVNum:	Number of constraints (may be updated).
Min:	Minimum domain values.
Max:	Maximum domain values.

Returned Value:

MvarMVStruct **: Extracted MVs.

See Also:

Keywords:

Mvar2CtFreeBVH

(mv2ctbvh.c:853)

Prototype:

void Mvar2CtFreeBVH(Mvar2CtBVHStruct *Bvh)

Description:

Free bounding volume hierarchy.

Parameters:

Bvh:	BVH to deallocate.

Returned Value:

void

See Also:

Keywords:

Mvar2CtFreeCparam

(mv2ctaux.c:234)

Prototype:

void Mvar2CtFreeCparam(Mvar2CtCParamStruct *Node)

Description:

Free Mvar2CtCParamStruct recursively.

Parameters:

Node:	var2CtCParamStruct node to free.

Returned Value:

void

See Also:

Keywords:

Mvar2CtGetMiddlePt

(mv2ctaux.c:1956)

Prototype:

MvarPtStruct *Mvar2CtGetMiddlePt(MvarPtStruct *PtList, int Length)

Description:

Find a middle point of Point list.

Parameters:

PtList:	Linked list of the points.
Length:	Length of the list.

Returned Value:

MvarPtStruct *: Middle point of the list.

See Also:

Keywords:

Mvar2CtGetParentBVNode

(mv2ctbvh.c:594)

Prototype:

void Mvar2CtGetParentBVNode(Mvar2CtBVNodeStruct *Node, CagdRType Min, CagdRType Max, Mvar2CtBVNodeStruct **Parent)

Description:

Find smallest bounding volume includes domain range Min~Max.

Parameters:

Node:	Data structure for rotation.
Min, Max:	Domain range for testing.
Parent:	lace for saving the result.

Returned Value:

void

See Also:

Keywords:

Mvar2CtGetParentCparam

(mv2ctaux.c:207)

Prototype:

void Mvar2CtGetParentCparam(Mvar2CtCParamStruct *Node, CagdRType Min, CagdRType Max, Mvar2CtCParamStruct **Parent)

Description:

Find smallest bounding volume includes the domain Min-Max.

Parameters:

Node:	Data structure for rotation.
Min, Max:	Domain range for testing.
Parent:	lace for saving the result.

Returned Value:

void

See Also:

Keywords:

Mvar2CtGetTheta

(mv2ctaux.c:369)

Prototype:

CagdRType Mvar2CtGetTheta(CagdRType x, CagdRType y)

Description:

Compute a rotation angle in radian correspond (x, y) vector.

Parameters:

x, y:	ector for computing rotation angle.

Returned Value:

CagdRType: Rotation angle in radian.

See Also:

Keywords:

Mvar2CtInDomain

(mv2ctaux.c:1555)

Prototype:

CagdBType Mvar2CtInDomain(CagdRType *Min, CagdRType *Max, MvarPtStruct *MPt)

Description:

Check if a point is located in a given domain.

Parameters:

Min:	inimum values of the domain.
Max:	aximum values of the domain.
MPt:	oint to check.

Returned Value:

CagdBType: TRUE if MPt is in the domain, FALSE otherwise.

See Also:

Keywords:

Mvar2CtIsConnectedNode

(mv2ctaux.c:998)

Prototype:

CagdBType Mvar2CtIsConnectedNode(Mvar2CtBVNodeStruct *Node1, Mvar2CtBVNodeStruct *Node2)

Description:

Check if two bounding volumes are connected.

Parameters:

Node1, Node2:	Bounding volumes to test.

Returned Value:

CagdBType: TRUE if connected, FALSE otherwise.

See Also:

Keywords:

Mvar2CtIsPassing

(mv2ctaux.c:1587)

Prototype:

CagdBType Mvar2CtIsPassing(CagdRType *Min, CagdRType *Max, MvarPolylineStruct *MPoly)

Description:

Check if a polyline passes a given domain.

Parameters:

Min:	inimum values of the domain.
Max:	aximum values of the domain.
MPoly:	varPolyline to check.

Returned Value:

CagdBType: TRUE if MPoly passes the domain, FALSE otherwise.

See Also:

Keywords:

Mvar2CtLineLineDist

(mv2ctbvh.c:267)

Prototype:

CagdRType Mvar2CtLineLineDist(Mvar2CtLineStruct *A, Mvar2CtLineStruct *B)

Description:

Compute distance between two line segments.

Parameters:

A, B:	wo line segments to compute distance.

Returned Value:

CagdRType: Distance between A and B.

See Also:

Keywords:

Mvar2CtLinePointDist

(mv2ctbvh.c:330)

Prototype:

CagdRType Mvar2CtLinePointDist(CagdPType P, CagdPType L[2])

Description:

Compute distance between point and line segment.

Parameters:

P:	oint to compute distance.
L:	wo end points of line segment.

Returned Value:

CagdRType: Minimum distance between a line segment and a point.

See Also:

Keywords:

Mvar2CtNormalOverlap

(mv2ctaux.c:410)

Prototype:

CagdBType Mvar2CtNormalOverlap(Mvar2CtBVNodeStruct *ANode, Mvar2CtBVNodeStruct *BNode, CagdRType RMin, CagdRType RMax)

Description:

Check the tangency condition for 2 contact points using BVH.

Parameters:

ANode, BNode:	Bounding volumes to test.
RMin:	Minimum rotation angle in radian.
RMax:	Maximum rotation angle in radian.

Returned Value:

CagdBType: FALSE if tangency condition does not satisfy TRUE otherwise.

See Also:

Keywords:

Mvar2CtNormalOverlapBoth

(mv2ctaux.c:571)

Prototype:

CagdBType Mvar2CtNormalOverlapBoth(Mvar2CtBVNodeStruct *ANode, Mvar2CtBVNodeStruct *BNode)

Description:

Check normal overlap for both direction.

Parameters:

ANode, BNode:	Nodes for normal overlapping test.

Returned Value:

CagdBType: TRUE if normal cones overlap FALSE otherwise.

See Also:

Keywords:

Mvar2CtPenetrationDepth

(mv2ctbvh.c:1158)

Prototype:

CagdRType Mvar2CtPenetrationDepth(Mvar2CtBVHStruct *BvhA, Mvar2CtBVHStruct **BvhBs, int BSize, CagdRType Xtrans, CagdRType Ytrans, CagdRType Rot)

Description:

Compute a maximum penetration depth of moving curve into obstacle curves using BVHs.

Parameters:

BvhA:	Bvh for moving curve.
BvhBs:	Bvh for obstacle curves.
BSize:	Number of obstacle curves.
Xtrans:	translation.
Ytrans:	translation.
Rot:	otation angle in radian.

Returned Value:

CagdRType: Maximum penetration depth, negative if moving curve penetrate obstacle curves positive, otherwise.

See Also:

MvarStewartPlatformSolve

Keywords:

Mvar2CtReduce2CtDomain

(mv2ctaux.c:1153)

Prototype:

void Mvar2CtReduce2CtDomain(Mvar2CtBVNodeStruct *Nodes[4], Mvar2CtCParamStruct *Cparam, CagdRType Min[5], CagdRType Max[5], int MinMax, int FixedDir, CagdRType Tol)

Description:

Reduce the domain for solving 2 contact points at domain boundary using BVH.

Parameters:

Nodes:	Bounding volumes for curves.
Cparam:	Data structure for rotation.
Min:	Current minimum domain values.
Max:	Current maximum domain values.
MinMax:	0 if fixed parameter is minimum parameter of the bounding volume, 1 if if fixed parameter is maximum parameter of the of the bounding volume.
FixedDir:	Fixed dimension.
Tol:	Subdivision tolerance of checking.

Returned Value:

void

See Also:

Keywords:

Mvar2CtReduce3CtDomain

(mv2ctaux.c:1308)

Prototype:

void Mvar2CtReduce3CtDomain(Mvar2CtBVNodeStruct *Nodes[6], Mvar2CtCParamStruct *Cparam, CagdRType Min[7], CagdRType Max[7])

Description:

Reduce the domain for solving 3 contact points using BVH.

Parameters:

Nodes:	Bounding volumes for curves.
Cparam:	Data structure for rotation.
Min:	Current minimum domain values.
Max:	Current maximum domain values.

Returned Value:

void

See Also:

Keywords:

Mvar2CtReduceRotExtremeDomain

(mv2ctaux.c:1404)

Prototype:

void Mvar2CtReduceRotExtremeDomain(Mvar2CtBVNodeStruct *Nodes[4], Mvar2CtCParamStruct *Cparam, CagdRType Min[5], CagdRType Max[5], CagdRType Tol)

Description:

Reduce the domain for solving rotational extreme point for2 contact trace using BVH.

Parameters:

Nodes:	Bounding volumes for curves.
Cparam:	data structure for rotation.
Min:	Current minimum domain values.
Max:	Current maximum domain values.
Tol:	Subdivision tolerance of checking.

Returned Value:

void

See Also:

Keywords:

Mvar2CtRejectbyCurvature

(mv2ctaux.c:960)

Prototype:

CagdBType Mvar2CtRejectbyCurvature(Mvar2CtBVNodeStruct *Node1, Mvar2CtBVNodeStruct *Node2)

Description:

Check if pair of curves satisfy curvature condition for 2 contact.

Parameters:

Node1, Node2:	ounding volumes of curves to test.

Returned Value:

CagdBType: TRUE if they don't satisfy the condition, FALSE otherwise.

See Also:

Keywords:

Mvar2CtSetNodeId

(mv2ctbvh.c:563)

Prototype:

void Mvar2CtSetNodeId(Mvar2CtBVNodeStruct *Node, int Id)

Description:

Set id of bounding volume recursively.

Parameters:

Node:	Bounding volume to set id.
Id:	id value to set.

Returned Value:

void

See Also:

Keywords:

Mvar2CtSwapTrace

(mv2ctaux.c:2039)

Prototype:

void Mvar2CtSwapTrace(MvarPolylineStruct *MPoly)

Description:

Swap the first and second parameter with third and fourth value .

Parameters:

MPoly:	race to swap.

Returned Value:

void

See Also:

Keywords:

Mvar2CtTraceBBox

(mv2ctaux.c:2085)

Prototype:

void Mvar2CtTraceBBox(CagdRType *Min, CagdRType *Max, MvarPtStruct *SPt, MvarPtStruct *EPt)

Description:

Compute bounding box of a trace.

Parameters:

Min, Max:	inimum and maximum values of Bounding box.
SPt, EPt:	Start and end point of the trace.

Returned Value:

void

See Also:

Keywords:

Mvar2CtTraceCollide

(mv2ctaux.c:1987)

Prototype:

int Mvar2CtTraceCollide(MvarPolylineStruct *Poly1, MvarPolylineStruct *Poly2)

Description:

Test whether two traces Poly1, Poly2 have common contact point.

Parameters:

Poly1, Poly2:	wo traces to check.

Returned Value:

int: 0 if there is no common contact 1~4 depending on the type of common contact point.

See Also:

Keywords:

Mvar2CtValidate2Ct

(mv2ctaux.c:1627)

Prototype:

MvarPtStruct *Mvar2CtValidate2Ct(MvarPtStruct *MPts, Mvar2CtBVHStruct *BvhA, Mvar2CtBVHStruct **BvhBs, int BSize, CagdCrvStruct *Circle)

Description:

Check whether the 2 contact points cause inter-penetration into obstacle curves. The 2 contact points having inter-penetration are removed from the list.

Parameters:

MPts:	Linked list of curvature contacts.
BvhA:	Bvh for moving curve.
BvhBs:	Bvh for obstacle curves.
BSize:	Number of obstacle curves.
Circle:	Unit circle.

Returned Value:

MvarPtStruct *: Linked list of curvature contact points having no penetration into obstacle curves.

See Also:

Keywords:

Mvar2CtValidateCurvContact

(mv2ctaux.c:1697)

Prototype:

MvarPtStruct *Mvar2CtValidateCurvContact(MvarPtStruct *MPts, Mvar2CtBVHStruct *BvhA, Mvar2CtBVHStruct **BvhBs, int BSize, int BIndex, CagdCrvStruct *Circle)

Description:

Check whether the curvature contact points cause inter-penetration into obstacle curves. The curvature contact points having inter-penetration are removed from the list.

Parameters:

MPts:	Linked list of curvature contacts.
BvhA:	Bvh for moving curve.
BvhBs:	Bvh for obstacle curves.
BSize:	Number of obstacle curves.
BIndex:	Index number of obstacle curve.
Circle:	Unit circle.

Returned Value:

MvarPtStruct *: Linked list of curvature contact points having no penetration into obstacle curves.

See Also:

Keywords:

Mvar2CtValidateTraces

(mv2ctaux.c:1759)

Prototype:

MvarPolylineStruct *Mvar2CtValidateTraces(MvarPolylineStruct *Polys, Mvar2CtBVHStruct *BvhA, Mvar2CtBVHStruct **BvhBs, int BSize, CagdCrvStruct *Circle)

Description:

Check if 2contact traces inter-penetrate the obstacle. The trace having inter-penetration is removed from the list.

Parameters:

Polys:	2contact traces.
BvhA:	Bvh for moving curve.
BvhBs:	Bvh for obstacle curves.
BSize:	Number of obstacle curves.
Circle:	Unit circle.

Returned Value:

MvarPolylineStruct *: 2contact motion curves.

See Also:

Keywords:

Mvar3CircsInTriangles

(mvarpack.c:50)

Prototype:

MvarPtStruct *Mvar3CircsInTriangles(const CagdPType Pts[3], CagdRType SubdivTol, CagdRType NumericTol)

Description:

Given a triangles in the XY plane, specified by its 3 vertices Pts, Find the 3 circles packed inside the triangle (and tangent to it while also tangent to each other. This problem is also known as the (incorrect solution to the) "Malfatti Circles" problem.

Parameters:

Pts:	3 vertices of triangle in the plane (only XY coordinates).
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Points in R9 as (X1, Y1, R1, X2, Y2, R2, X3, Y3, R3). Each such solution is also tagged with "InTriangle" that is TRUE if all solution is inside the triangle.

See Also:

Keywords:

Mvar6CircsInTriangles

(mvarpck2.c:40)

Prototype:

MvarPtStruct *Mvar6CircsInTriangles(const CagdPType Pts[3], CagdRType SubdivTol, CagdRType NumericTol)

Description:

Given a triangles in the XY plane, specified by its 3 vertices Pts, Find the 6 circles packed inside the triangle (and tangent to it while also tangent to each other. The code to this function was synthesized automatically using the code below.

Parameters:

Pts:	3 vertices of triangle in the plane (only XY coordinates).
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Points in R9 as (x2, x4, x5, y1, y2, y3, y4, y5, y6).

See Also:

Keywords:

MvarAdjacentSrfSrfInter

(selfintr.c:1402)

Prototype:

MvarPolylineStruct *MvarAdjacentSrfSrfInter(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdSrfBndryType Srf1Bndry, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes the intersection locations of two adjacent surfaces, that share an edge (a boundary curve). No intersections locations along the shared edge are returned. This case is common for adjacent patches in a B-spline surface.

Parameters:

Srf1, Srf2:	The two adjacent surfaces to intersect.
Srf1Bndry:	Boundary of Srf1 that is shared with Srf2. Srf2 Boundary Must be the reciprocal boundary. That is, if SrfBndry is UMin, Srf2's boundary will be UMax.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPolylineStruct *: List of intersection pllns, as (u, v) parameter pairs into the two surfaces' domains. Points in R^4.

See Also:

MvarBspSrfSelfInterDiagFactor MvarBzrSrfSelfInterDiagFactor BzrSrfFactorExtremeRowCol

Keywords:

MvarAre2MVsPossiblySharingBndry

(mvar_aux.c:1768)

Prototype:

CagdBType MvarAre2MVsPossiblySharingBndry(const MvarMVStruct *MV1, const MvarMVStruct *MV2, int Dir, CagdBType *MV1Rev, CagdBType *MV2Rev, CagdRType Eps)

Description:

A fast detection if the given two multivariates possibly share a Sub-MV face, in Dir, as boundaries.

Parameters:

MV1, MV2:	o detect if they possibly share a sub-MV in direction Dir.
Dir:	To share for similary of a sub-MV along.
MV1Rev:	TRUE if MV1 needs to be reversed in Dir to be merged with MV2.
MV2Rev:	TRUE if MV2 needs to be reversed in Dir to be merged with MV1.
Eps:	Tolerance of approximation.

Returned Value:

CagdBType: TRUE if they are likely to share a common sub-MV.

See Also:

MvarAre2MVsSharingBndry

Keywords:

MvarAre2MVsSharingBndry

(mvar_aux.c:1870)

Prototype:

int MvarAre2MVsSharingBndry(const MvarMVStruct *MV1, int Dir1, CagdBType MaxBndry1, const MvarMVStruct *MV2, int Dir2, CagdBType MaxBndry2, IrtRType Tolerance, int *Modified)

Description:

Compare designated two boundaries of given two multivariates for similarity.

Parameters:

MV1:	First multivariate to consider.
Dir1:	Axis to extract the sub-manifold boundary. Starts from 0.
MaxBndry1:	RUE for the maximal boundary in Dir1, FALSE for minimal.
MV2:	Second multivariate to consider.
Dir2:	Axis to extract the sub-manifold boundary. Starts from 0.
MaxBndry2:	RUE for the maximal boundary in Dir2, FALSE for minimal.
Tolerance:	olerance of similarity.
Modified:	If MVs requires degree raising, refinements, or reversing. See MvarMVSame3 for more. N

Returned Value:

int: TRUE if similar, FALSE otherwise.

See Also:

CagdSrfAre2SrfsSharingBndry MvarAre2MVsPossiblySharingBndry MvarMVsSame3

Keywords:

MvarBBoxOfCrossProd

(mvarbbox.c:458)

Prototype:

void MvarBBoxOfCrossProd(const MvarBBoxStruct *BBox1, const MvarBBoxStruct *BBox2, MvarBBoxStruct *DCrossBBox)

Description:

Computes the cross product of two bounding boxes in R^3, fetching the possible values that could result from the cross product of the original multiariate data these bounding boxes bound. Returned bbox is a vector bbox with bounds on those possible cross product values. Computation is done by computing min/max value for each axis of the pair of bbox's cross product.

Parameters:

BBox1, BBox2:	Two bounding boxes to compute their cross product.
DCrossBBox:	Where to place the returned result.

Returned Value:

void

See Also:

MvarMVBBox MvarBBoxOfDotProd

Keywords:

MvarBBoxOfDotProd

(mvarbbox.c:311)

Prototype:

void MvarBBoxOfDotProd(const MvarBBoxStruct *BBox1, const MvarBBoxStruct *BBox2, MvarBBoxStruct *DProdBBox)

Description:

Computes the dot product of two bounding boxes in R^n, fetching the possible values that could result from the dot product of the original multiariate data these bounding boxes bound. Returned bbox is a scalar bbox with bounds on those possible dot product values. Computation is done by computing min/max value for each axis of the pair of bbox's and summing that up.

Parameters:

BBox1, BBox2:	Two bounding boxes to compute their inner product.
DProdBBox:	Where to place the returned result.

Returned Value:

void

See Also:

MvarMVBBox MvarBBoxOfCrossProd MvarBBoxOfDotProd2

Keywords:

MvarBBoxOfDotProd2

(mvarbbox.c:355)

Prototype:

void MvarBBoxOfDotProd2(const MvarBBoxStruct *BBox1, const MvarBBoxStruct *BBox2, MvarBBoxStruct *DProdBBox)

Description:

Computes the dot product of two bounding boxes in R^n, fetching the possible values that could result from the dot product of the original multiariate data these bounding boxes bound. Returned bbox is a scalar bbox with bounds on those possible dot product values. Computation is done by enumerating all 2^n vertices of each bbox and computing their dot products. Slower than MvarBBoxOfDotProd.

Parameters:

BBox1, BBox2:	Two bounding boxes to compute their inner product.
DProdBBox:	Where to place the returned result.

Returned Value:

void

See Also:

MvarMVBBox MvarBBoxOfDotProd

Keywords:

MvarBlendConvexMVMV

(mvar_sym.c:1370)

Prototype:

MvarMVStruct *MvarBlendConvexMVMV(const MvarMVStruct *MV1, const MvarMVStruct *MV2, const MvarMVStruct *MVT)

Description:

Given two vector multivariates, MV1, and MV2, and a scalar multivariate, MVT, return a new multivariate equal to the convex blend function: MV1 * MVT + MV2 * (1 - MVT). The function does not verify that MVT is between zero and one.

Parameters:

MV1, MV2:	Two vector multivariates to blend.
MVT:	A multivariate indication the blend weight.

Returned Value:

MvarMVStruct *: A multivariate representing the blend of MV1 and MV2 by MVT and 1 - MVT, respectively.

See Also:

MvarBlendMVMV MvarMVMultScalar MvarMVMult

Keywords:

product symbolic computation multivariates

MvarBlendMVMV

(mvar_sym.c:1335)

Prototype:

MvarMVStruct *MvarBlendMVMV(const MvarMVStruct *MV1, const MvarMVStruct *Scalar1, const MvarMVStruct *MV2, const MvarMVStruct *Scalar2)

Description:

Given two vector multivariates, MV1, and MV2, and two scalar multivariates, Scalar1, and Scalar2, return a new multivariate equal to the blend function: MV1 * Scalar1 + MV2 * Scalar2.

Parameters:

MV1:	1st vector multivariates to blend.
Scalar1:	1st scalar multivariate, used as the blend MV1.
MV2:	2nd vector multivariates to blend.
Scalar2:	2nd scalar multivariate, used as the blend MV2.

Returned Value:

MvarMVStruct *: A multivariate representing the blend of MV1 and MV2 by Scalar1 and Scalar2, respectively.

See Also:

MvarMVMultScalar MvarMVMult

Keywords:

product symbolic computation multivariates

MvarBndryMVsFromMV

(mvarbbox.c:491)

Prototype:

MvarMVStruct **MvarBndryMVsFromMV(const MvarMVStruct *MV)

Description:

Extracts the 2N boundary MVs of the given N dimensional tensor product MV.

Parameters:

MV:	To extract the six boundary surfaces from.

Returned Value:

MvarMVStruct **: A pointer to a dynamically allocated vector of 2N MVs representing the 2N boundaries of the multivariate MV, in order of U1Min, U1Max, U2Min, U2Max, .....

See Also:

TrivBndrySrfsFromTV CagdBndryCrvsFromSrf

Keywords:

multivariates

MvarBsctApplyCC

(mvbiscon.c:246)

Prototype:

int MvarBsctApplyCC(MvarVoronoiCrvStruct *Cv1, MvarVoronoiCrvStruct **CCFreeCrvs)

Description:

Given the struct, this function says whether the bisector point satisfies the the following curvature constraints or not. Calculating the curvature constraints 1st constraint - 1 < 0 2nd constraint - 1 < 0

Parameters:

Cv1:	VoronoiCrvStruct
CCFreeCrvs:	VoronoiCrvStruct for storing the resultant curves

Returned Value:

int: TRUE or FALSE.

See Also:

MvarBsctApplyLL

Keywords:

bisectors

MvarBsctApplyLL

(mvbiscon.c:124)

Prototype:

MvarVoronoiCrvStruct *MvarBsctApplyLL(MvarVoronoiCrvStruct *Cv1)

Description:

Given the struct, this function says whether the bisector point is to the left of the curve or not. Compute the constraints as dot products 1st constraint > 0 2nd constraint > 0

Parameters:

Cv1:	VoronoiCrvStruct

Returned Value:

MvarVoronoiCrvStruct *: Returns the VoronoiCrvStruct after appying the LL constaint

See Also:

MvarBsctIsCurveLL

Keywords:

bisectors

MvarBsctCheckFootPtEqualsMinDistPt

(mvtrmpcr.c:709)

Prototype:

CagdBType MvarBsctCheckFootPtEqualsMinDistPt(CagdCrvStruct *Crv1, CagdRType *Pt, CagdPType BP)

Description:

Given the Crv1, point Pt and the Bisector point (BP), this function says BP's footpoint is the minimum distance point to Crv1. Uses the function SymbDistCrvPoint from symb_lib.

Parameters:

Crv1:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
BP:	isector point - CagdPType.

Returned Value:

CagdBType: Returns TRUE or FALSE.

See Also:

SymbDistCrvPoint

Keywords:

MvarBsctComputeCrvPtBis

(mvtrmpcr.c:223)

Prototype:

CagdPtStruct *MvarBsctComputeCrvPtBis(CagdCrvStruct *Crv, CagdRType *Pt, CagdRType t)

Description:

Given a Crv and a Pt, this function computes the point on the bisector using determinants for a particular parameter t on the curve.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
t:	arameter on the curve Crv - CagdRType.

Returned Value:

CagdPtStruct *: The identified bisector point.

See Also:

SymbCrvPtBisectorCrv2D

Keywords:

MvarBsctComputeDenomOfP

(mvtrmbis.c:49)

Prototype:

void MvarBsctComputeDenomOfP(CagdCrvStruct *Crv1Inp, CagdCrvStruct *Crv2Inp, CagdSrfStruct **DenomOut)

Description:

Computes the denominator of the bisector surface F3 of two given curves. Solve for the normal intersection surface in the plane and then substitute into (the bisector's correspondence is the zero set then).

            C1(s) + C2(t)
      < P - -------------, C1(t) - C2(s) > = 0.
                  2


Parameters:


 Crv1Inp, Crv2Inp:  wo curves to compute bisectors for.  Assumes
                     E2 curves.
 DenomOut:  he resulting denominator surface is stored here.



Returned Value:


  void



See Also:

  SymbCrvCnvxHull
  SymbCrvDiameter
  SymbCrvBisectors
  SymbCrvBisectorsSrf2
  
  SymbCrvBisectorsSrf
  SymbCrvPtBisectorsSrf3D
  SymbCrvCrvBisectorSrf3D.


Keywords:

  bisectors
  skeleton


 MvarBsctComputeF3 
  (mvtrmbis.c:142)

Prototype:

  void MvarBsctComputeF3(CagdCrvStruct *Crv1Inp,
                         CagdCrvStruct *Crv2Inp,
                         CagdCrvStruct **Crv1Coerced,
                         CagdCrvStruct **Crv2Coerced,
                         CagdSrfStruct **F3,
                         CagdSrfStruct **L1,
                         CagdSrfStruct **L2,
                         CagdSrfStruct **CC1,
                         CagdSrfStruct **CC2)


Description:

Computes the bisector surface definition of two curves. The result is a scalar surface whose zero set is the set of bisector(s) of the curves. Solve for the normal intersection surface in the plane and then substitute into (the bisector's correspondance is the zero set then).

            C1(s) + C2(t)
      < P - -------------, C1(t) - C2(s) > = 0.
                  2


Parameters:


 Crv1Inp, Crv2Inp:  wo curves to compute bisectors for.  Assumes
                     E2 curves.
 Crv1Coerced:  .S.F.I.
 Crv2Coerced:  .S.F.I.
 F3:          The resulting bisector surface is stored here.
 L1:          N.S.F.I.
 L2:          N.S.F.I.
 CC1:         N.S.F.I.
 CC2:         N.S.F.I.



Returned Value:


  void



See Also:

  SymbCrvCnvxHull
  SymbCrvDiameter
  SymbCrvBisectors
  SymbCrvBisectorsSrf2
  
  SymbCrvBisectorsSrf
  SymbCrvPtBisectorsSrf3D
  SymbCrvCrvBisectorSrf3D


Keywords:

  bisectors
  skeleton


 MvarBsctComputeLowerEnvelope 
  (mvlowenv.c:1045)

Prototype:

  void MvarBsctComputeLowerEnvelope(MvarVoronoiCrvStruct *InputCurves,
                                    MvarVoronoiCrvStruct **LowerEnvelope)


Description:

Given the monotone curves, compute the lower envelope. This is the main calling function. The current implementation is an improved version that uses the auxiliary MvarLECrvStruct structure for efficiency and robustness (less solver calls).

Parameters:

InputCurves:	A MvarVoronoiCrvStruct of monotone pieces.
LowerEnvelope:	A MvarVoronoiCrvStruct of lower envelope.

Returned Value:

void:

See Also:

MvarBsctComputeLowerEnvelopeAux MvarBsctComputeLowerEnvelopeOfOverlap MvarBsctMergeLowerEnvelopes MvarBsctSplitEnvelope1AtEnvelope2

Keywords:

MvarBsctComputeXYFromBisTR

(mvtrmbis.c:473)

Prototype:

CagdRType *MvarBsctComputeXYFromBisTR(CagdCrvStruct *Crv1, CagdRType t, CagdCrvStruct *Crv2, CagdRType r, CagdRType *InterPt)

Description:

Computes the bisector point given tr-values

Parameters:

Crv1:	First curve.
t:	Parameter value of first curve.
Crv2:	Second curve.
r:	Parameter value of second curve.
InterPt:	Bisector point from given tr.

Returned Value:

CagdRType *: Bisector point from given tr. Same as InterPt

Keywords:

MvarBsctCrvPtCurvature

(mvtrmpcr.c:473)

Prototype:

CagdCrvStruct *MvarBsctCrvPtCurvature(CagdCrvStruct *Crv, CagdRType *Pt, CagdRType Alpha)

Description:

Given the struct, this function says whether the bisector point satisfies the Curvature constraint.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
Alpha:	arameter of the alpha-sector - CagdRType. 0.5 for bisector.

Returned Value:

CagdCrvStruct *: CagdCrvStruct of the resultant.

See Also:

MvarBsctCrvPtLeft

Keywords:

MvarBsctCrvPtLeft

(mvtrmpcr.c:283)

Prototype:

CagdCrvStruct *MvarBsctCrvPtLeft(CagdCrvStruct *Crv, CagdRType *Pt, CagdRType Alpha)

Description:

Given the struct, this function says whether the bisector point satisfies the Left constraint.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
Alpha:	arameter of the alpha-sector - CagdRType. 0.5 for bisector.

Returned Value:

CagdCrvStruct *: CagdCrvStruct of the resultant.

See Also:

MvarBsctCrvPtCurvature

Keywords:

MvarBsctCurveLeft

(mvvorcrv.c:258)

Prototype:

void MvarBsctCurveLeft(MvarVoronoiCrvStruct *Cv, MvarPtStruct *Res)

Description:

A Geometric Primitive Function that returns the leftmost point of Cv.

Parameters:

Cv:	Input curve.
Res:	Output stored here.

Returned Value:

void

See Also:

MvarBsctCurveRight

Keywords:

MvarBsctCurveRight

(mvvorcrv.c:356)

Prototype:

void MvarBsctCurveRight(MvarVoronoiCrvStruct *Cv, MvarPtStruct *Res)

Description:

A Geometric Primitive Function that returns the rightmost point of Cv.

Parameters:

Cv:	nput curve
Res:	uput stored here

Returned Value:

void

See Also:

MvarBsctCurveLeft

Keywords:

MvarBsctCv1IsYSmallerAt

(mvvorcrv.c:467)

Prototype:

int MvarBsctCv1IsYSmallerAt(MvarVoronoiCrvStruct *Cv1, MvarVoronoiCrvStruct *Cv2, MvarPtStruct *MidPoint)

Description:

A Geometric Primitive Function that identifies whether Cv1 has Y min. at given mid-point parameter, assuming both curves are in range.

Parameters:

Cv1, Cv2:	nput curves.
MidPoint:	id-point parameter.

Returned Value:

int: Returns TRUE or FALSE.

Keywords:

MvarBsctDenomPtCrvBis

(mvtrmpcr.c:82)

Prototype:

CagdCrvStruct *MvarBsctDenomPtCrvBis(CagdCrvStruct *Crv, CagdPType Pt, CagdRType Alpha)

Description:

Computes the denominator of the alpha-/bi-sector curve of a planar curve and a point, all in the XY plane. The result is the denominator of the solution to the following two linear equations in alpha-/bi-sector's two unknowns, the x and y coefficients:

       = 
       =

where a is the Alpha of the alpha-sector, 0.5 for a bisector, Pt is the point entity, C(t) is the curve entity and B(t) is the saught bisector.

Parameters:

Crv:	Planar curve to compute its bisector curve with Pt.
Pt:	A point in the plane to compute its bisector with Crv.
Alpha:	Alpha-sector ratio (0.5 for a bisector).

Returned Value:

CagdCrvStruct *: The bisector curve, in the XY plane.

See Also:

SymbCrvDiameter SymbCrvCnvxHull SymbCrvBisectorsSrf SymbCrvCrvBisectorSrf3D SymbSrfPtBisectorSrf3D SymbCrvPtBisectorSrf3D

Keywords:

bisector

MvarBsctGetAllIntersectionPoints

(mvvorcrv.c:895)

Prototype:

void MvarBsctGetAllIntersectionPoints(MvarVoronoiCrvStruct *Cv1, MvarVoronoiCrvStruct *Cv2, MvarPtStruct **Points)

Description:

A Geometric Primitive Function that computes the equidistant points of three curves Cv1, Cv2 and Cv2 (third one also the second curve). Currently implemented just by calling Skel2DEqPts3Crvs (and purges away solutions). ToDo: implement a more efficient version, based on the already calculated F3.

Parameters:

Cv1, Cv2:	nput curves.
Points:	The resultant points.

Returned Value:

void

See Also:

MvarBsctSkel2DEqPts3Crvs

Keywords:

MvarBsctIsCrvLeftToLine

(mvtrmpcr.c:1069)

Prototype:

CagdRType MvarBsctIsCrvLeftToLine(CagdCrvStruct *Crv, CagdRType *Pt, CagdPType LeftNormal)

Description:

This function returns the value of the cross product between two vectors. First vector is between the point Pt and the midpoint of Crv and the second one is between the point and the LeftNormal.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The discontinuity point on Crv.
LeftNormal:	Left normal at the point Pt.

Returned Value:

CagdRType: Return the value of the expression.

See Also:

MvarBsctTrimCrvPt

Keywords:

MvarBsctIsCurveLL

(mvbiscon.c:35)

Prototype:

int MvarBsctIsCurveLL(MvarVoronoiCrvStruct *Cv)

Description:

Given the struct, this function says whether the bisector point is to the left of the curve or not. Compute the constraints as dot products 1st constraint > 0 2nd constraint > 0

Parameters:

Cv:	MvarVoronoiCrvStruct

Returned Value:

int: TRUE or FALSE.

See Also:

MvarBsctApplyLL

Keywords:

bisectors

MvarBsctIsXSmaller

(mvvorcrv.c:175)

Prototype:

int MvarBsctIsXSmaller(MvarPtStruct *P1, MvarPtStruct *P2)

Description:

A Geometric Primitive Function that identifies which x-coord of the two points P1 and P2 is smaller.

Parameters:

P1, P2:	oints as input.

Returned Value:

int: Returns true or false.

Keywords:

MvarBsctNewFindZeroSetOfSrfAtParam

(mvsplmon.c:206)

Prototype:

MvarPtStruct *MvarBsctNewFindZeroSetOfSrfAtParam(CagdSrfStruct *Srf, CagdRType Param, CagdSrfDirType Dir, CagdRType MvarBsctSubdivTol, CagdRType MvarBsctNumerTol, CagdBType ShouldCheckEndPoints)

Description:

Find the zeroset value at the given paramter of the given surface

Parameters:

Srf:	Implicit surface definition.
Param:	Parametric value for computation.
Dir:	U or V direction for computation
MvarBsctSubdivTol:	Subdivision tolerance for the multivariate solver.
MvarBsctNumerTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if MvarBsctNumerTol < MvarBsctSubdivTol.
ShouldCheckEndPoints:	o include end points also for checking.

Returned Value:

MvarPtStruct *: The computed values

Keywords:

MvarBsctPurgeAwayLLAndCCConstraints

(mvbiscon.c:358)

Prototype:

MvarVoronoiCrvStruct *MvarBsctPurgeAwayLLAndCCConstraints(MvarVoronoiCrvStruct *InputCrvs)

Description:

Given the struct, this function says whether the bisector point satisfies the LL and Curvature constraints

Parameters:

InputCrvs:	A VoronoiCrvStruct of monotone pieces

Returned Value:

MvarVoronoiCrvStruct *: VoronoiCrvStruct for storing the resultant

See Also:

MvarBsctApplyLL MvarBsctApplyCC

Keywords:

bisectors

MvarBsctSkel2DEqPts3Crvs

(mvtrmbis.c:553)

Prototype:

MvarPtStruct *MvarBsctSkel2DEqPts3Crvs(CagdCrvStruct *Crv1Inp, CagdCrvStruct *Crv2Inp, CagdCrvStruct *Crv3Inp)

Description:

Formulate multivariate constraints for the points that are at equal distance from the three primitives and solve for them. Assumes that the three primitives are lines or curves and that they do NOT intersect. Modified from from skel2d.c in mvar_lib to suit our needs

Parameters:

Crv1Inp, Crv2Inp, Crv3Inp:	The three input primitives to consider.

Returned Value:

MvarPtStruct *: A linked list of all equadistant points computed, or NULL if none found.

Keywords:

MvarBsctSplitCurve

(mvvorcrv.c:984)

Prototype:

void MvarBsctSplitCurve(MvarVoronoiCrvStruct *Cv, MvarPtStruct *SplitPt, MvarVoronoiCrvStruct **CvLeft, MvarVoronoiCrvStruct **CvRight)

Description:

A Geometric Primitive Function that splits the given curve into two - left and right curve of a given parameter t.

Parameters:

Cv:	Input curve.
SplitPt:	The parameter at which to split.
CvLeft, CvRight:	he resultant split curves.

Returned Value:

void

Keywords:

MvarBsctSplitImplicitCrvToMonotonePieces

(mvsplmon.c:1146)

Prototype:

void MvarBsctSplitImplicitCrvToMonotonePieces(CagdSrfStruct *Srf, CagdSrfStruct **OutLst, CagdRType MvarBsctSubdivTol, CagdRType MvarBsctNumerTol)

Description:

Splits the bivariate zero set Srf=0 (implicit form) into uv-monotone pieces. The recursive algorithm is based on the paper by Keyser et al.

Parameters:

Srf:	Implicit surface definition.
OutLst:	Output list of uv-monotone surfaces.
MvarBsctSubdivTol:	Subdivision tolerance for multivariate solver.
MvarBsctNumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if MvarBsctNumerTol < MvarBsctSubdivTol.

Returned Value:

void

Keywords:

MvarBsctTrimCrvPt

(mvtrmpcr.c:1132)

Prototype:

CagdCrvStruct *MvarBsctTrimCrvPt(CagdCrvStruct *Crv, CagdRType *Pt, CagdRType Alpha, CagdCrvStruct *BaseCrv)

Description:

This function returns the radial lower envelope if the input is a (list of) crv (s) and a point or returns the trimmed bisector if the input is a pair of crv and a point.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
Alpha:	arameter of the alpha-sector - CagdRType. 0.5 for bisector.
BaseCrv:	he Crv for which the trimming is sought along its discontinuity point.

Returned Value:

CagdCrvStruct *: Return the list of trimmed bisector curves.

See Also:

MvarBsctTrimCrvPtPair MvarBsctCrvPtLeft MvarBsctCrvPtCurvature SymbCrvsLowerEnvelop

Keywords:

bisectors

MvarBsctTrimCrvPtPair

(mvtrmpcr.c:770)

Prototype:

CagdCrvStruct *MvarBsctTrimCrvPtPair(CagdCrvStruct *Crv, CagdRType *Pt, CagdRType Alpha)

Description:

Given the struct, this function says whether the bisector point satisfies the LL and Curvature constraint for a crv and a point pair and trims it to the minimum.

Parameters:

Crv:	The input curve - CagdCrvStruct.
Pt:	The input point - CagdRType.
Alpha:	arameter of the alpha-sector - CagdRType. 0.5 for bisector.

Returned Value:

CagdCrvStruct *: Return the list of trimmed bisector curves.

See Also:

MvarBsctTrimCrvPt MvarBsctCrvPtLeft MvarBsctCrvPtCurvature

Keywords:

MvarBsctTrimCurveBetween

(mvlowenv.c:115)

Prototype:

void MvarBsctTrimCurveBetween(MvarVoronoiCrvStruct *Cv, MvarPtStruct *Pt1, MvarPtStruct *Pt2, MvarVoronoiCrvStruct **TrimmedCurve)

Description:

Splitting the Cv at the given points Pt1 and Pt2.

Parameters:

Cv:	Given a MvarVoronoiCrvStruct Cv.
Pt1:	A MvarPtStruct.
Pt2:	A MvarPtStruct.
TrimmedCurve:	MvarVoronoiCrvStruct of the resultant.

Returned Value:

void

See Also:

MvarBsctComputeLowerEnvelope MvarBsctMergeLowerEnvelopes MvarBsctComputeLowerEnvelopeAux MvarBsctComputeLowerEnvelopeOfOverlap

Keywords:

MvarBsctTrimSurfaceByUVBbox

(mvsplmon.c:369)

Prototype:

CagdSrfStruct *MvarBsctTrimSurfaceByUVBbox(CagdSrfStruct *Srf, CagdBBoxStruct UVBbox)

Description:

Trims the given surface Srf using the given box dimensions. Uses CagdSrfRegionFromSrf twice.

Parameters:

Srf:	Implicit surface definition.
UVBbox:	Given box dimensions.

Returned Value:

CagdSrfStruct *: The trimmed surface

Keywords:

MvarBspCrvInterpVecs

(mvar_int.c:58)

Prototype:

CagdCrvStruct *MvarBspCrvInterpVecs(const MvarVecStruct *vecList, int Order, int CrvSize, CagdParametrizationType ParamType, CagdBType Periodic)

Description:

Given a set of points, vecList, computes a Bspline curve of order Order that interpolates or least square approximates the set of points. The size of the control polygon of the resulting Bspline curve defaults to the number of points in PtList (if CrvSize = 0). However, this number is can smaller to yield a least square approximation. The created curve can be parametrized as specified by ParamType.

Parameters:

vecList:	List of points to interpolate/least square approximate. All points are assumed of same dimension (not tested.).
Order:	Of interpolating/approximating curve.
CrvSize:	Number of degrees of freedom (control points) of the interpolating/approximating curve.
ParamType:	Type of parametrization.
Periodic:	Constructed curve should be Periodic. Periodic necessitates uniform knot sequence in ParamType.

Returned Value:

CagdCrvStruct *: Constructed interpolating/approximating curve.

See Also:

BspCrvInterpPts BspCrvInterpolate BspCrvInterpPts2

Keywords:

interpolation least square approximation

MvarBspMVDerive

(mvar_der.c:176)

Prototype:

MvarMVStruct *MvarBspMVDerive(const MvarMVStruct *MV, MvarMVDirType Dir, CagdBType DeriveScalar)

Description:

Given a B-spline multi-variate, computes its partial derivative multi-variate in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)) / (Kv(i + k) - Kv(i + 1)), i = 0 to k-2.

This function computes the derivative of a rational function component- wise without taking into consideration the quotient rule.

Parameters:

MV:	Multi-Variate to differentiate.
Dir:	Direction of differentiation.
DeriveScalar:	TRUE to differentiate each channel independently. FALSE to treat geometry as a rational differentiation.

Returned Value:

MvarMVStruct *: Differentiated multi-variate in direction Dir. A B-spline multi-variate.

See Also:

MvarMVDeriveBound MvarBzrMVDerive MvarMVDerive

Keywords:

multi-variates

MvarBspMVDeriveAllBounds

(mvar_der.c:583)

Prototype:

void MvarBspMVDeriveAllBounds(const MvarMVStruct *MV, IrtMinMaxType *MinMax)

Description:

Given a scalar B-spline multi-variate, computes bounds to its partial derivative in all directions. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)) / (Kv(i + k) - Kv(i + 1)), i = 0 to k-2.


Parameters:


 MV:       Multi-Variate to differentiate.
 MinMax:   Bounds on the derivative values of MV in all directions.



Returned Value:


  void



See Also:

  MvarMVDerive
  MvarBzrMVDeriveBound
  MvarMVDeriveBound


Keywords:

  multi-variates


 MvarBspMVDeriveBound 
  (mvar_der.c:410)

Prototype:

  void MvarBspMVDeriveBound(const MvarMVStruct *MV,
                            MvarMVDirType Dir,
                            CagdRType MinMax[2])


Description:

Given a scalar B-spline multi-variate, computes bounds to its partial derivative in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)) / (Kv(i + k) - Kv(i + 1)), i = 0 to k-2.


Parameters:


 MV:       Multi-Variate to differentiate.
 Dir:      Direction of differentiation.
 MinMax:   Bounds on the derivative values of MV in direction Dir.



Returned Value:


  void



See Also:

  MvarMVDerive
  MvarBzrMVDeriveBound
  MvarMVDeriveBound


Keywords:

  multi-variates


 MvarBspMVDeriveRational 
  (mvbspsym.c:203)

Prototype:

  MvarMVStruct *MvarBspMVDeriveRational(const MvarMVStruct *MV,
                                        MvarMVDirType Dir)


Description:

Given a rational B-spline multivariates - computes its derivative surface in direction Dir, using the quotient rule for differentiation.

Parameters:

MV:	Rational B-spline multivariate to differentiate.
Dir:	Direction of Differentiation.

Returned Value:

MvarMVStruct *: Differentiated rational B-spline multivariate.

See Also:

MvarMVDerive MvarBzrMVDerive MvarBspMVDerive MvarBzrMVDeriveRational

Keywords:

derivatives

MvarBspMVDeriveScalar

(mvar_der.c:283)

Prototype:

MvarMVStruct *MvarBspMVDeriveScalar(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Given a Bezier multi-variate, computes its partial derivative multi-variate in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)), i = 0 to k-2.

For a Euclidean surface this is the same as MvarBzrMVDerive but for a rational multivar the returned multivar is not the vector field but simply the derivatives of all the multivar's coefficients, including the weights.

Parameters:

MV:	To differentiate.
Dir:	Direction of differentiation. Either U or V.

Returned Value:

MvarMVStruct *: Differentiated multi-variate.

See Also:

MvarMVDeriveBound MvarMVDerive MvarBspMVDerive MvarBspMVDerive MvarBzrMVDeriveScalar

Keywords:

derivatives

MvarBspMVHasOpenEC

(mvar_aux.c:1393)

Prototype:

CagdBType MvarBspMVHasOpenEC(const MvarMVStruct *MV)

Description:

Returns TRUE iff the given B-spline multivariate has open end conditions in all direction directions.

Parameters:

MV:	To check for open end conditions.

Returned Value:

CagdBType: TRUE, if MV has open end conditions in all directions, FALSE otherwise.

See Also:

BspCrvHasOpenEC MvarBspMVHasOpenECInDir MvarBspMVHasOpenECInDir

Keywords:

open end conditions

MvarBspMVHasOpenECInDir

(mvar_aux.c:1364)

Prototype:

CagdBType MvarBspMVHasOpenECInDir(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Returns TRUE iff the given B-spline multivariate has open end conditions in the specified direction Dir.

Parameters:

MV:	To check for open end conditions.
Dir:	Direction to test for open end conditions.

Returned Value:

CagdBType: TRUE, if MV has open end conditions in Dir, FALSE otherwise.

See Also:

BspCrvHasOpenEC MvarBspMVHasOpenEC MvarBspMVIsPeriodic MvarBspMVIsPeriodicInDir

Keywords:

open end conditions

MvarBspMVInteriorKnots

(mvar_aux.c:1487)

Prototype:

int MvarBspMVInteriorKnots(const MvarMVStruct *MV, CagdRType *Knot)

Description:

Returns -1 if the given B-spline multivariate has not interior knots in no direction. Otherwise, return the direction that has an interior knot and returns the knot value in Knot.

Parameters:

MV:	To check for interior knots.
Knot:	Where to return an interior knot if found one.

Returned Value:

int: -1 if MV has no interior knots, Axis of interior knot otherwise.

See Also:

BspCrvHasOpenEC MvarBspMVHasOpenEC MvarBspMVHasOpenECInDir MvarBspMVIsPeriodicInDir

Keywords:

Internal knots Bezier

MvarBspMVIsPeriodic

(mvar_aux.c:1455)

Prototype:

CagdBType MvarBspMVIsPeriodic(const MvarMVStruct *MV)

Description:

Returns TRUE iff the given B-spline multivariate has periodic end conditions in at least one direction.

Parameters:

MV:	To check for periodic end conditions.

Returned Value:

CagdBType: TRUE, if MV has periodic end conditions in some Dir, FALSE otherwise.

See Also:

BspCrvHasOpenEC MvarBspMVHasOpenEC MvarBspMVHasOpenECInDir MvarBspMVIsPeriodicInDir MvarBspMVInteriorKnots

Keywords:

periodic end conditions

MvarBspMVIsPeriodicInDir

(mvar_aux.c:1431)

Prototype:

CagdBType MvarBspMVIsPeriodicInDir(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Returns TRUE iff the given B-spline multivariate has periodic end conditions in the specified direction Dir.

Parameters:

MV:	To check for periodic end conditions.
Dir:	Direction to test for periodic end conditions.

Returned Value:

CagdBType: TRUE, if MV has periodic end conditions in Dir, FALSE otherwise.

See Also:

BspCrvHasOpenEC MvarBspMVHasOpenEC MvarBspMVHasOpenECInDir MvarBspMVIsPeriodic

Keywords:

periodic end conditions

MvarBspMVKnotInsertNDiff

(mvar_ref.c:88)

Prototype:

MvarMVStruct *MvarBspMVKnotInsertNDiff(const MvarMVStruct *MV, MvarMVDirType Dir, int Replace, CagdRType *t, int n)

Description:

Given a Bspline multi-variate, inserts n knots with different values as defined by t. If, however, Replace is TRUE, the knot are simply replacing the current knot vector in the prescribed direction.

Parameters:

MV:	Multi-variate to refine according to t in direction Dir.
Dir:	Direction of refinement. Either U or V or W.
Replace:	If TRUE t is a knot vector exactly in the length of the knot vector in direction Dir in MV and t simply replaces that knot vector. If FALSE, the knot vector in direction Dir in MV is refined by adding all the knots in t.
t:	Knot vector to refine/replace the knot vector of MV in direction Dir.
n:	Length of vector t.

Returned Value:

MvarMVStruct *: The refined multi-variate. A Bspline multi-variate.

Keywords:

multi-variates

MvarBspMVMult

(mvbspsym.c:58)

Prototype:

MvarMVStruct *MvarBspMVMult(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2)

Description:

Given two B-spline multivariates - multiply them coordinate-wise. The two multivariates are promoted to same point type before multiplication can take place. See also BspMultComputationMethod.

Parameters:

CMV1, CMV2:	The two multivariates to multiply.

Returned Value:

MvarMVStruct : The product MV1 MV2 coordinate-wise.

Keywords:

product

MvarBspMVNew

(mvar_gen.c:173)

Prototype:

MvarMVStruct *MvarBspMVNew(int Dim, const int *Lengths, const int *Orders, MvarPointType PType)

Description:

Allocates the memory required for a new Bspline multi-variate.

Parameters:

Dim:	Number of dimensions of this multivariate.
Lengths:	Of control mesh in each of the dimensions. Vector of size Dim.
Orders:	Of multi variate function in each of the dimensions.
PType:	Type of control points (E2, P3, etc.).

Returned Value:

MvarMVStruct *: An uninitialized freeform multi-variate Bspline.

See Also:

MvarMVFree MvarBzrMVNew MvarMVNew MvarPwrMVNew

Keywords:

multi-variates allocation

MvarBspMVSubdivAtParam

(mvar_sub.c:233)

Prototype:

MvarMVStruct *MvarBspMVSubdivAtParam(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir)

Description:

Given a Bspline multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	BsplineMulti-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.

Returned Value:

MvarMVStruct *: A list of two multi-variates, result of the subdivision.

See Also:

MvarMVSubdivAtParam MvarBzrMVSubdivAtParam

Keywords:

multi-variates

MvarBspMVSubdivAtParamOneSide

(mvar_sub.c:638)

Prototype:

MvarMVStruct *MvarBspMVSubdivAtParamOneSide(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir, IrtBType LeftSide)

Description:

Given a B-spline multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	BsplineMulti-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.
LeftSide:	TRUE to only fetch left half, FALSE to fetch right half.

Returned Value:

MvarMVStruct *: A single multi-variate, result of the subdivision.

See Also:

MvarMVSubdivAtParam MvarBzrMVSubdivAtParam

Keywords:

multi-variates

MvarBspMultComputationMethod

(mvbspsym.c:37)

Prototype:

int MvarBspMultComputationMethod(int BspMultUsingInter)

Description:

Sets method of B-spline product computation.

Parameters:

BspMultUsingInter:	If TRUE, B-spline product is computed by setting an interpolation problem. Otherwise, by decomposing the B-spline geometry to Bezier geometry.

Returned Value:

int: Previous setting.

Keywords:

product

MvarBspSrfSelfInterDiagFactor

(selfintr.c:1651)

Prototype:

MvarPolylineStruct *MvarBspSrfSelfInterDiagFactor(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Given a B-spline surface, S, compute its self intersections, if any, by dividing it at all internal knots and examining all patches against all other patches. Diagonal patches should also be examined against themselves with the aid of MvarBzrSrfSelfInterDiagFactor. Adjacent patches are sharing an edge (a curve) and hence spacial care is taken in those cases to eliminate and ignore that shared curve, in MvarAdjacentSrfSrfInter.

Parameters:

Srf:	The surface to derive its self intersections.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	Tolerance of the second zero set finding numeric stage.

Returned Value:

MvarPolylineStruct *: List of self intersection pllns, as (u, v) parameter pairs into the surfaces' domain. Points in R^4.

See Also:

MvarAdjacentSrfSrfInter MvarBzrSrfSelfInterDiagFactor

Keywords:

MvarBuildParamMV

(mvar_gen.c:270)

Prototype:

MvarMVStruct *MvarBuildParamMV(int Dim, int Dir, CagdRType Min, CagdRType Max)

Description:

Construct an MV that serves as a parameter function in direction Dir.

Parameters:

Dim:	Number of dimensions of the MV parameter function.
Dir:	Direction of this parameter (between 0 and Dim-1).
Min, Max:	The range of this parameter.

Returned Value:

MvarMVStruct *: Constructed parameter MV function.

See Also:

Keywords:

MvarBzrLinearInOneDir

(mvar_aux.c:1526)

Prototype:

MvarMVStruct *MvarBzrLinearInOneDir(int Dim, int Dir, MvarPointType PType)

Description:

Creates a Bezier multivariate that is constant in all directions but one.

Parameters:

Dim:	DImension f the sought multivariate Bezier.
Dir:	The direction that is to be linear, between 0 and Dim-1.
PType:	ype of points of this new multivariate.

Returned Value:

MvarMVStruct *: The constructed multivariate.

See Also:

Keywords:

MvarBzrMVDerive

(mvar_der.c:74)

Prototype:

MvarMVStruct *MvarBzrMVDerive(const MvarMVStruct *MV, MvarMVDirType Dir, CagdBType DeriveScalar)

Description:

Given a Bezier multi-variate, computes its partial derivative multi-variate in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)), i = 0 to k-2.

This function computes the derivative of a rational function component- wise without taking into consideration the quotient rule.

Parameters:

MV:	Multi-Variate to differentiate.
Dir:	Direction of differentiation.
DeriveScalar:	TRUE to differentiate each channel independently. FALSE to treat geometry as a rational differentiation.

Returned Value:

MvarMVStruct *: Differentiated multi-variate in direction Dir. A Bezier multi-variate.

See Also:

MvarMVDeriveBound MvarMVDerive MvarBspMVDerive MvarBzrMVDeriveScalar

Keywords:

multi-variates

MvarBzrMVDeriveAllBounds

(mvar_der.c:518)

Prototype:

void MvarBzrMVDeriveAllBounds(const MvarMVStruct *MV, CagdMinMaxType *MinMax)

Description:

Given a scalar Bezier multi-variate, computes bounds to its partial derivative in all directions. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)), i = 0 to k-2.


Parameters:


 MV:       Multi-Variate to differentiate.
 MinMax:   Bounds on the derivative values of MV in all directions.



Returned Value:


  void



See Also:

  MvarMVDerive
  MvarMVDeriveBound
  MvarBspMVDeriveBound


Keywords:

  multi-variates


 MvarBzrMVDeriveBound 
  (mvar_der.c:351)

Prototype:

  void MvarBzrMVDeriveBound(const MvarMVStruct *MV,
                            MvarMVDirType Dir,
                            CagdRType MinMax[2])


Description:

Given a scalar Bezier multi-variate, computes bounds to its partial derivative in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)), i = 0 to k-2.


Parameters:


 MV:       Multi-Variate to differentiate.
 Dir:      Direction of differentiation.
 MinMax:   Bounds on the derivative values of MV in direction Dir.



Returned Value:


  void



See Also:

  MvarMVDerive
  MvarMVDeriveBound
  MvarBspMVDeriveBound


Keywords:

  multi-variates


 MvarBzrMVDeriveRational 
  (mvbzrsym.c:525)

Prototype:

  MvarMVStruct *MvarBzrMVDeriveRational(const MvarMVStruct *MV,
                                        MvarMVDirType Dir)


Description:

Given a rational Bezier multivariates - computes its derivative surface in direction Dir, using the quotient rule for differentiation.

Parameters:

MV:	Rational Bezier multivariate to differentiate.
Dir:	Direction of Differentiation.

Returned Value:

MvarMVStruct *: Differentiated rational Bezier multivariate.

See Also:

MvarMVDerive MvarBzrMVDerive MvarBzrMVDerive MvarBzrMVDeriveRational

Keywords:

derivatives

MvarBzrMVDeriveScalar

(mvar_der.c:139)

Prototype:

MvarMVStruct *MvarBzrMVDeriveScalar(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Given a Bezier multi-variate, computes its partial derivative multi-variate in direction Dir. Let old control polygon be P(i), i = 0 to k-1, and Q(i) be new one. Then:

Q(i) = (k - 1) * (P(i+1) - P(i)), i = 0 to k-2.

MV:	To differentiate.
Dir:	Direction of differentiation. Either U or V.

Returned Value:

MvarMVStruct *: Differentiated multi-variate.

See Also:

MvarMVDeriveBound MvarMVDerive MvarBspMVDerive MvarBzrMVDerive MvarBspMVDeriveScalar

Keywords:

derivatives

MvarBzrMVMult

(mvbzrsym.c:309)

Prototype:

MvarMVStruct *MvarBzrMVMult(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two Bezier multivariates - multiply them coordinate-wise. The two multivariates are promoted to same point type before multiplication can take place. See also BzrMultInterpFlag.

Parameters:

MV1, MV2:	The two multivariates to multiply.

Returned Value:

MvarMVStruct : The product MV1 MV2 coordinate-wise.

Keywords:

product

MvarBzrMVNew

(mvar_gen.c:214)

Prototype:

MvarMVStruct *MvarBzrMVNew(int Dim, const int *Lengths, MvarPointType PType)

Description:

Allocates the memory required for a new Bezier multi-variate.

Parameters:

Dim:	Number of dimensions of this multivariate.
Lengths:	Of control mesh in each of the dimensions. Vector of size Dim.
PType:	Type of control points (E2, P3, etc.).

Returned Value:

MvarMVStruct *: An uninitialized freeform multi-variate Bezier.

See Also:

MvarMVFree MvarMVNew MvarBspMVNew MvarPwrMVNew

Keywords:

multi-variates allocation

MvarBzrMVRegionFromMV

(mvar_aux.c:747)

Prototype:

MvarMVStruct *MvarBzrMVRegionFromMV(const MvarMVStruct *MV, CagdRType t1, CagdRType t2, MvarMVDirType Dir)

Description:

Changing the domain of a multivariate, in direction Dir, such that: The values of the output multivariate over [0,1] in direction Dir, are those of the input multivariate over [NewMinDmn,NewMaxDmn]. If required, the user of this function should map back point x from [0,1] to [NewMinDmn,NewMaxDmn] by the affine domain change: y[dir] = (1 - x[dir]) * NewMinDmn + x[dir] * NewMaxDmn. NOTE: when the new domain is always known to be contained in the old domain, if possible use MvarMVRegionFromMV, which suits B-splines as well and supports the same operation. This function is made for cases where a new region is not contained in [0,1].

Parameters:

MV:	The Bezier multivariate, values of which are required over a domain other than [0,1].
t1:	The required min' domain.
t2:	The required max' domain.
Dir:	he direction to extract the domain.

Returned Value:

MvarMVStruct *: The new MV with the required new domain.

See Also:

MvarMVRegionFromMV MvarMVExtension

Keywords:

MvarBzrMVSubdivAtParam

(mvar_sub.c:179)

Prototype:

MvarMVStruct *MvarBzrMVSubdivAtParam(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir)

Description:

Given a Bezier multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	Bezier Multi-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.

Returned Value:

MvarMVStruct *: A list of two multi-variates, result of the subdivision.

See Also:

MvarBspMVSubdivAtParam MvarMVSubdivAtParam

Keywords:

multi-variates

MvarBzrMVSubdivAtParamOneSide

(mvar_sub.c:574)

Prototype:

MvarMVStruct *MvarBzrMVSubdivAtParamOneSide(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir, IrtBType LeftSide)

Description:

Given a Bezier multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	Bezier Multi-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.
LeftSide:	TRUE to only fetch left half, FALSE to fetch right half.

Returned Value:

MvarMVStruct *: A single multi-variate, result of the subdivision.

See Also:

MvarBspMVSubdivAtParamOneSide MvarMVSubdivAtParam

Keywords:

multi-variates

MvarBzrMultBrnBasis

(mvbzrsym.c:216)

Prototype:

MvarMVStruct *MvarBzrMultBrnBasis(const MvarMVStruct *MV, int *MulOrders, int *MulIndices)

Description:

Given a Bezier multivariate and a Bernstein basis function - multiply them coordinate-wise.

Parameters:

MV:	A Bezier multivariate.
MulOrders:	The orders of the Bernstein basis function to multiply with.
MulIndices:	ulIndices[i] is the exponent of the ith variable of the given Bernstein basis function.

Returned Value:

MvarMVStruct *: The product of MV with the given Bernstein basis monomial, coordinate-wise.

Keywords:

product

MvarBzrSelfInter4VarDecomp

(selfintr.c:1043)

Prototype:

void MvarBzrSelfInter4VarDecomp(const CagdSrfStruct *Srf, MvarMVStruct **U1MinusU3Factor, MvarMVStruct **U2MinusU4Factor)

Description:

Given a 2-variate Bezier function, Srf, that is to be subtracted from itself as,

         F(u1, u2, u3, u4) = Srf(u1, u2) - Srf(u3, u4),

computes a decomposition for F as

         F(u1, u2, u3, u4) = (u1 - u3) G(u1, u2, u3, u4) +
                             (u2 - u4) H(u1, u2, u3, u4),

that is known to always exist.

Parameters:

Srf:	The 2-variate to subtract against itself and decompose.
U1MinusU3Factor:	he G function above.
U2MinusU4Factor:	he H function above.

Returned Value:

void

See Also:

Keywords:

MvarBzrSrfSelfInterDiagFactor

(selfintr.c:1268)

Prototype:

MvarPolylineStruct *MvarBzrSrfSelfInterDiagFactor(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Given a Bezier surface, S, compute its self intersections, if any, by computing a (u1 - u3) G(u1, u2, u3, u4) + (u2 - u4) H(u1, u2, u3, u4) decomposition for the 4-variate function of S(u1, u2)-S(u3, u4). The self intersection is then derived as the solution of:

        Gx Hy - Gy Hx = 0,
        Gx Hz - Gz Hx = 0,
        (u1 - u3) Gx + (u2 - u4) Hx = 0.

The first two equations ensure the G an H are parallel while the last guarantee a zero point in X (which is therefore a zero point in Y an Z.) Due to singularities in these equations, all six equations of the form:

        Gx Hy - Gy Hx = 0,
        Gx Hz - Gz Hx = 0,
        Gy Hz - Gz Hy = 0,
        (u1 - u3) Gx + (u2 - u4) Hx = 0,
        (u1 - u3) Gy + (u2 - u4) Hy = 0,
        (u1 - u3) Gz + (u2 - u4) Hz = 0,

are employed during the subdivision stage. Finally a 7th equations of the form "|| S - S ||^2 = 0 is added for faster pruning of far regions.

Parameters:

Srf:	The surface to derive its self intersections.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	Tolerance of the second zero set finding numeric stage.

Returned Value:

MvarPolylineStruct *: List of self intersection pllns, as (u, v) parameter pairs into the surfaces' domain. Points in R^4.

See Also:

MvarBzrSelfInter4VarDecomp

Keywords:

MvarCalculateExtremePoints

(mvarjimp.c:299)

Prototype:

MvarPtStruct *MvarCalculateExtremePoints(const MvarMVStruct *MV)

Description:

Calculates list of extreme points of a given scalar function. Supports up to dimension 3 (i.e. trivariates). Note that the result, the returned list of parameteric locations, is a super set of the extreme values MV can assume as we decompose MV into low dimensional entities (i.e. boundary surfaces and curves) and an extrema in a lower diemsnional entities does not mean it is an extreme in MV.

Parameters:

MV:	Input scalar function, represented as a multivariate, to compute parametric locations of extreme values.

Returned Value:

MvarPtStruct *: List of extreme multivariate points candidates returns NULL in case of invalid input.

Keywords:

MvarCalculateTVJacobian

(mvarjimp.c:635)

Prototype:

MvarMVStruct *MvarCalculateTVJacobian(const TrivTVStruct *TV)

Description:

Calculates the Jacobian of a given trivariate.

Parameters:

TV:	The input trivariate.

Returned Value:

MvarMVStruct *: The Jacobian in a multi variate representation.

See Also:

Symb2DSrfJacobian MvarTrivJacobianImprove MvarCalculateExtremePoints TrivComputeJacobian

Keywords:

MvarCircAtDirMax

(mvarpck3.c:312)

Prototype:

MvarPtStruct *MvarCircAtDirMax(const CagdCrvStruct *Bndry, CagdPType XBnd, CagdPType YBnd, CagdRType Radius, const CagdPType Dir, CagdRType NumericTol, CagdRType SubdivTol)

Description:

Computes all circles which are tangent to a given cirve and have a locally maximum projection on a given direction. The following set of multivariates is solved:

      < Bndry(u) - (x,y), Bndry(u) - (x, y) > = R^2,
      < Bndry(u) - (x,y), Bndry'(u) > = 0,
      < Bndry'(u),  Dir > = 0


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 XBnd:          The range of x-coordinate of bounding box of Bndry.
 YBnd:          The range of y-coordinate of bounding box of Bndry.
 Radius:        The radius of the circle.
 Dir:           The direction to project the circle center on.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (x,y) solution points.



See Also:

  MvarCircTanAtTwoPts


Keywords:



 MvarCircOnLineTangToBdry 
  (mvarpck3.c:452)

Prototype:

  MvarPtStruct *MvarCircOnLineTangToBdry(const CagdCrvStruct *Bndry,
                                         const CagdCrvStruct *InNrml,
                                         CagdRType Radius,
                                         const CagdPType Dir,
                                         const CagdPType Pt,
                                         CagdRType NumericTol,
                                         CagdRType SubdivTol)


Description:

Computes all circles which are tangent to a given curve and whose centers lie on a given line. Following system of multivariates is solved:

      < Pt + c.Dir - Bndry(t), Bndry'(t) > = 0,
      < Pt + c.Dir - Bndry(t), Pt + c.Dir - Bndry(t) > - Radius^2= 0.


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 InNrml:        Normal pointing in the interior of Bndry, or NULL.
 Radius:        The radius of the circle.
 Dir:           The direction of the line on which circle center must lie.
 Pt:            A point through which the line passes.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (c,t) solution points.



Keywords:



 MvarCircTanAtTwoPts 
  (mvarpck3.c:578)

Prototype:

  MvarPtStruct *MvarCircTanAtTwoPts(const CagdCrvStruct *Bndry,
                                    CagdPType XBnd,
                                    CagdPType YBnd,
                                    CagdRType Radius,
                                    CagdRType NumericTol,
                                    CagdRType SubdivTol)


Description:

Computes all circles which are tangent to a given curve at two distinct points. The following set of multivariates is solved:

      < Bndry(u) - (x,y), Bndry(u) - (x, y) > = R^2,
      < Bndry(u) - (x,y), Bndry'(u) > = 0,
      < Bndry(v) - (x,y), Bndry(v) - (x, y) > = R^2,
      < Bndry(v) - (x,y), Bndry'(v) > = 0,
      u - v > Eps


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 XBnd:          The range of x-coordinate of bounding box of Bndry.
 YBnd:          The range of y-coordinate of bounding box of Bndry.
 Radius:        The radius of the circle.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (x,y) solution points.



See Also:

  MvarCircAtDirMax


Keywords:



 MvarCircTanTo2Crvs 
  (mvtangnt.c:415)

Prototype:

  MvarPtStruct *MvarCircTanTo2Crvs(const CagdCrvStruct *Crv1,
                                   const CagdCrvStruct *Crv2,
                                   CagdRType Radius,
                                   CagdRType Tol)


Description:

Computes all circles of prescribed radius that are tangent to given two curves. Solves for circles' centers P(x, y), using the following four equations in four unknowns (t, r, x, y), and R is the desired circle radius:

      ||C1(t) - P||^2 = R^2,
      ||C2(r) - P||^2 = R^2,
      < C1(t) - P, C1'(t) > = 0,
      < C2(t) - P, C2'(t) > = 0.


Parameters:


 Crv1, Crv2:  he two curves to find the circles that is tangent to both.
 Radius:     Of all the circle(s) that is tangent to Crv1/2.
 Tol:        Tolerance of approximation.  Subdiv Tol of MV Zeros.



Returned Value:


  MvarPtStruct *:    List of the 4-tuples as (t, r, x, y).



See Also:

  SymbCircTanTo2Crvs
  MvarCircTanTo3Crvs


Keywords:

  bi-tangent


 MvarCircTanTo3Crvs 
  (mvtangnt.c:553)

Prototype:

  MvarPtStruct *MvarCircTanTo3Crvs(const CagdCrvStruct *Crv1,
                                   const CagdCrvStruct *Crv2,
                                   const CagdCrvStruct *Crv3,
                                   CagdRType SubdivTol,
                                   CagdRType NumericTol,
                                   CagdBType OneSideOrientation)


Description:

Computes all circles that are tangent to given three curves. Solves for circles' centers P(x, y), using the following process: Solve, symbolically for P in the following 2x2 system by Cremmer rule:

      ||C1(u) - P||^2 = ||C2(v) - P||^2,
      ||C1(u) - P||^2 = ||C3(w) - P||^2,

and substitute P into the following 3 euqations and solve 3 equations in (u, v, w):

      < C1(u) - P, C1'(u) > = 0,
      < C2(v) - P, C2'(v) > = 0,
      < C3(w) - P, C2'(w) > = 0.


Parameters:


 Crv1, Crv2, Crv3:  he two curves to find the circles that is tangent to
                  both.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 OneSideOrientation:   TRUE to compute tri-tangencies on one side of the
                  curves only.



Returned Value:


  MvarPtStruct *:    List of (u, v, w) solution points.



See Also:

  MvarCircTanTo2Crvs


Keywords:

  tri-tangent


 MvarCircTanToCircCrv3By3 
  (mvarpck3.c:760)

Prototype:

  MvarPtStruct *MvarCircTanToCircCrv3By3(const CagdCrvStruct *Bndry,
                                         const CagdCrvStruct *InNrml,
                                         CagdPType XBnd,
                                         CagdPType YBnd,
                                         const CagdPType Center,
                                         CagdRType Radius,
                                         CagdBType BndBndryPar,
                                         CagdRType BndryPar,
                                         CagdRType NumericTol,
                                         CagdRType SubdivTol)


Description:

Computes all circles which are tangent to a given circle and also to the another curve. The following system of multivariats is solved:

      < Bndry(u) - (x,y), Bndry(u) - (x,y) > = R^2,
      < Center - (x,y), Center - (x,y) > = 4 * R^2,
      < Bndry(u) - (x,y), Bndry'(u) > = 0


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 InNrml:        Normal pointing in the interior of Bndry, or NULL.
 XBnd:          The range of x-coordinate of bounding box of Bndry.
 YBnd:          The range of y-coordinate of bounding box of Bndry.
 Center:        The center of circle to find circle tangent to.
 Radius:        The radius of the circle.
 BndBndryPar:   If TRUE, find contact points on boundary curve greater
                  than the specified value.
 BndryPar:      The boundary curve parameter to serve as lower bound.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (x, y) solution points.



Keywords:



 MvarCircTanToCrvXCoord 
  (mvarpck3.c:179)

Prototype:

  MvarPtStruct *MvarCircTanToCrvXCoord(const CagdCrvStruct *Bndry,
                                       const CagdCrvStruct *InNrml,
                                       CagdPType YBnd,
                                       CagdRType Radius,
                                       CagdRType XCoord,
                                       CagdRType NumericTol,
                                       CagdRType SubdivTol)


Description:

Computes all circles which are tangent to a given curve and have a given x-coordinate. Following system of bivariates is solved, where the variables are u and y, while X is fixed:

      < Bndry(u) - (X,y), Bndry(u) - (X, y) > = R^2,
      < Bndry(u) - (X,y), Bndry'(u) > = 0


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 InNrml:        Normal pointing in the interior of Bndry, or NULL.
 YBnd:          The range of y-coordinate of bounding box of Bndry.
 Radius:        The radius of the circle.
 XCoord:        The X-coordinate of the center of the circle.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (y) solution points.



See Also:

  MvarCircTanToCrvYCoord


Keywords:



 MvarCircTanToCrvYCoord 
  (mvarpck3.c:47)

Prototype:

  MvarPtStruct *MvarCircTanToCrvYCoord(const CagdCrvStruct *Bndry,
                                       const CagdCrvStruct *InNrml,
                                       CagdPType XBnd,
                                       CagdRType Radius,
                                       CagdRType YCoord,
                                       CagdRType NumericTol,
                                       CagdRType SubdivTol)


Description:

Computes all circles which are tangent to a given curve and have a given y-coordinate. Following system of bivariates is solved, where the variables are u and x, while Y is fixed:

      < Bndry(u) - (x,Y), Bndry(u) - (x, Y) > = R^2,
      < Bndry(u) - (x,Y), Bndry'(u) > = 0


Parameters:


 Bndry:         The curve to find the circles that is tangent to.
 InNrml:        Normal pointing in the interior of Bndry, or NULL.
 XBnd:          The range of x-coordinate of bounding box of Bndry.
 Radius:        The radius of the circle.
 YCoord:        The Y-coordinate of the center of the circle.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.



Returned Value:


  MvarPtStruct *:    List of (x) solution points.



See Also:

  MvarCircTanToCrvXCoord


Keywords:



 MvarCntctTangentialCrvCrvC1 
  (contacts.c:41)

Prototype:

  MvarPtStruct *MvarCntctTangentialCrvCrvC1(const CagdCrvStruct *Crv1,
                                            const CagdCrvStruct *Crv2,
                                            CagdRType Epsilon)


Description:

Computes tangential contact points of the given two curves by solving for Ci(t) = (xi(t), yi(t)), i = 1,2:

    x1(t) - x2(r) = 0,
    y1(t) - y2(r) = 0,
    < C1(t) - C2O(r), C1'(t) > = 0,
    < C1(t) - C2O(r), C2'(r) > = 0,

where C2O is an offset curve of C2 by amount larger than subdivision tol.

Parameters:

Crv1, Crv2:	The two curves to solve for their antipodal locations.
Epsilon:	Tolerance of computation.

Returned Value:

MvarPtStruct *: List of pairs of parameters in the r & t coefficients.

See Also:

MvarCrvAntipodalPoints

Keywords:

MvarCnvrtBsp2BzrMV

(mvar_gen.c:1645)

Prototype:

MvarMVStruct *MvarCnvrtBsp2BzrMV(const MvarMVStruct *MV)

Description:

Converts a Bspline multi-variate into a Bezier multi-variate by splitting at all interior knots.

Parameters:

MV:	A B-spline multi-variate to convert to Bezier MVs.

Returned Value:

MvarMVStruct *: A list of Bezier multi-variate representing the same geometry as the given B-spline MV.

Keywords:

conversion multi-variate

MvarCnvrtBzr2BspMV

(mvar_gen.c:1606)

Prototype:

MvarMVStruct *MvarCnvrtBzr2BspMV(const MvarMVStruct *MV)

Description:

Converts a Bezier multi-variate into a B-spline multi-variate by adding two open end uniform knot vectors to it.

Parameters:

MV:	A Bezier multi-variate to convert to a B-spline MV.

Returned Value:

MvarMVStruct *: A Bspline multi-variate representing the same geometry as the given Bezier MV.

Keywords:

conversion multi-variate

MvarCnvrtBzr2PwrMV

(mvbzrpwr.c:63)

Prototype:

MvarMVStruct *MvarCnvrtBzr2PwrMV(const MvarMVStruct *MV)

Description:

Converts the given multivariate from Bezier basis functions to a Power basis functions. Using:

        n
        __
 n      \      p-i n   p   p
B (t) = /  (-1)   ( ) ( ) t
 i      --         p   i
        p=i


 n0     n1         nm
B (u0) B (v1) ... B (um) =
 i0     i1         im

  n0       nm
  __       __
  \        \     p0-i0  n0   p0         pm-im  nm   pm      p0      pm
  /   ...  /  (-1)     (  ) (  ) ... (-1)     (  ) (  )   u0  ... um
  --       --           p0   i0                pm   im
 p0=i0   pm=im

This routine simply take the weight of each product of m Bezier basis functions B0(u0)... Bm(u0) and spread it into the different power basis u0^p0 ...um^pm functions scaled by:

     p0-i0 n0   p0        pm-im  nm   pm
  (-1)    (  ) (  ) ... (-1)    (  ) (  )
           p0   i0               pm   im


Parameters:


 MV:       To convert into Power basis function representation.



Returned Value:


  MvarMVStruct *:  Same geometry, but in the Power basis.



See Also:

  MvarCnvrtPwr2BzrMV
  CagdCnvrtBzr2PwrSrf
  CagdCnvrtPwr2BzrSrf


Keywords:

  power basis
  conversion


 MvarCnvrtCagdPtsToMVPts 
  (mvar_pll.c:814)

Prototype:

  MvarPtStruct *MvarCnvrtCagdPtsToMVPts(const CagdPtStruct *Pts)


Description:

Converts a list of Cagd points to a list of MV points.

Parameters:

Pts:	Cagd points to convert to MV points.

Returned Value:

MvarPtStruct *: MV points.

See Also:

MvarCnvrtMVPolysToIritPolys MvarCnvrtMVPolysToMVPts

Keywords:

MvarCnvrtCrvToMV

(mvareval.c:982)

Prototype:

MvarMVStruct *MvarCnvrtCrvToMV(const CagdCrvStruct *Crv)

Description:

Converts a curve into a multivariate function.

Parameters:

Crv:	Curve to convert into the multi-variate MV.

Returned Value:

MvarMVStruct *: A multi variate function representation to Crv.

Keywords:

multi-variates

MvarCnvrtFloat2OpenMV

(mvar_aux.c:1311)

Prototype:

MvarMVStruct *MvarCnvrtFloat2OpenMV(const MvarMVStruct *MV)

Description:

Converts a float B-spline multivariate to a B-spline multivariate with open end conditions.

Parameters:

MV:	B-spline multivariate to convert to open end conditions.

Returned Value:

MvarMVStruct *: A Bspline multivariate with open end conditions, representing the same geometry as MV.

See Also:

MvarCnvrtPeriodic2FloatMV CnvrtFloat2OpenMV

Keywords:

conversion

MvarCnvrtIritLinCrvsToMVPolys

(mvar_pll.c:1115)

Prototype:

MvarPolylineStruct *MvarCnvrtIritLinCrvsToMVPolys(const CagdCrvStruct *Crvs)

Description:

Converts a list of mvar polylines into a list of irit curves. Assumes crvs at most in E3.

Parameters:

Crvs:	List of linear curves to convert to mvar polylines.

Returned Value:

MvarPolylineStruct *: A list of polylines.

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPolysToIritPolys2 MvarCnvrtMVPolysToIritCrvs

Keywords:

MvarCnvrtMVPolysToCtlPts

(mvar_pll.c:876)

Prototype:

struct IPObjectStruct *MvarCnvrtMVPolysToCtlPts(const MvarPolylineStruct *MVPlls)

Description:

Converts a list of MV polylines to a list of MV control points.

Parameters:

MVPlls:	MV polylines to convert to MV points.

Returned Value:

struct IPObjectStruct *: MV control points.

See Also:

MvarCnvrtMVPolysToIritPolys

Keywords:

MvarCnvrtMVPolysToIritCrvs

(mvar_pll.c:1058)

Prototype:

CagdCrvStruct *MvarCnvrtMVPolysToIritCrvs(const MvarPolylineStruct *MVPlls, int Order)

Description:

Converts a list of mvar polylines into a list of irit curves. Assumes all points of same dimensions.

Parameters:

MVPlls:	List of multivariate polylines to convert to Irit curves.
Order:	Order of constructed curves, typically 2 (linear).

Returned Value:

CagdCrvStruct *: A list of curves.

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPolysToIritPolys2 MvarCnvrtIritLinCrvsToMVPolys

Keywords:

MvarCnvrtMVPolysToIritPolys

(mvar_pll.c:912)

Prototype:

IPObjectStruct *MvarCnvrtMVPolysToIritPolys(const MvarPolylineStruct *MVPlls)

Description:

Converts a list of mvar polylines into a list of irit polylines. Assumes all points of same dimensions.

Parameters:

MVPlls:	List of multivariate polylines to convert to Irit polylines.

Returned Value:

IPObjectStruct *: A list object of polylines (as lists of ctlpts).

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPtsToPolys2 MvarCnvrtMVPtsToPolys2 MvarCnvrtMVPolysToIritCrvs

Keywords:

MvarCnvrtMVPolysToIritPolys2

(mvar_pll.c:974)

Prototype:

IPObjectStruct *MvarCnvrtMVPolysToIritPolys2(const MvarPolylineStruct *MVPlls, int IgnoreIndividualPts)

Description:

Converts a list of mvar polylines into a list of irit polylines. Assumes all points of same dimensions.

Parameters:

MVPlls:	List of multivariate polylines to convert to Irit polylines.
IgnoreIndividualPts:	True to handle only polylines, ignoring points.

Returned Value:

IPObjectStruct *: A polylines object, or if have individual points a list of two objects, as (PllnObjs, PntObjs).

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPtsToPolys2 MvarCnvrtMVPtsToPolys MvarCnvrtMVPolysToIritCrvs

Keywords:

MvarCnvrtMVPolysToMVPts

(mvar_pll.c:845)

Prototype:

MvarPtStruct *MvarCnvrtMVPolysToMVPts(const MvarPolylineStruct *MVPlls)

Description:

Converts a list of MV polylines to a list of MV points.

Parameters:

MVPlls:	MV polylines to convert to MV points.

Returned Value:

MvarPtStruct *: MV points.

See Also:

MvarCnvrtMVPolysToIritPolys MvarCnvrtCagdPtsToMVPts

Keywords:

MvarCnvrtMVPtsToCagdPts

(mvar_pll.c:502)

Prototype:

CagdPtStruct *MvarCnvrtMVPtsToCagdPts(const MvarPtStruct *MVPts)

Description:

Converts a list of multivariate points into a list of cagd E3 points. Assumes all input points are E1, E2, or E3.

Parameters:

MVPts:	List of multivariate points to convert to list of =points.

Returned Value:

CagdPtStruct *: A list of points.

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPtsToPolys

Keywords:

MvarCnvrtMVPtsToCtlPts

(mvar_pll.c:537)

Prototype:

IPObjectStruct *MvarCnvrtMVPtsToCtlPts(const MvarPtStruct *MVPts, IrtRType MergeTol)

Description:

Converts a list of multivariate points into a list of control points. Assumes all points of same dimensions.

Parameters:

MVPts:	List of multivariate points to convert to list of ctlpts.
MergeTol:	If non negative, attempt to merge the data into polylines.

Returned Value:

IPObjectStruct *: A list object of ctlpts.

See Also:

MvarCnvrtMVPtsToPolys MvarCnvrtMVPtsToCagdPts

Keywords:

MvarCnvrtMVPtsToCagdPts

MvarCnvrtMVPtsToPolys

(mvar_pll.c:605)

Prototype:

IPObjectStruct *MvarCnvrtMVPtsToPolys(const MvarPtStruct *MVPts, const MvarMVStruct *MV, IrtRType MergeTol)

Description:

Converts a list of multivariate points into a list of polylines. Assumes all points of same dimensions.

Parameters:

MVPts:	List of multivariate points to convert to polylines.
MV:	A multivariate to evaluate through, if not NULL.
MergeTol:	Tolerance to merge points into polylines.

Returned Value:

IPObjectStruct *: A list object of polylines.

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPtsToPolys2

Keywords:

MvarCnvrtMVPtsToPolys2

(mvar_pll.c:678)

Prototype:

IPPolygonStruct *MvarCnvrtMVPtsToPolys2(const MvarPtStruct *InPts, CagdRType FineNess, int Dim, IrtRType *ParamDomain)

Description:

Connect a list of discrete points into a polylines.

Parameters:

InPts:	A list of discrete points.
FineNess:	Tolerance.
Dim:	The dimension of discrete points, 1 to 3.
ParamDomain:	The domain of the mvar points.

Returned Value:

IPPolygonStruct *: Connected list of polylines.

See Also:

MvarCnvrtMVPtsToCtlPts MvarCnvrtMVPtsToPolys

Keywords:

MvarCnvrtMVToCrv

(mvareval.c:1038)

Prototype:

CagdCrvStruct *MvarCnvrtMVToCrv(const MvarMVStruct *MV)

Description:

Converts a multivariate function into a curve. If the multivariate is of dimension higher than one, the lowest dimension is employed in the conversion.

Parameters:

MV:	A multivariate of at least dimension one to convert to a curve.

Returned Value:

CagdCrvStruct *: A curve representation the given multivariate (or its lowest dimension if higher dim.).

Keywords:

multi-variates

MvarCnvrtMVToSrf

(mvareval.c:1171)

Prototype:

CagdSrfStruct *MvarCnvrtMVToSrf(const MvarMVStruct *MV)

Description:

Converts a multivariate function into a surface. If the multivariate is of dimension higher than two, the lowest two dimensions are employed in the conversion.

Parameters:

MV:	A multivariate of dimension two or more to convert to a surface.

Returned Value:

CagdSrfStruct *: A surface representation the given multivariate (or its lowest two dimensions if higher dim.).

Keywords:

multi-variates

MvarCnvrtMVToTV

(mvareval.c:1329)

Prototype:

TrivTVStruct *MvarCnvrtMVToTV(const MvarMVStruct *MV)

Description:

Converts a multivariate function into a trivar. If the multivariate is of dimension higher than three, the lowest three dimensions are employed in the conversion.

Parameters:

MV:	A multivariate of dimension three or more to convert to a trivar.

Returned Value:

TrivTVStruct *: A trivar representation the given multivariate (or its lowest three dimensions if higher dim.).

Keywords:

multi-variates

MvarCnvrtMVTrsToIritPolygons

(mvar_pll.c:1197)

Prototype:

IPObjectStruct *MvarCnvrtMVTrsToIritPolygons(const MvarTriangleStruct *MVTrs, int *Coords)

Description:

Converts a list of mvar triangles into a list of irit polygons. If the list of triangles consists of points of dimension higher than three, the polygons list is created as the projection on R^3, using the coordinates specified in Coords. Assumes all points of same dimensions.

Parameters:

MVTrs:	List of multivariate triangles to convert to Irit polygons.
Coords:	The required coordinates, or NULL if the dimension is three.

Returned Value:

IPObjectStruct *: A list object of polygons.

See Also:

MvarIrit2DTrTo2DMVTrs MvarCnvrtMVPolysToIritPolys

Keywords:

MvarCnvrtPeriodic2FloatMV

(mvar_aux.c:1239)

Prototype:

MvarMVStruct *MvarCnvrtPeriodic2FloatMV(const MvarMVStruct *MV)

Description:

Converts a B-spline multivariate into a B-spline multivariate with floating end conditions.

Parameters:

MV:	B-spline multivariate to convert to floating end conditions. Assume MV is either periodic or has floating end condition.

Returned Value:

MvarMVStruct *: A Bspline multivariate with floating end conditions, representing the same geometry as MV.

See Also:

CnvrtPeriodic2FloatMV MvarCnvrtFloat2OpenMV

Keywords:

conversion

MvarCnvrtPwr2BzrMV

(mvbzrpwr.c:161)

Prototype:

MvarMVStruct *MvarCnvrtPwr2BzrMV(const MvarMVStruct *MV)

Description:

Converts the given multivariate from Power basis functions to Bezier basis functions. Using:


               n0       nm    i0       im
               __       __   (  ) ... (  )
   p0     pm   \        \     p0       pm    n0         nm
 u0 ... um  =  /    ... /    -------------- B (u0) ... B (um)
               --       --    n0       nm    i0         im
              i0=p0    im=pm (  ) ... (  )
                              p0       pm

This routine simply take the weight of each product of m power basis functions u0^p0 ...um^pm and spread it into the different Bezier basis B0(u0)... Bm(u0) functions scaled by:


     i0       im
    (  ) ... (  )
     p0       pm
    --------------
     n0       nm
    (  ) ... (  )
     p0       pm


Parameters:


 MV:       To convert into Bezier basis function representation.



Returned Value:


  MvarMVStruct *:  Same geometry, but in the Bezier basis.



See Also:

  MvarCnvrtBzr2PwrMV
  CagdCnvrtBzr2PwrMV
  MvarCnvrtPwr2BzrMV


Keywords:

  power basis
  conversion


 MvarCnvrtSrfToMV 
  (mvareval.c:1097)

Prototype:

  MvarMVStruct *MvarCnvrtSrfToMV(const CagdSrfStruct *Srf)


Description:

Converts a surface into a multivariate function.

Parameters:

Srf:	Surface to convert into the multi-variate MV.

Returned Value:

MvarMVStruct *: A multi variate function representation to Srf.

Keywords:

multi-variates

MvarCnvrtTVToMV

(mvareval.c:1244)

Prototype:

MvarMVStruct *MvarCnvrtTVToMV(const TrivTVStruct *TV)

Description:

Converts a trivar into a multivariate function.

Parameters:

TV:	Trivar to convert into the multi-variate MV.

Returned Value:

MvarMVStruct *: A multi variate function representation to TV.

Keywords:

multi-variates

MvarCoerceMVTo

(mvarcoer.c:52)

Prototype:

MvarMVStruct *MvarCoerceMVTo(const MvarMVStruct *MV, MvarPointType PType)

Description:

Coerces a multi-variate to point type PType.

Parameters:

MV:	To coerce to a new point type PType.
PType:	New point type for MV.

Returned Value:

MvarMVStruct *: A new multi-variate with PType as its point type.

Keywords:

coercion

MvarCoerceMVsTo

(mvarcoer.c:25)

Prototype:

MvarMVStruct *MvarCoerceMVsTo(const MvarMVStruct *MV, MvarPointType PType)

Description:

Coerces a list of multivariates to point type PType.

Parameters:

MV:	To coerce to a new point type PType.
PType:	New point type for MV.

Returned Value:

MvarMVStruct *: New multivariates with PType as their point type.

Keywords:

coercion

MvarComposeMVMdl

(mvcomps2.c:736)

Prototype:

MdlModelStruct *MvarComposeMVMdl(const MvarMVStruct *MV, const MdlModelStruct *Models)

Description:

Compose a list of B-rep models (Models) into a multivariate (MV), allowing the surfaces of the models to cross knot values of the mapping multivariate.

Parameters:

MV:	The mapping multivariate.
Models:	The models to compose into MV.

Returned Value:

MdlModelStruct *: The composed models.

See Also:

MvarTrimComposeMVSrf MvarUnTrimComposeMVSrf MvarComposeMVVModel

Keywords:

composition trimming multivariates

MvarComposeMVVModel

(mvcomps2.c:813)

Prototype:

VMdlVModelStruct *MvarComposeMVVModel(const MvarMVStruct *MV, const VMdlVModelStruct *Vmdl)

Description:

Compose a list of V-Models (Vmdl) into a multivariate (MV), allowing the V-models to cross knot values of the mapping multivariate.

Parameters:

MV:	The mapping multivariate.
Vmdl:	The V-models to compose into MV.

Returned Value:

VMdlVModelStruct *: The composed V-models.

See Also:

MvarTrimComposeMVSrf MvarUnTrimComposeMVSrf MvarComposeMVMdl

Keywords:

composition trimming multivariates V-model

MvarComposedSrfAssumeSrf

(mvcomps2.c:1051)

Prototype:

MvarComposedSrfStruct *MvarComposedSrfAssumeSrf(CagdSrfStruct *Srf)

Description:

Creates a MvarComposedSrfStruct from a given surface. The surface is NOT copied.

Parameters:

Srf:	The surface on which to base the MvarComposedSrfStruct.

Returned Value:

MvarComposedSrfStruct *: A MvarComposedSrfStruct with the given surface.

See Also:

MvarTrimComposeMVSrf MvarComposedSrfAssumeTSrf

Keywords:

composition trimming multivariates

MvarComposedSrfAssumeTSrf

(mvcomps2.c:1082)

Prototype:

MvarComposedSrfStruct *MvarComposedSrfAssumeTSrf(TrimSrfStruct *TSrf)

Description:

Creates a MvarComposedSrfStruct from a given trimmed surface. The trimmed surface is NOT copied.

Parameters:

TSrf:	The trimmed surface on which to base the MvarComposedSrfStruct.

Returned Value:

MvarComposedSrfStruct *: A MvarComposedSrfStruct with the given trimmed surface.

See Also:

MvarTrimComposeMVSrf MvarComposedSrfAssumeSrf

Keywords:

composition trimming multivariates

MvarComposedSrfCopy

(mvcomps2.c:1112)

Prototype:

MvarComposedSrfStruct *MvarComposedSrfCopy(const MvarComposedSrfStruct *CompSrf)

Description:

Copies a single MvarComposedSrfStruct.

Parameters:

CompSrf:	The MvarComposedSrfStruct to copy.

Returned Value:

MvarComposedSrfStruct *: A copy of the given MvarComposedSrfStruct.

See Also:

MvarTrimComposeMVSrf MvarComposedSrfCopyList

Keywords:

composition trimming multivariates

MvarComposedSrfCopyList

(mvcomps2.c:1144)

Prototype:

MvarComposedSrfStruct *MvarComposedSrfCopyList(const MvarComposedSrfStruct *CompSrfs)

Description:

Copies a list of MvarComposedSrfStruct.

Parameters:

CompSrfs:	The list of MvarComposedSrfStruct to copy.

Returned Value:

MvarComposedSrfStruct *: A copy of the given list of MvarComposedSrfStruct.

See Also:

MvarTrimComposeMVSrf MvarComposedSrfCopy

Keywords:

composition trimming multivariates

MvarComposedTrivAssumeTV

(mvcomps2.c:1237)

Prototype:

MvarComposedTrivStruct *MvarComposedTrivAssumeTV(TrivTVStruct *TV)

Description:

Creates a MvarComposedTrivStruct from a given trivariate. The trivariate is NOT copied.

Parameters:

TV:	The trivariate on which to base the MvarComposedTrivStruct.

Returned Value:

MvarComposedTrivStruct *: A MvarComposedTrivStruct with the given trivariate.

See Also:

MvarTrimComposeMVTV MvarComposedTrivAssumeVMdl

Keywords:

composition V-model multivariates

MvarComposedTrivAssumeVMdl

(mvcomps2.c:1268)

Prototype:

MvarComposedTrivStruct *MvarComposedTrivAssumeVMdl(VMdlVModelStruct *VMdl)

Description:

Creates a MvarComposedTrivStruct from a given V-model. The V-model is NOT copied.

Parameters:

VMdl:	The V-model on which to base the MvarComposedTrivStruct.

Returned Value:

MvarComposedTrivStruct *: A MvarComposedTrivStruct with the given V-model.

See Also:

MvarTrimComposeMVTV MvarComposedTrivAssumeTV

Keywords:

composition V-model multivariates

MvarComposedTrivCopy

(mvcomps2.c:1357)

Prototype:

MvarComposedTrivStruct *MvarComposedTrivCopy(const MvarComposedTrivStruct *CTV)

Description:

Copies a single MvarComposedTrivStruct.

Parameters:

CTV:	The MvarComposedTrivStruct to copy.

Returned Value:

MvarComposedTrivStruct *: A copy of the given MvarComposedTrivStruct.

See Also:

MvarTrimComposeMVTV MvarComposedTrivCopyList

Keywords:

composition trimming multivariates

MvarComposedTrivCopyList

(mvcomps2.c:1389)

Prototype:

MvarComposedTrivStruct *MvarComposedTrivCopyList( const MvarComposedTrivStruct *CTVs)

Description:

Copies a list of MvarComposedTrivStruct.

Parameters:

CTVs:	The list of MvarComposedTrivStruct to copy.

Returned Value:

MvarComposedTrivStruct *: A copy of the given list of MvarComposedTrivStruct.

See Also:

MvarTrimComposeMVTV MvarComposedTrivCopy

Keywords:

composition trimming multivariates

MvarComputeInterMidPoint

(mvtrmbis.c:363)

Prototype:

CagdRType *MvarComputeInterMidPoint(CagdCrvStruct *Crv1, CagdRType t1, CagdCrvStruct *Crv2, CagdRType t2, CagdRType *Inter)

Description:

Computes the intersection point of the normals of the given two points on the given two curves. Taken from crvskel.c - need to modify to avoid artifacts in near parallel normals.

Parameters:

Crv1:	First curve of the matching mid point.
t1:	Parameter value of first curve's mid point.
Crv2:	Second curve of the matching mid point.
t2:	Parameter value of second curve's mid point.
Inter:	Point of intersection.

Returned Value:

CagdRType *: Point of intersection.

Keywords:

MvarComputeMVPowers

(mvcompos.c:1286)

Prototype:

MvarMVStruct **MvarComputeMVPowers(const MvarMVStruct *CMV, int Order)

Description:

Computes the factors of the Bernstein polynomials where MV is a scalar-range multivariate, for i from 0 to n (degree):

  n                  n                    n-i               i
 B (MV(t0,...tm)) = ( ) (1 - MV(t0,...tm))    (MV(t0,...tm))
  i                  i

The multivariate MV(t0,...tm) is a scalar, possibly a rational multivariate. If rational, the returned vector, index Order will contain w MV(t0,...tm)^n. See: "Freeform surface analysis using a hybrid of symbolic and numeric computation" by Gershon Elber, PhD thesis, University of Utah, 1992.

Parameters:

CMV:	Multivariate to compute factors for.
Order:	Order is n + 1.

Returned Value:

MvarMVStruct **: A vector of all possible factors for i equal to 0 to n, allocated dynamically.

See Also:

MvarGenerateBspBasisMVs SymbComputeCurvePowers SymbComputeSurfacePowers MvarMVCompose

Keywords:

MvarComputeRayTraps

(ray-trap.c:70)

Prototype:

MvarPtStruct *MvarComputeRayTraps(const CagdCrvStruct *Crvs, int Orient, CagdRType SubdivTol, CagdRType NumerTol, CagdBType UseExprTree)

Description:

Computes solutions to locations on the given curves that would bounce rays from one curve to the next in a closed loop.

Parameters:

Crvs:	List of curves to handle in order (cyclically).
Orient:	Pick the proper orientation with respect to the normal if TRUE. May be faster at times.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the curves.
NumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: Linked list of solutions, each holding the parameter values of the different Crvs.

Keywords:

MvarComputeRayTraps3D

(raytrp3d.c:74)

Prototype:

MvarPtStruct *MvarComputeRayTraps3D(const CagdSrfStruct *Srfs, int Orient, CagdRType SubdivTol, CagdRType NumerTol, CagdBType UseExprTree)

Description:

Computes solutions to locations on the given surfaces that would bounce rays from one surface to the next in a closed loop.

Parameters:

Srfs:	List of surfaces to handle in order (cyclically).
Orient:	Pick the proper orientation with respect to the normal if TRUE. May be faster at times.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: Linked list of solutions, each holding the parameter values of the different Srfs.

Keywords:

MvarComputeVoronoiCell

(mvvorcel.c:143)

Prototype:

IPObjectStruct *MvarComputeVoronoiCell(CagdCrvStruct *Crv)

Description:

Computes the Voronoi cell of the first curve in the given list of curves. For the details of the algorithm, see the following paper. * Precise Voronoi Cell Extraction of Free-form Rational Planar Closed Curves. Iddo Hanniel, Ramanathan Muthuganapathy, Gershon Elber, Myung-Soo Kim ACM Symposium on Solid and Physical Modeling, 2005. The following are the files used for computing the Voronoi cell mvvorcel.c - Main function that call other function. It takes the input curves, process them for discontinuities and calls other functions. Displaying the output is also done in this function. mvsplmon.c - The function that creates monotone segments. mvbiscon.c - The monotone segments obtained from mvsplmon.c are then subjected to orientation and curvature constraint functions written in this file. mvtrmbis.c - Auxillary functions required for trimming are written here. mvtrmpcr.c - This file does the trimming of point/crv bisector. mvlowenv.c - Functions in this file compute the lower envelope. mvvorcrv.c - Operations on the MvarVoronoiCrvStruct are available in this file. Dependency of each of the above file is depicted in the following diagram:

                          vorcel, vorcrv
                         \               /
                          --------------
                            1  2  3  4
                       1    2       3   4
                  1      2            3     4
             1        2                 3       4
         splmon     biscon           trmpcr   lowenv
        \                                           /
         -------------------------------------------
                               |
                               |
                               |
                              \ /
                            trmbis


Parameters:


 Crv:   List of curves to compute the Voronoi cell.



Returned Value:


  IPObjectStruct *:  Returns the Voronoi cell.



Keywords:



 MvarConesOverlapAux 
  (mvcones.c:1579)

Prototype:

  CagdBType MvarConesOverlapAux(const MvarNormalConeStruct *ConesList)


Description:

Computes the tangency anti-cones of the set of normal cones, and returns whether they overlap or not.

Parameters:

ConesList:	ones in a list.

Returned Value:

CagdBType: TRUE if overlap, FALSE if not.

Keywords:

normals normal bound

MvarCrv2DMAT

(mv_mat2d.c:72)

Prototype:

CagdCrvStruct *MvarCrv2DMAT(const CagdCrvStruct *OCrv, CagdRType SubdivTol, CagdRType NumericTol, CagdBType InvertOrientation)

Description:

Computes the (inside) 2D MAT (medial axis transform) of a given closed planar self-intersection-free oriented B-spline curve.

Parameters:

OCrv:	B-spline curve to compute its 2D planar MAT.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
InvertOrientation:	Flip what is considered inside and outside.

Returned Value:

CagdCrvStruct *: The MAT as a list of curves.

Keywords:

MvarCrvAntipodalPoints

(selfintr.c:146)

Prototype:

MvarPtStruct *MvarCrvAntipodalPoints(const CagdCrvStruct *CCrv, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes antipodal points in the given curve - pairs of points C(t) and C(r) such that (t and r are two independent parameters of same curve):

           < C(t) - C(r), dC(t)/dt > = 0,
           < C(t) - C(r), dC(r)/dr > = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Crv satisfy these equations when t == r. The key is in adding a third inequality constaint of the form

           < C'(t), C'(r) > < 0.

Antipodal points must exists if Crv self intersect in a closed loop and hence can help in detecting self-intersections. Further, the diameter of Crv could be easily deduced from the antipodal points. Note this function also captures the self-intersection locations C(t) = C(r), for which the dot product of the tangents is negative.

Parameters:

CCrv:	To detect its antipodal points.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Antipodal points, as points in E2 (r, t).

See Also:

MvarCrvDiameter SymbCrvDiameter MvarSrfAntipodalPoints MvarHFDistAntipodalCrvCrvC1

Keywords:

MvarCrvArtGalleryPoint

(crv_krnl.c:1014)

Prototype:

IPObjectStruct *MvarCrvArtGalleryPoint(const CagdCrvStruct *Crv, CagdRType SubEps, int NumGuards, int BBoxSubdivDepth)

Description:

Estimates art gallery solution for a given freeform planar closed curve. The presented algebraic approach is NOT solving the art gallery (due to constraints being local and visibility is a global problem) but it shows a possible use of the partial positivity in constraints in the MV solver.

Parameters:

Crv:	Simple closed curve to estimates art gallery solution for.
SubEps:	Subdivision epsilon.
NumGuards:	umber of guards to try and place in this art gallery corevage. NumGuards > 1.
BBoxSubdivDepth:	Zero to use regular bounding boxes on constraints. Positive integer >= 2 for recursive subdivision of this depth for a more precise BBOx bounds.

Returned Value:

IPObjectStruct : XY locations of all Guards if found, as points in r^k, k = NumGuards 2. NULL if none found.

See Also:

MvarCrvKernel MvarCrvAntipodalPoints SymbCrvKernel MvarCrvKernelPoint

Keywords:

MvarCrvCrvBisector2D

(mvbisect.c:1287)

Prototype:

CagdCrvStruct *MvarCrvCrvBisector2D(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol, CagdRType *BBoxMin, CagdRType *BBoxMax, CagdBType SupportPrms)

Description:

Computes a bisector curve of two planar curves. Curves are assumed to to lie in z = 0 plane. The bisector curve is computed inside BBox.

Parameters:

Crv1, Crv2:	Planar curves to compute their bisector.
Step:	Stepsize for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.
BBoxMin, BBoxMax:	he bounding box, where the bisector is computed.
SupportPrms:	TRUE to return a curve in E4 as (X, Y, y1, t2), FALSE to return a curve in E2 as (X, Y).

Returned Value:

CagdCrvStruct *: A (list of) piecewise linear curves that approximates the bisector curve, or NULL if none.

See Also:

MvarCrvDtctSelfInterLocations

Keywords:

MvarCrvCrvContact

(mvarintr.c:594)

Prototype:

MvarPtStruct *MvarCrvCrvContact(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, const CagdCrvStruct *MotionCrv1, const CagdCrvStruct *ScaleCrv1, CagdRType SubdivTol, CagdRType NumericTol, CagdBType UseExprTree)

Description:

Computes the contact locations of two C^1 curves in R^3, possibly with multivariate expression trees. Expression trees could be beneficial computationally when the geometry is complex (i.e. dozens of control points or more, in each directions).

Parameters:

Crv1, Crv2:	Two curves to compute contacts over time in R^3.
MotionCrv1:	The motion over time Crv1 undergoes. Can be NULL.
ScaleCrv1:	The scale over time Crv1 undergoes. Can either be a scalar function, or vector function in R^3. Can be NULL. If both MotionCrv1 and Crv1Scale are defined, they better share their domains.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the curves.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: List of intersection points, as parameter pairs into the two curves domains.

See Also:

MvarCrvCrvInter MvarSrfSrfSrfInter MvarSrfSrfContact

Keywords:

MvarCrvCrvInter

(mvarintr.c:80)

Prototype:

MvarPtStruct *MvarCrvCrvInter(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdRType SubdivTol, CagdRType NumericTol, CagdBType UseExprTree)

Description:

Computes the intersection locations of two planar curves, possibly with multivariate expression trees. Expression trees could be beneficial computationally when the geometry is complex (i.e. dozens of control points or more).

Parameters:

Crv1, Crv2:	Two curves to intersect.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: List of intersection points, as parameter pairs into the two curves domains.

See Also:

CagdCrvCrvInter SymbCrvCrvInter SymbSrfSrfSrfInter MvarSrfSrfContact

Keywords:

MvarCrvCrvMinimalDist

(hasdrf2d.c:1107)

Prototype:

MvarPtStruct *MvarCrvCrvMinimalDist(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdRType *MinDist, CagdBType ComputeAntipodals, CagdRType Eps)

Description:

Computes the minimal distance between two given planar C1 curves. This minimal distance can occur: 1. At intersection locations, if any. 2. At end points vs. end points. 3. At the end points vs interior locations. 4. At antipodal interior locations.

Parameters:

Crv1:	To detect its minimal distance to Crv2.
Crv2:	To detect its minimal distance to Crv1.
MinDist:	Upon return, is set to the minimal distance detected.
ComputeAntipodals:	TRUE to compute antipodal locations as well in the search for minimal distance. If FALSE, samples are made along both curves and closest locations to other curve are computed.
Eps:	Numeric tolerance of the computation.

Returned Value:

MvarPtStruct *: Pairs of parameters at the minimal distance, allocated dynamically.

See Also:

MvarCrvCrvAntipodalPoints SymbDistCrvPoint CagdCrvCrvInter SymbSrfDistCrvCrv

Keywords:

MvarCrvCrvtrByOneCtlPt

(mv_crvtr.c:224)

Prototype:

MvarMVStruct *MvarCrvCrvtrByOneCtlPt(const CagdCrvStruct *Crv, int CtlPtIdx, CagdRType Min, CagdRType Max)

Description:

Given a parametric curve, Crv, and a control point index CtlPtIdx, compute the curvature sign field of the curve as function of the Euclidean locations of control point index CtlPtIdx. Returned is a multivariate of dimension "1 + Dim(Crv)", where Dim(Crv) is the dimension of the curve (E2, E3, etc.).

Parameters:

Crv:	To compute its curvature behaviour (convex vs. concave) as a function of the curve parameter and the Euclidean coordiate of the CtlPtIdx's control point.
CtlPtIdx:	Index of control point to make a parameter for the curvature.
Min, Max:	Domain each coordinate of CtlPtIdx point should vary.

Returned Value:

MvarMVStruct *: The computed curvature field of Crv.

See Also:

SymbCrv2DCurvatureSign MvarCrvMakeCtlPtParam UserCrvCrvtrByOneCtlPt

Keywords:

curvature

MvarCrvDiameter

(crv_krnl.c:476)

Prototype:

IPObjectStruct *MvarCrvDiameter(const CagdCrvStruct *Crv, CagdRType SubEps, CagdRType NumEps)

Description:

Computes the minimal and maximal diameter of the given curve. Let the input curve be C(t) and let f(t,r) = < C(t)-C(r), C(t)-C(r) >. Then, df/dt = df/dr = 0 find all the finite set of line segments that connects two points on the curve orthogonally to the curve. The min/max diameter is part of this set.

Parameters:

Crv:	Simple closed curve to compute the diameter for.
SubEps:	Subdivision epsilon.
NumEps:	Numeric marching tolerance.

Returned Value:

IPObjectStruct *: List of pair of parameter values between which the local diameter could be found.

See Also:

MvarCrvKernel MvarCrvAntipodalPoints SymbCrvKernel

Keywords:

MvarCrvDtctSelfInterLocations

(offset2.c:1124)

Prototype:

MvarPtStruct *MvarCrvDtctSelfInterLocations(const CagdCrvStruct *Crv, CagdRType OffsetDist, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Compute the locations where an offset by distance OffsetDist of Crv will yield self intersections.

Parameters:

Crv:	Curve to detects its self intersection locations, if any.
OffsetDist:	he desired offset distance.
SubdivTol, NumericTol:	Tolerances of MV solver.

Returned Value:

MvarPtStruct *: Locations of self intersection in R^4 as (u, v, x, y), if any. Can be NULL if none.

See Also:

MvarCrvCrvBisector2D MvarCrvTrimSelfInterLocations SymbCrvTrimGlblOffsetSelfInter SymbSrfTrimGlblOffsetSelfInter MvarCrvTrimGlblOffsetSelfInter MvarCrvTrimGlblOffsetSelfInter2

Keywords:

MvarCrvGammaKernel

(crv_krnl.c:152)

Prototype:

MvarMVStruct *MvarCrvGammaKernel(const CagdCrvStruct *Crv, CagdRType Gamma)

Description:

Computes the gamma-kernel of the given curve, or the points in the plane that have a line of sight (rotated gamma degrees) with all the points of the curve. The curve is assumed to be closed and simple. Let the input curve be C(t) and let S(u, v) = (u, v), the XY plane. Further let D'(t) = Rot(Gamma)[C'(t)]. Then, let F(u, v, t) = (C(t) - S(u, v)) x D'(t) (only the Z component of crossprod). The zero set of F projected over the XY plane defines all the domain that is NOT in the gamma-kernel of C(t).

Parameters:

Crv:	Simple closed curve to compute its gamma-kernel.
Gamma:	ngular deviation of the gamma-kernel, in degrees.

Returned Value:

MvarMVStruct *: The trivariate function F(u, v, t) whose zero set, projected on the XY plane, is the domain that is not in the gamma-kernel.

See Also:

MvarCrvKernelSilhouette MvarCrvKernel MvarCrvGammaKernelSrf

Keywords:

MvarCrvGammaKernelSrf

(crv_krnl.c:266)

Prototype:

MvarMVStruct *MvarCrvGammaKernelSrf(const CagdCrvStruct *Crv, CagdRType ExtentScale, CagdRType GammaMax)

Description:

Constructs a gamma-kernel surfaces the given curve and as a function of gamma. Let the input curve be C(t). If C(t) is a linear curve then we compute the surface: Let P = (Px, Py) be the initial point and (Dx, Dy) the slope of the line. Then the constructed surface equals (ES == ExtentScale): X(r, Gamma) = Px + r * Dx * ES + r * Gamma * Dy * ES Y(r, Gamma) = Py - r * Gamma * Dx * ES + r * Dy * ES Z(r, Gamma) = Gamma If C(t) is a higher order, non linear, curve then we compute trivar: X(t, r, Gamma) = Cx(t) + r * Cx'(t) * ES + r * Gamma * Cy'(t) * ES Y(t, r, Gamma) = Cy(t) - r * Gamma * Cx'(t) * ES + r * Cy'(t) * ES Z(t, r, Gamma) = Gamma

Parameters:

Crv:	Simple curve to compute its gamma-kernel surface.
ExtentScale:	To scale the constructed surface as function of Gamma.
GammaMax:	Max gamma deviation of the gamma-kernel, in degrees, for this curve. If negative, does so to opposite direction.

Returned Value:

MvarMVStruct *: The surface S(u, v) or trivariate function F(u, v, t) representing the gamma surface as a function of gamma.

See Also:

MvarCrvKernelSilhouette MvarCrvKernel MvarCrvGammaKernel

Keywords:

MvarCrvKernel

(crv_krnl.c:118)

Prototype:

MvarMVStruct *MvarCrvKernel(const CagdCrvStruct *Crv)

Description:

Computes the kernel of the given curve, or the points in the plane that have a line of sight with all the points of the curve. The curve is assumed to be closed and simple. Let the input curve be C(t) and let S(u, v) = (u, v), the XY plane. Then, let F(u, v, t) = (C(t) - S(u, v)) x C'(t) (only the Z component of cross prod). The zero set of F projected over the XY plane defines all the domain that is NOT in the kernel of C(t).

Parameters:

Crv:	Simple closed curve to compute its kernel.

Returned Value:

MvarMVStruct *: The trivariate function F(u, v, t) whose zero set, projected on the XY plane, is the domain that is not in the kernel.

See Also:

MvarCrvKernelSilhouette MvarCrvGammaKernel SymbCrvDiameter MvarCrvKernelPoint MvarCrvKernelPoint

Keywords:

MvarCrvKernelPoint

(crv_krnl.c:758)

Prototype:

IPObjectStruct *MvarCrvKernelPoint(const CagdCrvStruct *Crvs, CagdRType SubEps, int OneKernelPoint, IrtRType PreciseBBoundTol)

Description:

Computes a kernel point, if any, for the given curves. Let the input curve be C_i(t) and let N_i(t) be the normal filed of C_i(t), where i = 1, ..., n. Then: f_i(t_i, x, y) = < C_i(t)-P(x, y), N_i(t) >. If f_i(t_i, x, y) > 0, for all t_i and all i, then (x, y) is a kernel point. Computed with only one semi-algebraic (inequality) constraints.

Parameters:

Crvs:	Simple closed curve to compute a kernel point for.
SubEps:	Subdivision epsilon.
OneKernelPoint:	TRUE to return a kernel point, FALSE to return all points found.
PreciseBBoundTol:	Zero to use regular bounding boxes on constraints. Positive integer >= 2 for recursive subdivision of this depth for a more precise BBOx bounds. A positive fraction for the tolerance to use in precise BBox computations.

Returned Value:

IPObjectStruct *: XY location(s) of a kernel point if found, NULL if none found.

See Also:

MvarCrvKernel MvarCrvAntipodalPoints SymbCrvKernel MvarCrvArtGalleryPoint

Keywords:

MvarCrvKernelSilhouette

(crv_krnl.c:431)

Prototype:

MvarPolylineStruct *MvarCrvKernelSilhouette(const CagdCrvStruct *Crv, CagdRType Gamma, CagdRType SubEps, CagdRType NumEps)

Description:

Computes the kernel of the given curve, or the points in the plane that have a line of sight with all the points of the curve. The curve is assumed to be closed and simple. Let the input curve be C(t) and let S(u, v) = (u, v), the XY plane. Then, let f(u, v, t) = < C(t) - S(u, v), C'(t) >. The zero set of f projected over the XY plane defines all the domain that is NOT in the kernel of C(t).

Parameters:

Crv:	Simple closed curve to compute the silhouette of the kernel.
Gamma:	Angular deviation of the gamma-kernel, in degrees.
SubEps:	Subdivision epsilon.
NumEps:	Numeric marching tolerance.

Returned Value:

MvarPolylineStruct *: The silhouettes along the third, t, parameter of the trivariate function f(u, v, t).

See Also:

MvarCrvKernel MvarCrvGammaKernel

Keywords:

MvarCrvListPreciseBBox

(mvarbbox.c:1351)

Prototype:

void MvarCrvListPreciseBBox(const CagdCrvStruct *Crvs, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a list of curves.

Parameters:

Crvs:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

CagdCrvListBBox MvarCrvPreciseBBox

Keywords:

bbox bounding box

MvarCrvMakeCtlPtParam

(mvar_rev.c:464)

Prototype:

MvarMVStruct *MvarCrvMakeCtlPtParam(const CagdCrvStruct *Crv, int CtlPtIdx, CagdRType Min, CagdRType Max)

Description:

Given a polynomal curve and an index of a control point, CtlPtIdx, construct a new multiariate where the i'th control points is mapped to 2nd and above parameters of the returned multivariate. The first parameter of the multivariate remains the input curves' parameter. For example, if the input curve is E2 (planar), a trivariate will be returned, M(t, x, y), where t is the original curve's parameter and x and y parametrize the Euclidean values of the CtlPtIdx control point.

Parameters:

Crv:	Curve to make its i'th control point a parameter.
CtlPtIdx:	Index of control point to make a parameter.
Min, Max:	Domain each coordinate of CtlPtIdx point should vary.

Returned Value:

MvarMVStruct *: A multivariate parametrizing both the original curve and the CtlPtIdx's control points Euclidean values.

Keywords:

MvarCrvMaxXYOriginDistance

(lnsrfdst.c:32)

Prototype:

CagdRType MvarCrvMaxXYOriginDistance(const CagdCrvStruct *Crv, CagdRType Epsilon, CagdRType *Param)

Description:

Computes the maximal XY distance location of given curve from origin.

Parameters:

Crv:	To examine for its maximal XY distance for the origin.
Epsilon:	Tolerance of computation.
Param:	ill be set with the parameter location where this maximum occur.

Returned Value:

CagdRType: The distance.

Keywords:

MvarCrvPreciseBBox

(mvarbbox.c:1283)

Prototype:

void MvarCrvPreciseBBox(const CagdCrvStruct *Crv, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a curve freeform.

Parameters:

Crv:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarMVBBox MvarMVPreciseBBox CagdCrvBBox

Keywords:

bbox bounding box

MvarCrvSelfInterDiagFactor

(selfintr.c:666)

Prototype:

MvarPtStruct *MvarCrvSelfInterDiagFactor(const CagdCrvStruct *Crv, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes self intersection points for given curve using the following constraints r and t are two independent params of the same crv:

           x(r) - x(t) = 0,
           y(r) - y(t) = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Crv satisfy these equations when r == t. The key here is to remove all (u - v) factors off diagonal Bezier patches of the above.

Parameters:

Crv:	To detect its self intersection points.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Self intersection points, as points in E4 (r, t).

See Also:

MvarCrvAntipodalPoints MvarSrfSelfInterNrmlDev MvarCrvSelfInterNrmlDev

Keywords:

MvarCrvSelfInterNrmlDev

(selfintr.c:483)

Prototype:

MvarPtStruct *MvarCrvSelfInterNrmlDev(const CagdCrvStruct *CCrv, CagdRType SubdivTol, CagdRType NumericTol, CagdRType MinNrmlDeviation)

Description:

Computes self intersection points for given curve using the following constraints r and t are two independent params of the same crv):

           x(r) - x(t) = 0,
           y(r) - y(t) = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Crv satisfy these equations when r == t. The key is in adding a third inequality constaint of the form

                < N(r), N(t) >
           ---------------------- < Cos(Angle),
           || N(r) ||  || N(t) ||

Where Cos(Angle) is a provided constant that prescribes the minimal angle the curve is expected to intersect at. The closer Cos(Angle) to one the more work this function will have to do in order to isolate the self intersection points. The above expression is not rational and so, we use a logical or of the following two expressions:

                < N(r), N(t) >^2
           -------------------------- < Cos^2(Angle),
           || N(r) ||^2 || N(t) ||^2

                < N(r), N(t) > < 0.


Parameters:


 CCrv:         To detect its self intersection points.
 SubdivTol:    Tolerance of the solution.  This tolerance is measured in
                 the parametric space of the surfaces.
 NumericTol:   Numeric tolerance of a possible numeric improvment stage.
                 The numeric stage is employed if NumericTol < SubdivTol.
 MinNrmlDeviation:   At the intersection points.  Zero for 90 degrees
       minimum deviation, positive for smaller minimal deviation and
       negative for a larger minimal deviation.



Returned Value:


  MvarPtStruct *:  Self intersection points, as points in E4 (r, t).



See Also:

  MvarCrvAntipodalPoints
  MvarSrfSelfInterNrmlDev


Keywords:



 MvarCrvSrfBisector 
  (mvbisect.c:114)

Prototype:

  MvarMVStruct *MvarCrvSrfBisector(const MvarMVStruct *CMV1,
                                   const MvarMVStruct *CMV2)


Description:

Computes the bisectors of a curve and a surface in R^4.

Parameters:

CMV1:	The univariate (curve) in R^4.
CMV2:	The bivariate (surface) in R^4.

Returned Value:

MvarMVStruct *: The resulting bisector.

See Also:

MvarMVsBisector MvarSrfSrfBisector MvarCrvSrfBisectorApprox

Keywords:

bisectors

MvarCrvSrfBisectorApprox

(mvbisect.c:705)

Prototype:

MvarZeroSolutionStruct *MvarCrvSrfBisectorApprox(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes an approximation to the bisector of a curve and a surface. Let C(t) be the parametric curve and T(t) its unnormalized tangent field. Let S(u,v) be the parametric surface and n(u, v) its unnormalized normal. Then:

      < P - C(t), T(t) > = 0    defines the normal plane of T(t),

and the solution of

      < S(u, v) + n(u, v) Alpha - C(t), T(t) > = 0

finds the intersection point of of the normal of the surface with the normal plane of the curve. Then,

                  < C(t) - S(u, v), T(t) >
 Alpha(t, u, v) = ------------------------
                      < n(u, v), T(t) >

We now can define this intersection point, P, as P(u, v, t) = S(u, v) + Alpha(u, v, t) n(u, v) and end up with a single function we must extract its zero set

 < C(t) - P(u, v, t), C(t) - P(u, v, t) > -
                   < S(u, v) - P(u, v, t), S(u, v) - P(u, v, t) > = 0

 < C(t) - P(u, v, t), C(t) - P(u, v, t) > -
                   < Alpha(u, v, t) n(u, v), Alpha(u, v, t) n(u, v) > = 0

with simple algebraic manipulation, the following equivalent form is is obtained, and is a polynomial (not rational) function, assuming the the input is not rational:

 < S(u, v) - C(t), S(u, v) - C(t) > < n(u, v), T(t) > +
            2 < C(t) - S(u, v), T(t) >  = 0

Finding the zero set of the last equation provides the solution in (t, u, v) space, and the bisector point is given by:

          (x, y, z) = S(u, v) + Alpha(t, u, v) n(u, v)

which is implemented as a post-process mapping.

Parameters:

CMV1:	The univariate (curve) in R^3.
CMV2:	The bivariate (surface) in R^3.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.

Returned Value:

MvarZeroSolutionStruct *: An approximation of the bisector surface, either by polyline loops or triangles.

See Also:

MvarMVsBisector MvarSrfSrfBisector MvarCrvSrfBisector MvarSrfSrfBisectorApprox

Keywords:

bisectors

MvarCrvSrfBisectorApprox2

(mvbisect.c:463)

Prototype:

VoidPtr MvarCrvSrfBisectorApprox2(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, int OutputType, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes an approximation to the bisector of a curve and a surface. Let C(t) be the parametric curve and T(t) its unnormalized tangent field. Let S(u,v) be the parametric surface and n(u, v) its unnormalized normal. Then:

      < P - C(t), T(t) > = 0    defines the normal plane of T(t),

and the solution of

      < S(u, v) + n(u, v) Alpha - C(t), T(t) > = 0

finds the intersection point of of the normal of the surface with the normal plane of the curve. Then,

                  < C(t) - S(u, v), T(t) >
 Alpha(u, v, t) = ------------------------
                      < n(u, v), T(t) >

We now can define this intersection point, P, as P(u, v, t) = S(u, v) + Alpha(u, v, t) n(u, v) and end up with a single function we must extract its zero set

 < C(t) - P(u, v, t), C(t) - P(u, v, t) > -
                   < S(u, v) - P(u, v, t), S(u, v) - P(u, v, t) > = 0

 < C(t) - P(u, v, t), C(t) - P(u, v, t) > -
                   < Alpha(u, v, t) n(u, v), Alpha(u, v, t) n(u, v) > = 0

Finding the zero set of the last equation provides the correspondance between the (u, v) location and the surface and (t) locations on the curve that serve as mutual foot point for some bisector point.

Parameters:

CMV1:	The univariate (curve) in R^3.
CMV2:	The bivariate (surface) in R^3.
OutputType:	xpected output type: 1. For the computed multivariate constraints. 2. For the computed point cloud on the bisector. 3. Points in a form of (u, v, x, y, z) where (u, v) are the parameter space of the surface.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.

Returned Value:

VoidPtr: Following OutputType, either a set of multivariates (as a linked list of MvarMVStruct), or a cloud of points on the bisector (as a linked list of MvarPtStruct).

See Also:

MvarMVsBisector MvarSrfSrfBisector MvarCrvSrfBisector MvarSrfSrfBisectorApprox

Keywords:

bisectors

MvarCrvSrfInter

(lnsrfdst.c:340)

Prototype:

MvarPtStruct *MvarCrvSrfInter(const CagdCrvStruct *Crv, const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes intersection points of a surface and a curve.

Parameters:

Crv:	Curve to intersect.
Srf:	Surface to intersect.
SubdivTol:	Subdivision tolerance of computation.
NumericTol:	Numerical tolerance of computation.

Returned Value:

MvarPtStruct *: List of intersection points as parameters (t,u,v).

See Also:

MvarLineSrfInter

Keywords:

MvarCrvSrfMinimalDist

(hasdrf3d.c:864)

Prototype:

MvarPtStruct *MvarCrvSrfMinimalDist(const CagdSrfStruct *Srf1, const CagdCrvStruct *Crv2, CagdRType *MinDist)

Description:

Computes the minimal distance between a given C1 curve and a C1 surface. Shapes are assumed to not intersect. This minimal distance can occur: 1. At end points vs. end points. 2. At the end points vs interior locations. 3. At a boundary curve of the surface vs the other curves. 4. At antipodal interior locations.

Parameters:

Srf1:	To detect its minimal distance to Crv2.
Crv2:	To detect its minimal distance to Srf1.
MinDist:	Upon return, is set to the minimal distance detected.

Returned Value:

MvarPtStruct *: Pairs of parameters at the minimal distance.

See Also:

MvarSrfSrfAntipodalPoints MvarDistSrfPoint MvarSrfSrfMinimalDist

Keywords:

MvarCrvSrfMinkowskiSum

(mink_sum.c:286)

Prototype:

struct IPObjectStruct *MvarCrvSrfMinkowskiSum(const CagdCrvStruct *Crv, const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType CrvTraceStep, CagdRType NumericTol, CagdRType OffsetTrimDist)

Description:

Computation of the Minkowski sum of a curve and a surface. The sum is defined as the locus of points Crv(t) + Srf(u,v) in R^3, for t and (u,v) in the parameter spaces, such that the corresponding tangent vector T(t) is orthogonal to the surface normal and N(u,v), i.e. We solve: * < Crv_t , Srf_u x Srf_v > = 0. * The solution triangles (or polylines) in (t, u, v) space, are then mapped to the Euclidean space using the post-process mapping Crv(t) + Srf(u,v).

Parameters:

Crv, Srf:	The curve and surface to compute their Minkowski sum.
SubdivTol:	The subdivision tolerance for the solver call.
CrvTraceStep:	Univariate curve tracing step size.
NumericTol:	The numeric tolerance for the solver call.
OffsetTrimDist:	When positive, indicates that the Minkowski sum is an offset problem, i.e. Srf is a sphere of radius OffsetTrimDist, and the value is used in the offset trimming. If negative, trimming is skipped (the problem is not an offset problem, or any other reason).

Returned Value:

struct IPObjectStruct *: List of polygons or polylines (according to the setting of the bivariate solver), approximating the Minkowski sum.

See Also:

MvarSrfSrfMinkSumMVs

Keywords:

MvarCrvTrimGlblOffsetSelfInter

(offset2.c:119)

Prototype:

CagdCrvStruct *MvarCrvTrimGlblOffsetSelfInter(CagdCrvStruct *Crv, const CagdCrvStruct *OffCrv, CagdRType TrimAmount, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Trims regions in the offset curve OffCrv that are closer than TrimAmount to original Crv, bu compute all self intersections in the offset curve, splitting the offset curve at those intersections, and purges offset curve segments that are too close to original curve.

Parameters:

Crv:	Original curve, assumed to be C1 self intersection free.
OffCrv:	The offset curve approximation.
TrimAmount:	The trimming distance. A fraction smaller than the offset amount.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

CagdCrvStruct *: A list of curve segments that are valid, after the trimming process took place.

See Also:

SymbCrvTrimGlblOffsetSelfInter

Keywords:

MvarCrvTrimGlblOffsetSelfInter2

(offset2.c:565)

Prototype:

CagdCrvStruct *MvarCrvTrimGlblOffsetSelfInter2(const CagdCrvStruct *Crv, CagdRType OffsetDist, int Operation, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Trims regions in the offset curve of planar curve Crv are closer than TrimAmount to original Crv, bu computing all self intersections in the ffset curve. Constraints are define ONLY over the original curve. Then, Split the offset curve at those intersections, and purge offset curve segments that are too close to original curve.

Parameters:

Crv:	Original curve, assumed to be C1.
OffsetDist:	The expected offset distance.
Operation:	0 - return valid curve segments in original curve. 1 - return valid curve segments as offset curves (using SymbCrvAdapOffset). 2 - merge the offset curve segments (as in Operation = 1) into one final offset curve.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

CagdCrvStruct *: A list of curve segments that are valid, after the trimming process took place.

See Also:

SymbCrvTrimGlblOffsetSelfInter SymbSrfTrimGlblOffsetSelfInter MvarCrvTrimGlblOffsetSelfInter MvarCrvDtctSelfInterOffsetLocCreateOneMV

Keywords:

MvarCrvTrimSelfInterLocations

(offset2.c:1236)

Prototype:

CagdCrvStruct *MvarCrvTrimSelfInterLocations(const CagdCrvStruct *Crv, CagdRType OffsetDist, CagdRType SubdivTol, CagdRType NumericTol, CagdBType PurgeSelfInters)

Description:

Clips the regions in an offset by distance OffsetDist of Crv and returns the proper offset.

Parameters:

Crv:	Curve to detects its self intersection locations, if any.
OffsetDist:	he desired offset distance.
SubdivTol, NumericTol:	Tolerances of MV solver.
PurgeSelfInters:	TRUE to purge self intersecting regions in the offset. If FALSE, all curves segments are returned after splitting.

Returned Value:

CagdCrvStruct *: Offset curve, clipped to non self-intersecting locations.

See Also:

MvarCrvCrvBisector2D MvarCrvDtctSelfInterLocations SymbCrvTrimGlblOffsetSelfInter SymbSrfTrimGlblOffsetSelfInter MvarCrvTrimGlblOffsetSelfInter MvarCrvTrimGlblOffsetSelfInter2

Keywords:

MvarCrvZeroSet

(zrmvaux0.c:1274)

Prototype:

CagdPtStruct *MvarCrvZeroSet(const CagdCrvStruct *Curve, int Axis, CagdRType SubdivTol, CagdRType NumericTol, CagdBType FilterTangencies)

Description:

Computes the zeros of the given curve in the given axis.

Parameters:

Curve:	To compute its zeros.
Axis:	of Crv to seek its zeros: 0 for W, 1 for X, 2 for Y, etc.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the curves.
NumericTol:	umeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.
FilterTangencies:	If TRUE, filter out tangencies at the zeros.

Returned Value:

CagdPtStruct *: List of zeros (parametric locations on CUrve).

See Also:

MvarSrfZeroSet MvarMVsZeros0D

Keywords:

MvarCtrlComputeCrvNCycle

(control.c:48)

Prototype:

MvarPtStruct *MvarCtrlComputeCrvNCycle(const CagdCrvStruct *Crv, int CycLen, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes a cycle of length CycLen of bouncing lines between the given scalar curve C(t) and the diagonal of the domain. A ray is bounced 'down' from the diagonal to C and from C, we bounce a horizontal ray to the diagonal. Let Di, i == 1,k be the diagonal points and Ci, i == 1,k the points on C. Then, the cycle of length k = CycLen is: (D1, C1, D2, C2, ... Dk, Ck). The following algebraic constraints can be imposed:

   Ci(y) = Di+1(y), for all i, (horizontal move from curve to diagonal)
   Di(x) = Ci(x),   for all i. (vertical move from diagonal to curve)

Over all, we have 2n equations and 2n dofs. We can reduce them to n equations and dofs (eliminating the diagonals):

   Ci(y) = Ci+1(x),   for all i.

Over all, we have now n equations and n dofs (n different parameters of C).

Parameters:

Crv:	A curve to compute a cycle of length CycLen for.
CycLen:	Length of sought cycle (also k above).
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the curves.
NumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Linked list of solutions, each holding the parameter values of the different Cycles, if any.

See Also:

MvarCtrlComputeSrfNCycle

Keywords:

MvarCtrlComputeSrfNCycle

(control.c:186)

Prototype:

MvarPtStruct *MvarCtrlComputeSrfNCycle(const CagdSrfStruct *Srf, int CycLen, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes a cycle of length CycLen of bouncing lines between the given surface S(u, v) = (S1(u, v), S2(u, v)). The cycle of length k = CycLen is:

 S(u1, v1) -> (u2, v)
 S(ui, vi) -> (u(i+1), v(i+1))
 S(uk, vk) -> (u1, v1)

Over all, we have 2n equations and 2n dofs.

Parameters:

Srf:	A surface to compute a cycle of length CycLen for.
CycLen:	Length of sought cycle (also k above).
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surface.
NumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Linked list of solutions, each holding the parameter values of the different Cycles, if any.

See Also:

MvarCtrlComputeCrvNCycle

Keywords:

MvarDbg

(mvar_dbg.c:28)

Prototype:

void MvarDbg(const void *Obj)

Description:

Prints multi-variates to stderr. Should be linked to programs for debugging purposes, so multi-variates may be inspected from a debugger.

Parameters:

Obj:	A multi-variate - to be printed to stderr.

Returned Value:

void

Keywords:

debugging

MvarDbgDsp

(mvar_dbg.c:74)

Prototype:

void MvarDbgDsp(const void *Obj)

Description:

Views multivariates in a display device. Should be linked to programs for debugging purposes, so multivariates may be inspected from the debugger.

Parameters:

Obj:	A multivariate - to be displayed.

Returned Value:

void

Keywords:

debugging

MvarDbgInfo

(mvar_dbg.c:168)

Prototype:

void MvarDbgInfo(const void **Objs, int Size)

Description:

Prints multi-variates statistics to stderr. Should be linked to programs for debugging purposes, so multi-variates may be inspected from a debugger.

Parameters:

Objs:	A vector of multi-variate - to print statistics on to stderr.
Size:	Size of vector.

Returned Value:

void

Keywords:

debugging

MvarDbgMVZR1DExamineSegmentBndry

(zrmvaux1.c:403)

Prototype:

void MvarDbgMVZR1DExamineSegmentBndry(MvarPtStruct *PtList, const MvarMVStruct *MV)

Description:

Verify the given segment is closed or on MV's boundary.

Parameters:

PtList:	One traced segment to examine...
MV:	If PtList starting/ending on MV boundary or closed.

Returned Value:

void

Keywords:

MvarDbgMVZR1DPrintEndPtPlList

(zrmvaux1.c:368)

Prototype:

void MvarDbgMVZR1DPrintEndPtPlList(MvarPolylineStruct *PolyList)

Description:

Print the end points of a list of polylines.

Parameters:

PolyList:	List of polylines.

Returned Value:

void

Keywords:

MvarDescribeError

(mvar_err.c:110)

Prototype:

const char *MvarDescribeError(MvarFatalErrorType ErrorNum)

Description:

Returns a string describing a the given error. Errors can be raised by any member of this mvar library as well as other users. Raised error will cause an invocation of MvarFatalError function which decides how to handle this error. MvarFatalError can for example, invoke this routine with the error type, print the appropriate message and quit the program.

Parameters:

ErrorNum:	Type of the error that was raised.

Returned Value:

const char *: A string describing the error type.

Keywords:

error handling

MvarDevelopSrfFromCrvSrf

(pdvl_alg.c:838)

Prototype:

IPObjectStruct *MvarDevelopSrfFromCrvSrf(const CagdSrfStruct *Srf, const CagdCrvStruct *Crv, const CagdCrvStruct *OrientField, int CrvSizeReduction, CagdRType SubdivTol, CagdRType NumericTol, CagdBType Euclidean)

Description:

Computes a developable scroll between the given curve, Crv, and surface, Srf. The developable scroll will be tangent to both Crv and Srf and will be a ruled surface in between (with same surface normal along rulings). Computed by solving the following two equations with three unknowns:

< C(t) - S(u, v), n(u, v) > = 0,
< n(u, v), C'(t) > = 0.


Parameters:


 Srf:   A general surface to compute developable scroll from it to Crv.
 Crv:   A general curve to compute developable scroll from it to Srf.
 OrientField:  If exists, prescribes where to look for solutions of the
          next developable in the surface (u, v) space, along Crv params.
          Assumed to have the same parameterization as Crv.
 CrvSizeReduction:   reduction in size of traced curve while ensuring
          the Tolerance, conservatively.
 SubdivTol:    Tolerance of the subdivision process.  Tolerance is
          measured in the parametric space of the multivariates.
 NumericTol:   Numeric tolerance of the numeric stage.  The numeric
          stage is employed only if NumericTol < SubdivTol.
 Euclidean:  TRUE to return the construct developable scroll(s) in the
          Euclidean space, FALSE to return the result in (u, v, t) space.



Returned Value:


  IPObjectStruct *:  A developable scroll surface in Euclidean space if
         Euclidean (or a linked list of such), or a (list of) curve in
         (u, v, t) parametric space of the scroll(s), or NULL if none.



See Also:

  MvarDevelopSrFfromCrvSrfMakeSrfs


Keywords:



 MvarDevelopSrfFromCrvSrfMakeSrfs 
  (pdvl_alg.c:1009)

Prototype:

  CagdSrfStruct *MvarDevelopSrfFromCrvSrfMakeSrfs(const CagdCrvStruct *Crv,
                                                  const CagdSrfStruct *Srf,
                                                  const CagdCrvStruct *UVTCrvs,
                                                  int CrvSizeReduction)


Description:

Evaluate the given solution to curve(s) in (u, v, t) space to surfaces between the Crv and (tangential point on) Srf.

Parameters:

Crv:	A general curve to compute developable scroll from it to Srf.
Srf:	A general surface to compute developable scroll from it to Crv.
UVTCrvs:	he solution as polylines in (u, v, t) space.
CrvSizeReduction:	reduction in size of traced curve while ensuring the Tolerance, conservatively.

Returned Value:

CagdSrfStruct *: Euclidean space developable surface.

See Also:

MvarDevelopSrfFromCrvSrf

Keywords:

MvarDistCrvOfPtFromSrf

(mvardist.c:2295)

Prototype:

CagdCrvStruct *MvarDistCrvOfPtFromSrf(const CagdRType *Pt, const CagdSrfStruct *Srf, CagdRType Dist, CagdRType Step, CagdRType SubdivTol, CagdRType NumerTol, int LstSqrFit)

Description:

Computes curve(s) on Srf that are at a Euclidean distance Dist from Pt. Solves the following equation in two variables:

 || Srf(u, v) - Pt ||^2 = Dist^2.


Parameters:


 Pt:         Point in Euclidean space to compute the fixed distance
               curve(s) for.
 Srf:        Surface to compute the fixed distance curve(s) on.
 Dist:       Euclidean distance of the curves.
 Step:       Step size during the numeric tracing.
 SubdivTol:  The subdivision tolerance to use.
 NumerTol:   The numerical tolerance to use.
 LstSqrFit:  Number of control points to allow in fit, zero to disable.



Returned Value:


  CagdCrvStruct *:  Computed curves in UV space or NULL if not found.



Keywords:



 MvarDistPointCrvC1 
  (hasdrf2d.c:56)

Prototype:

  CagdRType MvarDistPointCrvC1(CagdPType P,
                               const CagdCrvStruct *Crv,
                               MvarHFDistParamStruct *Param,
                               CagdBType MinDist,
                               CagdRType Epsilon)


Description:

Computes the min or max distance between a point and a C^1 cont. curve. The curve and point are assumed to be either in R2 or R3. The extreme distance between a point and a curve could happen either at the end points of curve C or when

  C'(t)  = 0.


Parameters:


 P:        Point to measure its Hausdorff distance to curve Crv.
 Crv:      Crv to measure its hausdorff distance to point Pt.
 Param:    Where to return the parameter value with the maximal distance.
 MinDist:  TRUE for minimal distance, FALSE for maximal.
 Epsilon:  Tolerance of computation.



Returned Value:


  CagdRType:    The Hausdorff distance.



See Also:

  SymbDistCrvPoint


Keywords:



 MvarDistPointLine 
  (mvar_int.c:241)

Prototype:

  IrtRType MvarDistPointLine(const MvarVecStruct *Point,
                             const MvarVecStruct *Pl,
                             const MvarVecStruct *Vl)


Description:

Routine to compute the minimal point distance to a given line in R^n. The line is prescribed using a point on it (Pl) and a unit vector (Vl).

Parameters:

Point:	To find the closest to on the line.
Pl, Vl:	Position and direction that defines the line. Vl is assumed a unit length vector.

Returned Value:

IrtRType: The computed minimal distance.

See Also:

GMDistPointLine

Keywords:

point line distance

MvarDistSrfLine

(mvardist.c:465)

Prototype:

CagdRType *MvarDistSrfLine(const CagdSrfStruct *Srf, const CagdPType LnPt, const CagdVType LnDir, CagdBType MinDist, CagdRType SubdivTol, CagdRType NumericTol, CagdUVType ExtremeDistUV)

Description:

Given a surface and a line, finds the nearest point (if MinDist) or the farthest location (if MinDist FALSE) from the surface to the given line. This function assumes the surface does not intersect the line. Returned is the parameter value of the surface. Only internal extrema are considered. Let S and N be the surface and its normal field. Then the extrema points are computed as the simultaneous solution of,

  < (S - LnPt) x N, LnDir > = 0,
  < N, LnDir > = 0.


Parameters:


 Srf:        The surface to find its nearest (farthest) point to Line.
 LnPt:       A point on the line to consider.
 LnDir:      The direction of the line to consider.
 MinDist:    If TRUE nearest points is needed, if FALSE farthest.
 SubdivTol:  Tolerance of the first zero set finding subdivision stage.
 NumericTol:  olerance of the second zero set finding numeric stage.
 ExtremeDistUV:  arameter value in the parameter space of Srf of the
                  nearest (farthest) point to line Line.



Returned Value:


  CagdRType *:   Parameter value in the parameter space of Srf of the
                 nearest (farthest) point to line Line.



See Also:

  MvarLclDistSrfLine
  MvarLclDistCrvLine
  MvarDistCrvLine


Keywords:

  surface line distance


 MvarDistSrfPoint 
  (mvardist.c:99)

Prototype:

  CagdRType *MvarDistSrfPoint(const CagdSrfStruct *Srf,
                              void *SrfPtPrepHandle,
                              const CagdPType Pt,
                              MvarPtStruct *InitialSol,
                              CagdBType MinDist,
                              CagdRType SubdivTol,
                              CagdRType NumericTol,
                              MvarPtStruct **ExtremePts,
                              CagdRType *ExtremeDistUV,
                              CagdPointType DistSpace)


Description:

Given a surface and a point, finds the nearest point (if MinDist) or the farthest location (if MinDist FALSE) from the surface to the given point. Returned is the parameter value of the surface. Both internal as well as boundary extrema are considered. Computes the simultaneous zeros of:

      (Srf(u, v) - Pt) . dSrf(u, v)/Du = 0,
      (Srf(u, v) - Pt) . dSrf(u, v)/Dv = 0,

and also include all extrema on the boundaries.

Parameters:

Srf:	The surface to find its nearest (farthest) point to Pt.
SrfPtPrepHandle:	If not NULL, holds pre-processed data to speed up the surface - points distance computations, for multiple surface - point tests (same surface for all points). See MvarDistSrfPointPrep and MvarDistSrfPointFree.
Pt:	The point to find the nearest (farthest) point on Srf to it.
InitialSol:	ptional initial guess for a solution in which case we aim to improve numerically to within NumericTol. If successful, this solution is returned (in place here and the return value). Otherwise, the full solver is invoked.
MinDist:	If TRUE nearest points is needed, if FALSE farthest.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.
ExtremePts:	f not NULL, will be set to hold all dist solution, as can be more than one.
ExtremeDistUV:	V Parameter values in the parameter space of Srf of the nearest (farthest) point to point Pt.
DistSpace:	The (point) space to compute the distance to surface.

Returned Value:

CagdRType *: UV Parameter values in the parameter space of Srf of the nearest (farthest) point to point Pt.

Keywords:

surface point distance

MvarDistSrfPointFree

(mvardist.c:305)

Prototype:

void MvarDistSrfPointFree(void *SrfPtPrepHandle)

Description:

Free the pre-processed data structure, given using Handle.

Parameters:

SrfPtPrepHandle:	Handle on the preprocessed surface for multiple point - curve test, to free.

Returned Value:

void

See Also:

MvarLclDistSrfPoint MvarDistSrfPointPrep

Keywords:

curve point distance

MvarDistSrfPointPrep

(mvardist.c:258)

Prototype:

void *MvarDistSrfPointPrep(const CagdSrfStruct *CSrf)

Description:

Given a curve, pre-process it so many curve-distance test can be efficiently made.

Parameters:

CSrf:	The curve to pre-process for multi-point - curve tests.

Returned Value:

void *: A handle on a structure to boost multi-point - curve tests.

See Also:

MvarDistSrfPointFree MvarLclDistSrfPoint

Keywords:

curve point distance

MvarETDbg

(mvar_dbg.c:207)

Prototype:

void MvarETDbg(const MvarExprTreeStruct *ET)

Description:

Prints multivariate expression tree to stderr. Should be linked to programs for debugging purposes, so multi-variates may be inspected from a debugger.

Parameters:

ET:	A multivariate expression tree - to be printed to stderr.

Returned Value:

void

Keywords:

debugging

MvarETDomain

(mvarextr.c:1585)

Prototype:

int MvarETDomain(const MvarExprTreeStruct *ET, CagdRType *Min, CagdRType *Max, int Axis)

Description:

Computes the domain of the expression tree along direction Axis. The assumption is that any MV in ET with a non trivial degree in direction Axis possess the same domain.

Parameters:

ET:	Expression tree to derive the domain of, in direction Axis.
Min, Max:	Domain of ET in direction Axis.
Axis:	The direction along with to compute the domain of ET, or -1 to evaluate the domain in all direction (Min and Max should be vectors of size ET -> Dim). m

Returned Value:

int: TRUE for successful computation, FALSE otherwise.

See Also:

MvarExprTreeDomain

Keywords:

MvarETUpdateConstDegDomains

(mvarextr.c:1765)

Prototype:

int MvarETUpdateConstDegDomains(MvarExprTreeStruct **MVETs, int n)

Description:

Compute the shared domain of all given expression trees and update all expression trees leafs to that domain, in their constant directions. Only constant degree directions can be updated. Higher order degree of similar directions in two different (sub) expression trees must be sharing the same domain (or otherwise an error will be returned).

Parameters:

MVETs:	vectors of expression tree MVs to update.
n:	Size of vector MVETs.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarMVUpdateConstDegDomains

Keywords:

MvarETsZeros0D

(zrsolver.c:663)

Prototype:

MvarPtStruct *MvarETsZeros0D(MvarZeroPrblmSpecStruct *ZeroProblemSpec)

Description:

Interface function for a MV expression trees solver, 1D solutions. Computes the simultaneous solution of the given set of NumOfMVs expression trees constraints. A constraint can be equality or inequality as prescribed by the Constraints vector. All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

ZeroProblemSpec:	Specification of the 0D ET problem, which includes the number of constraints, the multivariates constraints, constraints types, tolerances, call back functions, etc.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVETs.

See Also:

MvarMVsZeros0D

Keywords:

MvarEditSingleMVPt

(mvaredit.c:34)

Prototype:

MvarMVStruct *MvarEditSingleMVPt(MvarMVStruct *MV, CagdCtlPtStruct *CtlPt, int *Indices, CagdBType Write)

Description:

Provides the way to modify/get a single control point into/from a multi-variate.

Parameters:

MV:	Multi-variate to be modified/query.
CtlPt:	New control point to be substituted into MV. Must carry the same PType as MV if to be written to MV.
Indices:	In multi-variate MV's control mesh to substitute/query CtlPt.
Write:	If TRUE CtlPt is copied into MV, if FALSE the point is copied from MV to CtlPt.

Returned Value:

MvarMVStruct *: If Write is TRUE, the new modified multi-variate, if WRITE is FALSE, NULL.

Keywords:

multi-variate editing

MvarEucCrvOffsetOnSrf

(mvardist.c:1901)

Prototype:

CagdCrvStruct *MvarEucCrvOffsetOnSrf(const CagdCrvStruct *Crv, const CagdSrfStruct *Srf, CagdRType Dist, CagdRType Step, CagdRType SubdivTol, CagdRType NumerTol, int Orient, int LstSqrFit)

Description:

Computes curve(s) on Srf that are at a Euclidean distance Dist from Crv. Such curves can be consider Euclidean offset curves of Crv on Srf. Solves the following set of two equations in three variables:

 || Crv(t) - Srf(u, v) ||^2 = Dist^2.
 < Crv(t) - Srf(u, v), Crv'(t) > = 0.

and optionally:

 < (Crv'(t) x (Crv(t) - Srf(u, v)), N(u, v) > > 0,

where N(u, v) is the normal field of Srf.

Parameters:

Crv:	Curve in E3 to compute its Euclidean offset curves on Srf, assumed C^1.
Srf:	Surface on which to seek parallel Euclidean offset curve(s) to Crv.
Dist:	Euclidean distance of the offset.
Step:	Step size during the numeric tracing.
SubdivTol:	The subdivision tolerance to use.
NumerTol:	The numerical tolerance to use.
Orient:	+/-1 to request left/right orientation inequality filter, or 0 to disable.
LstSqrFit:	Number of control points to allow in fit, zero to disable.

Returned Value:

CagdCrvStruct *: Computed curves in UVT space or NULL if not found.

See Also:

MvarSpiralCrvOnSrf

Keywords:

MvarExprAuxDomainReset

(mvarextr.c:1873)

Prototype:

void MvarExprAuxDomainReset(MvarExprTreeStruct *ET)

Description:

Reset aux. domains of all bezier multivariates in the expression tree.

Parameters:

ET:	Expression tree to reset all aux domain of Bezier MVs.

Returned Value:

void

See Also:

Keywords:

MvarExprTreeAdd

(mvarextr.c:739)

Prototype:

MvarExprTreeStruct *MvarExprTreeAdd(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Adds two sub expression tree into one new expression tree.

Parameters:

Left, Right:	The two expression trees to add. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct *: Added expression tree, "Left + Right".

See Also:

Keywords:

MvarExprTreeBBox

(mvarextr.c:1362)

Prototype:

const MvarBBoxStruct *MvarExprTreeBBox(MvarExprTreeStruct *ET)

Description:

Computes the BBox of the given expression tree.

Parameters:

ET:	Expression Tree to compute the bounding box for.

Returned Value:

const MvarBBoxStruct *: Computed bounding box, in static memory.

See Also:

Keywords:

MvarExprTreeCnvrtBsp2BzrMV

(mvarextr.c:2085)

Prototype:

int MvarExprTreeCnvrtBsp2BzrMV(MvarExprTreeStruct *ET, MvarMinMaxType *Domain)

Description:

Convert, in place, all Bspline MVs in expression tree ET to Beziers. All MVs are assumed to hold no interior knots. All created Bezier MVs are updated with their aux domain.

Parameters:

ET:	Expression tree to convert Bspline MVs to Beziers, in place.
Domain:	Optional domain to set the bezier ET as aux. domain. NULL for no setting of the aux. domain.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarExprTreeCnvrtBzr2BspMV

(mvarextr.c:2149)

Prototype:

int MvarExprTreeCnvrtBzr2BspMV(MvarExprTreeStruct *ET)

Description:

Convert, in place, all Bezier MVs in expression tree ET to Bspline.

Parameters:

ET:	Expression tree to convert Bspline MVs to Beziers, in place.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarExprTreeCompositionDerivBBox

(mvarextr.c:2756)

Prototype:

MvarBBoxStruct *MvarExprTreeCompositionDerivBBox(MvarExprTreeStruct *ET, MvarBBoxStruct *BBox)

Description:

Bounds the derivative of the composition function. Currently only scalar composition allowed.

Parameters:

ET:	To evaluate its gradient at given Params parametric location.
BBox:	Where the result will be written to.

Returned Value:

MvarBBoxStruct *: Returns the same result (for convinience).

See Also:

MvarExprTreeBBox

Keywords:

MvarExprTreeConesOverlap

(mvcones.c:2171)

Prototype:

CagdBType MvarExprTreeConesOverlap(MvarExprTreeEqnsStruct *Eqns)

Description:

Computes the tangency anti-cones of the set of multivariate constraints, and returns whether they overlap or not.

Parameters:

Eqns:	The MVETs constraints formated into equations with * common expressions. *

Returned Value:

CagdBType: TRUE if overlap, FALSE if not.

See Also:

MVarExprTreeNormalCone MvarConesOverlapAux

Keywords:

MvarExprTreeCopy

(mvarextr.c:390)

Prototype:

MvarExprTreeStruct *MvarExprTreeCopy(const MvarExprTreeStruct *ET, CagdBType ThisNodeOnly, CagdBType DuplicateMVs)

Description:

A copy function to duplicate a node (ThisNodeOnly TRUE) or entire expression tree.

Parameters:

ET:	Expression tree to duplicate.
ThisNodeOnly:	TRUE to duplicate just this node.
DuplicateMVs:	If TRUE, Multivariates in leaf nodes are duplicated. Otherwise, references for them are kept instead.

Returned Value:

MvarExprTreeStruct *: Duplicated node or tree.

See Also:

Keywords:

MvarExprTreeCos

(mvarextr.c:1039)

Prototype:

MvarExprTreeStruct *MvarExprTreeCos(MvarExprTreeStruct *Left)

Description:

Cosine of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to take cosine of. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Cosine expression tree, "Cos(Left)".

See Also:

Keywords:

MvarExprTreeCrossProd

(mvarextr.c:947)

Prototype:

MvarExprTreeStruct *MvarExprTreeCrossProd(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Cross Prod two sub expression tree into one new expression tree.

Parameters:

Left, Right:	The two expression trees to multiply. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct : Multiplied expression tree, "Left Right".

See Also:

Keywords:

MvarExprTreeDotProd

(mvarextr.c:912)

Prototype:

MvarExprTreeStruct *MvarExprTreeDotProd(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Dot Prod two sub expression tree into one new expression tree.

Parameters:

Left, Right:	The two expression trees to multiply. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct : Multiplied expression tree, "Left Right".

See Also:

Keywords:

MvarExprTreeEqnsFree

(zret0d.c:354)

Prototype:

void MvarExprTreeEqnsFree(MvarExprTreeEqnsStruct *Eqns)

Description:

Free all data allocated in the expression tree equation's structure.

Parameters:

Eqns:	Data structure to free.

Returned Value:

void

See Also:

MvarMVsZeros MvarExprTreeEqnsMalloc

Keywords:

MvarExprTreeEqnsMalloc

(zret0d.c:310)

Prototype:

MvarExprTreeEqnsStruct *MvarExprTreeEqnsMalloc(int NumEqns, int MaxNumCommonExprs)

Description:

Allocate a structure to hold NumEqns equations and at most MaxNumCommonExprs common expressions.

Parameters:

NumEqns:	Number of equations we have.
MaxNumCommonExprs:	Maximum number of common expression we can initially hold.

Returned Value:

MvarExprTreeEqnsStruct *: Allocated structure.

See Also:

MvarMVsZeros MvarExprTreeEqnsFree

Keywords:

MvarExprTreeEqnsReallocCommonExprs

(zret0d.c:395)

Prototype:

void MvarExprTreeEqnsReallocCommonExprs(MvarExprTreeEqnsStruct *Eqns, int NewSize)

Description:

Reallocate (increase) the number of common expressions give Eqns can hold, in place.

Parameters:

Eqns:	Set of equations to increase, in place, the number of coomon expressions it can old.
NewSize:	of vector of common expression, zero to double the size.

Returned Value:

void

See Also:

MvarMVsZeros

Keywords:

MvarExprTreeEval

(mvarextr.c:2318)

Prototype:

CagdRType *MvarExprTreeEval(const MvarExprTreeStruct *ET, CagdRType *Params, CagdRType *Pt)

Description:

Evaluate the expression tree at the given parametric location.

Parameters:

ET:	Expression tree to evaluate.
Params:	Parameter values to evaluate the expression at.
Pt:	Evaluation result.

Returned Value:

CagdRType *: Evaluation result. Note entry zero is reserved to the rational (weight) value.

See Also:

MvarExprTreeGrad

Keywords:

MvarExprTreeEvalTanPlane

(mvarextr.c:2709)

Prototype:

MvarPlaneStruct *MvarExprTreeEvalTanPlane(const MvarExprTreeStruct *ET, CagdRType *Params)

Description:

Evaluates the tangent hyperplane of the given ET at a given location, numerically.

Parameters:

ET:	To evaluate its gradient at given Params parametric location.
Params:	Parametric location to evaluate MV at.

Returned Value:

MvarPlaneStruct *: A hyperplane, allocated dynamically. The tangent is normalized so that its last (independent coefficient is one: "A1 X1 + A2 X2 + ... + An Xn + 1". The size, n, is to the dimension of the multivariate.

See Also:

MvarMVsZeros

Keywords:

MvarExprTreeExp

(mvarextr.c:981)

Prototype:

MvarExprTreeStruct *MvarExprTreeExp(MvarExprTreeStruct *Left)

Description:

Exponent of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to exponent. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Exponentiated expression tree, "e^Left".

See Also:

Keywords:

MvarExprTreeFree

(mvarextr.c:554)

Prototype:

void MvarExprTreeFree(MvarExprTreeStruct *ET, CagdBType ThisNodeOnly)

Description:

Free an expression tree node (ThisNodeOnly TRUE) or its entire tree.

Parameters:

ET:	Expression tree to free.
ThisNodeOnly:	TRUE to free just this node, FALSE for the entire tree.

Returned Value:

void

See Also:

MvarExprTreeFreeSlots

Keywords:

MvarExprTreeFreeSlots

(mvarextr.c:482)

Prototype:

void MvarExprTreeFreeSlots(MvarExprTreeStruct *ET, CagdBType ThisNodeOnly)

Description:

Free an expression tree node (ThisNodeOnly TRUE) or its entire tree.

Parameters:

ET:	Expression tree to free.
ThisNodeOnly:	TRUE to free just this node, FALSE for the entire tree.

Returned Value:

void

See Also:

MvarExprTreeFree

Keywords:

MvarExprTreeFromCrv

(mvarextr.c:47)

Prototype:

MvarExprTreeStruct *MvarExprTreeFromCrv(const CagdCrvStruct *Crv, int NewDim, int StartAxis)

Description:

Converts the input curve into a multivariate expression tree in newDim dimension so that the Crv is along the StartAxis dimension.

Parameters:

Crv:	TO convert into an expression tree of NewDim dimension.
NewDim:	The new multivariate dimension of this tree, to promote the curve from.
StartAxis:	he starting axis (dimension) of the directions of Crv.

Returned Value:

MvarExprTreeStruct *: The build multivariate expression tree.

See Also:

Keywords:

MvarExprTreeFromMV

(mvarextr.c:112)

Prototype:

MvarExprTreeStruct *MvarExprTreeFromMV(const MvarMVStruct *MV, int NewDim, int StartAxis)

Description:

Converts the input multivariate into a multivariate expression tree in newDim dimension so that the MV is along the StartAxis dimension (and beyond).

Parameters:

MV:	To convert into an expression tree of NewDim dimension.
NewDim:	The new multivariate dimension of this tree, to promote the surface from.
StartAxis:	he starting axis (dimension) of the directions of MV.

Returned Value:

MvarExprTreeStruct *: The build multivariate expression tree.

See Also:

MvarExprTreeFromMV2

Keywords:

MvarExprTreeFromMV2

(mvarextr.c:142)

Prototype:

MvarExprTreeStruct *MvarExprTreeFromMV2(const MvarMVStruct *MV)

Description:

Converts the input multivariate into a multivariate expression tree in newDim dimension so that the MV is along the StartAxis dimension (and beyond).

Parameters:

MV:	To convert into an expression tree of NewDim dimension.

Returned Value:

MvarExprTreeStruct *: The build multivariate expression tree.

See Also:

MvarExprTreeFromMV

Keywords:

MvarExprTreeFromSrf

(mvarextr.c:79)

Prototype:

MvarExprTreeStruct *MvarExprTreeFromSrf(const CagdSrfStruct *Srf, int NewDim, int StartAxis)

Description:

Converts the input surface into a multivariate expression tree in newDim dimension so that the Srf is along the StartAxis dimension (and beyond).

Parameters:

Srf:	TO convert into an expression tree of NewDim dimension.
NewDim:	The new multivariate dimension of this tree, to promote the surface from.
StartAxis:	he starting axis (dimension) of the directions of Srf.

Returned Value:

MvarExprTreeStruct *: The build multivariate expression tree.

See Also:

Keywords:

MvarExprTreeGradient

(mvarextr.c:2479)

Prototype:

CagdRType *MvarExprTreeGradient(const MvarExprTreeStruct *ET, CagdRType *Params, int *Dim, CagdRType *GradData, CagdRType *V)

Description:

Evaluate the gradient of the expression tree at the given parametric location.

Parameters:

ET:	Expression tree to evaluate its gradient.
Params:	Parameter values to evaluate the gradient of the expression.
Dim:	Will be set with the dimension of the gradient.
GradData:	Storage for gradient evaluation
V:	Place to save auxiliary evaluated result. Of size MVAR_MAX_PT_COORD^2. If the returned gradient vector is of dimension n, it will be saved in entries [0] to [n-1].

Returned Value:

CagdRType *: Evaluation result. Same as V.

See Also:

MvarExprTreeEval

Keywords:

MvarExprTreeInteriorKnots

(mvarextr.c:2209)

Prototype:

int MvarExprTreeInteriorKnots(const MvarExprTreeStruct *ET, CagdRType *Knot)

Description:

Tests if all MVs in expression tree ET are Bezier (no interior knots).

Parameters:

ET:	Expression tree to examine for interior knots.
Knot:	Interior knot value if non Bezier expression tree (valid only if a non negative value is returned).

Returned Value:

int: Negative if all MVs are Bezier, index to dimension with interior knots, from which Knot is extracted.

See Also:

Keywords:

MvarExprTreeIntrnlNew

(mvarextr.c:337)

Prototype:

MvarExprTreeStruct *MvarExprTreeIntrnlNew(MvarExprTreeNodeType NodeType, MvarExprTreeStruct *Left, MvarExprTreeStruct *Right, const MvarBBoxStruct *MVBBox)

Description:

An expression tree (ET) constructor for a tree internal node.

Parameters:

NodeType:	Type of internal node, addition, multiplication, etc.
Left, Right:	The left and right sons of this node.
MVBBox:	Bounding box, if any, of this node.

Returned Value:

MvarExprTreeStruct *: The expression tree constructed representation.

See Also:

Keywords:

MvarExprTreeLeafDomain

(mvarextr.c:1701)

Prototype:

int MvarExprTreeLeafDomain(MvarExprTreeStruct *ET, CagdRType *Min, CagdRType *Max, int Axis)

Description:

Computes the domain of the expression tree variable (leaf) along direction Axis. The assumption is that any MV in ET with a non trivial degree in direction Axis possess the same domain.

Parameters:

ET:	Expression tree to derive the domain of, in direction Axis.
Min, Max:	Domain of ET in direction Axis.
Axis:	The direction along with to compute the domain of ET.

Returned Value:

int: TRUE for successful computation, FALSE otherwise.

See Also:

Keywords:

MvarExprTreeLeafNew

(mvarextr.c:277)

Prototype:

MvarExprTreeStruct *MvarExprTreeLeafNew(CagdBType IsRef, MvarMVStruct *MV, int NewDim, int StartAxis, MvarNormalConeStruct *MVBCone, const MvarBBoxStruct *MVBBox)

Description:

An expression tree (ET) constructor for a tree leaf node.

Parameters:

IsRef:	TRUE to just reference MV instead of copying it. Note that if NewDim is non zero, the MV will always be copied with the new expanded dimension NewDim.
MV:	MV to occupy this leaf node. Can be NULL.
NewDim:	The new multivariate dimension of this tree.
StartAxis:	he starting axis of the directions of MV.
MVBCone:	Bounding code, if any, of MV.
MVBBox:	Bounding box, if any, of MV.

Returned Value:

MvarExprTreeStruct *: An expression tree representing MV.

See Also:

Keywords:

MvarExprTreeLog

(mvarextr.c:1010)

Prototype:

MvarExprTreeStruct *MvarExprTreeLog(MvarExprTreeStruct *Left)

Description:

Logarithm of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to take log of. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Logarithm'ed expression tree, "Log(Left)".

See Also:

Keywords:

MvarExprTreeMergeScalar

(mvarextr.c:842)

Prototype:

MvarExprTreeStruct *MvarExprTreeMergeScalar(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Concatenates two scalar sub expression tree into one new expression tree. Left and Right are assumed to be scalar ET function.

Parameters:

Left, Right:	The two expression trees to merge. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct : Multiplied expression tree, "Left Right".

See Also:

Keywords:

MvarExprTreeMult

(mvarextr.c:807)

Prototype:

MvarExprTreeStruct *MvarExprTreeMult(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Multiplies two sub expression tree into one new expression tree.

Parameters:

Left, Right:	The two expression trees to multiply. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct : Multiplied expression tree, "Left Right".

See Also:

Keywords:

MvarExprTreeMultScalar

(mvarextr.c:878)

Prototype:

MvarExprTreeStruct *MvarExprTreeMultScalar(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Multiplies two sub expression tree into one new expression tree. Right is assumed to be a scalar ET function.

Parameters:

Left, Right:	The two expression trees to multiply. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct : Multiplied expression tree, "Left Right".

See Also:

Keywords:

MvarExprTreeNPow

(mvarextr.c:1128)

Prototype:

MvarExprTreeStruct *MvarExprTreeNPow(MvarExprTreeStruct *Left, int Power)

Description:

Subexpression tree to a power of Power.

Parameters:

Left:	The expression tree to to raise to power. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.
Power:	he power to raise the expression to.

Returned Value:

MvarExprTreeStruct *: Square expression tree, "Left^power".

See Also:

Keywords:

MvarExprTreeNormalConeMul

(mvcones.c:1985)

Prototype:

MvarNormalConeStruct *MvarExprTreeNormalConeMul( const MvarNormalConeStruct *ConeF, const MvarNormalConeStruct *ConeG, const MvarBBoxStruct *BBoxF, const MvarBBoxStruct *BBoxG, int Dim)

Description:

Constructs a normal cone of a multiplication.

Parameters:

ConeF:	ormal cone of the first term.
ConeG:	ormal cone of the second term.
BBoxF:	ounding box of the first term.
BBoxG:	ounding box of the second term.
Dim:	Dimensions.

Returned Value:

MvarNormalConeStruct *: The resulting normal cone.

See Also:

MVarExprTreeNormalCone MvarExprTreeNormalConeSum MvarExprTreeNormalConeScale

Keywords:

MvarExprTreeNormalConeScale

(mvcones.c:2028)

Prototype:

MvarNormalConeStruct *MvarExprTreeNormalConeScale( const MvarNormalConeStruct *ConeF, const MvarBBoxStruct *BBoxGPrime, int Dim)

Description:

Scales normal cone (for composition and multiplication).

Parameters:

ConeF:	Normal cone of the function.
BBoxGPrime:	Bounding box of the scale factor.
Dim:	Dimensions.

Returned Value:

MvarNormalConeStruct *: New scaled cone.

See Also:

MVarExprTreeNormalCone MvarExprTreeNormalConeMul

Keywords:

MvarExprTreeNormalConeSub

(mvcones.c:1946)

Prototype:

MvarNormalConeStruct *MvarExprTreeNormalConeSub( const MvarNormalConeStruct *ConeF, const MvarNormalConeStruct *ConeG, int Dim)

Description:

Constructs a normal cone of a difference.

Parameters:

ConeF:	ormal cone of the minuend.
ConeG:	ormal cone of the subtrahend.
Dim:	Dimensions.

Returned Value:

MvarNormalConeStruct *: The resulting normal cone.

See Also:

MVarExprTreeNormalCone MvarExprTreeNormalConeSum

Keywords:

MvarExprTreeNormalConeSum

(mvcones.c:1758)

Prototype:

MvarNormalConeStruct *MvarExprTreeNormalConeSum( const MvarNormalConeStruct *ConeF, const MvarNormalConeStruct *ConeG, int Dim)

Description:

Constructs a normal cone of a sum.

Parameters:

ConeF:	ormal cone of the the first summand.
ConeG:	ormal cone of the second summand.
Dim:	Dimensions.

Returned Value:

MvarNormalConeStruct *: The resulting normal cone.

See Also:

MVarExprTreeNormalCone HyperplaneOrthoSystem

Keywords:

MvarExprTreePrintInfo

(mvarextr.c:1928)

Prototype:

void MvarExprTreePrintInfo(const MvarExprTreeStruct *ET, CagdBType CommonExprIdx, CagdBType PrintMVInfo, MvarExprTreePrintFuncType PrintFunc)

Description:

Traverses the ET in infix order and print the Info/Node in the ET.

Parameters:

ET:	To traverse and prints its Info/Node content.
CommonExprIdx:	TRUE to only dump the common expression index, FALSE for the full common expression in place.
PrintMVInfo:	TRUE to print information on MV leafs.
PrintFunc:	Call back function to print a string.

Returned Value:

void

See Also:

Keywords:

MvarExprTreeRecip

(mvarextr.c:1159)

Prototype:

MvarExprTreeStruct *MvarExprTreeRecip(MvarExprTreeStruct *Left)

Description:

Reciprocation of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to reciprocate. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Reciprocation expression tree, "1.0/Left".

See Also:

Keywords:

MvarExprTreeSize

(mvarextr.c:580)

Prototype:

int MvarExprTreeSize(MvarExprTreeStruct *ET)

Description:

Returns the size (number of nodes) an expression tree has.

Parameters:

ET:	Expression tree to compute its size (number of nodes).

Returned Value:

int: Number of nodes in ET.

See Also:

Keywords:

MvarExprTreeSqr

(mvarextr.c:1097)

Prototype:

MvarExprTreeStruct *MvarExprTreeSqr(MvarExprTreeStruct *Left)

Description:

Square of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to take square of. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Square expression tree, "Square(Left)".

See Also:

Keywords:

MvarExprTreeSqrt

(mvarextr.c:1068)

Prototype:

MvarExprTreeStruct *MvarExprTreeSqrt(MvarExprTreeStruct *Left)

Description:

Square root of subexpression tree into a new expression tree.

Parameters:

Left:	The expression tree to take square root of. The sub tree is used in place, so duplicate before calling this function if you like to keep the original Left.

Returned Value:

MvarExprTreeStruct *: Sqrt expression tree, "Sqrt(Left)".

See Also:

Keywords:

MvarExprTreeSub

(mvarextr.c:773)

Prototype:

MvarExprTreeStruct *MvarExprTreeSub(MvarExprTreeStruct *Left, MvarExprTreeStruct *Right)

Description:

Subtracts two sub expression tree into one new expression tree.

Parameters:

Left, Right:	The two expression trees to subtract. These sub trees are used in place, so duplicate before calling this function if you like to keep the original Left/Right.

Returned Value:

MvarExprTreeStruct *: Subtracted expression tree, "Left - Right".

See Also:

Keywords:

MvarExprTreeSubdivAtParam

(mvarextr.c:1194)

Prototype:

int MvarExprTreeSubdivAtParam(const MvarExprTreeStruct *ET, CagdRType t, MvarMVDirType Dir, MvarExprTreeStruct **Left, MvarExprTreeStruct **Right)

Description:

Subdivides the given multivariate expression tree at t in direction Dir.

Parameters:

ET:	The expression tree to subdivide at parameter value t, in Dir.
t:	The parameter value to subdivide at.
Dir:	The direction of subdivision.
Left:	First result of subdivision.
Right:	Second result of subdivision.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarExprTreeToMV

(mvarextr.c:164)

Prototype:

MvarMVStruct *MvarExprTreeToMV(const MvarExprTreeStruct *ET)

Description:

Converts an expression tree to a regular multivariate function.

Parameters:

ET:	Expression tree to convert to a multivariate.

Returned Value:

MvarMVStruct *: Multivariate representing the expression tree.

See Also:

Keywords:

MvarExprTreeZerosCnvrtBezier2MVs

(zret0d.c:1162)

Prototype:

int MvarExprTreeZerosCnvrtBezier2MVs(int Bezier2MVs)

Description:

Sets the way expression trees of Bezier MVs are treated. If TRUE, the ETs are converted into MVs and the regular MV zero solver is invoked. If FALSE, the ETs are subdivided all the way to SUbdivTol.

Parameters:

Bezier2MVs:	TRUE to convert to MVs, FALSE to subdivide Bezier ETs.

Returned Value:

int: Old setting for Bezier conversion setting.

See Also:

MvarExprTreesZeros MvarExprTreeZerosUseCommonExpr

Keywords:

MvarExprTreeZerosUseCommonExpr

(zret0d.c:1132)

Prototype:

int MvarExprTreeZerosUseCommonExpr(int UseCommonExpr)

Description:

Sets the exploitation of common expression extraction in expression trees. If TRUE, the ETs are scanned for common expressions that are then processed once only, during the subdivision process.

Parameters:

UseCommonExpr:	TRUE to use common expressions, FALSE otherwise.

Returned Value:

int: Old setting of common expressions' use.

See Also:

MvarExprTreesZeros MvarExprTreeZerosCnvrtBezier2MVs

Keywords:

MvarExprTreesSame

(mvarextr.c:637)

Prototype:

CagdBType MvarExprTreesSame(const MvarExprTreeStruct *ET1, const MvarExprTreeStruct *ET2, CagdRType Eps)

Description:

A comparison function to test for similarity (up to Eps) two expression trees.

Parameters:

ET1, ET2:	Two expression trees to compare.
Eps:	Tolerance of approximation.

Returned Value:

CagdBType: TRUE if the same ETs (up to Eps), FALSE otherwise.

See Also:

Keywords:

MvarExprTreesVerifyDomain

(mvarextr.c:698)

Prototype:

int MvarExprTreesVerifyDomain(MvarExprTreeStruct *ET1, MvarExprTreeStruct *ET2)

Description:

Examine the given two multivariate's expression trees if they share the same domains.

Parameters:

ET1, ET2:	Two multivariate expression trees to verify that they share the same domains.

Returned Value:

int: TRUE if Et1/2 shares the same domains, FALSE otherwise.

See Also:

MvarExprTreeDomain

Keywords:

MvarFatalError

(mvar_ftl.c:57)

Prototype:

void MvarFatalError(MvarFatalErrorType ErrID)

Description:

Trap Mvar_lib errors right here. Provides a default error handler for the mvar library. Gets an error description using MvarDescribeError, prints it and exit the program using exit.

Parameters:

ErrID:	Error type that was raised.

Returned Value:

void

Keywords:

error handling

MvarFindSrfMiterPoints

(selfintr.c:1978)

Prototype:

MvarPtStruct *MvarFindSrfMiterPoints(const CagdSrfStruct *Srf, int Axis, CagdRType SubdivTol, CagdRType NumericTol, CagdBType Euclidean)

Description:

Given a surface S(u,v), compute the singular or miter points, the points on the self-intersection curves of the surface that changes the normal direction abruptly. Specifically, it finds location where the normal (or Jacobian) is vanishing as the solutions of one of three systems of equations, using the multivariate solvers -

      Nx(u, v) = Ny(u, v) = 0

      Ny(u, v) = Nz(u, v) = 0

      Nz(u, v) = Nx(u, v) = 0

where Ni(u, v) is i-th coordinate (x, y or z) of the unnormalized normal of the surface. Miter points satisfy all the three systems simultaneously.

Parameters:

Srf:	Surface to compute miter points.
Axis:	System to compute the miter points. If Axis = 1, solve Nx(u, v) = Ny(u, v) = 0. If Axis = 2, solve Ny(u, v) = Nz(u, v) = 0. If Axis = 3, solve Nz(u, v) = Nx(u, v) = 0. If Axis = 0, find the miter points satisfying all three systems.
SubdivTol:	Subdivion tolerance used in the solver.
NumericTol:	Numeric tolerance used in the solver.
Euclidean:	If FALSE, find the UV coordinates of miter points. Otherwise, compute the XYZ coordinates.

Returned Value:

MvarPtStruct *: A list of miter points satisfying the constraint equations.

See Also:

MvarFindSrfMiterPointsPartial SymbSrfNormalSrf

Keywords:

Surface self-intersection Miter points singularities Jacobian

MvarFindSrfMiterPointsPartial

(selfintr.c:1849)

Prototype:

MvarPtStruct *MvarFindSrfMiterPointsPartial(const CagdSrfStruct *Srf, const CagdSrfStruct *NrmlSrf, int Axis1, int Axis2, CagdRType SubdivTol, CagdRType NumericTol, CagdRType UVDiffTol, CagdBType Euclidean)

Description:

Given a surface S(u,v), compute the singular or miter points, the points on the self-intersection curves of the surface that changes the normal direction abruptly. Specifically, it finds location where the normal (or Jacobian) is vanishing as the solutions of one of three systems of equations, using the multivariate solvers:

      Nx(u, v) = Ny(u, v) = 0

      Ny(u, v) = Nz(u, v) = 0

      Nz(u, v) = Nx(u, v) = 0

where Ni(u, v) is i-th coordinate (x, y or z) of the unnormalized normal of the surface. Miter points satisfy all the three systems simultaneously.

Parameters:

Srf:	Surface to compute miter points.
NrmlSrf:	Normal surface. If NULL, then compute the surface inside this routine.
Axis1:	First axis of normal equation in the system (1-3).
Axis2:	Second axis of normal equation in the system (1-3).
SubdivTol:	Subdivion tolerance used in the solver.
NumericTol:	Numeric tolerance used in the solver.
UVDiffTol:	If positive, merge the solution points within the tolerance.
Euclidean:	If FALSE, find the UV coordinates of miter points. Otherwise, compute the XYZ coordinates.

Returned Value:

MvarPtStruct *: A list of miter points satisfying the constraint equations.

See Also:

MVFindMiterPoints SymbSrfNormalSrf

Keywords:

Surface self-intersection Miter points singularities Jacobian

MvarFlecnodalCrvsCreateMVCnstrnts

(mvaccess.c:480)

Prototype:

MvarMVStruct **MvarFlecnodalCrvsCreateMVCnstrnts(const CagdSrfStruct *CSrf)

Description:

Computes the MV constraints of flecnodal curves on surface S(u, v). Denote by Suv the second order derivatives of S(u, v) and by Suvv the third order derivatives. Then, solution of the following 3 equations in 4 unknowns (u, v, a, b) provides the flecnodal curves:

            [ L M ] [ a ]
1. [ a  b ] [     ] [   ] =       (This location/direction is asymp.)
            [ M N ] [ b ]         (L, M, N are the coef. of SFF.)

               [ Suu Suv ]           [ a ]
    = [ a  b ] [         ] . n(u, v) [   ] = 0,
               [ Suv Svv ]           [ b ]

   < a^2 Suu + 2ab Suv + b^2 Svv, n(u, v) > = 0.

            (   [ Suuu Suuv ]       [ Svuu Svuv ] )            [ a ]
2. [ a  b ] ( a [           ]  +  b [           ] )  . n(u, v) [   ] = 0,
            (   [ Suuv Suvv ]       [ Svuv Svvv ] )            [ b ]

(A third derivative zero contact.) or

   < a^3 Suuu + 3a^2b Suuv + 3ab^2 Suvv + b^3 Svvv, n(u, v) > = 0.

3. a * a + b * b = 1 (A normalization constraint.)

Parameters:

CSrf:	To compute the (MV constraints of the) flecnodals for.

Returned Value:

MvarMVStruct **: The set of 3 constraints in 4 unknowns to derive the flecnodal curves of CSrf.

See Also:

SymbSrfGaussCurvature UserSrfTopoAspectGraph SymbEvalSrfAsympDir MvarSrfSilhInflections MvarSrfFlecnodalCrvs

Keywords:

MvarGetLastPt

(mvar_pll.c:270)

Prototype:

MvarPtStruct *MvarGetLastPt(MvarPtStruct *Pts)

Description:

Returns the last element in the list.

Parameters:

Pts:	List of points to fetch last one.

Returned Value:

MvarPtStruct *: Last element in list.

Keywords:

MvarGetMiniumIntnPar

(mvtrmpcr.c:1543)

Prototype:

static CagdPtStruct *MvarGetMiniumIntnPar(CagdCrvStruct *TrimmedBis, CagdRType *Pt, CagdPtStruct *Inter, CagdPType LeftNormal)

Description:

This function returns the minimum intersection parameter of the curve with the Line after confirming that the vector between the discontinuity point and the intersection parameter is in the same direction to the Left hand normal.

Parameters:

TrimmedBis:	The input curve in CagdCrvStruct.
Pt:	The input point - CagdRType.
Inter:	List of intersection parameters obtained using SymbLclDistCrvLine.
LeftNormal:	Left Normal of TrimmedBis at the point Pt.

Returned Value:

CagdPtStruct *: Return the TrimmedBis parameter.

See Also:

SymbLclDistCrvLine

Keywords:

MvarGetPointsMeshIndices

(mvar_aux.c:1099)

Prototype:

int MvarGetPointsMeshIndices(const MvarMVStruct *MV, int *Indices)

Description:

Given indices into the control mesh, return the index in the vector representation Points of that single point.

Parameters:

MV:	Whose indices are for.
Indices:	To compute the exact point location in MV -> Points

Returned Value:

int: Index of point whose indices are Indices in MV -> Points.

See Also:

MvarMeshIndicesFromIndex MvarGetPointsPeriodicMeshIndices

Keywords:

MvarGetPointsPeriodicMeshIndices

(mvar_aux.c:1151)

Prototype:

int MvarGetPointsPeriodicMeshIndices(const MvarMVStruct *MV, int *Indices)

Description:

Given indices into the control mesh, return the index in the vector representation Points of that single point. MV can be periodic.

Parameters:

MV:	Whose indices are for.
Indices:	To compute the exact point location in MV -> Points

Returned Value:

int: Index of point whose indices are Indices in MV -> Points.

See Also:

MvarMeshIndicesFromIndex MvarGetPointsMeshIndices

Keywords:

MvarHFDistAntipodalCrvCrvC1

(hasdrf2d.c:155)

Prototype:

MvarPtStruct *MvarHFDistAntipodalCrvCrvC1(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdRType Epsilon)

Description:

Computes the antipodal points of the given two curves by solving:

    < C1(t) - C2(r), C1'(t) > = 0,
    < C1(t) - C2(r), C2'(r) > = 0.
    < C1(t) - C2O(r), C1'(t) > = 0,       (Only during subdivision step)
    < C1(t) - C2O(r), C2'(r) > = 0,       (Only during subdivision step)

where C2O is an offset curve of C2 by amount larger than subdivison tol. The last two equations are used to purge intersection locations as they cause the first two equations to vanish.

Parameters:

Crv1, Crv2:	The two curves to solve for their antipodal locations.
Epsilon:	Tolerance of computation.

Returned Value:

MvarPtStruct *: List of pairs of parameters in the t & r coefficients.

See Also:

MvarCrvAntipodalPoints MvarCntctTangentialCrvCrvC1

Keywords:

MvarHFDistAntipodalCrvSrfC1

(hasdrf3d.c:139)

Prototype:

MvarPtStruct *MvarHFDistAntipodalCrvSrfC1(const CagdSrfStruct *Srf1, const CagdCrvStruct *Crv2)

Description:

Computes the antipodal points of the given surface and curve by solving:

    < C2(t) - S1(u, v), dS1(u, v) / du > = 0,
    < C2(t) - S1(u, v), dS1(u, v) / dv > = 0,
    < C2(t) - S1(u, v), dC2(t) / dt > = 0.


Parameters:


 Srf1, Crv2:  A surface and a curve to solve for their antipodal
                locations.



Returned Value:


  MvarPtStruct *: List of pairs of parameters in the uv & t coefficients.



See Also:

  MvarSrfAntipodalPoints


Keywords:



 MvarHFDistAntipodalSrfSrfC1 
  (hasdrf3d.c:404)

Prototype:

  MvarPtStruct *MvarHFDistAntipodalSrfSrfC1(const CagdSrfStruct *Srf1,
                                            const CagdSrfStruct *Srf2)


Description:

Computes the antipodal points of the given two surfaces by solving:

    < S2(r, t) - S1(u, v), dS1(u, v) / du > = 0,
    < S2(r, t) - S1(u, v), dS1(u, v) / dv > = 0,
    < S2(r, t) - S1(u, v), dS2(s, t) / ds > = 0,
    < S2(r, t) - S1(u, v), dS2(s, t) / ds > = 0.


Parameters:


 Srf1, Srf2:  The two surfaces to solve for their antipodal locations.



Returned Value:


  MvarPtStruct *: List of pairs of parameters in the uv & st coefficients.



See Also:

  


Keywords:



 MvarHFDistBisectSrfSrfC1 
  (hasdrf3d.c:582)

Prototype:

  MvarHFDistPairParamStruct *MvarHFDistBisectSrfSrfC1(const CagdSrfStruct *Srf1,
                                                      const CagdSrfStruct *Srf2)


Description:

Compute the intersection locations of (C^1 cont) Srf2 with the self bisectors of (C^1 cont.) Srf1, if any. The solution is computed by solving the following set of contraints:

    || S2(s, t) - S1(a, b) ||^2 == || S2(s, t) - S1(c, d) ||^2,
    < S2((s, t) - S1(a, b), dS1(a, b)/da > = 0,
    < S2((s, t) - S1(a, b), dS1(a, b)/db > = 0,
    < S2((s, t) - S1(c, d), dS1(c, d)/dc > = 0.
    < S2((s, t) - S1(c, d), dS1(c, d)/dd > = 0.

augumented with

    < (S1(a, b) - S(c, d)) x (S1(a, b) + S1(c, d) - 2S2(s, t)),
      NS2(s, t) > = 0,

where NS2 is a (non normalized) normnal field of S2. The first equation above (equal distance to two different locations in C1) could be rewritten as:

    < S1(a, b) + S1(c, d) - 2S2(s, t), S1(a, b) - S1(c, d) > = 0,

which hints to the fact that this equation vanish for ((a, b) == (c, d)). Hence, in the solution process, we eliminate the ((a, b) == (c, d)) factors from it.

Parameters:

Srf1:	First surface to intersect its self-bisector with Srf2.
Srf2:	Second surface to intersect against the self bisector of Srf1.

Returned Value:

MvarHFDistPairParamStruct *: Linked list of all detected intersections. Note each detected intersection holds two parameter locations of Srf1.

See Also:

Keywords:

MvarHFDistCrvCrvC1

(hasdrf2d.c:1051)

Prototype:

CagdRType MvarHFDistCrvCrvC1(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2, CagdRType Epsilon)

Description:

Computes the Hausdorff distance between two C^1 cont. curves, C1 and C2. The curves are assumed to be either in R2 or R3. The extreme distance between two curves could happen at: + The end points of the curves. + Antipodal locations where:

    C1'(t)  = 0,
    C2'(r)  = 0.

+ Locations where C1 crosses the self bisector of C2 (or vice versa): Let Bi(x,y) = 0 be self bisector of Ci(t), and Cj(r) = (xj(r), yj(r)). Then, solve for:

    || C2(r) - C1(s) ||^2 == || C2(r) - C1(t) ||^2,
    < C2(r) - C1(s), C1'(s) > = 0,
    < C2(r) - C1(t), C1'(t) > = 0.

All the above equations hold for R2 and for R3.

Parameters:

Crv1:	First Crv to measure its hausdorff distance to Crv2.
Crv2:	Second Crv to measure its hausdorff distance to Crv1.
Param1:	Where to return the parameter value(s) of Crv1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Crv2 with the maximal Hausdorff distance. Can be more than one location!
Epsilon:	Tolerance of computation.

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

Keywords:

MvarHFDistFromCrvToCrvC1

(hasdrf2d.c:864)

Prototype:

CagdRType MvarHFDistFromCrvToCrvC1(const CagdCrvStruct *CCrv1, const CagdCrvStruct *CCrv2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2, CagdRType Epsilon)

Description:

Computes the one sided Hausdorff distance between two C^1 cont. curves, from C1 to C2. The curves are assumed to be either in R2 or R3. The one sided extreme distance between two curves could happen at: + The end points of curve C1 or curve C2. + Antipodal locations or locations where:

    C1'(t)  = 0,
    C2'(r)  = 0,

that are also global distance minima from C1(t) to any point on C2. + Locations where C1 crosses the self bisector of C2 that are also local distance minima from C1 to any point on C2. All the above equations hold for R2 and for R3.

Parameters:

CCrv1:	First Crv to measure its hausdorff distance to CCrv2.
CCrv2:	Second Crv to measure its hausdorff distance from CCrv1.
Param1:	Where to return the parameter value(s) of Crv1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Crv2 with the maximal Hausdorff distance. Can be more than one location!
Epsilon:	Tolerance of computation.

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

Keywords:

MvarHFDistFromCrvToSrfC1

(hasdrf3d.c:293)

Prototype:

CagdRType MvarHFDistFromCrvToSrfC1(const CagdCrvStruct *Crv1, const CagdSrfStruct *Srf2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2)

Description:

Computes the one sided Hausdorff distance between a C^1 cont. curve and a C^1 cont. surface, from C1 to S2. The shapes are assumed to be in R3 and non intersecting. The one sided extreme distance between the two shapes could happen at: + The corner/end points of curve C1 or surface S2. + Antipodal locations between the two shapes. + Locations where C1 crosses the self bisector of S2 that are also local distance minima from C1 to any point on S2.

Parameters:

Crv1:	First crv to measure its hausdorff distance to Srf2.
Srf2:	Second srf to measure its hausdorff distance from Crv1.
Param1:	Where to return the parameter value(s) of Crv1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Srf2 with the maximal Hausdorff distance. Can be more than one location!

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

MvarHFDistFromSrfToSrfC1 MvarHFDistFromSrfToCrvC1

Keywords:

MvarHFDistFromSrfToCrvC1

(hasdrf3d.c:331)

Prototype:

CagdRType MvarHFDistFromSrfToCrvC1(const CagdSrfStruct *Srf1, const CagdCrvStruct *Crv2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2)

Description:

Computes the one sided Hausdorff distance between a C^1 cont. surface and a C^1 cont. curve, from S1 to C2 The shapes are assumed to be in R3 and non intersecting. The one sided extreme distance between the two shapes could happen at: + The corner/end points of surface S1 or curve C2. + Antipodal locations between the two shapes. + Locations where S1 crosses the self bisector of C2 that are also local distance minima from S1 to any point on C2.

Parameters:

Srf1:	First srf to measure its hausdorff distance to Crv2.
Crv2:	Second crv to measure its hausdorff distance from Srf1.
Param1:	Where to return the parameter value(s) of Srf1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Crv2 with the maximal Hausdorff distance. Can be more than one location!

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

MvarHFDistFromSrfToSrfC1

Keywords:

MvarHFDistFromSrfToSrfC1

(hasdrf3d.c:653)

Prototype:

CagdRType MvarHFDistFromSrfToSrfC1(const CagdSrfStruct *CSrf1, const CagdSrfStruct *CSrf2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2)

Description:

Computes the one sided Hausdorff distance between two C^1 cont. surfaces from S1 to S2. The surfaces are assumed to be in R3 and non intersecting. The one sided extreme distance between two surfaces could happen at: + The corner points of surface S1 or surface S2. + Antipodal locations between the two surfaces. + Locations where S1 crosses the self bisector of S2 that are also local distance minima from S1 to any point on S2.

Parameters:

CSrf1:	First Srf to measure its hausdorff distance to Srf2.
CSrf2:	Second Srf to measure its hausdorff distance from Srf1.
Param1:	Where to return the parameter value(s) of Srf1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Srf2 with the maximal Hausdorff distance. Can be more than one location!

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

Keywords:

MvarHFDistInterBisectCrvCrvC1

(hasdrf2d.c:597)

Prototype:

MvarHFDistPairParamStruct *MvarHFDistInterBisectCrvCrvC1( const CagdCrvStruct *CCrv1, const CagdCrvStruct *CCrv2, CagdRType Epsilon)

Description:

Compute the intersection locations of (C^1 cont) Crv2 with the self bisectors of (C^1 cont.) Crv1, if any. The solution is computed by solving the following cases: 1. The curve-curve self bisector of Crv1, intersected with Crv2:

    || C2(w) - C1(u) ||^2 == || C2(w) - C1(v) ||^2,
    < C2(w) - C1(u), C1'(u) > = 0,
    < C2(w) - C1(v), C1'(v) > = 0.

The first equations above (equal distance to two different locations in C1) could be rewritten as:

    < C1(u) + C1(v) - 2C2(w), C1(u) - C1(v) > = 0,

which hints to the fact that this equation vanish for (u == v). Hence, in the solution process, we eliminate the (u - v) factors from it. 2. Endpoint-curve self bisectors of Crv1, intersected with Crv2 (2 cases): Let B(t) be equal to the self bisector of Crv1 with one of its end points. Then, solve for B(t) = C2(w). 3. Endpoint-Endpoint self bisectors of Crv1, intersected with Crv2: solved as a line (Endpoint-Endpoint bisector) - Crv2 intersection.

Parameters:

CCrv1:	First curve to intersect its self-bisector with Crv2.
CCrv2:	Second curve to intersect against the self bisector of Crv1.
Epsilon:	Tolerance of computation.

Returned Value:

MvarHFDistPairParamStruct *: Linked list of all detected intersections. Note each detected intersection holds two parameters of Crv1.

See Also:

Keywords:

MvarHFDistInterBisectCrvCrvC1Crvtr

(hasdrf2d.c:350)

Prototype:

MvarHFDistPairParamStruct *MvarHFDistInterBisectCrvCrvC1Crvtr( CagdCrvStruct *Crv1, CagdCrvStruct *Crv2, CagdRType Epsilon)

Description:

Old version of MvarHFDistInterBisectCrvCrvC1 that splits the input curves at curvature max. locations whereas MvarHFDistInterBisectCrvCrvC1 eliminates the (u - v) terms directly. Computes the intersection locations of (C^1 cont) Crv2 with the self bisectors of (C^1 cont.) Crv1, if any. The solution is computed by solving the following cases: 1. The curve-curve self bisector of Crv1, intersected with Crv2:

    || C2(w) - C1(u) ||^2 == || C2(w) - C1(v) ||^2,
    < C2(w) - C1(u), C1'(u) > = 0,
    < C2(w) - C1(v), C1'(v) > = 0.

The first equations above (equal distance to two different locations in C1) could be rewritten as:

    < C1(u) + C1(v) - 2C2(w), C1(u) - C1(v) > = 0,

which hints to the fact that this equation vanish for (u == v). To speed up the process we also add a constraint that the distance from C2 to its two foot point should be greater than the radius of curvature of C1. 2. Endpoint-curve self bisectors of Crv1, intersected with Crv2 (2 cases): Let B(t) be equal to the self bisector of Crv1 with one of its end points. Then, solve for B(t) = C2(w). 3. Endpoint-Endpoint self bisectors of Crv1, intersected with Crv2: solved as a line (Endpoint-Endpoint bisector) - Crv2 intersection.

Parameters:

Crv1:	First curve to intersect its self-bisector with Crv2.
Crv2:	Second curve to intersect against the self bisector of Crv1.
Epsilon:	Tolerance of computation.

Returned Value:

MvarHFDistPairParamStruct *: Linked list of all detected intersections. Note each detected intersection holds two parameters of Crv1.

See Also:

MvarHFDistInterBisectCrvCrvC1

Keywords:

MvarHFDistInterBisectSrfSrfC1

(hasdrf3d.c:615)

Prototype:

MvarHFDistPairParamStruct *MvarHFDistInterBisectSrfSrfC1( const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2)

Description:

Compute the intersection locations of (C^1 cont) Srf2 with the self bisectors of (C^1 cont.) Srf1, if any. The solution is computed by solving the following set of contraints: 1. The surface-surface self bisector of Srf1, intersected with Srf2 2. boundary-curve self bisectors of Srf1, intersected with Srf2 3. corner-point self bisectors of Srf1, intersected with Srf2

Parameters:

Srf1:	First curve to intersect its self-bisector with Srf2.
Srf2:	Second curve to intersect against the self bisector of Srf1.

Returned Value:

MvarHFDistPairParamStruct *: Linked list of all detected intersections. Note each detected intersection holds two parameters locations of Srf1.

See Also:

Keywords:

MvarHFDistPointSrfC1

(hasdrf3d.c:43)

Prototype:

CagdRType MvarHFDistPointSrfC1(const CagdPType P, const CagdSrfStruct *Srf, MvarHFDistParamStruct *Param, CagdBType MinDist)

Description:

Computes the Hausdorff distance between a point and a C^1 cont. surface. The surface and point are assumed to be either in R3. The extreme distance between a point and a surface could happen either at the corner points of surface Srf, the boundary curves of Srf, or when

    dS'(u, v)/du = 0,
    dS'(u, v)/dv = 0.


Parameters:


 P:        Point to measure its Hausdorff distance to surface Srf.
 Srf:      Srf to measure its hausdorff distance to point Pt.
 Param:    Where to return the parameter value with the maximal distance.
 MinDist:  TRUE for minimal distance, FALSE for maximal.



Returned Value:


  CagdRType:    The Hausdorff distance.



See Also:

  MvarDistSrfPoint


Keywords:



 MvarHFDistSrfCrvC1 
  (hasdrf3d.c:364)

Prototype:

  CagdRType MvarHFDistSrfCrvC1(const CagdSrfStruct *Srf1,
                               const CagdCrvStruct *Crv2,
                               MvarHFDistParamStruct *Param1,
                               MvarHFDistParamStruct *Param2)


Description:

Computes Hausdorff distance between a C^1 cont. surface and a C^1 cont. curve, S1 and C2. The shapes are assumed to be in R3 and non intersecting.

Parameters:

Srf1:	First srf to measure its hausdorff distance to Crv2.
Crv2:	Second crv to measure its hausdorff distance to Srf1.
Param1:	Where to return the parameter value(s) of Srf1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Crv2 with the maximal Hausdorff distance. Can be more than one location!

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

MvarHFDistSrfSrfC1

Keywords:

MvarHFDistSrfSrfC1

(hasdrf3d.c:819)

Prototype:

CagdRType MvarHFDistSrfSrfC1(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, MvarHFDistParamStruct *Param1, MvarHFDistParamStruct *Param2)

Description:

Computes Hausdorff distance between two C^1 cont. surfaces, S1 and S2. The surfaces are assumed to be in R3 and non intersecting.

Parameters:

Srf1:	First Srf to measure its hausdorff distance to Srf2.
Srf2:	Second Srf to measure its hausdorff distance to Srf1.
Param1:	Where to return the parameter value(s) of Srf1 with the maximal Hausdorff distance. Can be more than one location!
Param2:	Where to return the parameter value(s) of Srf2 with the maximal Hausdorff distance. Can be more than one location!

Returned Value:

CagdRType: The Hausdorff distance.

See Also:

Keywords:

MvarHFExtremeLclDistPointCrvC1

(hasdrf2d.c:97)

Prototype:

CagdRType MvarHFExtremeLclDistPointCrvC1(CagdPType P, const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, MvarHFDistParamStruct *Param2, CagdRType Epsilon)

Description:

Computes the local extreme distance between a point P of Crv1 and Crv2. At the local extreme distance location on Crv2, denoted Q, verify that Q is closest to P than to any other location on Crv1. Returns maximal local extreme distance found, 0.0 if none.

Parameters:

P:	Point on Crv1 to measure its extreme distance to curve Crv2.
Crv1:	First curve that contains P.
Crv2:	Second curve to measure extreme distance to from P.
Param2:	Where to return the parameter value of Crv2 is returned.
Epsilon:	Tolerance of computation.

Returned Value:

CagdRType: The local extreme distance found, 0.0 if none.

See Also:

SymbLclDistCrvPoint

Keywords:

MvarHFExtremeLclDistPointSrfC1

(hasdrf3d.c:86)

Prototype:

CagdRType MvarHFExtremeLclDistPointSrfC1(const CagdPType P, const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, MvarHFDistParamStruct *Param2)

Description:

Computes the local extreme distance between a point P of Srf1 and Srf2. At the local extreme distance location on Srf2, denoted Q, verify that Q is closest to P than to any other location on Srf1. Returns maximal local extreme distance found, 0.0 if none.

Parameters:

P:	Point on Srf1 to measure its extreme distance to curve Srf2.
Srf1:	First curve that contains P.
Srf2:	Second curve to measure extreme distance to from P.
Param2:	Where to return the parameter value of Srf2 is returned.

Returned Value:

CagdRType: The local extreme distance found, 0.0 if none.

See Also:

MvarLclDistSrfPoint

Keywords:

MvarImplicitCrvExtreme

(mvartopo.c:34)

Prototype:

MvarPtStruct *MvarImplicitCrvExtreme(const CagdSrfStruct *Srf, CagdSrfDirType Dir, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes U or V extreme values of the zero set (implicit form) of Srf = 0.

Parameters:

Srf:	Implicit surface definition.
Dir:	U to compute U-extreme values in Srf = 0, V for V-extreme.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumerTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: The computed extreme values, in the parametric space of surface Srf.

Keywords:

MvarInverseCrvOnSrfProj

(mvardist.c:901)

Prototype:

CagdCrvStruct *MvarInverseCrvOnSrfProj(const CagdCrvStruct *E3Crv, const CagdSrfStruct *Srf, void *SrfPrepHandle, CagdRType ApproxTol, const CagdRType *PrevUVPt, int *RedundantSol)

Description:

Compute the inverse projection of a Euclidean curve on surface to the UV values of the surface.

Parameters:

E3Crv:	E3 Curve to compute its inverse projection onto Srf. If none linear, curve is approximated as a piecewise linear curve first using ApproxTol.
Srf:	The Surface E3Crv is on.
SrfPrepHandle:	Hold pre-processed data by MvarInverseCrvOnSrfProjPrep to speed up the crv on srf projections. See MvarInverseCrvOnSrfProjPrep/MvarInverseCrvOnSrfProjFree.
ApproxTol:	Tolerance of piecewise linear approximation if so needed.
PrevUVPt:	Optional parameter of previous UV location from the end location of last UV crv. NULL to ignore.
RedundantSol:	ill be set to true if solution was redundant - I.e. on a shared boundary seam. NULL to ignore.

Returned Value:

CagdCrvStruct *: The UV curve representing E3Crv on Srf.

See Also:

MvarInverseCrvOnSrfProjPrep MvarInverseCrvOnSrfProjFree MvarLclDistSrfPoint MvarDistSrfPoint MvarMVOrthoCrvProjOnSrf MvarProjCrvOnSrf

Keywords:

distance inverse projection

MvarInverseCrvOnSrfProjFree

(mvardist.c:814)

Prototype:

void MvarInverseCrvOnSrfProjFree(void *SrfPrepHandle)

Description:

Free the prepared data structure by MvarInverseCrvOnSrfProjPrep.

Parameters:

SrfPrepHandle:	Prep data struct by MvarInverseCrvOnSrfProjPrep to free.

Returned Value:

void

See Also:

MvarInverseCrvOnSrfProj MvarInverseCrvOnSrfProjPrep

Keywords:

distance inverse projection

MvarInverseCrvOnSrfProjPrep

(mvardist.c:785)

Prototype:

void *MvarInverseCrvOnSrfProjPrep(const CagdSrfStruct *Srf)

Description:

Do the necessary preparations for the inverse projection of a Euclidean curve on surface to the UV values of the surface.

Parameters:

Srf:	The Surface to prepare curve projection onto.

Returned Value:

void *: A structure holding the prepared data.

See Also:

MvarInverseCrvOnSrfProj MvarInverseCrvOnSrfProjFree

Keywords:

distance inverse projection

MvarIrit2DTrTo2DMVTrs

(mvar_pll.c:1280)

Prototype:

MvarTriangleStruct *MvarIrit2DTrTo2DMVTrs(IPObjectStruct *ObjTrs)

Description:

Converts a list of irit planar triangles (given as polygon objects) into a list of Mvar planar (2D) triangle structures.

Parameters:

ObjTrs:	Irit polygons.

Returned Value:

MvarTriangleStruct *: A list triangles.

See Also:

MvarCnvrtMVTrsToIritPolygons MvarCnvrtMVPolysToIritPolys

Keywords:

MvarLclDistSrfLine

(mvardist.c:535)

Prototype:

MvarPtStruct *MvarLclDistSrfLine(const CagdSrfStruct *CSrf, const CagdPType LnPt, const CagdVType LnDir, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Given a surface and a line, finds the nearest point (if MinDist) or the farthest location (if MinDist FALSE) from the surface to the given line. This function assumes the surface does not intersect the line. Returned is the parameter value of the surface. Only internal extrema are considered. Let S and N be the surface and its normal field. Then the extrema points are computed as the simultaneous solution of,

  < (S - LnPt) x N, LnDir > = 0,
  < N, LnDir > = 0.


Parameters:


 CSrf:       The surface to find its nearest (farthest) point to Line.
 LnPt:       A point on the line to consider.
 LnDir:      The direction of the line to consider.
 SubdivTol:  Tolerance of the first zero set finding subdivision stage.
 NumericTol:  olerance of the second zero set finding numeric stage.



Returned Value:


  MvarPtStruct *:   A list of parameter values of extreme distance
                    locations.



See Also:

  MvarDistSrfLine
  MvarDistCrvLine


Keywords:

  surface line distance


 MvarLclDistSrfPoint 
  (mvardist.c:361)

Prototype:

  MvarPtStruct *MvarLclDistSrfPoint(const CagdSrfStruct *CSrf,
                                    void *SrfPtPrepHandle,
                                    const CagdPType Pt,
                                    MvarPtStruct *InitialSol,
                                    CagdRType SubdivTol,
                                    CagdRType NumericTol)


Description:

Given a surface and a point, find the local extremum distance points on the surface to the given point. Only interior extrema are considered. Returned is a list of parameter value with local extremum. Computes the simultaneous zeros of:

      (Srf(u, v) - Pt) . dSrf(u, v)/Du = 0.
      (Srf(u, v) - Pt) . dSrf(u, v)/Dv = 0.


Parameters:


 CSrf:       The surface to find its extreme distance locations to Pt.
 SrfPtPrepHandle:  If not NULL, holds pre-processed data to speed up the
               surface - points distance computations, for multiple
               surface - point tests (same surface for all points).
               See MvarDistSrfPointPrep and MvarDistSrfPointFree.
 Pt:         The point to find the extreme distance locations from Srf.
 InitialSol:  ptional initial guess for a solution in which case we aim
               to improve numerically to within NumericTol.  If successful,
               this solution is returned (in place here and the return
               value). Otherwise, the full solver is invoked.
 SubdivTol:  Tolerance of the first zero set finding subdivision stage.
 NumericTol:  olerance of the second zero set finding numeric stage.



Returned Value:


  MvarPtStruct *:   A list of parameter values of extreme distance
                    locations.



See Also:

  MvarDistSrfPointPrep
  MvarDistSrfPointFree


Keywords:

  surface point distance


 MvarLineFitToPts 
  (mvar_int.c:280)

Prototype:

  CagdRType MvarLineFitToPts(const MvarVecStruct *VecList,
                             MvarVecStruct *LineDir,
                             MvarVecStruct *LinePos)


Description:

Given set of vecs, VecList, fits a line using least squares fit to them.

Parameters:

VecList:	List of vectors to interpolate/least square approximate.
LineDir:	A unit vector of the line.
LinePos:	A point on the computed line.

Returned Value:

CagdRType: Average distance between a vector and the fitted line, or IRIT_INFNTY if failed.

See Also:

CagdLineFitToPts

Keywords:

interpolation least square approximation

MvarLinePlaneInter

(mvar_vec.c:711)

Prototype:

MvarVecStruct *MvarLinePlaneInter(const MvarVecStruct *P, const MvarVecStruct *V, const MvarPlaneStruct *Pln, CagdRType *Param)

Description:

Compute the intersection of a line and a hyperplane, in R^Dim.

Parameters:

P, V:	Point and direction of line to intersect with hyperplane. Both P and V are of length Dim.
Pln:	Hyperplane to intersect with line.
Param:	Will be updated with the parameter along which the intersection has occurred, as Inter = P + V * t.

Returned Value:

MvarVecStruct *: The intersection point.

Keywords:

MvarLineSrfInter

(lnsrfdst.c:283)

Prototype:

MvarPtStruct *MvarLineSrfInter(const CagdPType LinePt, const CagdVType LineDir, const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes intersection points of a surface and a line specified as intersection of two implicitly defined planes.

Parameters:

LinePt, LineDir:	Line specification.
Srf:	Surface to intersect.
SubdivTol:	Subdivision tolerance of computation.
NumericTol:	Numerical tolerance of computation.

Returned Value:

MvarPtStruct *: List of intersection points as surface parameters (u,v).

See Also:

MvarCrvSrfInter

Keywords:

MvarMSCircOfThreeCurves

(ms_circ.c:232)

Prototype:

int MvarMSCircOfThreeCurves(const CagdCrvStruct *OrigCrv1, const CagdCrvStruct *OrigCrv2, const CagdCrvStruct *OrigCrv3, CagdRType Center[2], CagdRType *Radius, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the minimum spanning circle to three curves that are disjoint. Assumption is made that the MSC is tangent to all three curves.

Parameters:

OrigCrv1, OrigCrv2, OrigCrv3:	The three curves to consider. Curves could be identical.
Center:	Center of the computed MSC.
Radius:	Radius of the computed MSC.
SubdivTol, NumerTol:	Of computation.

Returned Value:

int: TRUE if successful, FALSE otherwise

See Also:

MvarMSCircOfTwoCurves MvarMinSpanCirc MVarIsCrvInsideCirc MvarSkel2DInter3Prims

Keywords:

MvarMSCircOfTwoCurves

(ms_circ.c:64)

Prototype:

int MvarMSCircOfTwoCurves(const CagdCrvStruct *OrigCrv1, const CagdCrvStruct *OrigCrv2, CagdRType Center[2], CagdRType *Radius, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the minimum spanning circle to two curves that are disjoint. Assumption is made that the MSC is tangent to both curves.

Parameters:

OrigCrv1, OrigCrv2:	The two curves to consider.
Center:	Center of the computed MSC.
Radius:	Radius of the computed MSC.
SubdivTol, NumerTol:	Of computation.

Returned Value:

int: TRUE if successful, FALSE otherwise

See Also:

MvarMSCircOfThreeCurves MvarMinSpanCirc MVarIsCrvInsideCirc

Keywords:

MvarMVAdd

(mvar_sym.c:38)

Prototype:

MvarMVStruct *MvarMVAdd(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - add them coordinate-wise. The two multivariates are promoted to same point type before the operation can take place. Furthermore, order and continuity are matched as well.

Parameters:

MV1, MV2:	Two multivariate to add up coordinate-wise.

Returned Value:

MvarMVStruct *: The summation of MV1 + MV2 coordinate-wise.

See Also:

MvarMVSub MvarMeshAddSub MvarMVMult

Keywords:

addition symbolic computation multivariates

MvarMVAuxDomainSlotCopy

(mvar_aux.c:284)

Prototype:

int MvarMVAuxDomainSlotCopy(MvarMVStruct *MVDst, const MvarMVStruct *MVSrc)

Description:

Copies the optional aux. domain slot from MVSrc to MVDst.

Parameters:

MVDst:	Destination multivariate to copy domain slot to.
MVSrc:	Source multivariate to copy domain slot from.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarMVAuxDomainSlotReset MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotSetRel

Keywords:

MvarMVAuxDomainSlotGet

(mvar_aux.c:385)

Prototype:

int MvarMVAuxDomainSlotGet(const MvarMVStruct *MV, CagdRType *Min, CagdRType *Max, int Dir)

Description:

Gets one aux. domain range in the given Direction. The Min/Max arrays are assumed to be of sufficiently large enough space to hold all dimensions, if Axis == -1.

Parameters:

MV:	Multivariate to get its aux. domain slot.
Min, Max:	The domain of this Bezier multivariate.
Dir:	The direction to get the domain of MV.

Returned Value:

int: TRUE if aux. domain exist and can get domain, FALSE otherwise.

See Also:

MvarMVAuxDomainSlotReset MvarMVAuxDomainSlotCopy MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotSetRel

Keywords:

MvarMVAuxDomainSlotReset

(mvar_aux.c:252)

Prototype:

void MvarMVAuxDomainSlotReset(MvarMVStruct *MV)

Description:

Resets an optional aux. domain slot inside MV for use in cases where MV has no explict domain (such as Bezier and/or Power basis).

Parameters:

MV:	Multivariate to reset domain slot.

Returned Value:

void

See Also:

MvarMVAuxDomainSlotCopy MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotSetRel

Keywords:

MvarMVAuxDomainSlotSet

(mvar_aux.c:322)

Prototype:

void MvarMVAuxDomainSlotSet(MvarMVStruct *MV, CagdRType Min, CagdRType Max, int Dir)

Description:

Sets one aux. domain range in the given direction.

Parameters:

MV:	Multivariate to set its aux. domain slot.
Min, Max:	The domain of this Bezier multivariate.
Dir:	The direction where to set the MV domain.

Returned Value:

void

See Also:

MvarMVAuxDomainSlotReset MvarMVAuxDomainSlotCopy MvarMVAuxDomainSlotGet MvarMVAuxDomainSlotSetRel

Keywords:

MvarMVAuxDomainSlotSetRel

(mvar_aux.c:352)

Prototype:

void MvarMVAuxDomainSlotSetRel(MvarMVStruct *MV, CagdRType Min, CagdRType Max, int Dir)

Description:

Sets one aux. domain range in the given direction. Input Min/Max is relative to current domain.

Parameters:

MV:	Multivariate to set its aux. domain slot.
Min, Max:	The relative to current domain new interval of this Bezier multivariate.
Dir:	The direction where to set the MV domain.

Returned Value:

void

See Also:

MvarMVAuxDomainSlotReset MvarMVAuxDomainSlotCopy MvarMVAuxDomainSlotSet MvarMVAuxDomainSlotGet

Keywords:

MvarMVAvgArcLenMesh

(mvar_aux.c:2260)

Prototype:

CagdRType MvarMVAvgArcLenMesh(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Computes the average arc length of the mesh of MV in direction Dir.

Parameters:

MV:	Multi-Variate to compute its mesh's arc-length in Dir.
Dir:	Direction of arc length estimation.

Returned Value:

CagdRType: Avarage arc-length of the mesh of MV in directuion Dir.

See Also:

MvarMVDerive CagdCrvArcLenPoly

Keywords:

multi-variates

MvarMVBBox

(mvarbbox.c:41)

Prototype:

MvarBBoxStruct *MvarMVBBox(const MvarMVStruct *MV, MvarBBoxStruct *BBox)

Description:

Computes a bounding box for a multi-variate freeform function.

Parameters:

MV:	To compute a bounding box for.
BBox:	Where bounding information is to be saved.

Returned Value:

MvarBBoxStruct *: The computed BBox. Same as the BBox parameter.

Keywords:

bbox bounding box

MvarMVBiTangentLine

(mvtangnt.c:1180)

Prototype:

MvarPtStruct *MvarMVBiTangentLine(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes the bi-tangent line of two freeform curves. If Crv1 == Crv2, the self bi-tangent is computed.

Parameters:

Crv1, Crv2:	The 2 curves to compute their bi-tangent lines for. If Crv1 == Crv2, the self bi-tangent is computed.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Pairs of parameter values on both curves, each pair defines a single bi-tangent.

See Also:

SymbTangentToCrvAtTwoPts MvarMVBiTangents MvarMVBiTangents2 MvarMVTriTangentLineCreateMVs MvarMVTriTangentLine

Keywords:

bi-tangent

MvarMVBiTangents

(mvtangnt.c:65)

Prototype:

MvarPolylineStruct *MvarMVBiTangents(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes bi-tangents of freeform bivariate. Let,

      DMV = MV1(u, v) - MV2(r, s)

then, computed the simultaneous solution of the following three equations:

  d MV1   d MV1  d MV2
< ----- x -----, ----- > = 0,
    du      dv     dr

  d MV1   d MV1  d MV2
< ----- x -----, ----- > = 0,
    du      dv     ds

  d MV1   d MV1
< ----- x -----, DMV > = 0.
    du      dv


Parameters:


 CMV1, CMV2:   The two multivariates to compute the bi-tangents for.
 SubdivTol:    Tolerance of the subdivision process.  Tolerance is
                 measured in the parametric space of the multivariates.
 NumericTol:   Numeric tolerance of the numeric stage.  The numeric stage
                 is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPolylineStruct *: Pllns on the bi-tangents of the two multivariates.



See Also:

  SymbTangentToCrvAtTwoPts
  MvarMVBiTangents2
  MvarMVTriTangents
  MvarMVTriTangentLine


Keywords:

  bi-tangent


 MvarMVBoundGradient 
  (mvar_der.c:902)

Prototype:

  MvarMVGradientStruct *MvarMVBoundGradient(const MvarMVStruct *MV)


Description:

Provides a set of vectors that bounds the gradient function of given MV

Parameters:

MV:	Input MV function to compute bounds on its gradient.

Returned Value:

MvarMVGradientStruct *: Holding the set of vectors bounding the gradient of MV in the MVGrad slot.

See Also:

MvarMVDerive MvarMVFreeGradient MvarMVPrepGradient MvarMVEvalGradient MvarMVEvalGradient2

Keywords:

MvarMVCompose

(mvcompos.c:132)

Prototype:

MvarMVStruct *MvarMVCompose(const MvarMVStruct *TargetMV, const MvarMVStruct *ReParamMV, const int *DimMapping, CagdBType DoMerge)

Description:

The main interface function for composition of multivariates. Given two multivariates TargetMV and ReParamMV, it returns their composition TargetMV(ReParamMV(t0,...,tn)) . The composition is possible if the range of the reparametrization multivariate is contained in a patch of the target multivariate that doesn't have internal knots. If the reparametrization multivariate is B-spline, it is subdivided at the knots, and the resulting composed multivariates are either merged into a single multivariate, or returned as a linked list, depending on the flag DoMerge.

Parameters:

TargetMV:	The target multivariate.
ReParamMV:	The reparametrization multivariate.
DimMapping:	he mapping from ReParamMV's range dimensions to TargetMV's domain dimensions. Of length of dimension of range of ReParamMV and holds indices into the domain of TargetMV. If NULLm assumes the trivial mapping - range of ReParamMV is mapped to the domain of TargetMV.
DoMerge:	A flag indicating whether to merge the results into a single multivariate (applies if the reparametrization is B-spline, and was subdivided).

Returned Value:

MvarMVStruct *: The composed multivariate TargetMV(ReParamMV(t0,...,tn)) or a list of composed multivariates.

See Also:

MvarComputeMVPowers MvarGenerateBspBasisMVs TrivComposeTVCrv TrivComposeTVCrv SymbComposeCrvCrv SymbComposeSrfCrv SymbComposeSrfSrf

Keywords:

composition

MvarMVCompose2

(mvcomps2.c:1580)

Prototype:

IPObjectStruct *MvarMVCompose2(const MvarMVStruct *MVMapping, const MvarMVStruct *MVToCompose, int HandleCrossKVLines)

Description:

Compose two multivariate functions: MVMapping(MVToCompose). The function chooses the most general type of composition given the dimensions of the parameters.

Parameters:

MVMapping:	The mapping multivariate function.
MVToCompose:	The multivariate function to compose.
HandleCrossKVLines:	henever possible, TRUE to divide first Obj at all locations it crosses knot lines in MVMapping, and treat the crossing of knot lines correctly.

Returned Value:

IPObjectStruct *: The composed function.

See Also:

MvarMVCompose MvarMVCompose3

Keywords:

composition multivariates

MvarMVCompose3

(mvcomps2.c:1431)

Prototype:

IPObjectStruct *MvarMVCompose3(const IPObjectStruct *MappingFunction, const IPObjectStruct *Obj, int HandleCrossKVLines)

Description:

Compose two geometric structures: MappingFunction(Obj). The function chooses the most general type of composition (including knot-crossing), given the types of the parameters.

Parameters:

MappingFunction:	The geometry representing the mapping function.
Obj:	The geometry to compose.
HandleCrossKVLines:	henever possible, TRUE to divide first Obj at all locations it crosses knot lines in MVMapping, and treat the crossing of knot lines correctly.

Returned Value:

IPObjectStruct *: The composed geometry.

See Also:

MvarMVCompose MvarMVCompose2

Keywords:

composition multivariates

MvarMVConesOverlap

(mvcones.c:1703)

Prototype:

CagdBType MvarMVConesOverlap(MvarMVStruct **MVs, int NumOfZeroMVs)

Description:

Computes the tangency anti-cones of the set of multivariate constraints, and returns whether they overlap or not.

Parameters:

MVs:	Multivariates to derive their tangency anti-cones.
NumOfZeroMVs:	Size of the vector MVs.

Returned Value:

CagdBType: TRUE if overlap, FALSE if not.

See Also:

MVarMVNormalCone MvarConesOverlapAux

Keywords:

MvarMVCopy

(mvar_gen.c:301)

Prototype:

MvarMVStruct *MvarMVCopy(const MvarMVStruct *MV)

Description:

Allocates and duplicates all slots of a multi-variate structure.

Parameters:

MV:	Multi-Variate to duplicate

Returned Value:

MvarMVStruct *: Duplicated multi-variate.

Keywords:

multi-variates

MvarMVCopyList

(mvar_gen.c:428)

Prototype:

MvarMVStruct *MvarMVCopyList(const MvarMVStruct *MVList)

Description:

Duplicates a list of multi-variate structures.

Parameters:

MVList:	List of multi-variates to duplicate.

Returned Value:

MvarMVStruct *: Duplicated list of multi-variates.

Keywords:

multi-variates

MvarMVCornersMinMax

(mvarbbox.c:124)

Prototype:

void MvarMVCornersMinMax(const MvarMVStruct *MV, int Coord, CagdRType *Min, CagdRType *Max)

Description:

Computes the minimum and maximum values of the control points at the corners of the control mesh of a multivariate. Can be applied to a specific coordinate or to all the coordinates of the multivariate.

Parameters:

MV:	In which to find the minimum and maximum at the corners of the control mesh.
Coord:	The coordinate of the minimum/maximum values that need to be found, or -1 for all coordinates.
Min, Max:	Output parameters. Pointers into which the minimum and maximum values are written. If more than one coordinate is requested, then Min and Max must be arrays of sufficient lengths for all the coordinates.

Returned Value:

void

See Also:

MvarMVMinMax

Keywords:

MvarMVCrossProd

(mvar_sym.c:647)

Prototype:

MvarMVStruct *MvarMVCrossProd(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - computes their cross product. Returned multivariate is a vector multivariate representing the cross product of the two given multivariates.

Parameters:

MV1, MV2:	Two multivariate to multiply and compute a cross product for.

Returned Value:

MvarMVStruct *: A vector multivariate representing the cross product of MV1 x MV2.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd2D MvarMVCrossProdZ

Keywords:

product cross product multivariates mbolic computation

MvarMVCrossProd2D

(mvar_sym.c:744)

Prototype:

MvarMVStruct *MvarMVCrossProd2D(const MvarMVStruct *MV1X, const MvarMVStruct *MV1Y, const MvarMVStruct *MV2X, const MvarMVStruct *MV2Y)

Description:

Given four multivariates - computes their 2D cross product. Returned multivariate is a scalar multivariate representing the cross product of the four given multivariates, as X1 * Y2 - X2 * Y1.

Parameters:

MV1X, MV1Y:	First pair of scalar multivariates (X, Y) of first funcs.
MV2X, MV2Y:	Second pair of scalar multivariates (X, Y) of second funcs.

Returned Value:

MvarMVStruct : A scalar multivariate representing the cross product of MV1X MV2Y - MV2X * MV1Y.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd MvarMVCrossProdZ

Keywords:

product cross product multivariates mbolic computation

MvarMVCrossProdZ

(mvar_sym.c:602)

Prototype:

MvarMVStruct *MvarMVCrossProdZ(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - computes the Z component of the cross product. Returned multivariate is a scalar multivariate representing the Z component of the cross product of the two given multivariates.

Parameters:

MV1, MV2:	Two multivariate to multiply and compute a Z component of cross product for.

Returned Value:

MvarMVStruct *: A scalar multivariate representing the Z component of the cross product of MV1 x MV2.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd MvarMVCrossProd2D

Keywords:

product cross product multivariates symbolic computation

MvarMVDSetDecompositionMode

(zrdcm_main.c:2695)

Prototype:

MvarMVDDecompositionModeType MvarMVDSetDecompositionMode( MvarMVDDecompositionModeType m)

Description:

Sets the decomposition mode used by the multivariate solver. The possible decomposition modes are: MVAR_MVD_NO_DECOMPOSITION - no decomposition MVAR_MVD_DECOMPOSITION_COMPOSITION - decomposition and propagation of the partial solutions using functional composition. MVAR_MVD_DECOMPOSITION_POINT_TRACING - decomposition and point-by-point tracing of the complete solution from the solution to the first univariate problem. THIS MODE IS UNTESTES AND UNRECOMMENDED FOR USE

Parameters:

m:	The new decomposition mode.

Returned Value:

MvarMVDDecompositionModeType: The previous decomposition mode.

Keywords:

MvarZeroSolverWithDecomposition

MvarMVDegreeRaise

(mvarrais.c:323)

Prototype:

MvarMVStruct *MvarMVDegreeRaise(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Returns a new multivariate representing the same curve as MV but with its degree raised by one.

Parameters:

MV:	To raise its degree.
Dir:	Direction of degree raising.

Returned Value:

MvarMVStruct *: A multivariate with same geometry as MV but with one degree higher.

See Also:

MvarMVDegreeRaiseN MvarMVDegreeRaise2 MvarMVPwrDegreeRaise

Keywords:

degree raising

MvarMVDegreeRaise2

(mvarrais.c:358)

Prototype:

MvarMVStruct *MvarMVDegreeRaise2(MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Returns a new multivariate representing the same curve as MV but with its degree raised by one.

Parameters:

MV:	To raise its degree.
Dir:	Direction of degree raising.

Returned Value:

MvarMVStruct *: A multivariate with same geometry as MV but with one degree higher.

See Also:

MvarMVDegreeRaise MvarMVDegreeRaise3 MvarMVDegreeRaiseN MvarMVPwrDegreeRaise

Keywords:

degree raising

MvarMVDegreeRaise3

(mvarrais.c:440)

Prototype:

MvarMVStruct *MvarMVDegreeRaise3(MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Returns a new multivariate representing the same curve as MV but with its degree raised by one.

Parameters:

MV:	To raise its degree.
Dir:	Direction of degree raising.

Returned Value:

MvarMVStruct *: A multivariate with same geometry as MV but with one degree higher.

See Also:

MvarMVDegreeRaiseN MvarMVDegreeRaise MvarMVDegreeRaise2 MvarMVPwrDegreeRaise

Keywords:

degree raising

MvarMVDegreeRaiseN

(mvarrais.c:34)

Prototype:

MvarMVStruct *MvarMVDegreeRaiseN(const MvarMVStruct *MV, int *NewOrders)

Description:

Returns a new multivariate representing the same curve as MV but with its degree raised by the NewOrders prescription.

Parameters:

MV:	To raise its degree.
NewOrders:	A vector prescribing the new orders of MV. Length of this vector is MV -> Dim.

Returned Value:

MvarMVStruct *: A multivariate with same geometry as MV but with higher degrees.

See Also:

MvarMVDegreeRaise MvarMVPwrDegreeRaise MvarMVDegreeRaiseN2

Keywords:

degree raising

MvarMVDegreeRaiseN2

(mvarrais.c:228)

Prototype:

MvarMVStruct *MvarMVDegreeRaiseN2(const MvarMVStruct *MV, int *NewOrders)

Description:

Returns a new multivariate representing the same curve as MV but with its degree raised by the NewOrders prescription.

Parameters:

MV:	To raise its degree.
NewOrders:	A vector prescribing the new orders of MV. Length of this vector is MV -> Dim.

Returned Value:

MvarMVStruct *: A multivariate with same geometry as MV but with higher degrees.

See Also:

MvarMVDegreeRaise MvarMVPwrDegreeRaise MvarMVDegreeRaiseN

Keywords:

degree raising

MvarMVDerive

(mvar_der.c:33)

Prototype:

MvarMVStruct *MvarMVDerive(const MvarMVStruct *MV, MvarMVDirType Dir)

Description:

Given a multi-variate, computes its partial derivative multi-variate in direction Dir.

Parameters:

MV:	Multi-Variate to differentiate.
Dir:	Direction of differentiation.

Returned Value:

MvarMVStruct *: Differentiated multi-variate in direction Dir.

See Also:

MvarMVDeriveBound MvarBzrMVDerive MvarBspMVDerive

Keywords:

multi-variates

MvarMVDeriveAllBounds

(mvar_der.c:483)

Prototype:

void MvarMVDeriveAllBounds(const MvarMVStruct *MV, CagdMinMaxType *MinMax)

Description:

Given a multi-variate, computes its partial derivative multi-variate in all directions.

Parameters:

MV:	Multi-Variate to differentiate.
MinMax:	Bounds on the derivative values of MV in all directions.

Returned Value:

void

See Also:

MvarMVDerive MvarBzrMVDeriveBound MvarBspMVDeriveBound

Keywords:

multi-variates

MvarMVDeriveBound

(mvar_der.c:313)

Prototype:

void MvarMVDeriveBound(const MvarMVStruct *MV, MvarMVDirType Dir, CagdRType MinMax[2])

Description:

Given a multi-variate, computes its partial derivative multi-variate in direction Dir.

Parameters:

MV:	Multi-Variate to differentiate.
Dir:	Direction of differentiation.
MinMax:	Bounds on the derivative values of MV in direction Dir.

Returned Value:

void

See Also:

MvarMVDerive MvarBzrMVDeriveBound MvarBspMVDeriveBound

Keywords:

multi-variates

MvarMVDeterminant

(mvar_det.c:296)

Prototype:

MvarMVStruct *MvarMVDeterminant(const MvarMVStruct * const *MVsMatrix, int MatSize)

Description:

Computes the expression of a determinant of MVs, recursively. Expansion is always using the first row. Does not check for a better option, such as a row with more zeros, etc. (Existing zeros means the zero function as a multivariate).

Parameters:

MVsMatrix:	The matrix of MVs, as a linear array, with the following double index to linear index convention - [i][j] <----> [(i - 1) * MatSize + (j - 1)], where i, j = 1, 2, ..., MatSize (double index as in the usual linear algebra convention).
MatSize:	The size in each of the dimensions of the square MVs matrix.

Returned Value:

MvarMVStruct *: A scalar field representing the determinant computation.

See Also:

MvarMVDeterminant2

Keywords:

determinant

MvarMVDeterminant2

(mvar_det.c:42)

Prototype:

MvarMVStruct *MvarMVDeterminant2(const MvarMVStruct *MV11, const MvarMVStruct *MV12, const MvarMVStruct *MV21, const MvarMVStruct *MV22)

Description:

Computes the expression of MV11 * MV22 - MV12 * MV21, which is a determinant of a 2 by 2 matrix.

Parameters:

MV11, MV12, MV21, MV22:	The four factors of the determinant.

Returned Value:

MvarMVStruct *: A scalar field representing the determinant computation.

See Also:

MvarMVDeterminant3 MvarSrfDeterminant2 MvarCrvDeterminant2

Keywords:

determinant

MvarMVDeterminant3

(mvar_det.c:81)

Prototype:

MvarMVStruct *MvarMVDeterminant3(const MvarMVStruct *MV11, const MvarMVStruct *MV12, const MvarMVStruct *MV13, const MvarMVStruct *MV21, const MvarMVStruct *MV22, const MvarMVStruct *MV23, const MvarMVStruct *MV31, const MvarMVStruct *MV32, const MvarMVStruct *MV33)

Description:

Computes the expression of a 3 by 3 determinants.

Parameters:

MV11, MV12, MV13:	The nine factors of the determinant.
MV21, MV22, MV23:	"
MV31, MV32, MV33:	"

Returned Value:

MvarMVStruct *: A scalar field representing the determinant computation.

See Also:

MvarMVDeterminant2 MvarMVDeterminant4 SymbSrfDeterminant3 SymbCrvDeterminant3

Keywords:

determinant

MvarMVDeterminant4

(mvar_det.c:138)

Prototype:

MvarMVStruct *MvarMVDeterminant4(const MvarMVStruct *MV11, const MvarMVStruct *MV12, const MvarMVStruct *MV13, const MvarMVStruct *MV14, const MvarMVStruct *MV21, const MvarMVStruct *MV22, const MvarMVStruct *MV23, const MvarMVStruct *MV24, const MvarMVStruct *MV31, const MvarMVStruct *MV32, const MvarMVStruct *MV33, const MvarMVStruct *MV34, const MvarMVStruct *MV41, const MvarMVStruct *MV42, const MvarMVStruct *MV43, const MvarMVStruct *MV44)

Description:

Computes the expression of a 4 by 4 determinants.

Parameters:

MV11, MV12, MV13, MV14:	The 16 factors of the determinant.
MV21, MV22, MV23, MV24:	"
MV31, MV32, MV33, MV34:	"
MV41, MV42, MV43, MV44:	"

Returned Value:

MvarMVStruct *: A scalar field representing the determinant computation.

See Also:

MvarMVDeterminant3 MvarMVDeterminant5

Keywords:

determinant

MvarMVDeterminant5

(mvar_det.c:220)

Prototype:

MvarMVStruct *MvarMVDeterminant5(const MvarMVStruct *MV11, const MvarMVStruct *MV12, const MvarMVStruct *MV13, const MvarMVStruct *MV14, const MvarMVStruct *MV15, const MvarMVStruct *MV21, const MvarMVStruct *MV22, const MvarMVStruct *MV23, const MvarMVStruct *MV24, const MvarMVStruct *MV25, const MvarMVStruct *MV31, const MvarMVStruct *MV32, const MvarMVStruct *MV33, const MvarMVStruct *MV34, const MvarMVStruct *MV35, const MvarMVStruct *MV41, const MvarMVStruct *MV42, const MvarMVStruct *MV43, const MvarMVStruct *MV44, const MvarMVStruct *MV45, const MvarMVStruct *MV51, const MvarMVStruct *MV52, const MvarMVStruct *MV53, const MvarMVStruct *MV54, const MvarMVStruct *MV55)

Description:

Computes the expression of a 5 by 5 determinants.

Parameters:

MV11, MV12, MV13, MV14, MV15:	The 25 factors of the determinant.
MV21, MV22, MV23, MV24, MV25:	"
MV31, MV32, MV33, MV34, MV35:	"
MV41, MV42, MV43, MV44, MV45:	"
MV51, MV52, MV53, MV54, MV55:	"

Returned Value:

MvarMVStruct *: A scalar field representing the determinant computation.

See Also:

MvarMVDeterminant4

Keywords:

determinant

MvarMVDistCrvSrf

(mvardist.c:603)

Prototype:

MvarMVStruct *MvarMVDistCrvSrf(const CagdCrvStruct *Crv1, const CagdSrfStruct *Srf2, int DistType)

Description:

Given a curve and a surface, creates a multivariate scalar field representing the distance function square, between them.

Parameters:

Crv1, Srf2:	The two entities, Crv1(t) and Srf2(u, v), to form their distance function square between them as a multivariate function.
DistType:	0 for distance vector function, 1 for distance square scalar function, 2 for distance vector projected on the normal of Crv1, 3 for distance vector projected on the normal of Srf2. In cases 2 and 3 the normal field is not normalized.

Returned Value:

MvarMVStruct *: The distance function square d2(t, u, v) of the distance from Crv1(t) to Srf2(u, v).

See Also:

SymbSrfDistCrvCrv SymbCrvCrvInter SymbSrfDistFindPoints MvarMVDistSrfSrf MvarProjCrvOnSrf2

Keywords:

curve surface distance

MvarMVDistSrfSrf

(mvardist.c:698)

Prototype:

MvarMVStruct *MvarMVDistSrfSrf(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, int DistType)

Description:

Given two surfaces, creates a multivariate scalar field representing the distance function square, between them.

Parameters:

Srf1, Srf2:	The two surfaces, Srf1(u, v) and Srf2(r, t), to form their distance function square between them as a multivariate function.
DistType:	0 for distance vector function, 1 for distance square scalar function, 2 for distance vector projected on the normal of Srf1, 3 for distance vector projected on the normal of Srf2. In cases 2 and 3 the normal field is not normalized.

Returned Value:

MvarMVStruct *: The distance function square d2(u, v, r, t) of the distance from Srf1(u, v) to Srf2(r, t).

See Also:

SymbSrfDistCrvCrv SymbCrvCrvInter SymbSrfDistFindPoints MvarMVDistCrvSrf

Keywords:

surface surface distance

MvarMVDomain

(mvar_aux.c:49)

Prototype:

void MvarMVDomain(const MvarMVStruct *MV, CagdRType *Min, CagdRType *Max, int Axis)

Description:

Given a multi-variate, returns its parametric domain. The Min/Max arrays are assumed to of sufficiently large enough space to hold all dimensions, if Axis == -1.

Parameters:

MV:	Multivariate function to consider.
Min:	Minimum domains of MV will be placed herein.
Max:	Maximum domains of MV will be placed herein.
Axis:	axis to extract or -1 for all axes.

Returned Value:

void

See Also:

varMVSetDomain MvarMVSetAllDomains MvarParamInDomain varParamsInDomain

Keywords:

multi-variates

MvarMVDomainAlloc

(mvar_aux.c:147)

Prototype:

void MvarMVDomainAlloc(const MvarMVStruct *MV, CagdRType **MinDmn, CagdRType **MaxDmn)

Description:

Same as MvarMVDomain but also allocate the space to hold the domain.

Parameters:

MV:	Multivariate structures to receive its domain.
MinDmn:	Array of maximal values.
MaxDmn:	Array of minimal values.

Returned Value:

void:

See Also:

MvarMVDomain MvarMVDomainFree

Keywords:

MvarMVDomainFree

(mvar_aux.c:174)

Prototype:

void MvarMVDomainFree(CagdRType *MinDmn, CagdRType *MaxDmn)

Description:

Deallocates the memory of MV's domain, as allocated by MvarMVDomain2.

Parameters:

MinDmn:	Array of maximal values.
MaxDmn:	Array of minimal values.

Returned Value:

void:

See Also:

MvarMVDomain MvarMVDomainAlloc

Keywords:

MvarMVDotProd

(mvar_sym.c:494)

Prototype:

MvarMVStruct *MvarMVDotProd(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - computes their dot product. Returned multivariate is a scalar multivariate representing the dot product of the two given multivariates. While typically in R3, the dot product can be computed for any dimension of MV1 and MV2.

Parameters:

MV1, MV2:	Two multivariate to multiply and compute a dot product for.

Returned Value:

MvarMVStruct *: A scalar multivariate representing the dot product of MV1 . MV2.

See Also:

MvarMVMult MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd

Keywords:

product dot product symbolic computation multivariates

MvarMVEvalGradient

(mvar_der.c:809)

Prototype:

CagdRType *MvarMVEvalGradient(const MvarMVGradientStruct *MVGrad, const CagdRType *Params, int Axis, CagdRType *Grad)

Description:

Evaluates the gradient function at the given parametric location.

Parameters:

MVGrad:	Input gradient function to evaluate at.
Params:	Parametric location to evaluate gradient at.
Axis:	If the input function whose gradient we seek is scalar, Axis will always be zero. However we can also handle input vector functions in which case Axis specifies which function in the vector to compute the gradient for - 0 for X, 1 for Y, etc.
Grad:	The gradient at Params.

Returned Value:

CagdRType *: The gradient at Params.

See Also:

MvarMVDerive MvarMVFreeGradient MvarMVPrepGradient MvarMVEvalGradient2 MvarMVBoundGradient

Keywords:

MvarMVEvalGradient2

(mvareval.c:559)

Prototype:

CagdRType *MvarMVEvalGradient2(const MvarMVStruct *MV, const CagdRType *Params, int *HasOrig, CagdRType *Grad)

Description:

Evaluates the gradient of the given multivariate function at a given location, numerically. Allowed for scalar multivariates only.

Parameters:

MV:	To evaluate its gradient at given Params parametric location.
Params:	Parametric location to evaluate MV at.
HasOrig:	TRUE if the cached gradient also contains the original scalar field, as last, additional, coordinate.
Grad:	A vector holding all the coefficients of all components of the multi-variate's point type.

Returned Value:

CagdRType *: A vector holding all the coefficients of all components of the multi-variate's point type. If for example multi-variate point type is P2, the W, X, and Y will be saved in the first three locations of the returned vector. The first location (index 0) of the returned vector is reserved for the rational coefficient W and XYZ always starts at second location of the returned vector (index 1). Same as Grad.

See Also:

MvarMVEval MvarMVEvalTanPlane MvarMVEvalGradient

Keywords:

evaluation multi-variates gradient

MvarMVEvalMalloc

(mvareval.c:517)

Prototype:

CagdRType *MvarMVEvalMalloc(const MvarMVStruct *MV, const CagdRType *Params)

Description:

Evaluates the given multivariate function at a given location. Same functionality as MvarMVEval but a different implementation.

Parameters:

MV:	To evaluate at given Params parametric location.
Params:	Parametric location to evaluate MV at.

Returned Value:

See Also:

MvarMVEvalGradient MvarMVEvalGradient2 MvarMVEvalToData

Keywords:

evaluation multi-variates

MvarMVEvalTanPlane

(mvareval.c:642)

Prototype:

MvarPlaneStruct *MvarMVEvalTanPlane(const MvarMVStruct *MV, const CagdRType *Params)

Description:

Evaluates the tangent hyperplane of the given multivariate function at a given location, numerically. Assumes a scalar multivariates of n parameters in a space of dimension n+1 (An explicit surface in E3).

Parameters:

MV:	To evaluate its gradient at given Params parametric location.
Params:	Parametric location to evaluate MV at.

Returned Value:

MvarPlaneStruct *: A hyperplane, allocated dynammically. The tanegnt is normalized so that its last (independent coefficient is one: "A1 X1 + A2 X2 + ... + An Xn + 1". The size, n, is to the dimension of the multivariate.

See Also:

MvarMVEval MvarMVEvalGradient2

Keywords:

evaluation multi-variates gradient

MvarMVEvalToData

(mvareval.c:43)

Prototype:

void MvarMVEvalToData(const MvarMVStruct *MV, const CagdRType *Params, CagdRType *Pt)

Description:

Evaluates the given multivariate function at a given location. Same functionality as MvarMVEval but a different implementation.

Parameters:

MV:	To evaluate at given Params parametric location.
Params:	Parametric location to evaluate MV at.
Pt:	A vector holding all the coefficients of all components of the multi-variate's point type. If for example multi-variate point type is P2, the W, X, and Y will be saved in the first three locations of the returned vector. The first location (index 0) of the returned vector is reserved for the rational coefficient W and XYZ always starts at second location of the returned vector (index 1).

Returned Value:

void

See Also:

MvarMVEvalGradient MvarMVEvalGradient2 MvarMVEvalMalloc

Keywords:

evaluation multi-variates

MvarMVExtension

(mvar_gen.c:1891)

Prototype:

MvarMVStruct *MvarMVExtension(const MvarMVStruct *OrigMV, const CagdBType *ExtMins, const CagdBType *ExtMaxs, const CagdRType *Epsilons)

Description:

Extension of a B-spline muiltivariate, in any of the 2 * Dim optional directions of the Dim dimensional domain. The extension is such that the image coincides with the original image over the original domain. Assumes open end conditions (in all knot vectors). OrigNV can have "ExtntSclU", "ExtntSclV" and/or "ExtntSclW" (or for all axes "ExtndScl") real attributes to scale the extension in Euclidean space (for same Epsilon parametric extension).

Parameters:

OrigMV:	The multivariate to be extended.
ExtMins:	A vector of Dim Boolean values to set the extension directions in the Min side. Direction i is extended in its Min side if ExtMins[i] is TRUE, or if ExtMins is NULL.
ExtMaxs:	A vector of Dim Boolean values to set the extension directions in the Max side. Direction i is extended in its Max side if ExtMaxs[i] is TRUE, or if ExtMaxs is NULL.
Epsilons:	A vector of real numbers representing the length of the extension in each direction (both Min and Max).

Returned Value:

MvarMVStruct *: The new extended MV.

See Also:

BspCrvExtensionOneSide BspCrvExtraKnotRmv BspCrvExtension BspSrfExtension

Keywords:

MvarMVFactorRMinusT

(mvar_sym.c:1156)

Prototype:

MvarMVStruct *MvarMVFactorRMinusT(const MvarMVStruct *MV, int RIdx, int TIdx)

Description:

Removes a (r - t) factor from the given scalar multivariate which is assumed to be of dimension greater than 3. The r, t parameters are the RIdx and TIdx parameters of the multivariate.

Parameters:

MV:	multivariate to factor out (r - t) term from.
RIdx, TIdx:	Indices of the r and t axes inside MV.

Returned Value:

MvarMVStruct *: Factored out multivariate.

See Also:

BspSrfFactorUMinusV BzrSrfFactorUMinusV MvarMVFactorUMinusV

Keywords:

MvarMVFactorUMinusV

(mvar_sym.c:1213)

Prototype:

MvarMVStruct *MvarMVFactorUMinusV(const MvarMVStruct *MV)

Description:

Removes a (u - v) factor from the given scalar multivariate which is assumed to be of dimension 2 or more. The u, v parameters are the first and second parameters of the multivariate.

Parameters:

MV:	Multivariate to factor out (u - v) term from.

Returned Value:

MvarMVStruct *: Factored out multivariate.

See Also:

BspSrfFactorUMinusV BzrSrfFactorUMinusV MvarMVFactorRMinusT

Keywords:

MvarMVFree

(mvar_gen.c:460)

Prototype:

void MvarMVFree(MvarMVStruct *MV)

Description:

Deallocates and frees all slots of a multi-variate structure.

Parameters:

MV:	Multi-Variate to free.

Returned Value:

void

See Also:

MvarMVNew

Keywords:

multi-variates

MvarMVFreeGradient

(mvar_der.c:763)

Prototype:

void MvarMVFreeGradient(MvarMVGradientStruct *MVGrad)

Description:

Free an gradient function.

Parameters:

MVGrad:	Gradient function to free.

Returned Value:

void

See Also:

MvarMVDerive MvarMVPrepGradient MvarMVEvalGradient

Keywords:

MvarMVFreeList

(mvar_gen.c:523)

Prototype:

void MvarMVFreeList(MvarMVStruct *MVList)

Description:

Deallocates and frees a list of multi-variate structures.

Parameters:

MVList:	Multi-Variate list to free.

Returned Value:

void

Keywords:

multi-variates

MvarMVFromMV

(mvareval.c:695)

Prototype:

MvarMVStruct *MvarMVFromMV(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir)

Description:

Extract an isoparametric sub multivariate out of the given tensor product multivariate, or expand its dimension by one.

Parameters:

MV:	To extract an isoparametric multi-variate from at parameter value t in direction Dir, or exapand its dimension by one.
t:	Parameter value at which to extract the isosurface (if Dir >= 0).
Dir:	Direction of isosurface extraction. If Dir is negative, however, its absolute value defines the order of a new axis added as last and new dimension to the given MV.

Returned Value:

MvarMVStruct *: A multi - variate with one less (or more) dimensions.

See Also:

MvarMVReverse MvarMVFromMesh MvarPromoteMVToMV

Keywords:

multi-variates

MvarMVFromMesh

(mvareval.c:877)

Prototype:

MvarMVStruct *MvarMVFromMesh(const MvarMVStruct *MV, int Index, MvarMVDirType Dir)

Description:

Extract an isoparametric sub multi variate out of the given tensor product multi-variate, or expand its dimension by one.

Parameters:

MV:	To extract an isoparametric multi-variate from as a sub-mesh in direction Dir, or exapand its dimension by one.
Index:	ndex of sub mesh of MV's mesh in direction Dir.
Dir:	Direction of isosurface extraction. If Dir is negative, however, its absolute value defines the order of a new axis added as last and new dimension to the given MV.

Returned Value:

MvarMVStruct *: A multi - variate with one less (or more) dimensions.

See Also:

MvarMVReverse MvarMVFromMVm MvarPromoteMVToMV

Keywords:

multi-variates

MvarMVIntersPtOnBndry

(mvar_aux.c:591)

Prototype:

MvarPtStruct *MvarMVIntersPtOnBndry(MvarMVStruct *MV, MvarPtStruct *PointIns, MvarPtStruct *PointOuts)

Description:

Computes the intersection point of line (PoinIns, PointOuts) with the boundary of the domain of multivariate MV.

Parameters:

MV:	Multivariate structure.
PointIns:	point inside the domain.
PointOuts:	point outside the domain.

Returned Value:

MvarPtStruct *: The intersection point.

See Also:

MvarParamsInDomain

Keywords:

MvarMVInvert

(mvar_sym.c:289)

Prototype:

MvarMVStruct *MvarMVInvert(const MvarMVStruct *MV)

Description:

Given a scalar multivariate, returns a scalar multivariate representing the reciprocal values, by making it rational (if was not one) and flipping the numerator and the denominator.

Parameters:

MV:	A scalar multivariate to compute a reciprocal value for.

Returned Value:

MvarMVStruct *: A rational scalar multivariate that is equal to the reciprocal value of MV.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVMult MvarMVCrossProd

Keywords:

division symbolic computation reciprocal value ltivariates

MvarMVIsConstant

(mvarbbox.c:206)

Prototype:

int MvarMVIsConstant(const MvarMVStruct *MV, IrtRType Eps)

Description:

Checks if this MV is a constant multi-variate freeform function.

Parameters:

MV:	To verify if constant or not..
Eps:	Tolerance of equality allowed.

Returned Value:

int: TRUE if indeed a constant(s) valued multi-variate.

Keywords:

bbox bounding box

MvarMVIsMeshC0DiscontAt

(mvar_gen.c:2170)

Prototype:

CagdBType MvarMVIsMeshC0DiscontAt(const MvarMVStruct *MV, int Dir, CagdRType t)

Description:

Examines the mesh at given parametric location for a C0 discontinuity.

Parameters:

MV:	Multivariate to examine for C0 discontinuity.
Dir:	Parametric direction to examine at.
t:	Parameter value to examine at.

Returned Value:

CagdBType: TRUE if MV has a C0 discontinuity at parameter t in direction Dir, FALSE otherwise.

See Also:

MvarMVMeshC0Continuous MvarMVKnotHasC0Discont

Keywords:

MvarMVIsMeshC1DiscontAt

(mvar_gen.c:2313)

Prototype:

CagdBType MvarMVIsMeshC1DiscontAt(const MvarMVStruct *MV, int Dir, CagdRType t)

Description:

Examines the mesh at given parametric location for a C1 discontinuity.

Parameters:

MV:	Multivariate to examine for C1 discontinuity.
Dir:	Parametric direction to examine at.
t:	Parameter value to examine at.

Returned Value:

CagdBType: TRUE if MV has a C1 discontinuity at parameter t in direction Dir, FALSE otherwise.

See Also:

MvarMVMeshC1Continuous MvarMVKnotHasC1Discont

Keywords:

MvarMVKnotHasC0Discont

(mvar_gen.c:2067)

Prototype:

CagdBType MvarMVKnotHasC0Discont(const MvarMVStruct *MV, int *Dir, CagdRType *t)

Description:

Searches the given MV for parameter locations that are C0 discont, based on the given knot vector of the MV. If found update Dir and t to this finding and returns TRUE.

Parameters:

MV:	The multivariate.
Dir:	If a non-negative value, only that direction will be checked for C0 discontinuity. If a negative value, all directions in the domain will be searched for a C0 discont, if has one. The detected direction will be returned here if found.
t:	The parameter at the C0 discont. if has one.

Returned Value:

CagdBType: TRUE if found a C0 discont., FALSE otherwise.

See Also:

MvarMVMeshC0Continuous MvarMVIsMeshC0DiscontAt

Keywords:

MvarMVKnotHasC1Discont

(mvar_gen.c:2207)

Prototype:

CagdBType MvarMVKnotHasC1Discont(const MvarMVStruct *MV, int *Dir, CagdRType *t)

Description:

Searches the given MV for parameter locations that are C1 discont, based on the given knot vector of the MV. If found update Dir and t to this finding and returns TRUE.

Parameters:

MV:	The multivariate.
Dir:	If a non-negative value, only that direction will be checked for C0 discontinuity. If a negative value, all directions in the domain will be searched for a C0 discont, if has one. The detected direction will be returned here if found.
t:	The parameter at the C1 discont. if has one.

Returned Value:

CagdBType: TRUE if found a C1 discont., FALSE otherwise.

See Also:

MvarMVMeshC1Continuous MvarMVIsMeshC1DiscontAt

Keywords:

MvarMVListBBox

(mvarbbox.c:237)

Prototype:

void MvarMVListBBox(const MvarMVStruct *MVs, MvarBBoxStruct *BBox)

Description:

Computes a bounding box for a list of multi-variate freeform function.

Parameters:

MVs:	To compute a bounding box for.
BBox:	Where bounding information is to be saved.

Returned Value:

void

Keywords:

bbox bounding box

MvarMVListMatTransform

(mvar_gen.c:1537)

Prototype:

MvarMVStruct *MvarMVListMatTransform(const MvarMVStruct *MVs, CagdMType Mat)

Description:

Transforms the given list of MVs as specified by homogeneous matrix Mat.

Parameters:

MVs:	To be transformed.
Mat:	Defining the transformation.

Returned Value:

MvarMVStruct *: Transformed MVs.

See Also:

MvarMVMatTransform MvarMVMatTransform2 CagdSrfListMatTransform

Keywords:

scaling rotation translation transformations

MvarMVListPreciseBBox

(mvarbbox.c:821)

Prototype:

void MvarMVListPreciseBBox(const MvarMVStruct *MVs, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a list of multi-variate freeform function.

Parameters:

MVs:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarMVListBBox MvarMVPreciseBBox

Keywords:

bbox bounding box

MvarMVMatTransform

(mvar_gen.c:1490)

Prototype:

MvarMVStruct *MvarMVMatTransform(const MvarMVStruct *MV, CagdMType Mat)

Description:

Transforms the given MV as specified by homogeneous matrix Mat.

Parameters:

MV:	Multi-variate to transform.
Mat:	Homogeneous transformation to apply to MV.

Returned Value:

MvarMVStruct *: Transformed MV.

See Also:

MvarMVListMatTransform MvarMVMatTransform2 CagdSrfListMatTransform

Keywords:

multi-variates

MvarMVMatTransform2

(mvar_gen.c:1567)

Prototype:

void MvarMVMatTransform2(MvarMVStruct *MV, CagdMType Mat)

Description:

Transforms, in place, the given MV as specified by homogeneous matrix Mat.

Parameters:

MV:	Multi-variate to transform.
Mat:	Homogeneous transformation to apply to MV.

Returned Value:

void

See Also:

MvarMVMatTransform MvarMVListMatTransform CagdSrfListMatTransform

Keywords:

multi-variates

MvarMVMergeScalar

(mvar_sym.c:1068)

Prototype:

MvarMVStruct *MvarMVMergeScalar(MvarMVStruct * const *ScalarMVs)

Description:

Given a set of scalar multivariates, treat them as coordinates into a new multivariates Assumes at least X axis not NULL when a scalar multivariate is returned. Assumes all axes are either E1 or P1 in which the weights are assumed to be identical and can be ignored if W axis exists or copied otherwise.

Parameters:

ScalarMVs:	A vector of scalar MVs. Location 0 holds the W or NULL otherwise, Location 1 holds the X axis and so on. This vector is assumed to have MVAR_MAX_PT_COORD coordinates.

Returned Value:

MvarMVStruct *: A new multivariates constructed from given scalar multivariates.

See Also:

MvarMVSplitScalar

Keywords:

merge multivariates symbolic computation

MvarMVMeshC0Continuous

(mvar_gen.c:2121)

Prototype:

CagdBType MvarMVMeshC0Continuous(const MvarMVStruct *MV, int Dir, int Idx)

Description:

Examine the mesh of the given surface across direction Dir in index of mesh Index for a real discontinuity in the mesh. This index will typically be for a knot multiplicity potential discont.

Parameters:

MV:	To examine its potential discontinuity across Dir.
Dir:	Direction to examine the discontinuity across.
Idx:	Index where to examine the discontinuity.

Returned Value:

CagdBType: TRUE if continuous there, FALSE otherwise.

See Also:

MvarMVKnotHasC0Discont MvarMVIsMeshC0DiscontAt

Keywords:

MvarMVMeshC1Continuous

(mvar_gen.c:2260)

Prototype:

CagdBType MvarMVMeshC1Continuous(const MvarMVStruct *MV, int Dir, int Idx)

Description:

Examine the mesh of the given surface across direction Dir in index of mesh Index for a real discontinuity in the mesh. This index will typically be for a knot multiplicity potential discont.

Parameters:

MV:	To examine its potential discontinuity across Dir.
Dir:	Direction to examine the discontinuity across.
Idx:	Index where to examine the discontinuity.

Returned Value:

CagdBType: TRUE if continuous there, FALSE otherwise.

See Also:

MvarMVKnotHasC1Discont MvarMVIsMeshC1DiscontAt

Keywords:

MvarMVMinMax

(mvarbbox.c:71)

Prototype:

void MvarMVMinMax(const MvarMVStruct *MV, int Axis, CagdRType *Min, CagdRType *Max)

Description:

Computes a min max bound on a multivariate in a given axis. The multivariate is not coerced to anything and the given axis is tested directly where 0 is the W axis and 1, 2, 3 are the X, Y, Z etc.

Parameters:

MV:	To test for minimum/maximum.
Axis:	0 for W, 1 for X, 2 for Y etc.
Min:	Where minimum found value should be place.
Max:	Where maximum found value should be place.

Returned Value:

void

Keywords:

bbox bounding box minimum maximum

MvarMVMult

(mvar_sym.c:214)

Prototype:

MvarMVStruct *MvarMVMult(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - multiply them coordinate-wise. The two multivariates are promoted to same point type before the multiplication can take place.

Parameters:

MV1, MV2:	Two multivariate to multiply coordinate-wise.

Returned Value:

MvarMVStruct : The product of MV1 MV2 coordinate wise.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert

Keywords:

product symbolic computation multivariates

MvarMVMultBlend

(mvar_sym.c:827)

Prototype:

MvarMVStruct *MvarMVMultBlend(const MvarMVStruct *MV1, const MvarMVStruct *MV2, CagdRType Blend)

Description:

Blend two multivariates assumed to share a domain and point type.

Parameters:

MV1, MV2:	wo multivariates to blend as "MV1 * Blend + MV2 * (1-Blend)".
Blend:	Blending factor.

Returned Value:

MvarMVStruct *: Blended multivariate.

See Also:

Keywords:

MvarMVMultScalar

(mvar_sym.c:433)

Prototype:

MvarMVStruct *MvarMVMultScalar(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariate - a vector multivariate MV1 and a scalar multivariate MV2, multiply all MV1's coordinates by the scalar multivariate MV2. Returned multivariate is a multivariate representing the product of the two given multivariates.

Parameters:

MV1, MV2:	Two multivariates to multiply. Note MV2 is a scalar field.

Returned Value:

MvarMVStruct *: A multivariate representing the product of MV1 and MV2.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVMult MvarMVCrossProd MvarCrvMultScalar

Keywords:

product symbolic computation multivariates

MvarMVMultiLinearMV

(mvarprim.c:29)

Prototype:

MvarMVStruct *MvarMVMultiLinearMV(const IrtRType *Min, const IrtRType *Max, int Dim)

Description:

Constructs a multi-linear multivariates that spans the [Min, Max] ranges in all Dim dimenions.

Parameters:

Min:	Minimal values of the expected ranges.
Max:	Maximal values of the expected ranges.
Dim:	Dimension of expect multivariate.

Returned Value:

MvarMVStruct *: Constructed multi-linear function.

Keywords:

MvarMVNew

(mvar_gen.c:61)

Prototype:

MvarMVStruct *MvarMVNew(int Dim, MvarGeomType GType, MvarPointType PType, const int *Lengths)

Description:

Allocates the memory required for a new multi-variate.

Parameters:

Dim:	Number of dimensions of this multi-variate.
GType:	Type of geometry the curve should be - Bspline, Bezier etc.
PType:	Type of control points (E2, P3, etc.).
Lengths:	Of control mesh in each of the dimensions. Vector of size Dim.

Returned Value:

MvarMVStruct *: An uninitialized freeform multi-variate.

See Also:

MvarMVFree MvarBzrMVNew MvarBspMVNew

Keywords:

multi-variates allocation

MvarMVNormal2Cones

(mvcones.c:1440)

Prototype:

MvarNormalConeStruct *MvarMVNormal2Cones(const MvarMVStruct *MV, CagdRType ExpandingFactor, int NumOfZeroMVs, MvarNormalConeStruct **Cone1, MvarNormalConeStruct **Cone2)

Description:

Computes a 2cones bound to the normal field of multivariate MV. The 2cones bounds the normal field in the common intersection space. The 2cones are computed using the regular normal cone by expanding in the direction orthogonal to the cone axis and its main principal component. The expansion is done an amount that is equal to regular cone radius times ExpandingFactor.

Parameters:

MV:	To compute the normal 2cones for.
ExpandingFactor:	actor to expand placement of 2cones axes locations.
NumOfZeroMVs:	Number of zero type MVs in the problem we solve.
Cone1, Cone2:	The two cones to compute or ConeAngle = M_PI if error. Can be NULL in which case no 2cones are computed - only the regular cone is computed.

Returned Value:

MvarNormalConeStruct *: Regular normal cone if successful, NULL otherwise.

See Also:

SymbNormalConeForSrf MvarNormalConeOverlap

Keywords:

normals normal bound

MvarMVOpenEnd

(mvar_aux.c:803)

Prototype:

MvarMVStruct *MvarMVOpenEnd(const MvarMVStruct *MV)

Description:

Returns a multivar with open end conditions, similar to given multivar. Open end multivar is computed by extracting a subregion from multivar that is the entire multivar's parametric domain, by inserting multiple knots at the domain's boundary.

Parameters:

MV:	To convert to a new multivar with open end conditions. Input can also be periodic.

Returned Value:

MvarMVStruct *: Same multivar as MV but with open end conditions.

See Also:

BspCrvOpenEnd BspSrfOpenEnd

Keywords:

open end conditions

MvarMVOrthoCrvProjOnModel

(mvarproj.c:236)

Prototype:

MvarPolylineStruct *MvarMVOrthoCrvProjOnModel(const CagdCrvStruct *Crv, const MdlModelStruct *Mdl, CagdRType Tol, TrimSrfStruct **TSrfs)

Description:

Computes the orthogonal projection of a curve C(t) on a model. computes the tensor product projection and then clip to the trimming zone. if TSrfs is not NULL, because the curves are returned in the UV space of the (trimmed) surfaces in the model, each such UV plln will have a "trimsrf" attribute that references the corresponding trimmed surfaces, that are returned in TSrfs.

Parameters:

Crv:	The curve to project on Srf, orthogonally.
Mdl:	The model to project Crv on.
Tol:	Tolerance of the computation.
TSrfs:	Optional pointer to return the trimmed surfaces the computed UV curves are on, if not NULL.

Returned Value:

MvarPolylineStruct *: The projections in UV space of Srf.

See Also:

MvarMVOrthoIsoCrvProjOnSrf MvarInverseCrvOnSrfProj MvarMVOrthoCrvProjOnSrf MvarMVOrthoCrvProjOnTrimSrf

Keywords:

projection

MvarMVOrthoCrvProjOnSrf

(mvarproj.c:49)

Prototype:

MvarPolylineStruct *MvarMVOrthoCrvProjOnSrf(const CagdCrvStruct *Crv, const CagdSrfStruct *Srf, CagdRType Tol)

Description:

Computes the orthogonal projection of a curve C(t) on a surface S(u, v). That is, the projection is along the normal lines of the surface S. Computed as the univariate solution to the following two equations:

                   dS
< C(t) - S(u, v), ----- > = 0,
                   du

                   dS
< C(t) - S(u, v), ----- > = 0.
                   dv


Parameters:


 Crv:          The curve to project on Srf, orthogonally.
 Srf:          The surface to project Crv on.
 Tol:          Tolerance of the computation.



Returned Value:


  MvarPolylineStruct *:    The projections in UV space of Srf.



See Also:

  MvarMVOrthoIsoCrvProjOnSrf
  MvarInverseCrvOnSrfProj
  
  MvarMVOrthoCrvProjOnModel
  MvarMVOrthoCrvProjOnTrimSrf


Keywords:

  projection


 MvarMVOrthoCrvProjOnTrimSrf 
  (mvarproj.c:179)

Prototype:

  MvarPolylineStruct *MvarMVOrthoCrvProjOnTrimSrf(const CagdCrvStruct *Crv,
                                                  const TrimSrfStruct *TSrf,
                                                  CagdRType Tol)


Description:

Computes the orthogonal projection of a curve C(t) on a trimmed surface. computes the tensor product projection and then clip to the trimming zone.

Parameters:

Crv:	The curve to project on Srf, orthogonally.
TSrf:	The trimmed surface to project Crv on.
Tol:	Tolerance of the computation.

Returned Value:

MvarPolylineStruct *: The projections in UV space of Srf.

See Also:

MvarMVOrthoIsoCrvProjOnSrf MvarInverseCrvOnSrfProj MvarMVOrthoCrvProjOnModel MvarMVOrthoCrvProjOnSrf

Keywords:

projection

MvarMVOrthoIsoCrvProjOnSrf

(mvarproj.c:306)

Prototype:

MvarPolylineStruct *MvarMVOrthoIsoCrvProjOnSrf(const CagdSrfStruct *Srf1, const CagdRType RVal, const CagdRType CrvT0, const CagdRType CrvT1, CagdSrfDirType Dir, const CagdSrfStruct *Srf2, CagdRType Tol)

Description:

Computes the orthogonal projection of a region of an isoparametric curve of surface S1(r, t) at a fixed parameter value, RVal, into surface S2(u, v). The projection is along the normal lines of S1, that contains the curve. Computed as the univariate solution to the following two equations:

                        dS1
< S2(u, v) - S1(r, t), ----- > |          = 0,
                        dr     | (r=RVal)

                        dS1
< S2(u, v) - S1(r, t), ----- > |          = 0.
                        dt     | (r=RVal)


Parameters:


 Srf1:         The surface to project from, orthogonally.
 RVal:         The isoparametric value of the curve of Srf1 to project.
 CrvT0:        Minimal parametric value of the curve region.
 CrvT1:        Maximal parametric value of the curve region.
 Dir:          Direction of isoparametric curve of S1.
 Srf2:         The surface to project to.
 Tol:          Computation tolerance.



Returned Value:


  MvarPolylineStruct *:    The projections in UV space of Srf2.



See Also:

  MvarMVOrthoCrvProjOnSrf


Keywords:

  projection


 MvarMVParamShift 
  (mvar_rev.c:265)

Prototype:

  MvarMVStruct *MvarMVParamShift(const MvarMVStruct *MV, int AxisSrc, int AxisTar)


Description:

Reorders the axes (or variables) of the given MV, so that AxisSrc moves to the index AxisTar. The order of all the other axes is preserved.

Parameters:

MV:	Multi-Variate in which the axes are to be reordered.
AxisSrc:	The axis to move.
AxisTar:	The required new index of AxisSrc.

Returned Value:

MvarMVStruct *: Reordered multi-variate.

See Also:

MvarMVShiftAxes MvarMVReverse

Keywords:

multi-variates

MvarMVPreciseBBox

(mvarbbox.c:547)

Prototype:

MvarPtStruct *MvarMVPreciseBBox(const MvarMVStruct *MV, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a multi-variate freeform function. The precise bbox is computed by: 1. Deriving the MV with respect to all parameters, in all direction and seeking all the interior local extrema. 2. Recursively extract the boundaries as one-less dimensional MV and call recursively, until it is a curve, in which case its two end points are considered.

Parameters:

MV:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved. If NULL, all computed extrema are returned instead.
Tol:	Tolerance of computations.

Returned Value:

MvarPtStruct *: If BBox is NULL, all extrema locations identified are returned here. Otherwise a NULL is returned.

See Also:

MvarMVBBox

Keywords:

bbox bounding box

MvarMVPrepGradient

(mvar_der.c:702)

Prototype:

MvarMVGradientStruct *MvarMVPrepGradient(const MvarMVStruct *MV, CagdBType Orig)

Description:

Builds a gradient for the given scalar multivariate. If the input is rational, returned is a dynamically allocated vector of scalar multivariate functions each representing DMV/Dui, i from 0 to Dim. The returned partial derivative are differentiated directly without the quotient rule which must be applied manually. Otherwise, if the input is polynomial, the gradient is returned as one vector function.

Parameters:

MV:	Input scalar field to compute its gradient function.
Orig:	If orig TRUE and input is polynomial, the original scalar MV is also placed as last, additional, dimension (for faster evaluation of MV and its gradient).

Returned Value:

MvarMVGradientStruct *: The gradient function of the input scalar field.

See Also:

MvarMVDerive MvarMVFreeGradient MvarMVEvalGradient

Keywords:

MvarMVPwrDegreeRaise

(mvarrais.c:568)

Prototype:

MvarMVStruct *MvarMVPwrDegreeRaise(const MvarMVStruct *MV, int Dir, int IncOrder)

Description:

Increase the order of the given power basis multivariate in direction Dir by IncOrder amount. IncOrder amount is at least one.

Parameters:

MV:	Multivariate to increase its order in direction Dir.
Dir:	Direction to increase the order.
IncOrder:	y how much to increase the order, at least one.

Returned Value:

MvarMVStruct *: New multivariate with higher order.

See Also:

MvarMVDegreeRaise MvarMVDegreeRaiseN MvarMVDegreeRaise2

Keywords:

MvarMVRefineAtParams

(mvar_ref.c:42)

Prototype:

MvarMVStruct *MvarMVRefineAtParams(const MvarMVStruct *MV, MvarMVDirType Dir, CagdBType Replace, CagdRType *t, int n)

Description:

Given a multi-variate, refines it at the given n knots as defined by the vector t. If Replace is TRUE, the values replace the current knot vector. Returns pointer to refined MV (Note a Bezier multi-variate will be converted into a Bspline multi-variate).

Parameters:

MV:	Multi-variate to refine according to t in direction Dir.
Dir:	Direction of refinement. Either U or V or W.
Replace:	If TRUE t is a knot vector exactly in the length of the knot vector in direction Dir in MV and t simply replaces than knot vector. If FALSE, the knot vector in direction Dir in MV is refined by adding all the knots in t.
t:	Knot vector to refine/replace the knot vector of MV in direction Dir.
n:	Length of vector t.

Returned Value:

MvarMVStruct *: The refined multi-variate. Always a Bspline.

Keywords:

multi-variates

MvarMVRegionFromMV

(mvar_aux.c:663)

Prototype:

MvarMVStruct *MvarMVRegionFromMV(const MvarMVStruct *MV, CagdRType t1, CagdRType t2, MvarMVDirType Dir)

Description:

Given a multi-variate, returns a sub-region of it.

Parameters:

MV:	To extract a sub-region from.
t1, t2:	Domain to extract from MV, in parametric direction Dir.
Dir:	Direction to extract the sub-region. Either U or V or W.

Returned Value:

MvarMVStruct *: A sub-region of MV from t1 to t2 in direction Dir.

See Also:

MvarMVExtension MvarBzrMVRegionFromMV

Keywords:

multi-variates

MvarMVReverse

(mvar_rev.c:32)

Prototype:

MvarMVStruct *MvarMVReverse(const MvarMVStruct *MV, int Axis1, int Axis2)

Description:

Reverse the role of the given two axis by flipping them out.

Parameters:

MV:	Multi-Variate to reverse.
Axis1, Axis2:	Two axis to flip over.

Returned Value:

MvarMVStruct *: Reversed multi-variate.

See Also:

MvarPromoteMVToMV MvarMVShiftAxes

Keywords:

multi-variates

MvarMVReverseDir

(mvar_rev.c:101)

Prototype:

MvarMVStruct *MvarMVReverseDir(const MvarMVStruct *MV, int Axis)

Description:

Reverses the direction of the mesh of the given MV in direction Axis (and also reverse the knot vector if B-spline.

Parameters:

MV:	Multi-Variate to reverse.
Axis:	Direction to reverse.

Returned Value:

MvarMVStruct *: Reversed multi-variate.

See Also:

MvarPromoteMVToMV MvarMVShiftAxes MvarMVReverse

Keywords:

multi-variates

MvarMVRtnlMult

(mvar_sym.c:787)

Prototype:

MvarMVStruct *MvarMVRtnlMult(const MvarMVStruct *MV1X, const MvarMVStruct *MV1W, const MvarMVStruct *MV2X, const MvarMVStruct *MV2W, CagdBType OperationAdd)

Description:

Given two multivariates - multiply them using the quotient product rule:

 X = X1 W2 +/- X2 W1

All provided multivariates are assumed to be non rational scalar multivariates. Returned is a non rational scalar multivariate (CAGD_PT_E1_TYPE).

Parameters:

MV1X:	Numerator of first multivariate.
MV1W:	Denominator of first multivariate. Can be NULL.
MV2X:	Numerator of second multivariate.
MV2W:	Denominator of second multivariate. Can be NULL.
OperationAdd:	TRUE for addition, FALSE for subtraction.

Returned Value:

MvarMVStruct *: The result of MV1X MV2W +/- MV2X MV1W.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd2D

Keywords:

product multivariates symbolic computation

MvarMVScalarScale

(mvar_sym.c:351)

Prototype:

MvarMVStruct *MvarMVScalarScale(const MvarMVStruct *CMV, CagdRType Scale)

Description:

Given a multivariate, scale it by Scale.

Parameters:

CMV:	A multivariate to scale by magnitude Scale.
Scale:	Scaling factor.

Returned Value:

MvarMVStruct *: A multivariates scaled by Scale compared to MV.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVMult MvarMVMultScalar MvarMVInvert MvarMVCrossProd

Keywords:

scaling symbolic computation multivariates

MvarMVScalarScale2

(mvar_sym.c:391)

Prototype:

MvarMVStruct *MvarMVScalarScale2(const MvarMVStruct *CMV, const CagdRType *Scale)

Description:

Given a multivariate, scale each of its coordinates by a given factor.

Parameters:

CMV:	A multivariate to scale by magnitude Scale.
Scale:	The scaling factors.

Returned Value:

MvarMVStruct *: A multivariates scaled by Scale compared to MV.

See Also:

MvarMVDotProd MvarMVVecDotProd MvarMVMult MvarMVMultScalar MvarMVInvert MvarMVCrossProd MvarMVScalarScale

Keywords:

scaling symbolic computation multivariates

MvarMVSetAllDomains

(mvar_aux.c:430)

Prototype:

MvarMVStruct *MvarMVSetAllDomains(MvarMVStruct *MV, CagdRType *Min, CagdRType *Max, int InPlace)

Description:

Given a multi-variate, sets its parametric domain in all directions to be between Min and Max. If the MV is a Bezier, it is coerced to a Bspline first (and if InPlace TRUE, the original Bezier is freed).

Parameters:

MV:	Multivariate function to update its domain.
Min:	New minimum domains of MV.
Max:	New maximum domains of MV.
InPlace:	f TRUE, updates domain in place, unless was a Bezier that was converted into a Bspline, in which case the Bezier is released.

Returned Value:

MvarMVStruct *: Same multivariate with the updated domain in dir Axis.

See Also:

varMVDomain MvarMVSetAllDomains MvarParamInDomain MvarParamsInDomain

Keywords:

multi-variates

MvarMVSetCompositionCheckDomains

(mvcompos.c:1900)

Prototype:

CagdBType MvarMVSetCompositionCheckDomains(CagdBType NewValue)

Description:

Set the flag which determines if domain checks are performed in multivariate composition. If set to TRUE, the composition algorithm will verify that all of the Bezier patches of the reparametrization multivariate are fully contained (by bounding box) in the parametric domain of the target multivariate. If FALSE, then these checks are skipped.

Parameters:

NewValue:	The new value to set to the flag.

Returned Value:

CagdBType: The previous value of the flag.

See Also:

MvarMVCompose MvarMVComposeBzrBzr MvarComposeExtractTargetSubdomain

Keywords:

MvarMVSetCompositionPropagateHigherDims

(mvcompos.c:1932)

Prototype:

CagdBType MvarMVSetCompositionPropagateHigherDims(CagdBType NewValue)

Description:

Set the flag which determines if tiles with higher dimensions (more than the deformation function's domain) will propagate their higher dimensions to the output or not.

Parameters:

NewValue:	The new value to set to the flag.

Returned Value:

CagdBType: The previous value of the flag.

See Also:

MvarMVCompose MvarMVComposeBzrBzr MvarComposeExtractTargetSubdomain MvarMVSetCompositionPropagateHigherDims

Keywords:

MvarMVSetDomain

(mvar_aux.c:207)

Prototype:

MvarMVStruct *MvarMVSetDomain(MvarMVStruct *MV, CagdRType Min, CagdRType Max, int Axis, int InPlace)

Description:

Given a multi-variate, sets its parametric domain in direction Axis to be between Min and Max. If the MV is a Bezier and the domain requested is not [0, 1], it is coerced to a B-spline first.

Parameters:

MV:	Multivariate function to update its domain.
Min:	New minimum domain in Axis direction of MV.
Max:	New maximum domain in Axis direction of MV.
Axis:	Axis to set a new domain for.
InPlace:	f TRUE, updates domain in place if possible. A Bezier can be converted into a B-spline, in which case the Bezier is released.

Returned Value:

MvarMVStruct *: Same multivariate with the updated domain in dir Axis.

See Also:

varMVDomain MvarMVSetAllDomains MvarParamInDomain MvarParamsInDomain

Keywords:

multi-variates

MvarMVShiftAxes

(mvar_rev.c:170)

Prototype:

MvarMVStruct *MvarMVShiftAxes(const MvarMVStruct *MV, int Axis)

Description:

Shift the last index in, instead of index Axis. All axes after Axis are shifted forward one location as well.

Parameters:

MV:	Multi-Variate to shift axes.
Axis:	From where to shift forward until last Axis and put last Axis Here instead.

Returned Value:

MvarMVStruct *: Multi-variate, with shifted axes

See Also:

MvarMVReverse MvarPromoteMVToMV

Keywords:

multi-variates

MvarMVSplitScalar

(mvar_sym.c:1014)

Prototype:

void MvarMVSplitScalar(const MvarMVStruct *MV, MvarMVStruct **MVs)

Description:

Given a multivariate, splits it to its scalar component multivariates.

Parameters:

MV:	Multivariate to split.
MVs:	An array to hold the newly dynamically allocated scalar MVs. The zero entry would hold the W, or NULL otherwise. The first entry would hold X axis, etc. This vector should have MVAR_MAX_PT_COORD coordinates.

Returned Value:

void

See Also:

MvarMVMergeScalar

Keywords:

split multivariates symbolic computation

MvarMVSub

(mvar_sym.c:116)

Prototype:

MvarMVStruct *MvarMVSub(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Given two multivariates - subtract them coordinate-wise. The two multivariates are promoted to same point type before the operation can take place. Furthermore, order and continuity are matched as well.

Parameters:

MV1, MV2:	Two multivariate to subtract coordinate-wise.

Returned Value:

MvarMVStruct *: The difference of MV1 - MV2 coordinate-wise.

See Also:

MvarMVAdd MvarMeshAddSub MvarMVMult

Keywords:

subtraction symbolic computation multivariates

MvarMVSubdivAtParam

(mvar_sub.c:48)

Prototype:

MvarMVStruct *MvarMVSubdivAtParam(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir)

Description:

Given a multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	Multi-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.

Returned Value:

MvarMVStruct *: A list of two multi-variates, result of the subdivision.

See Also:

MvarBspMVSubdivAtParam MvarBzrMVSubdivAtParam

Keywords:

multi-variates

MvarMVSubdivAtParamOneSide

(mvar_sub.c:431)

Prototype:

MvarMVStruct *MvarMVSubdivAtParamOneSide(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir, IrtBType LeftSide)

Description:

Given a multi-variate, subdivides it at parameter value t in direction Dir.

Parameters:

MV:	Multi-Variate to subdivide.
t:	Parameter to subdivide at.
Dir:	Direction of subdivision.
LeftSide:	TRUE to only fetch left half, FALSE to fetch right half.

Returned Value:

MvarMVStruct *: A single multi-variate, result of the subdivision.

See Also:

MvarBspMVSubdivAtParamOneSide MvarBzrMVSubdivAtParamOneSide MvarMVSubdivAtParam

Keywords:

multi-variates

MvarMVTransform

(mvar_gen.c:1455)

Prototype:

void MvarMVTransform(MvarMVStruct *MV, CagdRType *Translate, CagdRType Scale)

Description:

Linearly transforms, in place, given MV as specified by Translate and Scale.

Parameters:

MV:	Multi-variate to transform.
Translate:	Translation factor. Can be NULl for non.
Scale:	Scaling factor.

Returned Value:

void

Keywords:

multi-variates

MvarMVTriTangentLine

(mvtangnt.c:1318)

Prototype:

CagdCrvStruct *MvarMVTriTangentLine(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdSrfStruct *Srf3, CagdRType StepSize, CagdRType SubdivTol, CagdRType NumericTol, int Euclidean)

Description:

Computes the tri-tangent line of three freeform bivariate. In other words, computes the tangent line at three different points to the three surface(s). The result is a univariate (describing the line tri-tangent to the surfaces as it slides over the three surfaces).

Parameters:

Srf1, Srf2, Srf3:	he 3 bivariates to compute the tri-tangent lines for. Assumed Bsplines surfaces with Open End Cond.
StepSize:	Tolerance of numeric tracing of univariate solution.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
Euclidean:	True to return the result in Euclidean space, FALSE to return it in parameteric space.

Returned Value:

CagdCrvStruct *: Triplets of univariate solutions (three curves on the three surfaces) of tri-tangent lines.

See Also:

SymbTangentToCrvAtTwoPts MvarMVBiTangents MvarMVBiTangents2 MvarMVTriTangentLineCreateMVs

Keywords:

tri-tangent

MvarMVTriTangentLineCreateETs

(mvtangnt.c:1065)

Prototype:

void MvarMVTriTangentLineCreateETs(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, const MvarMVStruct *CMV3, MvarExprTreeStruct **ETs, MvarConstraintType *Constraints)

Description:

Computes the constraints to solve for the tri-tangent line of three freeform bivariate. In other words, to compute the tangent line at three different points to the three surface(s). Let,

      DMV12 = MV1(u, v) - MV2(s, t)
      DMV13 = MV1(u, v) - MV3(a, b)
      DMV23 = MV2(s, t) - MV3(a, b)

Then, compute the simultaneous solution of the following five equations:

  d MV1   d MV1
< ----- x -----, DMV13 > = 0,
    du      dv
                                                                           *
  d MV2   d MV2
< ----- x -----, DMV13 > = 0,
    dr      ds
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV13 > = 0,
    da      db
                                                                           *
  d MV1   d MV1
< ----- x -----, DMV12 > = 0,
    du      dv
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV23 > = 0,
    da      db


Parameters:


 CMV1, CMV2, CMV3:  he 3 bivariates to compute the tri-tangent lines for.
 ETs:           To be populated with the computed ETs constraints.
 Constraints:   To be populated with the constraints' types.



Returned Value:


  void



See Also:

  SymbTangentToCrvAtTwoPts
  MvarMVBiTangents
  MvarMVBiTangents2
  MvarMVTriTangentLine
  MvarMVTriTangentLineCreateMVs


Keywords:

  tri-tangent


 MvarMVTriTangentLineCreateMVs 
  (mvtangnt.c:925)

Prototype:

  void MvarMVTriTangentLineCreateMVs(const MvarMVStruct *CMV1,
                                     const MvarMVStruct *CMV2,
                                     const MvarMVStruct *CMV3,
                                     MvarMVStruct **MVs,
                                     MvarConstraintType *Constraints)


Description:

Computes the constraints to solve for the tri-tangent line of three freeform bivariate. In other words, to compute the tangent line at three different points to the three surface(s). Let,

      DMV12 = MV1(u, v) - MV2(s, t)
      DMV13 = MV1(u, v) - MV3(a, b)
      DMV23 = MV2(s, t) - MV3(a, b)

Then, compute the simultaneous solution of the following five equations:

  d MV1   d MV1
< ----- x -----, DMV13 > = 0,
    du      dv
                                                                           *
  d MV2   d MV2
< ----- x -----, DMV13 > = 0,
    dr      ds
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV13 > = 0,
    da      db
                                                                           *
  d MV1   d MV1
< ----- x -----, DMV12 > = 0,
    du      dv
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV23 > = 0,
    dx      dy


Parameters:


 CMV1, CMV2, CMV3:  he 3 bivariates to compute the tri-tangent lines for.
 MVs:           To be populated with the computed MVS constraints.
 Constraints:   To be populated with the constraints' types.



Returned Value:


  void



See Also:

  SymbTangentToCrvAtTwoPts
  MvarMVBiTangents
  MvarMVBiTangents2
  MvarMVTriTangentLine


Keywords:

  tri-tangent


 MvarMVTriTangents 
  (mvtangnt.c:218)

Prototype:

  MvarPtStruct *MvarMVTriTangents(const MvarMVStruct *CMV1,
                                  const MvarMVStruct *CMV2,
                                  const MvarMVStruct *CMV3,
                                  int Orientation,
                                  CagdRType SubdivTol,
                                  CagdRType NumericTol)


Description:

Computes tri-tangents of freeform bivariate. In other words, compute the tangent plane at three points to the surface(s). Let,

      DMV12 = MV1(u, v) - MV2(r, s)
      DMV13 = MV1(u, v) - MV3(x, y)
      DMV23 = MV2(r, s) - MV3(x, y)

then, compute the simultaneous solution of the following six equations:

  d MV1   d MV1
< ----- x -----, DMV12 > = 0,
    du      dv

  d MV1   d MV1
< ----- x -----, DMV13 > = 0,
    du      dv

  d MV2   d MV2
< ----- x -----, DMV23 > = 0,
    dr      ds
                                                                           *
  d MV2   d MV2
< ----- x -----, DMV12 > = 0,
    dr      ds
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV13 > = 0,
    dx      dy
                                                                           *
  d MV3   d MV3
< ----- x -----, DMV23 > = 0,
    dx      dy


Parameters:


 CMV1, CMV2, CMV3:  The 3 multivariates to compute the tri-tangents for.
                  If MV2 == MV3 == NULL, the self tri-tangents of MV1 are
                  computed.
 Orientation:   0 for no effect, -1 or +1 for a request to get opposite
                  or similar normal orientation bi tangencies only.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *:    Points on the bi-tangents of the two multivariates.



See Also:

  SymbTangentToCrvAtTwoPts
  MvarMVBiTangents
  MvarMVBiTangents2
  MvarMVTriTangentLine


Keywords:

  tri-tangent


 MvarMVUnitMaxCoef 
  (mvar_gen.c:1394)

Prototype:

  MvarMVStruct *MvarMVUnitMaxCoef(MvarMVStruct *MV)


Description:

Normalize in place the given multivariate so its maximal coefficient is of unit size. Each axis is treated independently, including W.

Parameters:

MV:	Multivariate to normalize in place its coefficients.

Returned Value:

MvarMVStruct *: Normalized multivariate, in place.

See Also:

MvarSrfUnitMaxCoef MvarCrvUnitMaxCoef

Keywords:

MvarMVUpdateConstDegDomains

(mvar_aux.c:549)

Prototype:

void MvarMVUpdateConstDegDomains(MvarMVStruct **MVs, int NumOfMVs)

Description:

Given a vector of MVs, some with constant degrees and invalid domain, update all MVs domains, exploiting MVs with non constant degrees' domains.

Parameters:

MVs:	To update their domains.
NumOfMVs:	Size of MVs vector.

Returned Value:

void

See Also:

MvarETUpdateConstDegDomains

Keywords:

MvarMVVecDotProd

(mvar_sym.c:548)

Prototype:

MvarMVStruct *MvarMVVecDotProd(const MvarMVStruct *MV, const CagdRType *Vec)

Description:

Given a multivariate and a vector - computes their dot product. Returned multivariate is a scalar multivariate representing the dot product. While typically in R3, the dot product can be computed for any dimension of MV, and Vec should be of the appropriate size.

Parameters:

MV:	Multivarients to multiply and compute a dot product for.
Vec:	Vector to project MV onto.

Returned Value:

MvarMVStruct *: A scalar multivariate representing the dot product of MV . Vec.

See Also:

MvarMVDotProd MvarMVMult MvarMVScalarScale MvarMVMultScalar MvarMVInvert MvarMVCrossProd

Keywords:

product dot product symbolic computation ltivariates

MvarMVVolumeOfDomain

(mvar_aux.c:112)

Prototype:

IrtRType MvarMVVolumeOfDomain(MvarMVStruct * const MVs, int Dim)

Description:

Compute the volume of a multivariate's domain.

Parameters:

MVs:	The multivariate.
Dim:	Number of dimensions.

Returned Value:

IrtRType: Volume of domain.

Keywords:

MvarMVZR1DMergeTwoPoly

(zrmvaux1.c:85)

Prototype:

MvarPolylineStruct *MvarMVZR1DMergeTwoPoly(MvarPolylineStruct *Poly1, MvarPolylineStruct *Poly2, CagdRType Tol)

Description:

Merges two neighboring polylines together, in place.

Parameters:

Poly1:	1st polyline.
Poly2:	2nd polyline.
Tol:	The tolerance under which two points are proclaimed to be identical.

Returned Value:

MvarPolylineStruct *: If the start/endpoint of Poly1 coincides with the start/endpoint of Poly2, up to Tol, they are merged.

See Also:

MvarMVZR1DPrelimLink

Keywords:

MvarMVZR1DPrelimLink

(zrmvaux1.c:279)

Prototype:

MvarPolylineStruct *MvarMVZR1DPrelimLink(MvarPolylineStruct **PolyList, MvarPolylineStruct *Poly, CagdRType Tol, const MvarMVStruct *MV)

Description:

Finds a polyline in the list, which is to be merged to a given polyline and remove it from the input list.

Parameters:

PolyList:	List of polylines (found poly is removed from, in place).
Poly:	Polyline, to be merged with the one from the list.
Tol:	The tolerance under which two points are proclaimed to be identical.
MV:	Optional parameter that, when not NULL, defines the domain where no merges close to boundary will take place.

Returned Value:

MvarPolylineStruct *: Polyline which is suitable for Poly to be merged, NULL, if no such polyline exist.

See Also:

MvarMVZR1DMergeTwoPoly

Keywords:

MvarMVsBisector

(mvbisect.c:45)

Prototype:

MvarMVStruct *MvarMVsBisector(const MvarMVStruct *MV1, const MvarMVStruct *MV2)

Description:

Compute bisector to two given multivariates.

Parameters:

MV1, MV2:	The two multivariates to compute the bisector for.

Returned Value:

MvarMVStruct *: The result bisector.

See Also:

SymbSrfPtBisectorSrf3D SymbCrvPtBisectorSrf3D SymbCrvCrvBisectorSrf3D

Keywords:

bisectors

MvarMVsDetectZeros

(zrsolver.c:555)

Prototype:

CagdBType MvarMVsDetectZeros(MvarMVStruct * const *MVs, MvarConstraintType *Constraints, int NumOfMVs, CagdRType SubdivTol, CagdRType NumericTol, int HighDimBndry)

Description:

Interface function for determining whether or not a MV equation has a solution. Constructs the generic problem structure, calls the solver in the detection-only mode. The set of NumOfMVs constraints may consist of equality or inequality constraints, as prescribed by the constraints vector. All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

MVs:	Vector of multivariate constraints.
Constraints:	Either an equality or an inequality type of constraint. Can be NULL in which case all constraints are equality.
NumOfMVs:	Size of the MVs and Constraints vector.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. Measured in the image space of the constraints function.
HighDimBndry:	TRUE if invoked when solving boundary of a higher dimensional problem, FALSE otherwise.

Returned Value:

CagdBType: Whether or not a solution to the zero problem exists.

See Also:

MvarMVsZeros0D MvarMVsZerosNormalConeTest MvarMVsZerosDomainReduction MvarMVsZerosVerifier MvarETsZeros0D MvarMVsZeros1D MvarMVsZeros2D

Keywords:

MvarMVsSame

(mvar_gen.c:1765)

Prototype:

CagdBType MvarMVsSame(const MvarMVStruct *MV1, const MvarMVStruct *MV2, CagdRType Eps)

Description:

Compare the two multivariates for similarity.

Parameters:

MV1, MV2:	The two multivariates to compare.
Eps:	Tolerance of equality.

Returned Value:

CagdBType: TRUE if multivariates are the same, FALSE otherwise.

See Also:

CagdSrfsSame CagdCrvsSame TrivTVsSame MvarMVsSame3 MvarMVsSameSpace VMdlVModelsSame

Keywords:

MvarMVsSame3

(mvar_gen.c:1808)

Prototype:

CagdBType MvarMVsSame3(const MvarMVStruct *MV1, const MvarMVStruct *MV2, CagdRType Eps, int *Modified)

Description:

Compare the two multivariates for similarity. If the MVs are curves or surfaces, performs all possible reflections, searching for similarity, and bring them to common function spaces.

Parameters:

MV1, MV2:	The two multivariates to compare.
Eps:	Tolerance of equality.
Modified:	Tags how MVs are reflected (See CagdSrfsSame3 and CagdCrvsSame for sub-MVs that are curves or surfaces). Can be NULL in which case it is ignored.

Returned Value:

CagdBType: TRUE if multivariates are the same, FALSE otherwise.

See Also:

CagdSrfsSame3 CagdCrvsSame3 TrivTVsSame MvarMVsSame MvarMVsSameSpace

Keywords:

MvarMVsSameSpace

(mvar_gen.c:1713)

Prototype:

CagdBType MvarMVsSameSpace(const MvarMVStruct *MV1, const MvarMVStruct *MV2, CagdRType Eps)

Description:

Compare the two multivariates to be in the same function space.

Parameters:

MV1, MV2:	The two multivariates to compare.
Eps:	Tolerance of equality.

Returned Value:

CagdBType: TRUE if multivariates are in the same sapce, FALSE otehrwise.

See Also:

MvarMVsSame

Keywords:

MvarMVsZeros0D

(zrsolver.c:90)

Prototype:

MvarPtStruct *MvarMVsZeros0D(MvarZeroPrblmSpecStruct *ZeroProblemSpec)

Description:

Interface function for a generic MV equation solver, 0D solutions: constructs the generic problem structure, calls the solver and extracts the solution point list from the generic solution structure. The set of NumOfMVs constraints may consist of equality or inequality constraints, as prescribed by the constraints vector. All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

ZeroProblemSpec:	Specification of the 0D problem, which includes the number of constraints, the multivariates constraints, constraints types, tolerances, call back functions, etc.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVs.

See Also:

MvarMVsZerosNormalConeTest MvarMVsZerosDomainReduction MvarMVsZerosVerifier MvarETsZeros0D MvarMVsZeros1D MvarMVsZeros2D

Keywords:

MvarMVsZeros0DNumeric

(zrsolver.c:217)

Prototype:

MvarPtStruct *MvarMVsZeros0DNumeric(MvarMVStruct * const *MVs, int NumOfMVs, CagdRType NumericTol, MvarPtStruct *ZeroPt)

Description:

Interface function for a numeric solution, as part of the MV equation solver, for 0D solutions. An initial guess must be provided and note that solution is not guaranteed, even if one exists.

Parameters:

MVs:	Vector of multivariate constraints.
NumOfMVs:	Size of the MVs and Constraints vector.
NumericTol:	Numeric tolerance of the numeric stage. Measured in the image space of the constraints function.
ZeroPt:	An initial guess. The closer this guess to the precise solution the better chance it will converge.

Returned Value:

MvarPtStruct *: Preicse solution if successful or NULL if failed (the improved solution is not within NumericTol).

See Also:

MvarMVsZerosNormalConeTest MvarMVsZerosDomainReduction MvarMVsZerosVerifier MvarETsZeros0D MvarMVsZeros1D MvarMVsZeros2D MvarZero0DNumeric

Keywords:

MvarMVsZeros1D

(zrsolver.c:334)

Prototype:

MvarPolylineStruct *MvarMVsZeros1D(MvarZeroPrblmSpecStruct *ZeroProblemSpec)

Description:

Interface function for a generic MV equation solver, 1D solutions: constructs the generic problem structure, calls the solver and extracts the list of solution polylines from the generic solution structure. The set of NumOfMVs constraints may consist of equality or inequality constraints, as prescribed by the constraints vector. All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

ZeroProblemSpec:	Specification of the 1D problem, which includes the number of constraints, the multivariates constraints, constraints types, tolerances, call back functions, etc.

Returned Value:

MvarPolylineStruct *: The solution, either holding list of polylines which approximate the intersection curve, or a list of polylines of length 1, which represent the critical points of the problem. In the intersection polyline case, each polyline corresponds to the topologically isolated component of the curve and is in R^k, the unioned parametric spaces of all input MVs.

See Also:

MvarSrfSrfInter MvarMVsZeros1DMergeSingularPts MvarMVsZeros0D MvarETsZeros0D MvarMVsZeros2D MvarMVsZeros1DTrace2Pts

Keywords:

MvarMVsZeros1DMergeSingularPts

(zrmv1d.c:980)

Prototype:

int MvarMVsZeros1DMergeSingularPts(int MergeSingularPts)

Description:

Sets the state of the singular points merger: If 0, singular locations are ignored (skipped). If 1, singular locations are merged using the subdivision tolerance which improves the changes of a complete long merged curves. If 2, singular locations are merged using the numeric tolerances (like every other case) which means most likely they will be left as isolated points.

Parameters:

MergeSingularPts:	Set the desired state of singular points mergers.

Returned Value:

int: Old state.

See Also:

MvarSrfSrfInter MvarMVsZeros1D

Keywords:

MvarMVsZeros1DTrace2Pts

(zrsolver.c:411)

Prototype:

MvarPolylineStruct *MvarMVsZeros1DTrace2Pts(MvarMVStruct * const *MVs, MvarConstraintType *Constraints, int NumOfMVs, MvarPtStruct *StartEndPts, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Interface function similar to MvarMVsZeros1D but only for tracing a single univariate component between StartEndPts.

Parameters:

MVs:	Vector of multivariate constraints.
Constraints:	Either an equality or an inequality type of constraint. Can be NULL in which case all constraints are equality.
NumOfMVs:	Size of the MVs and Constraints vector.
StartEndPts:	Start/end points for the polyline solution to trace.
Step:	Step size to use in the numeric tracing.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. Measured in the image space of the constraints function.

Returned Value:

MvarPolylineStruct *: The traced polyline which approximates solution, in R^k.

See Also:

MvarSrfSrfInter MvarMVsZeros1DMergeSingularPts MvarMVsZeros0D MvarETsZeros0D MvarMVsZeros2D MvarMVsZeros1D

Keywords:

MvarMVsZeros2D

(zrsolver.c:488)

Prototype:

MvarZeroSolutionStruct *MvarMVsZeros2D(MvarZeroPrblmSpecStruct *ZeroProblemSpec)

Description:

Interface function for a generic MV equation solver, 2D solutions: constructs the generic problem structure, calls the solver and extracts the list of either solution triangles or solution polylines from the generic solution structure. The set of NumOfMVs constraints must consist of equality constraints, prescribed by the constraints vector (inequalities not supported). All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

ZeroProblemSpec:	Specification of the 2D problem, which includes the number of constraints, the multivariates constraints, constraints types, tolerances, call back functions, etc.

Returned Value:

MvarZeroSolutionStruct *: The list of either triangles or polylines, according to the required output types, which approximate the surface.

See Also:

MvarSrfSrfInter MvarMVsZeros0D MvarETsZeros0D MvarMVsZeros1D

Keywords:

MvarMVsZeros2DBy0D

(zrsolver.c:251)

Prototype:

MvarPtStruct *MvarMVsZeros2DBy0D(MvarZeroPrblmSpecStruct *ZeroProblemSpec)

Description:

Interface function for a generic MV equation solver, 2D solutions, in the temporary case where the problem is solved using the 0D solver and then surface fitting to the solution points. Constructs the generic problem structure, calls the solver and extracts the solution point list from the generic solution structure. The surface fitting step is done by the specific problem algorithm outside the solver environment. The set of NumOfMVs constraints may consist of equality or inequality constraints, as prescribed by the constraints vector. All multivariates are assumed to be in the same parametric domain size and dimension.

Parameters:

ZeroProblemSpec:	Specification of the 0D problem, which includes the number of constraints, the multivariates constraints, constraints types, tolerances, call back functions, etc.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVs.

See Also:

MvarCrvSrfBisectorApprox

Keywords:

MvarMVsZeros2DCornersOnly

(zrmv2dTs.c:1535)

Prototype:

int MvarMVsZeros2DCornersOnly(int Is2DSolutionCornersOnly)

Description:

Sets the filter state of the polyline loops, when tagging loop points for later triangulation. If set to TRUE, the only chosen points are domain corners and points added due to T-Junction handling. Otherwise, intermediate solution points will be selected as well. NOTE: if set to TRUE, then the MVAR_ZRMV2D_LIMIT_EDGE_LEN flag must be set to FALSE. Otherwise black holes can appear in the mesh.

Parameters:

Is2DSolutionCornersOnly:	New setting for the filter state.

Returned Value:

int: Old setting for the filter state.

See Also:

MvarZeroSolverOrganizeSol2DMVs MvarZeroTagSegmentForTr

Keywords:

MvarMVsZeros2DPolylines

(zrmv2dTp.c:708)

Prototype:

int MvarMVsZeros2DPolylines(int IsPolyLines2DSolution)

Description:

Sets the output type of the bivariate solver: either a collection of loops (polylines) or a collection of triangles.

Parameters:

IsPolyLines2DSolution:	New setting for the output type.

Returned Value:

int: Old setting for the output type.

See Also:

MvarZeroSolverInseparableProblem MvarZeroSolverOne2OneProjMVs

Keywords:

MvarMVsZerosCrtPts

(zrsolver.c:3120)

Prototype:

int MvarMVsZerosCrtPts(int CrtPtsDetection)

Description:

Controls the critical points detection task of the solver. If FALSE, the main problem is solved, disregarding the question of critical points. Otherwise, the main problem is not solved, but is converted to its critical points detection problem, and this is the problem solved.

Parameters:

CrtPtsDetection:	New setting for the critical points detection.

Returned Value:

int: Old setting of the critical points detection.

See Also:

MvarZeroSolverInseparableProblem

Keywords:

MvarMVsZerosDmnExt

(zrsolver.c:2407)

Prototype:

CagdRType MvarMVsZerosDmnExt(CagdRType DmnExt)

Description:

Sets the tolerance (or zero to disable) of the domain extension inside the multivariate subdivisions' zero set solver.

Parameters:

DmnExt:	New setting for domain extension usage.

Returned Value:

CagdRType: Old extensions tolerance for domain extension usage.

See Also:

MvarZeroSolverInseparableProblem MvarMVsZerosDomainReduction MvarMVsZerosGradPreconditioning

Keywords:

MvarMVsZerosDomainReduction

(zrmvaux0.c:118)

Prototype:

int MvarMVsZerosDomainReduction(int DomainReduction)

Description:

Sets the use (or not) of the domain reduction option - Bezier (and (B-spline) clipping in multivariate subdivisions' zero set solver.

Parameters:

DomainReduction:	New setting for the domain reduction option.

Returned Value:

int: Old setting for normal cone testing usage.

See Also:

MvarMVsZeros MvarMVsZerosNormalConeTest MvarMVsZerosGradPreconditioning

Keywords:

MvarMVsZerosGradPreconditioning

(zrmvaux0.c:87)

Prototype:

int MvarMVsZerosGradPreconditioning(int GradPreconditioning)

Description:

Sets the use (or not) of gradient precondition option - application of and orthogonalization process over the gradients in multivariate subdivisions' zero set solver.

Parameters:

GradPreconditioning:	New setting for the gradient orthogonalization.

Returned Value:

int: Old setting of gradient orthogonalization.

See Also:

MvarMVsZeros MvarMVsZerosNormalConeTest MvarMVsZerosDomainReduction

Keywords:

MvarMVsZerosKantorovichTest

(zrmvkant.c:794)

Prototype:

int MvarMVsZerosKantorovichTest(int KantorovichTest)

Description:

Sets the use (or not) of the Kantorovich test inside the multivariate subdivisions' zero set solver.

Parameters:

KantorovichTest:	New setting for normal cone testing usage.

Returned Value:

int: Old setting for normal cone testing usage.

See Also:

MvarMVsZeros MvarMVsZerosDomainReduction MvarMVsZerosGradPreconditioning

Keywords:

MvarMVsZerosNormalConeTest

(zrmvaux0.c:56)

Prototype:

int MvarMVsZerosNormalConeTest(int NormalConeTest)

Description:

Sets the use (or not) of the normal cone tests inside the multivariate subdivisions' zero set solver.

Parameters:

NormalConeTest:	New setting for normal cone testing usage.

Returned Value:

int: Old setting for normal cone testing usage.

See Also:

MvarMVsZeros MvarMVsZerosDomainReduction MvarMVsZerosGradPreconditioning

Keywords:

MvarMVsZerosNormalizeConstraints

(zrsolver.c:3089)

Prototype:

int MvarMVsZerosNormalizeConstraints(int NormalizeConstraints)

Description:

Controls the option of normalizing the constraints on every recursive call. Might be useful for constraints that are very steep on one side and shallow in another.

Parameters:

NormalizeConstraints:	New setting for the constraints normalization.

Returned Value:

int: Old setting of the constraints normalization.

See Also:

MvarZeroSolverInseparableProblem MvarMVsZerosCrtPts

Keywords:

MvarMVsZerosParallelHyperPlaneTest

(zrmvaux0.c:148)

Prototype:

int MvarMVsZerosParallelHyperPlaneTest(int ParallelHPlaneTest)

Description:

Sets the use (or not) of the parallel plane termination criteria in multivariate subdivisions' zero set solver.

Parameters:

ParallelHPlaneTest:	New setting for the domain reduction option.

Returned Value:

int: Old setting for normal cone testing usage.

See Also:

MvarMVsZeros MvarMVsZerosNormalConeTest MvarMVsZerosGradPreconditioning MvarMVsZerosDomainReduction

Keywords:

MvarMVsZerosSameSpace

(zrmvaux0.c:178)

Prototype:

CagdBType MvarMVsZerosSameSpace(MvarMVStruct **MVs, int NumOfMVs)

Description:

Make sure all given MVs are in the same function space.

Parameters:

MVs:	Vector of multivariate constraints.
NumOfMVs:	Size of the MVs vector.

Returned Value:

CagdBType: TRUE if in same function space, FALSE otherwise.

See Also:

MvarMVsSameSpace

Keywords:

MvarMVsZerosVerifier

(zrmvaux0.c:935)

Prototype:

void MvarMVsZerosVerifier(MvarMVStruct * const *MVs, int NumOfZeroMVs, MvarPtStruct *Sols, CagdRType NumerEps)

Description:

A verification function to test the correctness of the solutions. For mostly development/debugging purposes.

Parameters:

MVs:	Input constraints.
NumOfZeroMVs:	Number of (zero only) constraints.
Sols:	Linked lists of solutions found.
NumerEps:	Numeric tolerance used in the solution.

Returned Value:

void

See Also:

MvarZeroSolver

Keywords:

MvarMakeCrvsOnSrfsMatchSpeed

(mvardist.c:1744)

Prototype:

int MvarMakeCrvsOnSrfsMatchSpeed(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdCrvStruct **UVCrv1, CagdCrvStruct **UVCrv2)

Description:

Given surfaces Srf1/2 and curves UVCrv1/2 in the domain of the surfaces so that the trace the same shape, recreate UVCrv1 and UVCrv2 so the move along the trace at the same speed, or Srf1(UVCrv1) = Srf2(UVCrv2), and the two curve are in the same function space.

Parameters:

Srf1:	First surface to consider.
Srf2:	Second surface to consider.
UVCrv1:	First curve in the domain of Srf1 to modify, in place.
UVCrv2:	Second curve in the domain of Srf2 to modify, in place.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarProjUVCrvOnE3CrvMatchSpeed TrimMatch2ndCrvLenSpeedAs1stCrv

Keywords:

MvarMakeMVsCompatible

(mvarcmpt.c:40)

Prototype:

CagdBType MvarMakeMVsCompatible(MvarMVStruct **MV1, MvarMVStruct **MV2, CagdBType SameOrders, CagdBType SameKVs)

Description:

Given two multi-variates, makes them compatible by: 1. Coercing their point type to be the same. 2. Making them have the same multi-variate type. 3. Raising the degree of the lower one to be the same as the higher (If SameOrder TRUE). 4. Refining them to a common knot vector (If Bspline and SameOrder TRUE). Note 3 is performed if SameOrder TRUE, 4 if SameKV TRUE. Both multi-variates are modified IN PLACE.

Parameters:

MV1, MV2:	Two surfaces to be made compatible, in place.
SameOrders:	f TRUE, this routine make sure they share the same orders.
SameKVs:	If TRUE, this routine make sure they share the same KVs.

Returned Value:

CagdBType: TRUE if successful, FALSE otherwise.

See Also:

MvarMakeMVsCompatible2 CagdMakeCrvsCompatible CagdMakeSrfsCompatible

Keywords:

compatibility

MvarMakeMVsCompatible2

(mvarcmpt.c:90)

Prototype:

CagdBType MvarMakeMVsCompatible2(MvarMVStruct **MV1, MvarMVStruct **MV2, CagdBType SameOrders, CagdBType SameKVs)

Description:

Given two multi-variates, makes them compatible by: 1. Making them have the same multi-variate type. 2. Raising the degree of the lower one to be the same as the higher (If SameOrder TRUE). 3. Refining them to a common knot vector (If Bspline and SameOrder TRUE). Note 2 is performed if SameOrder TRUE, 3 if SameKV TRUE. Both multi-variates are modified IN PLACE. Note here point type can be different and will stay different.

Parameters:

MV1, MV2:	Two surfaces to be made compatible, in place.
SameOrders:	f TRUE, this routine make sure they share the same orders.
SameKVs:	If TRUE, this routine make sure they share the same KVs.

Returned Value:

CagdBType: TRUE if successful, FALSE otherwise.

See Also:

MvarMakeMVsCompatible CagdMakeCrvsCompatible CagdMakeSrfsCompatible

Keywords:

compatibility

MvarMakeMVsOneDimCompatible

(mvarcmpt.c:234)

Prototype:

CagdBType MvarMakeMVsOneDimCompatible(MvarMVStruct **MV1, MvarMVStruct **MV2, int Dim, CagdBType SameOrders, CagdBType SameKVs)

Description:

Given two multi-variates, makes one of their directions compatible by: 1. Making them have the same multi-variate type (Bezier or B-spline). 2. Raising the degree of the lower one to be the same as the higher in Dim (If SameOrder TRUE). 3. Refining them to a common knot vector in Dim (If Bspline and SameOrder TRUE). Note 2 is performed if SameOrder TRUE, 3 if SameKV TRUE. Both multi-variates are modified IN PLACE. Note here point type can be different and will stay different.

Parameters:

MV1, MV2:	Two surfaces to be made compatible, in place.
Dim:	The dimension in which MV1 and MV2 are to be made compatible.
SameOrders:	f TRUE, this routine make sure they share the same orders.
SameKVs:	If TRUE, this routine make sure they share the same KVs.

Returned Value:

CagdBType: TRUE if successful, FALSE otherwise.

See Also:

MvarMakeMVsCompatible CagdMakeCrvsCompatible CagdMakeSrfsCompatible

Keywords:

compatibility

MvarMakeUniquePointsList

(mvarjimp.c:241)

Prototype:

void MvarMakeUniquePointsList(MvarPtStruct **PtList, CagdRType Tol)

Description:

Removes duplicated points in a given multivariate points list, in place.

Parameters:

PtList:	nput point list to make unique in place.
Tol:	Equality tolerance on the different coefficient of the points.

Returned Value:

void

Keywords:

unique

MvarMatchPointListIntoPolylines

(mvar_pll.c:470)

Prototype:

MvarPolylineStruct *MvarMatchPointListIntoPolylines(const MvarPtStruct *PtsList, IrtRType MaxTol)

Description:

Connect the list of multivariate points into multivariate polylines by connecting the closest multivariate point pairs, until the distances between adjacent multivariate points/polylines is more than MaxTol.

Parameters:

PtsList:	Point list to connect into multivariate polylines.
MaxTol:	Maximum distance allowed to connect multivariate points.

Returned Value:

MvarPolylineStruct *: Connected multivariate polylines, upto MaxTol tolerance.

See Also:

GMMatchPointListIntoPolylines2

Keywords:

MvarMdlTrimSrfListPreciseBBox

(mvarbbox.c:1132)

Prototype:

void MvarMdlTrimSrfListPreciseBBox(const MdlTrimSrfStruct *TSrfs, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a list of mdl trimmed surfaces.

Parameters:

TSrfs:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MdlSrfListPreciseBBox MdlTrimSrfPreciseBBox CagdSrfListBBox MdlSrfPreciseBBox

Keywords:

bbox bounding box

MvarMdlTrimSrfPreciseBBox

(mvarbbox.c:1074)

Prototype:

void MvarMdlTrimSrfPreciseBBox(const MdlTrimSrfStruct *TSrf, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a model trimmed surface.

Parameters:

TSrf:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarSrfPreciseBBox MvarTrimSrfPreciseBBox MVarMdlrimSrfListPreciseBBox MdlMVPreciseBBox CagdSrfBBox

Keywords:

bbox bounding box

MvarMergeBBox

(mvarbbox.c:273)

Prototype:

void MvarMergeBBox(MvarBBoxStruct *DestBBox, const MvarBBoxStruct *SrcBBox)

Description:

Merges (union) two bounding boxes into one, in place.

Parameters:

DestBBox:	One BBox operand as well as the result.
SrcBBox:	Second BBox operand.

Returned Value:

void

Keywords:

bbox bounding box

MvarMergeMVList

(mvar_aux.c:2196)

Prototype:

MvarMVStruct *MvarMergeMVList(MvarMVStruct *MVList, int Dir, IrtRType Tolerance, int InterpDiscont)

Description:

Merges a list of multivariates by connecting shared boundaries that are (almost) the same, in place. Uses the generic merging package in geom_lib.

Parameters:

MVList:	To connect into larger multivariates. Expected to be open ended. Merge is performed in-place - MVList is freed.
Dir:	Axis direction to merge. First axis is 0.
Tolerance:	To consider two shared boundaries the same.
InterpDiscont:	f TRUE, linearly interpolate discontinuity.

Returned Value:

MvarMVStruct *: The merged multivariates, or NULL if error.

See Also:

CagdMergeMVList CagdMergeMVList3 GMMergeSameGeometry

Keywords:

merge

MvarMergeMVMV

(mvar_aux.c:1578)

Prototype:

MvarMVStruct *MvarMergeMVMV(const MvarMVStruct *MV1, const MvarMVStruct *MV2, MvarMVDirType Dir, CagdBType Discont)

Description:

Merges two multivariates in the requested direction Dir. It is assumed that last Sub-MV of MV1 is identical to first Sub-MV of MV2 in Dir. It is assumed that both MVs have open end conditions and share the same orders and knot sequences in all axes, but the merged axes which can have different knots.

Parameters:

MV1:	To connect to CMV2's starting boundary at its end.
MV2:	To connect to CMV1's end boundary at its start.
Dir:	Direction the merge should take place.
Discont:	If TRUE, assumes the merged "edge" is discontinuous.

Returned Value:

MvarMVStruct *: The merged multivariate.

See Also:

CagdMergeSrfSrf

Keywords:

merge multivariate

MvarMergeMVMV2

(mvar_aux.c:1918)

Prototype:

MvarMVStruct *MvarMergeMVMV2(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, MvarMVDirType Dir, CagdBType Discont)

Description:

Merges two multivariates in the requested direction Dir. It is assumed that first/last Sub-MV of MV1 is identical to first/last Sub-MV of MV2, in Dir, up to all possible reflections on other directions. It is assumed that both MVs have open end conditions and share the same orders and knot sequences in all axes, but the merged axes which can have different knots.

Parameters:

CMV1:	To connect to CMV2's starting boundary at its end.
CMV2:	To connect to CMV1's end boundary at its start.
Dir:	Direction the merge should take place.
Discont:	If TRUE, assumes the merged "edge" is discontinuous.

Returned Value:

MvarMVStruct *: The merged multivariate, or NULL if failed.

See Also:

CagdMergeSrfSrf MvarMergeMVMV MvarAre2MVsPossiblySharingBndry MvarAre2MVsSharingBndry

Keywords:

merge multivariate

MvarMergeTVList

(mvtrivar.c:896)

Prototype:

TrivTVStruct *MvarMergeTVList(const TrivTVStruct *TVList, int Dir, IrtRType Tolerance, int InterpDiscont)

Description:

Merges a list of trivariates by connecting shared boundaries that are (almost) the same, in place. Uses the generic merging package in geom_lib.

Parameters:

TVList:	To connect into larger trivariates. Expected to be open ended.
Dir:	Axis direction to merge. First axis is 0.
Tolerance:	To consider two shared boundaries the same.
InterpDiscont:	f TRUE, linearly interpolate discontinuity.

Returned Value:

TrivTVStruct *: The merged trivariates, or NULL if error.

See Also:

CagdMergeMVList MvarMergeMVList GMMergeSameGeometry TrivMergeTVTV

Keywords:

merge

MvarMergeTwoPointTypes

(mvarcoer.c:153)

Prototype:

MvarPointType MvarMergeTwoPointTypes(MvarPointType PType1, MvarPointType PType2)

Description:

Returns a point type which spans the spaces of both two given point types.

Parameters:

PType1, PType2:	o point types to find the point type of their union.

Returned Value:

MvarPointType: A point type of the union of the spaces of PType1 and PType2.

Keywords:

coercion

MvarMeshIndicesFromIndex

(mvar_aux.c:1205)

Prototype:

int MvarMeshIndicesFromIndex(int Index, const MvarMVStruct *MV, int *Indices)

Description:

Given a linear Index into the vector of control points, compute the indices of the multivariates in all dimensions.

Parameters:

Index:	To decompose into the different axes of the multivariate.
MV:	Whose indices are for.
Indices:	To compute the exact point location in MV -> Points

Returned Value:

int: TRUE if Index in range, false otherwise.

See Also:

MvarGetPointsMeshIndices

Keywords:

MvarMinSpanCirc

(ms_circ.c:565)

Prototype:

int MvarMinSpanCirc(IPObjectStruct *Objs, CagdRType *Center, CagdRType *Radius, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Minimum spanning circle (MSC) computation of given Objs geometry. Geometry could be freeform C^1 curves.

Parameters:

Objs:	The geometry to compute the MSC for as a list object.
Center:	Of computed MSC.
Radius:	Of computed MSC.
SubdivTol, NumerTol:	Of computation.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarMSCircOfThreeCurves MvarMSCircOfThreeCurves MvarMinSpanCirc MVarMSCircCurveInCirc GMMinSpanCirc

Keywords:

minimum spanning circle

MvarMinSpanCone

(mvcones.c:325)

Prototype:

int MvarMinSpanCone(MvarVecStruct *MVVecs, int VecsNormalized, int NumOfVecs, MvarNormalConeStruct *MVCone)

Description:

Minimum spanning cone (MSC) computation of a set of vectors. Algorithm is based on the Minimum Spanning Circle in Section 4.7 of "Computational Geometry, Algorithms and Applications" by M. de Berg et. al.

Parameters:

MVVecs:	The set of vectors to compute their MSC.
VecsNormalized:	TRUE if vectors are normalized, FALSE otherwise.
NumOfVecs:	Number of vectors in set MVVecs.
MVCone:	Returns cone axis and cone cos angle of computed MSC.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

GMMinSpanCone

Keywords:

MvarMinSpanConeAvg

(mvcones.c:254)

Prototype:

int MvarMinSpanConeAvg(MvarVecStruct *MVVecs, int VecsNormalized, int NumOfVecs, MvarNormalConeStruct *MVCone)

Description:

Minimum spanning cone (MSC) computation of a set of vectors. Find a central vector as the average of all given vectors and find the vector with maximal angular distance from it.

Parameters:

MVVecs:	The set of vectors to compute their MSC.
VecsNormalized:	TRUE if vectors are normalized, FALSE otherwise.
NumOfVecs:	Number of vectors in set MVVecs.
MVCone:	Returns cone axis and cone cos angle of computed MSC.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

GMMinSpanConeAvg

Keywords:

MvarNormalConeCopy

(mvcones.c:125)

Prototype:

MvarNormalConeStruct *MvarNormalConeCopy(const MvarNormalConeStruct *NormalCone)

Description:

Copy a multivariate normal cone structure.

Parameters:

NormalCone:	Normal cone to copy.

Returned Value:

MvarNormalConeStruct *: Copied normal cone.

See Also:

MvarNormalConeNew MvarNormalConeCopyList MvarNormalConeFree

Keywords:

MvarNormalConeCopyList

(mvcones.c:161)

Prototype:

MvarNormalConeStruct *MvarNormalConeCopyList(const MvarNormalConeStruct *NormalCones)

Description:

Copy a list of multivariate normal cones' structures.

Parameters:

NormalCones:	List of multivariate normal cones to duplicate.

Returned Value:

MvarNormalConeStruct *: Duplicated list of multivariate normal cones.

See Also:

MvarNormalConeNew MvarNormalConeCopy MvarNormalConeFree

Keywords:

multi-variates

MvarNormalConeFree

(mvcones.c:193)

Prototype:

void MvarNormalConeFree(MvarNormalConeStruct *NormalCone)

Description:

Free a multivariate normal cone structure.

Parameters:

NormalCone:	Normal cone to free.

Returned Value:

void

See Also:

MvarNormalConeNew MvarNormalConeFreeList MvarNormalConeCopy

Keywords:

MvarNormalConeFreeList

(mvcones.c:219)

Prototype:

void MvarNormalConeFreeList(MvarNormalConeStruct *NormalConeList)

Description:

Deallocates and frees a list of multi-variate cone structures.

Parameters:

NormalConeList:	Multi-Variate cone list to free.

Returned Value:

void

See Also:

MvarNormalConeFree MvarNormalConeNew

Keywords:

MvarNormalConeNew

(mvcones.c:93)

Prototype:

MvarNormalConeStruct *MvarNormalConeNew(int Dim)

Description:

Constructs a multivariate normal cone structure.

Parameters:

Dim:	Dimension of the cone.

Returned Value:

MvarNormalConeStruct *: Constructed cone.

See Also:

MvarNormalConeFree MvarNormalConeFreeList MvarNormalConeCopy

Keywords:

MvarNumericImporveSharedPoints

(mvardist.c:1589)

Prototype:

int MvarNumericImporveSharedPoints(const CagdSrfStruct *Srf1, void *DistSrfPointPreps1, CagdRType *UV1, const CagdSrfStruct *Srf2, void *DistSrfPointPreps2, CagdRType *UV2)

Description:

Numerically improve UV1 and UV2, in Srf1 and Srf2 domains, respectively, so that Srf1(UV1) = Srf2(UV2).

Parameters:

Srf1:	Surface holding UV1 in its domain.
DistSrfPointPreps1:	oint projection on Srf1 prep struct.
UV1:	First surface location (on Srf1).
Srf2:	Surface holding UV2 in its domain.
DistSrfPointPreps2:	oint projection on Srf1 prep struct.
UV2:	Second surface location (on Srf2).

Returned Value:

int: TRUE if improved, FALSE otherwise.

See Also:

Keywords:

MvarParamInDomain

(mvar_aux.c:472)

Prototype:

CagdBType MvarParamInDomain(const MvarMVStruct *MV, CagdRType t, MvarMVDirType Dir)

Description:

Given a multi-variate and a domain - validate it.

Parameters:

MV:	To make sure t is in its Dir domain.
t:	Parameter value to verify.
Dir:	Direction. Either U or V or W.

Returned Value:

CagdBType: TRUE if in domain, FALSE otherwise.

See Also:

varMVSetDomain MvarMVSetAllDomains MvarParamInDomain

Keywords:

multi-variates

MvarParamsInDomain

(mvar_aux.c:500)

Prototype:

CagdBType MvarParamsInDomain(const MvarMVStruct *MV, const CagdRType *Params)

Description:

Given a multi-variate and a domain - validate it.

Parameters:

MV:	To make sure (u, v, w) is in its domain.
Params:	Array of real valued parameters of size Dim to verify if this point is in MV's parametric domain.

Returned Value:

CagdBType: TRUE if in domain, FALSE otherwise.

See Also:

varMVSetDomain MvarMVSetAllDomains MvarParamsInDomain varMVIntersPtOnBndry

Keywords:

multi-variates

MvarPiecewiseDvlpAlgApproxLineAnalyze

(pdvl_alg.c:108)

Prototype:

CagdSrfStruct *MvarPiecewiseDvlpAlgApproxLineAnalyze( const CagdSrfStruct *Srf, CagdRType Tolerance, CagdCrvStruct **StripBoundriesUV, int CrvSizeReduction, CagdRType SubdivTol, CagdRType NumericTol, CagdRType SrfExtent, int DvlpSteps)

Description:

Computes piecewise developable strips to Srf, within Tolerance. That is, every location on Srf is within tolerance to at least one developable surface position. Computation is performed starting from the VMin boundary of Srf.

Parameters:

Srf:	To compute piecewise developable approximation for.
Tolerance:	Maximal allowed distance from Srf to developables.
StripBoundriesUV:	f points to a curve, used as first curve to develop from. This curve is considered a UV curve in Srf. Otherwise, will be initialized with VMin curve. Will be updated with the list of UV curves in the parametric domain of Srf that delineates the boundaries of the developable strips.
CrvSizeReduction:	reduction in size of traced curve while ensuring the Tolerance, conservatively.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
SrfExtent:	Amount to extend the surface so the developable sheet will span it all. Zero to ignore.
DvlpSteps:	Number of double-strip constructions to perform from the VMin boundary.

Returned Value:

CagdSrfStruct *: List of piecewise developables approximation of Srf to within Tolerance.

See Also:

MvarPiecewiseDvlpAlgApproxBuildDvlpSrfs SymbSrfDevelopableCrvOnSrf MvarPiecewiseRuledAlgApproxBuildRuledSrfs MvarPiecewiseRuledAlgApproxLineAnalyze

Keywords:

MvarPiecewiseRuledAlgApproxBuildRuledSrfs

(prld_alg.c:862)

Prototype:

IPObjectStruct *MvarPiecewiseRuledAlgApproxBuildRuledSrfs( const IPObjectStruct *Srf, const IPObjectStruct *UVRld)

Description:

Build ruled surfaces from the extracted UV curves.

Parameters:

Srf:	Input surfaces. Can be either a regular or a trimmed surface.
UVRld:	The computed ruled surfaces approximation for Srf, as UV curves.

Returned Value:

IPObjectStruct *: A list of ruled surface depicting the result. If input Srf is trimmed, will be a set of trimmed surfaces as well.

See Also:

MvarPiecewiseRuledAlgApproxLineAnalyze MvarPiecewiseDvlpAlgApproxLineAnalyze MvarPiecewiseDvlpAlgApproxBuildDvlpSrfs

Keywords:

MvarPiecewiseRuledAlgApproxLineAnalyze

(prld_alg.c:97)

Prototype:

CagdCrvStruct *MvarPiecewiseRuledAlgApproxLineAnalyze( const CagdSrfStruct *Srf, CagdRType Tolerance, CagdCrvStruct **StripBoundriesUV, int CrvSizeReduction, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes piecewise ruled strips to Srf that can, for example be used for gouging-free flanked milling, within Tolerance. That is, every location on Srf is within tolerance to at least one ruled surface position. Note we assume the tool radius is zero for flanked milling application, as surface can be offset by tool radius, reducing tool to a line. Also computation is performed from VMin boundary of Srf.

Parameters:

Srf:	To compute piecewise ruling approximation for.
Tolerance:	Maximal allowed distance between Srf and rulings.
StripBoundriesUV:	ist of UV curves in the parametric domain of Srf that delineates the boundaries of the strips.
CrvSizeReduction:	reduction in size of traced curve while ensuring the Tolerance conservatively.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Returned Value:

CagdCrvStruct *: List of UV curves in the parametric domain of Srf that define the piecewise ruling approximation of Srf to within Tolerance.

See Also:

MvarPiecewiseRuledAlgApproxBuildRuledSrfs MvarPiecewiseDvlpAlgApproxLineAnalyze MvarPiecewiseDvlpAlgApproxBuildDvlpSrfs

Keywords:

MvarPlaneCopy

(mvar_gen.c:1284)

Prototype:

MvarPlaneStruct *MvarPlaneCopy(const MvarPlaneStruct *Pln)

Description:

Allocates and duplicates all slots of a multi-variate plane structure.

Parameters:

Pln:	Multi-Variate plane to duplicate.

Returned Value:

MvarPlaneStruct *: Duplicated multi-variate plane.

Keywords:

MvarPlaneCopyList

(mvar_gen.c:1310)

Prototype:

MvarPlaneStruct *MvarPlaneCopyList(const MvarPlaneStruct *PlnList)

Description:

Duplicates a list of multi-variate structures.

Parameters:

PlnList:	List of multi-variates to duplicate.

Returned Value:

MvarPlaneStruct *: Duplicated list of multi-variates.

Keywords:

multi-variates

MvarPlaneFree

(mvar_gen.c:1342)

Prototype:

void MvarPlaneFree(MvarPlaneStruct *Pln)

Description:

Deallocates and frees all slots of a multi-variate plane structure.

Parameters:

Pln:	Multivariate plane to free.

Returned Value:

void

See Also:

MvarPlaneNew

Keywords:

MvarPlaneFreeList

(mvar_gen.c:1366)

Prototype:

void MvarPlaneFreeList(MvarPlaneStruct *PlnList)

Description:

Deallocates and frees a list of multi-variate plane structures.

Parameters:

PlnList:	Multi-Variate plane list to free.

Returned Value:

void

Keywords:

MvarPlaneNew

(mvar_gen.c:1250)

Prototype:

MvarPlaneStruct *MvarPlaneNew(int Dim)

Description:

Allocates the memory required for a new multi-variate plane.

Parameters:

Dim:	Number of dimensions of this multi-variate.

Returned Value:

MvarPlaneStruct *: An uninitialized freeform multi-variate plane.

See Also:

MvarPlaneFree

Keywords:

MvarPlaneNormalize

(mvar_vec.c:668)

Prototype:

int MvarPlaneNormalize(MvarPlaneStruct *Pln)

Description:

Normalize a given multivariate plane's normal direction to a unit length, in place.

Parameters:

Pln:	Plane to normalize its normal direction.

Returned Value:

int: TRUE if successful, FALSE if the input is the ZERO vector.

See Also:

MvarVecNormalize

Keywords:

MvarPointFromPointLine

(mvar_int.c:198)

Prototype:

void MvarPointFromPointLine(const MvarVecStruct *Point, const MvarVecStruct *Pl, const MvarVecStruct *Vl, MvarVecStruct *ClosestPoint)

Description:

Routine to compute the closest point on a line to point, in R^n. The line is prescribed using a point on it (Pl) and a unit vector (Vl).

Parameters:

Point:	To find the closest to on the line.
Pl, Vl:	Position and direction that defines the line. Vl is assumed a unit length vector.
ClosestPoint:	Where closest point found on the line is to be saved.

Returned Value:

void

See Also:

GMPointFromPointLine

Keywords:

point line distance

MvarPolyMergePolylines

(mvar_pll.c:220)

Prototype:

MvarPolylineStruct *MvarPolyMergePolylines(MvarPolylineStruct *Polys, IrtRType Eps)

Description:

Merges separated multivariate polylines into longer ones, in place, as possible. Given a list of multivariate polylines, matches end points and merged as possible multivariate polylines with common end points, in place.

Parameters:

Polys:	Multivariate polylines to merge, in place.
Eps:	Epsilon of similarity to merge multivariate polylines at.

Returned Value:

MvarPolylineStruct *: Merged as possible multivariate polylines.

See Also:

GMMergePolylines

Keywords:

merge polyline

MvarPolyReverseList

(mvar_gen.c:741)

Prototype:

MvarPtStruct *MvarPolyReverseList(MvarPtStruct *Pts)

Description:

Reverses a list of multivariate points, in place.

Parameters:

Pts:	Multi-Variate point list to reverse.

Returned Value:

MvarPtStruct *: Reversed list of Multi-Variate points, in place.

Keywords:

reverse

MvarPolylineCopy

(mvar_gen.c:801)

Prototype:

MvarPolylineStruct *MvarPolylineCopy(const MvarPolylineStruct *Poly)

Description:

Allocates and duplicates all slots of a multi-variate polyline structure.

Parameters:

Poly:	Multi-Variate polyline to duplicate.

Returned Value:

MvarPolylineStruct *: Duplicated multi-variate polyline.

Keywords:

MvarPolylineCopyList

(mvar_gen.c:824)

Prototype:

MvarPolylineStruct *MvarPolylineCopyList(MvarPolylineStruct *PolyList)

Description:

Duplicates a list of multi-variate polyline structures.

Parameters:

PolyList:	List of multi-variate polylines to duplicate.

Returned Value:

MvarPolylineStruct *: Duplicated list of multi-variate polylines.

Keywords:

multi-variates

MvarPolylineFree

(mvar_gen.c:931)

Prototype:

void MvarPolylineFree(MvarPolylineStruct *Poly)

Description:

Deallocates and frees all slots of a multi-variate polyline structure.

Parameters:

Poly:	Multivariate polyline to free.

Returned Value:

void

See Also:

MvarPolylineNew

Keywords:

MvarPolylineFreeList

(mvar_gen.c:951)

Prototype:

void MvarPolylineFreeList(MvarPolylineStruct *PolyList)

Description:

Deallocates and frees a list of multi-variate polyline structures.

Parameters:

PolyList:	Multi-Variate polyline list to free.

Returned Value:

void

Keywords:

MvarPolylineNew

(mvar_gen.c:775)

Prototype:

MvarPolylineStruct *MvarPolylineNew(MvarPtStruct *Pl)

Description:

Allocates the memory required for a new multi-variate polyline.

Parameters:

Pl:	List of points forming the polyline.

Returned Value:

MvarPolylineStruct *: A new multi-variate polyline.

See Also:

MvarPolylineFree

Keywords:

MvarProjCrvOnSrf

(mvardist.c:1429)

Prototype:

CagdCrvStruct *MvarProjCrvOnSrf(const CagdCrvStruct *Crv, const CagdSrfStruct *Srf, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol, void *SrfPrepHandle, CagdBType GenUVCrv)

Description:

Checks if given curve is precisely contained in the given surface. returns a UV curve in Srf that represent it if indeed on Srf. Computation is done by sampling points on the curve and projecting these points on the surface.

Parameters:

Crv:	E3 Curve to check if precisely contained inside Srf.
Srf:	Surface to check if Crv is precisely contained in it.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	he numerical tolerance to use.
SrfPrepHandle:	Hold pre-processed data by MvarInverseCrvOnSrfProjPrep to speed up the crv on srf projections. See MvarInverseCrvOnSrfProjPrep/MvarInverseCrvOnSrfProjFree. Optional and can be NULL.
GenUVCrv:	If TRUE, a UV curve on the surface is generated and returned, if precisely on Srf. If FALSE, and precisely on Srf, Crv is returned.

Returned Value:

CagdCrvStruct *: The (UV) curve representation of Crv that is found to be precisely on Srf or NULL otherwise.

See Also:

MvarMVDistCrvSrf SymbSrfDistCrvCrv SymbSrfDistFindPoints MvarMVDistSrfSrf MvarMVDistCrvSrf MvarProjCrvOnSrf1 MvarProjCrvOnSrf2 MvarSrfSrfInter MvarInverseCrvOnSrfProj

Keywords:

MvarProjCrvOnSrf1

(mvardist.c:1285)

Prototype:

MvarPolylineStruct *MvarProjCrvOnSrf1(const CagdCrvStruct *Crv1, const CagdSrfStruct *Srf2, int Axes, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Checks if given curve is precisely (partially) contained in the given surface and returns the portion that is indeed on Srf, if any. Computation is done by computing the distance field as a trivariate and finding the zeros of two out of three components of this distance field.

Parameters:

Crv1, Srf2:	he two entities, Crv1(t) and Srf2(u, v), to find their common domains.
Axes:	One of 12, 13, 23 for XY, XZ, YZ solution.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	he numerical tolerance to use.

Returned Value:

MvarPolylineStruct *: Location where distance function square d2(t, u, v) of Crv1(t) and Srf2(u, v) is zero, as (t, u, v) tuples.

See Also:

MvarMVDistCrvSrf SymbSrfDistCrvCrv SymbSrfDistFindPoints MvarMVDistSrfSrf MvarMVDistCrvSrf MvarProjCrvOnSrf MvarProjCrvOnSrf2 MvarCrvSrfInter MvarSrfSrfInter

Keywords:

curve surface distance

MvarProjCrvOnSrf2

(mvardist.c:1364)

Prototype:

MvarPolylineStruct *MvarProjCrvOnSrf2(const CagdCrvStruct *Crv1, const CagdSrfStruct *Srf2, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Checks if given curve is precisely (partially) contained in the given surface and returns the portion that is indeed on Srf, if any. Computation is done by computing the distance field as a trivariate and finding the zeros of the derivatives of this distance field with respect to the two surface parameters.

Parameters:

Crv1, Srf2:	he two entities, Crv1(t) and Srf2(u, v), to find their common domains.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	he numerical tolerance to use.

Returned Value:

MvarPolylineStruct *: Location where distance function square d2(t, u, v) of Crv1(t) and Srf2(u, v) is zero, as (t, u, v) tuples.

See Also:

MvarMVDistCrvSrf SymbSrfDistCrvCrv SymbSrfDistFindPoints MvarMVDistSrfSrf MvarMVDistCrvSrf MvarProjCrvOnSrf MvarProjCrvOnSrf1 MvarCrvSrfInter MvarSrfSrfInter

Keywords:

curve surface distance

MvarProjUVCrvOnE3CrvMatchSpeed

(mvardist.c:1660)

Prototype:

CagdCrvStruct *MvarProjUVCrvOnE3CrvMatchSpeed(const CagdCrvStruct *UVLinCrv1, const CagdSrfStruct *Srf1, const CagdCrvStruct *UVCrv2, const CagdSrfStruct *Srf2)

Description:

Projects all vertices of Srf1(UVLinCrv1) (UVLinCrv1 is in the UV space of Srf1) onto EucCrv2 = Sf2(UCrv2) and reconstruct another linear curve of same length as UVLinCrv1 for Srf2 that matches positions and speeds. That is, Srf2(NewUVLinCrv2) = Srf1(UVLinCrv1). The new returned curve is forced to interpolate end points of UVCrv2.

Parameters:

UVLinCrv1:	The linear curve in the UV domain of Srf1.
Srf1:	Surface holding UVLinCrv1 in its domain.
UVCrv2:	The UV curve in the UV domain of Srf2.
Srf2:	Surface holding UVCrv2 in its domain.

Returned Value:

CagdCrvStruct *: Reconstructed matching linear UVCrv2 for Srf2.

See Also:

TrimMatch2ndCrvLenSpeedAs1stCrv

Keywords:

MvarPromoteMVToMV

(mvar_rev.c:363)

Prototype:

MvarMVStruct *MvarPromoteMVToMV(const MvarMVStruct *MV, int Axis)

Description:

Increase by one the dimensionality of the given multivariate, by introducing a new constant (degree zero) axis with one control point in direction Axis.

Parameters:

MV:	Multi-Variate to promote.
Axis:	Axis of promotion. Between zero and MV -> Dim.

Returned Value:

MvarMVStruct *: Promoted multi-variate.

See Also:

MvarMVShiftAxes MvarMVFromMV MvarPromoteMVToMV2

Keywords:

multi-variates

MvarPromoteMVToMV2

(mvar_rev.c:407)

Prototype:

MvarMVStruct *MvarPromoteMVToMV2(const MvarMVStruct *MV, int NewDim, int StartAxis)

Description:

Increase by the dimensionality of the given multivariate to NewDim, by introducing new constant (degree zero) axes with one control points in all new directions. The Axis of the original MV will be starting at StartAxis.

Parameters:

MV:	Multi-Variate to promote.
NewDim:	New dimension of the promoted multivariate.
StartAxis:	riginal MV would span axes StartAxis to StartAxis+MV->Dim-1.

Returned Value:

MvarMVStruct *: Promoted multi-variate.

See Also:

MvarMVShiftAxes MvarMVFromMV MvarPromoteMVToMV

Keywords:

multi-variates

MvarPtCmpTwoPoints

(mvar_pll.c:302)

Prototype:

int MvarPtCmpTwoPoints(const MvarPtStruct *P1, const MvarPtStruct *P2, CagdRType Eps)

Description:

A comparison function to examine if the given two points are the same.

Parameters:

P1, P2:	Two multivariate points to compare.
Eps:	The tolerance of the comparison.

Returned Value:

int: 0 if identical, -1 or +1 if first point is less than/greater than second point, in lexicographic order over dimensions. 2 is returned if the dimensions are different.

See Also:

MvarPtDistTwoPoints MvarPtDistSqrTwoPoints MvarVecCmpTwoVectors

Keywords:

MvarPtCopy

(mvar_gen.c:636)

Prototype:

MvarPtStruct *MvarPtCopy(const MvarPtStruct *Pt)

Description:

Allocates and duplicates all slots of a multi-variate point structure.

Parameters:

Pt:	Multi-Variate point to duplicate.

Returned Value:

MvarPtStruct *: Duplicated multi-variate point.

Keywords:

MvarPtCopyList

(mvar_gen.c:661)

Prototype:

MvarPtStruct *MvarPtCopyList(const MvarPtStruct *PtList)

Description:

Duplicates a list of multi-variate point structures.

Parameters:

PtList:	List of multi-variate points to duplicate.

Returned Value:

MvarPtStruct *: Duplicated list of multi-variate points.

Keywords:

multi-variates

MvarPtDistSqrTwoPoints

(mvar_pll.c:432)

Prototype:

CagdRType MvarPtDistSqrTwoPoints(const MvarPtStruct *P1, const MvarPtStruct *P2)

Description:

Compute the Eucildean distance between two multivariate points.

Parameters:

P1, P2:	Two points to compute the distance between.

Returned Value:

CagdRType: Distance computed.

See Also:

MvarPtCmpTwoPoints MvarPtDistTwoPoints

Keywords:

MvarPtDistTwoPoints

(mvar_pll.c:372)

Prototype:

CagdRType MvarPtDistTwoPoints(const MvarPtStruct *P1, const MvarPtStruct *P2)

Description:

Compute the Euclidean distance between two multivariate points.

Parameters:

P1, P2:	Two points to compute the distance between.

Returned Value:

CagdRType: Distance computed.

See Also:

MvarPtCmpTwoPoints MvarPtDistSqrTwoPoints

Keywords:

MvarPtFree

(mvar_gen.c:693)

Prototype:

void MvarPtFree(MvarPtStruct *Pt)

Description:

Deallocates and frees all slots of a multi-variate point structure.

Parameters:

Pt:	Multivariate point to free.

Returned Value:

void

See Also:

MvarPtNew

Keywords:

MvarPtFreeList

(mvar_gen.c:717)

Prototype:

void MvarPtFreeList(MvarPtStruct *PtList)

Description:

Deallocates and frees a list of multi-variate point structures.

Parameters:

PtList:	Multi-Variate point list to free.

Returned Value:

void

Keywords:

MvarPtInBetweenPoint

(mvar_pll.c:397)

Prototype:

MvarPtStruct *MvarPtInBetweenPoint(const MvarPtStruct *Pt1, const MvarPtStruct *Pt2, CagdRType t)

Description:

Computes an in-between point (middle if t = 0.5) of given two points.

Parameters:

Pt1, Pt2:	Multivariate points.
t:	Blending factor, 0 for Pt1, 0.5 for mid pt, 1 for Pt2.

Returned Value:

MvarPtStruct *: The in-between point of Pt1 and Pt2.

See Also:

MvarPtCmpTwoPoints MvarPtDistSqrTwoPoints

Keywords:

MvarPtNew

(mvar_gen.c:550)

Prototype:

MvarPtStruct *MvarPtNew(int Dim)

Description:

Allocates the memory required for a new multi-variate point.

Parameters:

Dim:	Number of dimensions of this multi-variate.

Returned Value:

MvarPtStruct *: An uninitialized multi-variate point.

See Also:

MvarPtFree

Keywords:

MvarPtRealloc

(mvar_gen.c:590)

Prototype:

MvarPtStruct *MvarPtRealloc(MvarPtStruct *Pt, int NewDim)

Description:

Reallocates the memory that is required for a new dimension of a multi-variate point.

Parameters:

Pt:	Multi-Variate point to reallocate. Should not be used after this operation as it might be freed.
NewDim:	Number of new dimensions of this multi-variate.

Returned Value:

MvarPtStruct *: A reallocated point of dimension NewDim.

See Also:

MvarPtNew

Keywords:

MvarPtSortListAxis

(mvar_gen.c:881)

Prototype:

MvarPtStruct *MvarPtSortListAxis(MvarPtStruct *PtList, int Axis)

Description:

Sorts given list of points based on their increasing order in axis Axis. Sorting is done in place.

Parameters:

PtList:	List of points to sort.
Axis:	Axis to sort along: 1,2,3 for X,Y,Z.

Returned Value:

MvarPtStruct *: Sorted list of points, in place.

Keywords:

MvarPwrMVNew

(mvar_gen.c:242)

Prototype:

MvarMVStruct *MvarPwrMVNew(int Dim, const int *Lengths, MvarPointType PType)

Description:

Allocates the memory required for a new power basis multi-variate.

Parameters:

Dim:	Number of dimensions of this multivariate.
Lengths:	Of control mesh in each of the dimensions. Vector of size Dim.
PType:	Type of control points (E2, P3, etc.).

Returned Value:

MvarMVStruct *: An uninitialized freeform multi-variate power basis.

See Also:

MvarMVFree MvarMVNew MvarBspMVNew MvarBzrMVNew

Keywords:

multi-variates allocation

MvarRationalSrfsPoles

(mvarpole.c:35)

Prototype:

MvarPolylineStruct *MvarRationalSrfsPoles(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes the poles of a rational surface, solving for the zeros of the surface's denominator.

Parameters:

Srf:	Rational surface to extract its poles.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.

Returned Value:

MvarPolylineStruct *: The poles, as piecewise linear approximations.

See Also:

CagdPointsHasPoles SymbCrvsSplitPoleParams

Keywords:

MvarRoundChamferCrvAtC1Discont

(mvtangnt.c:1514)

Prototype:

CagdCrvStruct *MvarRoundChamferCrvAtC1Discont(const CagdCrvStruct *Crv, CagdCrvCornerType CornerType, CagdRType Radius)

Description:

Round all C1 discontinuities in the given curve Crv by an arc of radius Radius.

Parameters:

Crv:	The curve to round all its C1 discontinuities.
CornerType:	Corner type desired.
Radius:	The desired radius of rounding.

Returned Value:

CagdCrvStruct *: Rounded curve.

See Also:

MvarCircTanTo2Crvs MvarRoundChamferCrvAtC1DiscontArc

Keywords:

bi-tangent

MvarRoundChamferCrvAtC1DiscontArc

(mvtangnt.c:1419)

Prototype:

CagdCrvStruct *MvarRoundChamferCrvAtC1DiscontArc(CagdCrvStruct **Crv1, CagdCrvStruct **Crv2, CagdCrvCornerType CornerType, CagdRType Radius)

Description:

Build bridging arc in the C^1 discontinuity - i.e an arc or a chamfer. If a bridging arc between the end of Crv1 and the beginning of Crv2 is indeed found, Crv1/2 are also trimmed to the proper location of the arc.

Parameters:

Crv1, Crv2:	The two curves to bridge.
CornerType:	Corner type desired.
Radius:	The desired radius of rounding.

Returned Value:

CagdCrvStruct *: Constructed bridging arc.

See Also:

MvarCircTanTo2Crvs MvarRoundChamferCrvAtC1Discont

Keywords:

bi-tangent

MvarSCvrBiNormals

(mvar_cvr.c:1321)

Prototype:

MvarPtStruct *MvarSCvrBiNormals(const CagdCrvStruct *Crv1, const CagdCrvStruct *Crv2, CagdBType ElimDiagonals, CagdRType RadiusLB, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes binormals to the given curves, i.e., the pair of points on curves C1 and C2 such that the line-segment joining these points is orthogonalto C1 and C2 at those points. This is done by solving the following system of two equations in two unknowns.

      < C1(u) - C2(v), C1'(u) > = 0
      < C1(u) - C2(v), C2'(v) > = 0

Diagonal solutions are eliminated, if requested, by factoring out the (u - v) term from the above multivariates.

Parameters:

Crv1, Crv2:	The input curves to which binormals are to be computed. Can be the same curve for self-bisectors (turn ElimDiagonals on then).
ElimDiagonals:	If TRUE, the diagonal solutions are eliminated.
RadiusLB:	Lower-bound on radius of circles - the diameter between the two intersecting points of the binormal and curves.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: The list of solutions which consists of points of the form (u, v).

See Also:

MvarCircTanTo2Crvs

Keywords:

bi-normal

MvarSCvrCircTanTo2CrvsCntrOnCrv

(mvar_cvr.c:186)

Prototype:

MvarPtStruct *MvarSCvrCircTanTo2CrvsCntrOnCrv(const CagdCrvStruct *Crv, const CagdCrvStruct *CntrOnCrv, CagdRType RadiusLB, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes all circles that are tangent to given curve at two points and whose centers lie on the given third curve. The following system of multivariats is solved. The last positivity constraint is added in order to eliminate the diagonal solutions.

      < Crv(u) - CntrCrv(w), Crv'(u) > = 0,
      < Crv(v) - CntrCrv(w), Crv'(v) > = 0,
      || Crv(u) - CntrCrv(w) || - || Crv(v) - CntrCrv(w) ||   = 0
      u - v - SubdivTol*10 > 0


Parameters:


 Crv:           The curves to find the circles that is tangent to at two
                  points.
 CntrOnCrv:     The curve on which the center of circle should lie.
 RadiusLB:      Lower-bound on radius of circle.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *:    List of (u, v, w) solution points.



See Also:

  MvarSCvrCircTanToCrvEndPtCntrOnCrv
  MvarCircTanTo2Crvs


Keywords:



 MvarSCvrCircTanTo2CrvsEndPtNoDiag 
  (mvar_cvr.c:711)

Prototype:

  MvarPtStruct *MvarSCvrCircTanTo2CrvsEndPtNoDiag(const CagdCrvStruct *Crv1,
                                                  const CagdCrvStruct *Crv2,
                                                  const CagdPType Pt3,
                                                  CagdBType ElimDiagonals,
                                                  CagdRType RadiusLB,
                                                  CagdRType SubdivTol,
                                                  CagdRType NumericTol)


Description:

Computes all circles that are tangent to given two curves and pass through the given point. Solves for circles' Centers P(x, y), using the following process: Solve, symbolically for P in the following 2x2 system by Cremmer rule:

      ||C1(u) - P||^2 = ||C2(v) - P||^2,
      ||C1(u) - P||^2 = ||Pt3   - P||^2,

and substitute P into the following 2 euqations and solve 2 equations in (u, v):

      < C1(u) - P, C1'(u) > = 0,
      < C2(v) - P, C2'(v) > = 0,


Parameters:


 Crv1, Crv2:    The two curves to find the circles that is tangent to
                  both.
                  Can be the same curve for self-bisectors (turn
                  ElimDiagonals on then).
 Pt3:           The point through which circles should pass.
 ElimDiagonals:  liminate diagonal solutions if TRUE.
 RadiusLB:      Lower-bound on radius of circles.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *:    List of (u, v) solution points.



See Also:

  MvarSCvrCircTanTo3CrvsExprTreeNoDiagonal
  MvarCircTanTo2Crvs


Keywords:



 MvarSCvrCircTanTo3CrvsExprTreeNoDiagonal 
  (mvar_cvr.c:351)

Prototype:

  MvarPtStruct *MvarSCvrCircTanTo3CrvsExprTreeNoDiagonal(
                                                       const CagdCrvStruct *Crv,
                                                       CagdRType RadiusLB,
                                                       CagdRType SubdivTol,
                                                       CagdRType NumericTol)


Description:

Computes all circles that are tangent to given curve at three points. Diagonal solutions are eleminated. The computation is done using expression trees. Use this for big problems which otherwise require a lot of memory. Solves for circles' Centers P(x, y), using the following process: Solve, symbolically for P in the following 2x2 system by Crammer rule:

      ||C1(u) - P||^2 = ||C1(v) - P||^2,
      ||C1(u) - P||^2 = ||C1(w) - P||^2,

and substitute P into the following 3 euqations and solve 3 equations in (u, v, w):

      < C1(u) - P, C1'(u) > = 0,
      < C1(v) - P, C1'(v) > = 0,
      < C1(w) - P, C1'(w) > = 0.

Diagonal solutions are eliminated by adding the following two constraints.

      u - v - SubdivTol*10 > 0,
      v - w - SubdivTol*10 > 0.


Parameters:


 Crv:          The curves to find the circles that is tangent to at three
                 points.
 RadiusLB:     Lower-bound on the radius of circles.
 SubdivTol:    Tolerance of the subdivision process.  Tolerance is
                 measured in the parametric space of the multivariates.
 NumericTol:   Numeric tolerance of the numeric stage.  The numeric
                 stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *:    List of (u, v, w) solution points.



See Also:

  MvarSCvrCircTanTo3Crvs
  MvarCircTanTo3Crvs


Keywords:

  tri-tangent


 MvarSCvrCircTanToCrv2EndPt 
  (mvar_cvr.c:1138)

Prototype:

  MvarPtStruct *MvarSCvrCircTanToCrv2EndPt(const CagdCrvStruct *Crv1,
                                           const CagdPType Pt2,
                                           const CagdPType Pt3,
                                           CagdRType RadiusLB,
                                           CagdRType SubdivTol,
                                           CagdRType NumericTol)


Description:

Computes all circles that are tangent to the given curve and pass through the given two points.

Parameters:

Crv1:	The curve to find the circles that is tangent to.
Pt2, Pt3:	The two points through which the circles should pass.
RadiusLB:	Lower-bound on radius of circles.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: List of (u) solution points.

See Also:

MvarCircTanTo2Crvs

Keywords:

MvarSCvrCircTanToCrvEndPt

(mvar_cvr.c:1047)

Prototype:

MvarPtStruct *MvarSCvrCircTanToCrvEndPt(const CagdCrvStruct *Crv1, const CagdPType Pt2, CagdRType RadiusLB, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes all the circles tangent to a given curve and passing throuth the the given point. The line-segment joining the given point and the ponit on the curve passes through the center of the circle. This is done by solving the following univariate.

      < C(u) - Pt2, C'(u) > = 0


Parameters:


 Crv1:           The input curve to which the circles should be tangent.
 Pt2:            The point through which the circles should pass.
 RadiusLB:       Lower-bound on radius of circle.
 SubdivTol:      Tolerance of the subdivision process.  Tolerance is
                   measured in the parametric space of the multivariates.
 NumericTol:     Numeric tolerance of the numeric stage.  The numeric
                   stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *: The list of solutions which consists of points of the
                  form (u).



See Also:

  MvarSCvrCircTanTo2CrvEndpt
  MvarSCvrCircTanToCrvEndPt
  MvarSCvrBinormals


Keywords:



 MvarSCvrCircTanToCrvEndPtCntrOnCrv 
  (mvar_cvr.c:59)

Prototype:

  MvarPtStruct *MvarSCvrCircTanToCrvEndPtCntrOnCrv(
                                                 const CagdCrvStruct *Crv1,
                                                 const CagdPType Pt2,
                                                 const CagdCrvStruct *CntrOnCrv,
                                                 CagdRType RadiusLB,
                                                 CagdRType SubdivTol,
                                                 CagdRType NumericTol)


Description:

Computes all circles that are tangent to a given curve, are passing through a given point and whose centers lie on another curve. The following system of multivariates is solved.

      < Crv1(u) - CntrCrv(v), Crv1'(u) > = 0,
      || Crv1(u) - CntrCrv(v) || = || Pt - CntrCrv(v) ||


Parameters:


 Crv1:          The curve to find the circles that is tangent to.
 Pt2:           The point through which the circle should pass.
 CntrOnCrv:     The curve on which the center of circle should lie.
 RadiusLB:      Lower-bound on radius of circle.
 SubdivTol:     Tolerance of the subdivision process.  Tolerance is
                  measured in the parametric space of the multivariates.
 NumericTol:    Numeric tolerance of the numeric stage.  The numeric
                  stage is employed only if NumericTol < SubdivTol.



Returned Value:


  MvarPtStruct *:    List of (u, v) solution points.



See Also:

  MvarSCvrCircTanTo2CrvsCntrOnCrv


Keywords:



 MvarSCvrPromoteCrvToSrfWithOtherCrv 
  (mvar_cvr.c:1659)

Prototype:

  CagdSrfStruct *MvarSCvrPromoteCrvToSrfWithOtherCrv(
                                                  const CagdCrvStruct *Crv,
                                                  CagdSrfDirType Dir,
                                                  const CagdCrvStruct *OtherCrv)


Description:

Creating a degenerate surface out of the given curve and parametrize the other direction of the surface to follow the parametrization of OtherCrv.

Parameters:

Crv:	Curve to promote to a surfaces.
Dir:	Direction in surface where Crv will be.
OtherCrv:	Curve from which the other direction's parametrization is to be taken from.

Returned Value:

CagdSrfStruct *: Created surfaces or NULL if error.

See Also:

MvarSCvrUMinusVSrf

Keywords:

bilinear

MvarSCvrUMinusVSrf

(mvar_cvr.c:1599)

Prototype:

CagdSrfStruct *MvarSCvrUMinusVSrf(const CagdRType *TMin, const CagdRType *TMax)

Description:

Creates a scalar surface in R^1 which is given by the following map (u, v) |-> (u - v).

Parameters:

TMin:	rray containing the two lower bounds of the domain.
TMax:	rray containing the two upper bounds of the domain.

Returned Value:

CagdSrfStruct *: The surface.

See Also:

MvarSCvrPromoteCrvToSrfWithOtherCrv

Keywords:

bilinear

MvarSetFatalErrorFunc

(mvar_ftl.c:29)

Prototype:

MvarSetErrorFuncType MvarSetFatalErrorFunc(MvarSetErrorFuncType ErrorFunc)

Description:

Sets the error function to be used by Mvar_lib.

Parameters:

ErrorFunc:	New error function to use.

Returned Value:

MvarSetErrorFuncType: Old error function reference.

Keywords:

error handling

MvarSkel2DInter3Prims

(skel2d.c:176)

Prototype:

MvarSkel2DInter3PrimsStruct *MvarSkel2DInter3Prims(MvarSkel2DPrimStruct *Prim1, MvarSkel2DPrimStruct *Prim2, MvarSkel2DPrimStruct *Prim3)

Description:

Computes all points in R2 that are equadistant from the given three primitives. A primitive can be a point, a line, an arc, or a freeform curve. The end points of the line/arc/curve are NOT considered.

Parameters:

Prim1, Prim2, Prim3:	The three input primitives to consider.

Returned Value:

MvarSkel2DInter3PrimsStruct *: A linked list of all equadistant points computed, or NULL if none found.

See Also:

MvarSkel2DSetEpsilon MvarSkel2DSetFineness MvarSkel2DSetOuterExtent

Keywords:

skeleton bisector

MvarSkel2DInter3PrimsFree

(skel2d.c:240)

Prototype:

void MvarSkel2DInter3PrimsFree(MvarSkel2DInter3PrimsStruct *SK2DInt)

Description:

Deallocates and frees all slots of 2d skeleton intersection structure.

Parameters:

SK2DInt:	To be deallocated.

Returned Value:

void

Keywords:

free

MvarSkel2DInter3PrimsFreeList

(skel2d.c:259)

Prototype:

void MvarSkel2DInter3PrimsFreeList(MvarSkel2DInter3PrimsStruct *SK2DIntList)

Description:

Deallocates and frees a 2d skeleton intersection structure list:

Parameters:

SK2DIntList:	To be deallocated.

Returned Value:

void

Keywords:

free

MvarSkel2DSetEpsilon

(skel2d.c:55)

Prototype:

CagdRType MvarSkel2DSetEpsilon(CagdRType NewEps)

Description:

Sets the epsilon of the 2D skeleton computation.

Parameters:

NewEps:	New epsilon to use.

Returned Value:

CagdRType: Old epsilon value.

See Also:

Skel2DInter3Primitives

Keywords:

skeleton bisector

MvarSkel2DSetFineNess

(skel2d.c:112)

Prototype:

CagdRType MvarSkel2DSetFineNess(CagdRType NewFineNess)

Description:

Sets the fineness of the 2D skeleton computation.

Parameters:

NewFineNess:	New fineness to use.

Returned Value:

CagdRType: Old fineness value.

See Also:

Skel2DInter3Primitives

Keywords:

skeleton bisector

MvarSkel2DSetMZeroTols

(skel2d.c:85)

Prototype:

CagdRType MvarSkel2DSetMZeroTols(CagdRType SubdivTol, CagdRType NumerTol)

Description:

Sets the tolerances to be used in this module for the multivariate zero set solver.

Parameters:

SubdivTol, NumerTol:	Subdivision and numeric tolerance of mvar solver.

Returned Value:

CagdRType: Old SubdivTol.

See Also:

MvarMVsZeros MvarSkel2DSetEpsilon MvarSkel2DSetFineNess

Keywords:

MvarSkel2DSetOuterExtent

(skel2d.c:142)

Prototype:

CagdRType MvarSkel2DSetOuterExtent(CagdRType NewOutExtent)

Description:

Sets the outer extent of created (infinite) primitives in the 2D skeleton computation.

Parameters:

NewOutExtent:	New outer extent to use.

Returned Value:

CagdRType: Old outer extent value.

See Also:

Skel2DInter3Primitives

Keywords:

skeleton bisector

MvarSpiralCrvOnSrf

(mvardist.c:2152)

Prototype:

CagdCrvStruct *MvarSpiralCrvOnSrf(const CagdSrfStruct *Srf, CagdSrfDirType Dir, CagdRType Pitch, CagdRType Step, CagdRType SubdivTol, CagdRType NumerTol, int OutputType)

Description:

Construct a spiraling curve (mostly in Dir up to Pitch) on Srf. Srf is assumed to be closed/periodic in Dir.

Parameters:

Srf:	Surface on which to seek a Euclidean spiral curve.
Dir:	The U or V direction of the spirals This Dir min and max should be the same (Srf is closed in Dir).
Pitch:	Euclidean advancement in one spiral round surface.
Step:	Step size during the numeric tracing.
SubdivTol:	The subdivision tolerance to use.
NumerTol:	The numerical tolerance to use.
OutputType:	- curves in UVT space, 1 - curves in Euclidean space, 2 - merged curves in Euclidean space.

Returned Value:

CagdCrvStruct *: Created curve on Srf.

See Also:

MvarEucCrvOffsetOnSrf

Keywords:

MvarSrfAccessibility

(mvaccess.c:47)

Prototype:

MvarPolylineStruct *MvarSrfAccessibility(const CagdSrfStruct *CPosSrf, const CagdSrfStruct *COrientSrf, const CagdSrfStruct *CCheckSrf, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Derives the visibility domain of CPosSrf, when accessed from the direction that is specified by COrientSrf, not gouging into CCheckSrf. The boundary of the domain is prescribed by the following set of three constraints:

      F1(u, v, s, t):   = 0
      F2(u, v, s, t):   = 0
      F3(u, v, s, t):   = 0

where O1(u, v), O2(u, v) are two vector fields orthogonal to O(u, v), the orientation field. K(s, t) is the check surface and Nk(s, t) is its normal field, and S(u, v) is the position surface.

Parameters:

CPosSrf:	The position surface to examine.
COrientSrf:	The orientation field of the access to the position surface. Must be in same function space as CPosSrf. If NULL, the normal field of CPosSrf is employed.
CCheckSrf:	The surface to check gouging against.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumerTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPolylineStruct *: The boundary of the accessible regions of CPosSrf.

Keywords:

MvarSrfAntipodalPoints

(selfintr.c:287)

Prototype:

MvarPtStruct *MvarSrfAntipodalPoints(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes antipodal points in the given surface - pairs of points S(u, v) and S(s, t) such that ((u, v) and (s, t) are two independent params of the same srf):

           < S(u, v) - S(s, t), dS(u, v)/du > = 0,
           < S(u, v) - S(s, t), dS(u, v)/dv > = 0,
           < N(s, t), dS(u, v)/du > = 0,
           < N(s, t), dS(u, v)/dv > = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Srf satisfy these equations when (u, v) == (s, t). The key is in adding a fifth inequality constaint of the form

           < N(u, v), N(s, t) > < 0.

Antipodal points must exists if Srf self intersect in a closed loop and hence can help in detecting sefl-intersections. Further, the diameter of Srf could be easily deduced from the antipodal points. Original version of this function was written by Diana Pekerman, Technion, Israel.

Parameters:

Srf:	To detect its antipodal points.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Antipodal points, as points in E4 (u, v, s, t).

See Also:

MvarCrvAntipodalPoints MvarHFDistAntipodalSrfSrfC1

Keywords:

MvarSrfCalcAsympDirsCones

(ln_access_hyper.c:163)

Prototype:

int MvarSrfCalcAsympDirsCones(const CagdSrfStruct *Srf, SymbNormalConeStruct *DirsCones)

Description:

Computes bounding cones of the asymptotic directions of a surface. Up to two cones can be found.

Parameters:

Srf:	The surface for which to find the bounds of the asymptotic directions.
DirsCones:	Out parameter: the array of bounding cones of the asymptotic directions of the surface. The array must be long enough to contain up to two cones.

Returned Value:

int: The number of asymptotic directions on the surface.

See Also:

MvarSrfCalcAsympDirsVolume MvarSrfCalcAsympDirsCoeffs

Keywords:

asymptotic directions bounding volume

MvarSrfCalcAsympDirsVolume

(ln_access_hyper.c:39)

Prototype:

MvarMVStruct *MvarSrfCalcAsympDirsVolume(const CagdSrfStruct *Srf)

Description:

Computes bounding volumes of the asymptotic directions of a surface, as multivariates. The general form of the multivariates is: a(r) * Su(u,v) + b(r) * Sv(u,v), where Su, Sv, are the partial derivatives of the surface, and a(r), b(r) are the ranges of the coefficients of the asymptotic directions expressed as a function of parameter r. For more information on the computation of a(r), b(r), see: SymbSrfCalcAsympDirsCoeffs.

Parameters:

Srf:	The surface for which to find the bounds of the asymptotic directions.

Returned Value:

MvarMVStruct *: The multivariates which bound the asymptotic directions of the surface. A list of up to two multivariates can be returned.

See Also:

MvarSrfCalcAsympDirsCoeffs

Keywords:

asymptotic directions bounding volume

MvarSrfFindOffsetSelfInter

(self_inter_ofst.c:907)

Prototype:

IPObjectStruct *MvarSrfFindOffsetSelfInter(const CagdSrfStruct *Srf, CagdRType OffsetDist, CagdRType SubdivTol, CagdRType NumericTol, int OutputType)

Description:

Main routine to find the unfiltered global self-intersection curves in offset surface by solving multi-variate constraints equations with inequality constraints. * Example experiment setting used: SubdiviTol = 0.01, NumericTol = 1e-8 Currently StepSize and UVRTInequalityTol (eps used to remove trivial solutions) is 0.2 * SubdivTol and 5.0 * SubdivTol, resepctively.

Parameters:

Srf:	Base surface to be offset.
OffsetDist:	Distance between the offset surface and the base surface.
SubdivTol:	The subdivision tolerance for the solver.
NumericTol:	The numeric tolerance for the solver.
OutputType:	0 - return UVST coordinates of solution curves 1 - return UV coordinates of solution curves 2 - return XYZ coordinates of solution curves

Returned Value:

IPObjectStruct *: A list of unfiltered global self intersection curves of the given offset surface.

Keywords:

MvarSrfFlecnodalCrvs

(mvaccess.c:637)

Prototype:

MvarPolylineStruct *MvarSrfFlecnodalCrvs(const CagdSrfStruct *Srf, CagdRType Step, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the flecnodal curves on surface Srf = S(u, v). Uses the univariate MV solver.

Parameters:

Srf:	To compute the flecnodal curves for.
Step:	Step size in the curve-tracing stage.
SubdivTol:	Accuracy of the subdivision stage of the approximation.
NumerTol:	Accuracy of numeric approx.

Returned Value:

MvarPolylineStruct *: Flecnodal curves as polylines in (a, b, u, v) space.

See Also:

MvarFlecnodalCrvsCreateMVs MvarSrfFlecnodalCrvs

Keywords:

MvarSrfFlecnodalPts

(mvaccess.c:717)

Prototype:

MvarPtStruct *MvarSrfFlecnodalPts(const CagdSrfStruct *CSrf, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the flecnodal points on surface Srf = S(u, v). Denote by Suv the second order derivatives of S(u, v) and by Suvv the third order derivatives. Then, solution of the following 4 equations in 4 unknowns (u, v, a, b) provides the flecnodal points:

            [ L M ] [ a ]
1. [ a  b ] [     ] [   ] =       (This location/direction is asymp.)
            [ M N ] [ b ]         (L, M, N are the coef. of SFF.)

               [ Suu Suv ]           [ a ]
    = [ a  b ] [         ] . n(u, v) [   ] = 0,
               [ Suv Svv ]           [ b ]

   < a^2 Suu + 2ab Suv + b^2 Svv, n(u, v) > = 0.

            (   [ Suuu Suuv ]       [ Svuu Svuv ] )            [ a ]
2. [ a  b ] ( a [           ]  +  b [           ] )  . n(u, v) [   ] = 0,
            (   [ Suuv Suvv ]       [ Svuv Svvv ] )            [ b ]

(A third derivative zero contact.) or

   < a^3 Suuu + 3a^2b Suuv + 3ab^2 Suvv + b^3 Svvv, n(u, v) > = 0.

3. < a^4 Suuuu + 4 a^3b Suuuv + 6 a^2b^2 suuvv + 4ab^3 suvvv + b^4 Svvvv,
                                                          n(u, v) > = 0.

(A fourth derivative zero contact.)

4. a * a + b * b = 1             (A normalization nconstraint.)


Parameters:


 CSrf:       To compute the silhouette higher orders' contact points.
 SubdivTol:  Accuracy of the subdivision stage of the approximation.
 NumerTol:   Accuracy of numeric approx.



Returned Value:


  MvarPtStruct *:   Polylines on the unit sphere, depicting the
               flecnodal's partitioning lines.



See Also:

  SymbSrfGaussCurvature
  UserSrfTopoAspectGraph
  SymbEvalSrfAsympDir
  
  MvarSrfSilhInflections


Keywords:



 MvarSrfHyperbolicLocallyAccessibleDirs 
  (ln_access_hyper.c:227)

Prototype:

  CagdBType MvarSrfHyperbolicLocallyAccessibleDirs(
                                          const CagdSrfStruct *Srf,
                                          const CagdVType SrfVAxis,
                                          SymbNormalConeStruct *AccessibleCones)


Description:

Compute a range of locally-accessible directions of a hyperbolic surface patch. The function computes cones containing all its asymptotic directions. These cones separate the tangent space of the surface patch into ranges of directions with negative normal curvature (accessible) and positive normal curvature (inaccessible). The locally-accessible directions are represented as cones.

Parameters:

Srf:	The surface for which to find the locally accessible directions.
SrfVAxis:	The (approximate) vertical axis of the surface. concave, hyperbolic, or mixed.
AccessibleCones:	Output parameter. Two cones, representing ranges of accessible directions.

Returned Value:

CagdBType: TRUE is accessible direction were found, FALSE otherwise.

See Also:

MvarSrfHyperbolicLocallyAccessibleDirs2

Keywords:

hyperbolic direction line accessibility

MvarSrfHyperbolicLocallyAccessibleDirs2

(ln_access_hyper.c:410)

Prototype:

CagdBType MvarSrfHyperbolicLocallyAccessibleDirs2( const CagdSrfStruct *Srf, SymbNormalConeStruct *AccessibleCones)

Description:

Compute a range of locally-accessible directions of a hyperbolic surface patch, similarly to MvarSrfHyperbolicLocallyAccessibleDirs. This function does not require an approximate vertical axis for the surface, and instead computes it using SymbNormalConeForSrfToData.

Parameters:

Srf:	The surface for which to find the locally accessible directions.
AccessibleCones:	Output parameter. Two cones, representing ranges of accessible directions.

Returned Value:

CagdBType: TRUE is accessible direction were found, FALSE otherwise.

See Also:

MvarSrfHyperbolicLocallyAccessibleDirs

Keywords:

hyperbolic direction line accessibility

MvarSrfLineOneSidedMaxDist

(lnsrfdst.c:117)

Prototype:

CagdRType MvarSrfLineOneSidedMaxDist(const CagdSrfStruct *Srf, const CagdUVType UV1, const CagdUVType UV2, CagdSrfDirType ClosedDir, CagdRType Epsilon)

Description:

Computes the maximal distance between a given line segment to a given surface. This is the one sided Hausdorff distance from the line to Srf. The line segment is assumed to be on the surface and is prescribed by two surface locations. The distance is bounded as follow. The composition of Srf(UV1UV2) is computed and the maximal distance to line is used as an upper bound, UB. Then, assuming the line is the Z axis, the farthest solution to: Nz(u, v) = 0, Nx(u, v) Y(u, v) - Ny(u, v) X(u, v) = 0,

where Srf = (X(u, v), Y(u, v), Z(u, v)), and
(Nx, Ny, Nz) is its normal field, that is smaller than UB is selected.


Parameters:


 Srf:         Surface to compute the line distance to.
 UV1, UV2:    The two points on Srf the prescribes the line.
 ClosedDir:   If a valid direction the surface is to be treated as closed
                in that direction when examining the line segment.
 Epsilon:     Tolerance of computation.



Returned Value:


  CagdRType:   The maximal distance from a point on the line to nearest
               location on the surfaces.



See Also:

  MvarCrvMaxXYOriginDistance


Keywords:



 MvarSrfListPreciseBBox 
  (mvarbbox.c:1241)

Prototype:

  void MvarSrfListPreciseBBox(const CagdSrfStruct *Srfs,
                              MvarBBoxStruct *BBox,
                              CagdRType Tol)


Description:

Computes the precise bounding box for a list of surfaces.

Parameters:

Srfs:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

CagdSrfListBBox MvarSrfPreciseBBox

Keywords:

bbox bounding box

MvarSrfPreciseBBox

(mvarbbox.c:1174)

Prototype:

void MvarSrfPreciseBBox(const CagdSrfStruct *Srf, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a surface.

Parameters:

Srf:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarMVBBox MvarMVPreciseBBox CagdSrfBBox

Keywords:

bbox bounding box

MvarSrfRadialCurvature

(mv_crvtr.c:51)

Prototype:

MvarPtStruct *MvarSrfRadialCurvature(const CagdSrfStruct *CSrf, const CagdVType ViewDir, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the radial curvature lines on surface Srf viewed from ViewDir. This amounts to finding the asymptotic directions of Srf that are in also the projection of ViewDir onto the tangent plane. Let a and b be two parameters that prescribe the tanget space. Then, the solution is derived as the solution of the following three equations:

       dS     dS
 < ( a -- + b -- ) x N, V > = 0,  (the tangent direction is the projection
       du     dv                   of V onto the tangent plane.)

            [ L M ] [ a ]
   [ a  b ] [     ] [   ] = 0,    (This location/direction is asymp.)
            [ M N ] [ b ]         (L, M, N are the coef. of SFF.)

where a and b are normalized so

    a^2 + b^2 = 1.


Parameters:


 CSrf:       To compute the radial curvature lines for.
 ViewDir:    View direction to consider.
 SubdivTol:  Accuracy of the subdivision stage of the approximation.
 NumerTol:   Accuracy of numeric approx.



Returned Value:


  MvarPtStruct *:   Polylines in the parameter space, depicting the
               radial curvature lines.



See Also:

  SymbSrfGaussCurvature
  UserSrfTopoAspectGraph
  SymbEvalSrfAsympDir


Keywords:



 MvarSrfRayIntersect 
  (ray-srf.c:155)

Prototype:

  int MvarSrfRayIntersect(const CagdSrfStruct *Srf,
                          const CagdVType RayPt,
                          const CagdVType RayDir,
                          CagdUVStruct **InterPntsUV)


Description:

Calculates the intersection between a ray and a surface.

Parameters:

Srf:	The surface.
RayPt:	Starting point of the ray.
RayDir:	he ray's direction.
InterPntsUV:	utput parameters that contain all the intersection points in the UV parametric space of the surface, as linked list. Can be NULL if this information is not needed.

Returned Value:

int: The number of intersection points.

Keywords:

MvarSrfSelfInterDiagFactor

(selfintr.c:1214)

Prototype:

MvarPolylineStruct *MvarSrfSelfInterDiagFactor(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes self intersection points for a given surface S using the following constraints ((u, v) and (s, t) are two independent params of the same srf):

           x(u, v) - x(s, t) = 0,
           y(u, v) - y(s, t) = 0,
           z(u, v) - z(s, t) = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Srf satisfy these equations when u == v and s == t. The key here is to remove all (u - s) (and possibly (v - t)) factors off diagonal Bezier patches of the above, using a decomposition of the Bezier patches as (u1 - u3) G(u1, u2, u3, u4) + (u2 - u4) H(u1, u2, u3, u4).

Parameters:

Srf:	To detect its self intersecting points.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPolylineStruct *: Self intersection pllns, as points in E4 (u, v, s, t).

See Also:

MvarSrfAntipodalPoints MvarCrvSelfInterNrmlDev MvarCrvSelfInterDiagFactor MvarSrfSelfInterDiagFactor2

Keywords:

MvarSrfSelfInterNrmlDev

(selfintr.c:835)

Prototype:

MvarPolylineStruct *MvarSrfSelfInterNrmlDev(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol, CagdRType MinNrmlDeviation)

Description:

Computes self intersection points for given surface using the following constraints (u, v) and (s, t) are two independent params of the same srf:

           x(u, v) - x(s, t) = 0,
           y(u, v) - y(s, t) = 0,
           z(u, v) - z(s, t) = 0.

Direct attempt to solve this set of constraints is bound to be slow as all points in Srf satisfy these equations when (u, v) == (s, t). The key is in adding a fourth inequality constaint of the form

                < N(u, v), N(s, t) >
           ---------------------------- < Cos(Angle),
           || N(u, v) ||  || N(s, t) ||

Where Cos(Angle) is a provided constant that prescribes the minimal angle the surface is expected to intersect at. The closer Cos(Angle) to one the more work this function will have to do in order to isolate the self intersection curve. The above expression is not rational and so, we use a logical or of the following two expressions:

                < N(u, v), N(s, t) >^2
           ------------------------------- < Cos^2(Angle),
           || N(u, v) ||^2 || N(s, t) ||^2

or < N(u, v), N(s, t) > < 0.

Parameters:

Srf:	To detect its self intersecting points.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvment stage. The numeric stage is employed if NumericTol < SubdivTol.
MinNrmlDeviation:	The minimal angle teh surfaces are suppose to intersect at.

Returned Value:

MvarPolylineStruct *: Self intersection pllns, as points in E4 (u, v, s, t).

See Also:

MvarSrfAntipodalPoints MvarCrvSelfInterNrmlDev MvarSrfSelfInterDiagFactor

Keywords:

MvarSrfSilhInflections

(mvaccess.c:229)

Prototype:

MvarPtStruct *MvarSrfSilhInflections(const CagdSrfStruct *Srf, const CagdVType ViewDir, CagdRType SubdivTol, CagdRType NumerTol)

Description:

Computes the silhouette locations on surface Srf viewed from ViewDir that has inflection points or contact for second order or more. This amounts to finding the asymptotic directions of Srf that are in the direction of ViewDir. Let V(s, t) be a parametrization of all possible viewing directions. Solution is derived as the solution of the following three equations:

     dS   dS
   < -- x -- , V > = 0,           (View direction is in the tangent space)
     du   dv

            [ L M ] [ a ]
   [ a  b ] [     ] [   ] = 0,    (This location/direction is asymp.)
            [ M N ] [ b ]         (L, M, N are the coef. of SFF.)

where a and b are the solutions of

     dS     dS
   a -- + b -- = V.
     du     dv


Parameters:


 Srf:        To compute the silhouette higher orders' contact points.
 ViewDir:    View direction to consider.
 SubdivTol:  Accuracy of the subdivision stage of the approximation.
 NumerTol:   Accuracy of numeric approx.



Returned Value:


  MvarPtStruct *:   Polylines on the unit sphere, depicting the
               flecnodal's partitioning lines.



See Also:

  SymbSrfGaussCurvature
  UserSrfTopoAspectGraph
  SymbEvalSrfAsympDir


Keywords:



 MvarSrfSilhouette 
  (mvarsils.c:41)

Prototype:

  IPObjectStruct *MvarSrfSilhouette(const CagdSrfStruct *Srf,
                                    const CagdVType VDir,
                                    CagdRType Step,
                                    CagdRType SubdivTol,
                                    CagdRType NumericTol,
                                    CagdBType Euclidean)


Description:

Computes the silhouette edges of the given surfaces, orthographically seen from the given view direction VDir.

Parameters:

Srf:	To compute its silhouette edges.
VDir:	View direction vector (a unit vector).
Step:	Step size for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.
Euclidean:	If TRUE, returns the silhouettes in Euclidean space. Otherwise, the silhouette edges are returned in the Parametric domain.

Returned Value:

IPObjectStruct *: The silhouettes as piecewise linear edges. Can include two object, 1st with points.

See Also:

SymbSrfOrthotomic SymbSrfSilhouette

Keywords:

MvarSrfSilhouetteThroughPoint

(mvarsils.c:124)

Prototype:

IPObjectStruct *MvarSrfSilhouetteThroughPoint(const CagdSrfStruct *Srf, const CagdPType VPoint, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol, CagdBType Euclidean)

Description:

Computes the silhouette edges of the given surfaces, seen from the given view point VPoint.

Parameters:

Srf:	To compute its silhouette edges.
VPoint:	A point location.
Step:	Step size for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.
Euclidean:	If TRUE, returns the silhouettes in Euclidean space. Otherwise, the silhouette edges are returned in the Parametric domain.

Returned Value:

IPObjectStruct *: The silhouettes as piecewise linear edges. Can include two object, 1st with points.

See Also:

SymbSrfOrthotomic SymbSrfSilhouette MvarSrfSilhouetteThroughPoint2

Keywords:

MvarSrfSilhouetteThroughPoint2

(mvarsils.c:188)

Prototype:

struct IPObjectStruct *MvarSrfSilhouetteThroughPoint2( MvarMVStruct *SrfMv, const MvarMVStruct *NrmlMv, const CagdPType VPoint, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes the silhouette edges of the given surfaces, seen from the given view point VPoint.

Parameters:

SrfMv:	A MultiVariate problem for the surface. This variable will be translated by -VPoint, in place.
NrmlMv:	A MultiVariate for the normals field of SrfMV.
VPoint:	A point location.
Step:	Step size for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.

Returned Value:

struct IPObjectStruct *: The silhouettes as piecewise linear edges. Can include two object, 1st with points.

See Also:

SymbSrfOrthotomic SymbSrfSilhouette MvarSrfSilhouetteThroughPoint

Keywords:

MvarSrfSplitPoleParams

(mvarpole.c:91)

Prototype:

TrimSrfStruct *MvarSrfSplitPoleParams(const CagdSrfStruct *Srf, CagdRType SubdivTol, CagdRType NumericTol, CagdRType OutReach)

Description:

Split the given rational surface at its poles, if any, by solving for the zeros of the surface's denominator.

Parameters:

Srf:	Rational surface to split at its poles.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.
OutReach:	Small offset to clip poles regions at, zero to disable.

Returned Value:

TrimSrfStruct *: Trimmed surfaces, divided at all poles, or NULL if no poles.

See Also:

CagdPointsHasPoles SymbCrvsSplitPoleParams

Keywords:

MvarSrfSrfBisector

(mvbisect.c:254)

Prototype:

MvarMVStruct *MvarSrfSrfBisector(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2)

Description:

Computes the bisectors of two surfaces in R^5.

Parameters:

CMV1, CMV2:	he two bivariates (surfaces) in R^5.

Returned Value:

MvarMVStruct *: The resulting bisector.

See Also:

MvarMVsBisector MvarCrvSrfBisector MvarSrfSrfBisectorApprox

Keywords:

bisectors

MvarSrfSrfBisectorApprox

(mvbisect.c:860)

Prototype:

MvarZeroSolutionStruct *MvarSrfSrfBisectorApprox(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes an approximation to the bisector of two surfaces. Let S1(u, v) and S2(r, s) be two parametric surfaces and let n1(u, v) and n2(r, s) be their unnormalized normal fields. Because the two normals of the two surfaces must be coplanar we introduce the following constraint, forcing the three vectors n1, n2, and S1 - S2 to all be in the same plane.

 < ( S1(u, v) - S2(r, s) ) x n1(u, v), n2(r, s) > = 0.

To make sure the distance to the intersection point of the normals, from both surface's foot points we also coerces these three vectors to form a isosceles triangle:

 || n2(r, s) ||^2 < S1(u, v) - S2(r, s), n1(u, v) > ^ 2 -
                || n1(r, s) ||^2 < S1(u, v) - S2(r, s), n2(u, v) > ^ 2

Finding the zero set of the last equation provides the correspondence between the (u, v) locations on the first surface and (r, s) locations on the second surface that serve as mutual foot point for some bisector point.

Parameters:

CMV1, CMV2:	he two bivariates (surfaces) in R^3.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.

Returned Value:

MvarZeroSolutionStruct *: Either a list of polyline loops or a list of triangles.

See Also:

MvarMVsBisector MvarCrvSrfBisector MvarSrfSrfBisector MvarCrvSrfBisectorApprox

Keywords:

bisectors

MvarSrfSrfBisectorApprox2

(mvbisect.c:1016)

Prototype:

VoidPtr MvarSrfSrfBisectorApprox2(const MvarMVStruct *CMV1, const MvarMVStruct *CMV2, int OutputType, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes an approximation to the bisector of two surfaces - old version that does not use the 2D solver. Let S1(u, v) and S2(r, s) be two parametric surfaces and let n1(u, v) and n2(r, s) be their unnormalized normal fields. Because the two normals of the two surfaces must be coplanar we introduce the following constraint, forcing the three vectors n1, n2, and S1 - S2 to all be in the same plane.

 < ( S1(u, v) - S2(r, s) ) x n1(u, v), n2(r, s) > = 0.

To make sure the distance to the intersection point of the normals, from both surface's foot points we also coerces these three vectors to form a isosceles triangle:

 || n2(r, s) ||^2 < S1(u, v) - S2(r, s), n1(u, v) > ^ 2 -
                || n1(r, s) ||^2 < S1(u, v) - S2(r, s), n2(u, v) > ^ 2

Finding the zero set of the last equation provides the correspondence between the (u, v) location and the first surface and (r, s) locations on the second surface that serve as mutual foot point for some bisector point.

Parameters:

CMV1, CMV2:	he two bivariates (surfaces) in R^3.
OutputType:	xpected output type: 1. For the computed multivariate constraints. 2. For the computed point cloud on the bisector. 3. Points in a form of (u1, v2, x, y, z) where (u1, v1) are the parameter space of the first surface.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.

Returned Value:

VoidPtr: Following OutputType, either a set of multivariates (as a linked list of MvarMVStruct), or a cloud of points on the bisector (as a linked list of MvarPtStruct).

See Also:

MvarMVsBisector MvarCrvSrfBisector MvarSrfSrfBisector MvarCrvSrfBisectorApprox

Keywords:

bisectors

MvarSrfSrfCacheShouldAssignIds

(ssi_cache.c:153)

Prototype:

CagdBType MvarSrfSrfCacheShouldAssignIds(const MvarSrfSrfInterCacheStruct *DataCache)

Description:

Returns if it is the cache responsibility for assigning surface Ids.

Parameters:

DataCache:	The cache.

Returned Value:

CagdBType: TRUE iff the cache is responsible for assigning surfaces Ids.

Keywords:

MvarSrfSrfContact

(mvarintr.c:901)

Prototype:

MvarPtStruct *MvarSrfSrfContact(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdCrvStruct *MotionSrf1, const CagdCrvStruct *ScaleSrf1, CagdRType SubdivTol, CagdRType NumericTol, CagdBType UseExprTree)

Description:

Computes the contact locations of two C^1 surfaces in R^3, possibly with multivariate expression trees. Expression trees could be beneficial computationally when the geometry is complex (i.e. dozens of control points or more, in each directions).

Parameters:

Srf1, Srf2:	Two surface to compute contacts over time in R^3.
MotionSrf1:	The motion over time Srf1 undergoes. Can be NULL.
ScaleSrf1:	The scale over time Srf1 undergoes. Can either be a scalar function, or vector function in R^3. Can be NULL. If both MotionSrf1 and Srf1Scale are defined, they better share their domains.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: List of intersection points, as parameter pairs into the two surfaces domains.

See Also:

MvarCrvCrvInter MvarSrfSrfSrfInter

Keywords:

MvarSrfSrfInter

(mvar_ssi.c:641)

Prototype:

MvarPolylineStruct *MvarSrfSrfInter(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes intersection curve of two surfaces.

Parameters:

Srf1, Srf2:	wo surfaces to be intersected.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	he numerical tolerance to use.

Returned Value:

MvarPolylineStruct *: The list of polylines which approximate the curve. Each polyline corresponds to the topologically isolated component of the curve and is in R^4, the parametric spaces of both surfaces.

See Also:

MvarMVsZeros1DMergeSingularPts MvarMVsZeros1D MvarSrfZeroSet MvarCrvSrfSingularInter MvarSrfSrfInterDisc

Keywords:

MvarSrfSrfInterCacheAddData

(ssi_cache.c:180)

Prototype:

MvarSrfSrfInterCacheDataStruct *MvarSrfSrfInterCacheAddData( MvarSrfSrfInterCacheStruct *SSICache, CagdSrfStruct *Srf1, CagdSrfStruct *Srf2, MvarPolylineStruct *InterData)

Description:

Adds a copy of the result of intersection of two surfaces to the cache. The order of the surfaces is not important.

Parameters:

SSICache:	The cache.
Srf1:	he first surface .
Srf2:	he second surface .
InterData:	ntersection result of Srf1 and Srf2.

Returned Value:

MvarSrfSrfInterCacheDataStruct *: Cached data of the intersection. The data is not added twice if already exists.

Keywords:

MvarSrfSrfInterCacheAlloc

(ssi_cache.c:33)

Prototype:

MvarSrfSrfInterCacheStruct *MvarSrfSrfInterCacheAlloc( IPAttrIDType AttribID, CagdBType ShouldAssignIds)

Description:

Allocated new SSI cache structure. Each surface in the cache should have a unique integer Id attribute. Since the attributes are copied when the surface is copied, it is not necessary to use the same surface for querying the cache, a copy can be used also.

Parameters:

AttribID:	The surface Id attribute name.
ShouldAssignIds:	f FALSE, the user is responsible for assigning Ids for the surfaces, otherwise it is the cache responsibility.

Returned Value:

MvarSrfSrfInterCacheStruct *: New cache structure.

Keywords:

MvarSrfSrfInterCacheClear

(ssi_cache.c:250)

Prototype:

void MvarSrfSrfInterCacheClear(MvarSrfSrfInterCacheStruct *SSICache)

Description:

Empties a given SSI cache.

Parameters:

SSICache:	The cache.

Returned Value:

void.

Keywords:

MvarSrfSrfInterCacheFree

(ssi_cache.c:274)

Prototype:

void MvarSrfSrfInterCacheFree(MvarSrfSrfInterCacheStruct *SSICache)

Description:

Deallocated memory of a given SSI cache.

Parameters:

SSICache:	The cache.

Returned Value:

void.

Keywords:

MvarSrfSrfInterCacheGetData

(ssi_cache.c:85)

Prototype:

MvarSrfSrfInterCacheDataStruct *MvarSrfSrfInterCacheGetData( const MvarSrfSrfInterCacheStruct *SSICache, const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2)

Description:

Searches for a cached result of intersection of two given surfaces. The order between the surfaces is not important.

Parameters:

SSICache:	The cache.
Srf1:	The first surface.
Srf2:	The second surface.

Returned Value:

MvarSrfSrfInterCacheDataStruct *: Cached result of the intersection, or NULL if not found in the cache.

Keywords:

MvarSrfSrfInterCacheGetSrfId

(ssi_cache.c:60)

Prototype:

int MvarSrfSrfInterCacheGetSrfId(const MvarSrfSrfInterCacheStruct *SSICache, const CagdSrfStruct *Srf)

Description:

Returns the Id of a given surface.

Parameters:

SSICache:	The cache.
Srf:	The surface to get its Id.

Returned Value:

int: integer Id of the surface, or IP_ATTR_BAD_INT if doesn't exist.

Keywords:

MvarSrfSrfInterDisc

(mvar_ssi.c:322)

Prototype:

MvarPolylineStruct *MvarSrfSrfInterDisc(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Computes intersection curve of two surfaces. This function detects special cases of C^1 discontinuity curves and treat them first. Then, the regular SSI cases are resolved by MvarSrfSrfIner.

Parameters:

Srf1:	First surface to be intersected.
Srf2:	Second surface to be intersected.
Step:	Step size for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.

Returned Value:

MvarPolylineStruct *: The list of polylines which approximate the curve. Each polyline corresponds to the topologically isolated component of the curve and is in R^4, the parametric spaces of both surfaces.

See Also:

MvarMVsZeros1DMergeSingularPts MvarMVsZeros1D MvarSrfZeroSet MvarCrvSrfSingularInter MvarSrfSrfInter

Keywords:

MvarSrfSrfInterExamineBBoxes

(mvar_ssi.c:1058)

Prototype:

IrtBType MvarSrfSrfInterExamineBBoxes(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2)

Description:

Examine bounding boxes for no-overlap for quick pruning.

Parameters:

Srf1, Srf2:	Surfaces to be intersected.

Returned Value:

IrtBType: TRUE if the surfaces BBoxes intersect, FALSE otherwise.

Keywords:

MvarSrfSrfInterNormalizeDomain

(mvar_ssi.c:1031)

Prototype:

CagdBType MvarSrfSrfInterNormalizeDomain(CagdBType NewValue)

Description:

Set a flag to control if domains of interesting surfaces are temporarily normalized to a canonical domain, before SSI takes place. This normalization have virtually no affect on the SSI output.

Parameters:

NewValue:	The new value to set to the flag.

Returned Value:

CagdBType: The previous value of the flag.

See Also:

MvarMVCompose MvarMVComposeBzrBzr MvarComposeExtractTargetSubdomain

Keywords:

MvarSrfSrfMinimalDist

(hasdrf3d.c:1023)

Prototype:

MvarPtStruct *MvarSrfSrfMinimalDist(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdRType *MinDist)

Description:

Computes the minimal distance between two given C1 surfaces. Surfaces are assumed to not intersect. This minimal distance can occur: 1. At end points vs. end points. 2. At the end points vs interior locations. 3. At a boundary curve vs the other surface. 4. At antipodal interior locations.

Parameters:

Srf1:	To detect its minimal distance to Srf2.
Srf2:	To detect its minimal distance to Srf1.
MinDist:	Upon return, is set to the minimal distance detected.

Returned Value:

MvarPtStruct *: Pairs of parameters at the minimal distance.

See Also:

MvarSrfSrfAntipodalPoints MvarDistSrfPoint MvarCrvSrfMinimalDist

Keywords:

MvarSrfSrfMinkowskiSum

(mink_sum.c:116)

Prototype:

struct IPObjectStruct *MvarSrfSrfMinkowskiSum(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdRType SubdivTol, CagdRType CrvTraceStep, CagdRType NumericTol, int ParallelNrmls, CagdRType OffsetTrimDist)

Description:

Computation of the Minkowski sum of two surfaces. The sum is defined as the locus of points Srf1(u,v) + Srf2(r,s) in R^3, for (u,v) and (r,s) pairs in the parameter spaces, such that the corresponding normal vectors N1(u,v) and N2(r,s) are parallel. In other words, we solve: * < Srf1_u x Srf1_v , Srf2_r > = 0, < Srf1_u x Srf1_v , Srf2_s > = 0. * The solution triangles (or polylines) in (u,v,r,s) space, are then mapped to R^3 using the post-process mapping Srf1(u,v) + Srf2(r,s).

Parameters:

Srf1, Srf2:	The surfaces to compute their Minkowski sum.
SubdivTol:	The subdivision tolerance for the solver call.
CrvTraceStep:	Univariate curve tracing step size.
NumericTol:	The numeric tolerance for the solver call.
ParallelNrmls:	A flag determining if the problem solved shall be parallel normal vectors only (1), anti-parallel normals only (-1) or both (0).
OffsetTrimDist:	When positive, indicates that the Minkowski sum is an offset problem, under the convention that the second surface, Srf2, is a sphere of radius OffsetTrimDist, and the value is used in the offset trimming. If negative, trimming is skipped (the problem is not an offset problem, or any other reason).

Returned Value:

struct IPObjectStruct *: List of polygons or polylines (according to the setting of the bivariate solver), approximating the Minkowski sum.

See Also:

MvarSrfSrfMinkSumMVs

Keywords:

MvarSrfSrfSrfInter

(mvarintr.c:301)

Prototype:

MvarPtStruct *MvarSrfSrfSrfInter(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdSrfStruct *Srf3, CagdRType SubdivTol, CagdRType NumericTol, CagdBType UseExprTree)

Description:

Computes the intersection locations of three surfaces in R^3, possibly with multivariate expression trees. Expression trees could be beneficial computationally when the geometry is complex (i.e. dozens of control points or more, in each directions).

Parameters:

Srf1, Srf2, Srf3:	hree surface to intersect in R^3.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: List of intersection points, as parameter pairs into the three surfaces domains.

See Also:

MvarCrvCrvInter MvarSrfSrfContact

Keywords:

MvarSrfSrfTestInter

(mvar_ssi.c:828)

Prototype:

CagdBType MvarSrfSrfTestInter(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol)

Description:

Tests if the given two surfaces intersect.

Parameters:

Srf1, Srf2:	The two surfaces to be tested for intersection.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.

Returned Value:

CagdBType: TRUE if the surfaces intersect, FALSE otherwise.

See Also:

MvarSrfSrfInter MvarMVsZeros1DMergeSingularPts MvarMVsZeros1D MvarSrfZeroSet MVarCrvSrfSingularInter MvarSrfSrfInterC1Disc MvarSrfSrfInterNormalizeDomain

Keywords:

MvarSrfTrimGlblOffsetSelfInter

(offset2.c:300)

Prototype:

IPObjectStruct *MvarSrfTrimGlblOffsetSelfInter(CagdSrfStruct *Srf, const CagdSrfStruct *OffSrf, CagdRType TrimAmount, int Validate, int Euclidean, CagdRType SubdivTol, CagdRType NumerTol, CagdBType NumerImp)

Description:

trims regions in the offset surface OffSrf that are closer than TrimAmount to original Srf. TrimAmount should be a fraction smaller than the offset amount itself. See also: Joon-Kyung Seong, Gershon Elber, and Myung-Soo Kim. ``Trimming Local and Global Self-intersections in Offset Curves and Surfaces using Distance Maps.'' Computer Aided Design, Vol 38, No 3, pp 183-193, March 2006.

Parameters:

Srf:	Original surface.
OffSrf:	The offset surface approximation.
TrimAmount:	The trimming distance. A fraction smaller than the offset amount.
Validate:	If TRUE, compute only points along the self intersections that are valid and serve to delineate between valid and invalid (to be purged) offset surface regions.
Euclidean:	If TRUE, returned data is in the Euclidean space of OffSrf. FALSE for parametric space of OffSrf.
SubdivTol:	Accuracy of computation.
NumerTol:	If smaller that SubdivTol, a numerical improvement stage is applied by the solver.
NumerImp:	If TRUE, a final stage of numerical marching over the surface is applied to improve the solution even further.

Returned Value:

IPObjectStruct *: A list of self inter. curves, on the offset surface.

Keywords:

MvarSrfTrimGlblOffsetSelfInterNI

(offst2ni.c:88)

Prototype:

IPObjectStruct *MvarSrfTrimGlblOffsetSelfInterNI(IPPolygonStruct *Plls, const CagdSrfStruct *OffSrf, CagdRType SubdivTol, CagdRType NumerTol, int Euclidean, CagdRType SameUVTol)

Description:

Improve self-intersection curves of offset surfaces using numerical methods.

Parameters:

Plls:	Connected list of polylines to be improved.
OffSrf:	The offset surface approximation.
SubdivTol:	Accuracy of computation.
NumerTol:	NumerTol tolerance.
Euclidean:	If TRUE, returned data is in the Euclidean space of OffSrf. FALSE for parametric space of OffSrf.
SameUVTol:	Tolerance for termination condition around singular points.

Returned Value:

IPObjectStruct *: A list of self inter. curves, on the offset surface.

Keywords:

MvarSrfZeroSet

(mvar_ssi.c:966)

Prototype:

MvarPolylineStruct *MvarSrfZeroSet(const CagdSrfStruct *Surface, int Axis, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol, MvarMVsZerosVerifyAllSolsCBFuncType OutputPtsFilterCB, void *OutputPtsFilterCBData)

Description:

Computes the zeros of some surface.

Parameters:

Surface:	Cagd surface to compute its zeros.
Axis:	Axis of Surface to consider its zeros.
Step:	Distance (step) in direction of tangent vec., while tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	he numerical tolerance to use.
OutputPtsFilterCB:	Optional filtering function for output. NULL to disable.
OutputPtsFilterCBData:	Optional data to to pass to OutputPtsFilterCB.

Returned Value:

MvarPolylineStruct *: The list of polylines which approximate the zeros. Each polyline corresponds to the topologically isolated component of the curve and is in R^2, the parametric spaces of the surface.

See Also:

MvarCrvZeroSet MvarMVsZeros1D MvarSrfSrfInter

Keywords:

MvarStewartPlatform2Solve

(mvarstpl.c:429)

Prototype:

MvarPtStruct *MvarStewartPlatform2Solve(const CagdPType BottomBasePoints[3], const CagdRType BotTopEdgeLengths[6], const CagdRType TopEdgeLengths[3], CagdBType Rational, CagdRType SubdivTol, CagdRType NumericTol)

Description:

A second solver for Stewart platform that is optimized. The original constraints are mapped to find a triangle (of TopEdgeLengths edges) whose vertices resides on three computed circles Ci, as follows, 1. Compute circles Ci, i = 0, 1, 2, as the locus of points of distance BotTopEdgeLengths[2i], and BotTopEdgeLengths[2i+1] from bottom base points BottomBasePoints[i], BottomBasePoints[(i+1)%3], respectively. 2. Solve for the three constraints and three unknowns || Ci - C[(i+1)%3] || = TopEdgeLengths[i].

Parameters:

BottomBasePoints:	The three points of the bottom base.
BotTopEdgeLengths:	he six edge lengths of rods connection bottom and top bases.
TopEdgeLengths:	The three edge lengths of the top base.
Rational:	TRUE to represent the circles precisely as rational, FALSE to approximate the circles as polynomials.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Computed solution locations.

See Also:

MvarStewartPlatformSolve MvarStewartPlatformGenEqns

Keywords:

MvarStewartPlatformGenEqns

(mvarstpl.c:205)

Prototype:

MvarMVStruct **MvarStewartPlatformGenEqns(const CagdPType BottomBase[3], const CagdRType TopBaseEdgeLengths[6], const CagdPType WorkDomain[2])

Description:

Derive nine constraints for a Stewart platform, so that given the lengths of the six rods connection the bottom and top bases, we can solve the problem. The bottom base is specified and so are the lengths of the edges of the top base.

Parameters:

BottomBase:	Three vertices of triangle forming the base, denoted Pi.
TopBaseEdgeLengths:	Three edge lengths between three vertices Qi, of top base.
WorkDomain:	The Euclidean space working domain min./max. range.

Returned Value:

MvarMVStruct **: Dynamically allocated vector of nine constraints, in nine unknowns (bottom base with given vertices Pi, top vertices with unknown vertices Qi) as follows: || Q1 - P1 || = L1, || Q1 - P2 || = L2, || Q2 - P2 || = L3, || Q2 - P3 || = L4, || Q3 - P3 || = L5, || Q3 - P1 || = L6, || Q1 - Q2 || = D1, || Q2 - Q3 || = D2, || Q3 - Q1 || = D3, where Li are the six BaseConnectLengths and Dj are lengths between adjacent edges of the top, moving, base. Note the Li are not given and so in this building process the are assumed all zero.

See Also:

MvarStewartPlatformSolve

Keywords:

MvarStewartPlatformSolve

(mvarstpl.c:289)

Prototype:

MvarPtStruct *MvarStewartPlatformSolve(const MvarMVStruct **AllCnstrnts, const CagdRType BaseConnectLengths[6], const CagdPType WorkDomain[2], CagdRType SubdivTol, CagdRType NumericTol)

Description:

Derive nine constraints for a Stewart platform, so that given the lengths of the six rods connection the bottom and top bases, we can solve the problem. The bottom base is specified and so are the lengths of the edges of the top base.

Parameters:

AllCnstrnts:	Nine constraints without base connecting length set.
BaseConnectLengths:	Six specific edge-lengths of rods connection bases.
WorkDomain:	The Euclidean space working domain min./max. range.
SubdivTol:	Tolerance of the solution. This tolerance is measured in the parametric space of the surfaces.
NumericTol:	Numeric tolerance of a possible numeric improvement stage. The numeric stage is employed if NumericTol < SubdivTol.

Returned Value:

MvarPtStruct *: Solution(s) of the Qi locations, if any.

See Also:

MvarStewartPlatformGenEqns

Keywords:

MvarSubDmnInfoStructFree

(zrsolver.c:2899)

Prototype:

void MvarSubDmnInfoStructFree(MvarZeroSubDmnInfoStruct *InfoStruct, int NumOfMVs)

Description:

Deallocates a sub-domain info' structure.

Parameters:

InfoStruct:	The info' structure to be freed.
NumOfMVs:	Number of multi-variates held by the info' structure.

Returned Value:

void.

See Also:

MvarSubDmnInfoStructNew

Keywords:

MvarSubDmnInfoStructNew

(zrsolver.c:2869)

Prototype:

MvarZeroSubDmnInfoStruct *MvarSubDmnInfoStructNew(MvarMVStruct **MVs, MvarMVDirType ProjDir1, MvarMVDirType ProjDir2)

Description:

Allocates the slots required for a sub-domain info' structure.

Parameters:

MVs:	Vector of multivariate constraints, defined in the required sub-domain.
ProjDir1:	First coordinate direction of the two directions w.r.t. which the IPT succeeded.
ProjDir2:	Second coordinate direction of the two directions w.r.t. which the IPT succeeded.

Returned Value:

MvarZeroSubDmnInfoStruct *: The new info' structure.

See Also:

MvarSubDmnInfoStructFree

Keywords:

MvarSurfaceRayIntersection

(ray-srf.c:47)

Prototype:

MvarPtStruct *MvarSurfaceRayIntersection(const CagdSrfStruct *Srf, const IrtPtType RayOrigin, const IrtVecType RayDir, IrtRType SubdivTol)

Description:

Computes a ray - surface intersection by finding two planes through the ray and solve for points on the surface that are on both plane (i.e. the ray). Let S(u, v) = (x(u, v), y(u, v), z(u, v)) and let the two planes be Aix + Biy + CiZ + Di = 0, i = 1,2. Then, solve for the following two algebraic constraints:

       Aix(u, v) + Biy(u, v) + Ciz(u, v) + Di = 0, i = 1,2.

in two unknowns. This function returns ALL intersections of Srf and the infinite line holding the ray, from which the desired solution(s) must be filtered.

Parameters:

Srf:	The surface to seek intersection(s) with a ray.
RayOrigin, RayDir:	Parameters of ray.
SubdivTol:	Subdivision tolerance of the solution.

Returned Value:

MvarPtStruct *: List of all intersection locations of Srf (as UV coordinates in Srf) with ray.

See Also:

MvarCrvAntipodalPoints

Keywords:

MvarTVRglrIsNegJacobian

(mvtrivar.c:938)

Prototype:

int MvarTVRglrIsNegJacobian(const TrivTVStruct *TV)

Description:

Test at a middle point of the given trivariate, assumed regular, is inverted and has a negative Jacobian.

Parameters:

TV:	The trivariate to consider.

Returned Value:

int: TRUE if Jacobian is inverted (negative), FALSE if positive.

See Also:

TrivTVEvalJacobian MvarCalculateTVJacobian TrivComputeJacobian

Keywords:

MvarTanHyperSpheresofNManifolds

(ms_sphr.c:49)

Prototype:

MvarPtStruct *MvarTanHyperSpheresofNManifolds(MvarMVStruct **MVs, int NumOfMVs, CagdRType SubdivTol, CagdRType NumericTol, CagdBType UseExprTree)

Description:

Computes all the hyper-spheres that are tangent to all the given set of manifolds. All manifolds should share the same range space, R^d, space in which the hyper-spheres are sought.

Parameters:

MVs:	The manifolds to consider in R^d.
NumOfMVs:	Number of multivariates we need to process.
SubdivTol, NumericTol:	Of computation.
UseExprTree:	TRUE to use expression trees in the computation, FALSE to use regular multivariate expressions.

Returned Value:

MvarPtStruct *: List of tangent hyper-spheres, NULL if error.

See Also:

MvarMSCircOfThreeCurves MvarMSCircOfTwoCurves MvarMinSpanCirc MvarTanHyperSpheresofNManifoldsET

Keywords:

MvarTriangleFree

(zrmv2dTp.c:1224)

Prototype:

void MvarTriangleFree(MvarTriangleStruct *Tr)

Description:

Deallocates and frees all slots of a multi-variate triangle structure.

Parameters:

Tr:	Multivariate triangle to free.

Returned Value:

void

See Also:

MvarTriangleNew MvarTriangleFreeList

Keywords:

MvarTriangleFreeList

(zrmv2dTp.c:1245)

Prototype:

void MvarTriangleFreeList(MvarTriangleStruct *TrList)

Description:

Deallocates and frees a list of triangle structures.

Parameters:

TrList:	Multivariate triangles list to free.

Returned Value:

void

See Also:

MvarTriangleNew MvarTriangleFree

Keywords:

MvarTriangleNew

(zrmv2dTp.c:1185)

Prototype:

MvarTriangleStruct *MvarTriangleNew(int Dim)

Description:

Allocates the memory required for a new multi-variate triangle.

Parameters:

Dim:	Number of dimensions of each vertex.

Returned Value:

MvarTriangleStruct *: An uninitialized triangle.

See Also:

MvarTriangleFree

Keywords:

MvarTrimComposeMVSrf

(mvcomps2.c:447)

Prototype:

MvarComposedSrfStruct *MvarTrimComposeMVSrf(const MvarMVStruct *MV, const CagdSrfStruct *Srfs)

Description:

Compose a list of surfaces (Srfs) into a multivariate (MV), such that the surfaces are allowed to cross knot values of the mapping multivariate. The results are returned as trimmed surfaces, except surface patches which result from only iso-parametric subdivisions, which are represented as tensor-product surfaces.

Parameters:

MV:	The mapping multivariate.
Srfs:	The surfaces to compose into MV.

Returned Value:

MvarComposedSrfStruct *: The composed surfaces, represented as either trimmed surfaces, or, when possible tensor-product surfaces.

See Also:

MvarUntrimComposeMVSrf MvarComposeMVMdl MvarComposeMVVModel

Keywords:

composition trimming multivariates

MvarTrimComposeMVTV

(mvcomps2.c:860)

Prototype:

MvarComposedTrivStruct *MvarTrimComposeMVTV(const MvarMVStruct *MV, const TrivTVStruct *TV)

Description:

Compose a list of trivariates (TV) into a multivariate (MV), allowing the surfaces of the models to cross knot values of the mapping multivariate.

Parameters:

MV:	The mapping multivariate.
TV:	The trivariates to compose into MV.

Returned Value:

MvarComposedTrivStruct *: The composed geometry, a mixed list of trivariates and V-models.

See Also:

MvarComposeMVVModel

Keywords:

composition trimming multivariates V-model

MvarTrimSrfListPreciseBBox

(mvarbbox.c:1031)

Prototype:

void MvarTrimSrfListPreciseBBox(const TrimSrfStruct *TSrfs, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a list of trimmed surfaces.

Parameters:

TSrfs:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarSrfListPreciseBBox MvarTrimSrfPreciseBBox CagdSrfListBBox MvarSrfPreciseBBox

Keywords:

bbox bounding box

MvarTrimSrfPreciseBBox

(mvarbbox.c:973)

Prototype:

void MvarTrimSrfPreciseBBox(const TrimSrfStruct *TSrf, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a trimmed surface.

Parameters:

TSrf:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarSrfPreciseBBox MvarTrimSrfListPreciseBBox MvarMVBBox MvarMVPreciseBBox CagdSrfBBox

Keywords:

bbox bounding box

MvarTrimSrfRayIntersect

(ray-srf.c:215)

Prototype:

int MvarTrimSrfRayIntersect(const TrimSrfStruct *TrimSrf, const CagdVType RayPt, const CagdVType RayDir, CagdUVStruct **InterPntsUV)

Description:

Calculates the intersection between a ray and a trimmed surface.

Parameters:

TrimSrf:	The trimmed surface.
RayPt:	Starting point of the ray.
RayDir:	The ray's direction.
InterPntsUV:	utput parameter that contains the intersection points in the UV parametric space of the surface. Can be NULL if this information is not needed.

Returned Value:

int: The number of intersection points.

See Also:

MvarSrfRayIntersect

Keywords:

MvarTrisector3DCreateMVs

(mvbisect.c:1373)

Prototype:

MvarMVStruct **MvarTrisector3DCreateMVs(VoidPtr FF1, VoidPtr FF2, VoidPtr FF3, CagdRType *BBoxMin, CagdRType *BBoxMax, int *Eqns)

Description:

Creates a set of MV constraints for the computation of a trisector curve of three objects (bspsline curves or surfaces) in R3. The trisector is considered to lie inside a spatial domain BBox.

Parameters:

FF1, FF2, FF3:	Freeform objects (curve or surface) to compute their trisector.
BBoxMin, BBoxMax:	The bounding box, where the trisector is computed.
Eqns:	Will be updated with the number of MVs constraints.

Returned Value:

MvarMVStruct **: The multivar system, its solution is the desired trisector curve in R3.

Keywords:

MvarTrisectorCrvs

(mvbisect.c:1578)

Prototype:

MvarPolylineStruct *MvarTrisectorCrvs(VoidPtr FF1, VoidPtr FF2, VoidPtr FF3, CagdRType Step, CagdRType SubdivTol, CagdRType NumericTol, CagdRType *BBoxMin, CagdRType *BBoxMax)

Description:

Computes a trisector curve of three objects (curves or surfaces). The trisector is considered to lie inside a spatial domain BBox.

Parameters:

FF1, FF2, FF3:	Objects to compute their trisector.
Step:	Stepsize for curve tracing.
SubdivTol:	The subdivision tolerance to use.
NumericTol:	The numerical tolerance to use.
BBoxMin, BBoxMax:	he bounding box, where the trisector is computed.

Returned Value:

MvarPolylineStruct *: A (list of) polyline(s) that approximates the trisector curve.

Keywords:

MvarTrivJacobianImprove

(mvarjimp.c:608)

Prototype:

void MvarTrivJacobianImprove(TrivTVStruct *TV, CagdRType StepSize, int NumIters)

Description:

Attempt the improve the Jacobian of the given trivariate by adjusting interior control-points of the TV.

Parameters:

TV:	To try and improve (make more uniform) its Jacobian.
StepSize:	Numerical step size to move along the gradient (at the Jacobian extreme values.)
NumIters:	Number of numerical iterations to allow in the improvement process.

Returned Value:

void

See Also:

MvarCalculateTVJacobian SymbSrfJacobianImprove

Keywords:

MvarTrivarBoolOne

(mvtrivar.c:73)

Prototype:

TrivTVStruct *MvarTrivarBoolOne(const CagdSrfStruct *Srf)

Description:

Computes the volumetric (trivariate) boolean sum as follows: 1. Divide Srf into 4 side patches, in U. 2. Compute the volumetric boolean sum for the 4 patches in 1 and 2. Two cap patches will be computed on the fly.

Parameters:

Srf:	Surface to derive a trivariate volume for its interior.

Returned Value:

TrivTVStruct *: A trivariate volume boolean sum of Srf.

See Also:

MvarTrivarBoolSum

Keywords:

MvarTrivarBoolSum

(mvtrivar.c:168)

Prototype:

TrivTVStruct *MvarTrivarBoolSum(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdSrfStruct *Srf3, const CagdSrfStruct *Srf4, const CagdSrfStruct *Srf5, const CagdSrfStruct *Srf6)

Description:

Computes the volumetric (trivariate) boolean sum as follows: Srf1/2/3/4 are around the sweep surface and Srf5/6 are its two caps. The boolean sum is computed as follows:

      T0 = Trilinear(4Corners(Srf1), 4Corners(Srf3))
      T1 = RuledVolume(Srf1, Srf3)
      T2 = RuledVolume(Srf2, Srf4)
      T3 = RuledVolume(Srf5, Srf6)
      T4 = RuledVolume(RuledSrf(Bndry(Srf1, UMin), Bndry(Srf1, UMax)),
                       RuledSrf(Bndry(Srf3, UMin), Bndry(Srf3, UMax)),
      T5 = RuledVolume(RuledSrf(Bndry(Srf2, VMin), Bndry(Srf2, VMax)),
                       RuledSrf(Bndry(Srf4, VMin), Bndry(Srf4, VMax)),
      T6 = RuledVolume(RuledSrf(Bndry(Srf5, VMin), Bndry(Srf5, VMax)),
                       RuledSrf(Bndry(Srf6, VMin), Bndry(Srf6, VMax)),
And the final boolean sum equals:
     BoolSumVolume = T1 + t2 + t3 - (T4 + t5 + t6) + T0


Parameters:


 Srf1, Srf2, Srf3, Srf4, Srf5, Srf6:   Surfaces to derive a trivariate
        volume for its interior.  If Srf5 or Srf6 are NULL, they are
        generated as surface Boolean sum, from V boundaries of Srf1/2/3/4.



Returned Value:


  TrivTVStruct *:   A trivariate volume boolean sum of Srf.



See Also:

  MvarTrivarBoolOne
  MvarTrivarBoolSum2
  MvarTrivarBoolSumRtnl


Keywords:



 MvarTrivarBoolSum2 
  (mvtrivar.c:474)

Prototype:

  TrivTVStruct *MvarTrivarBoolSum2(const CagdSrfStruct *UMin,
                                   const CagdSrfStruct *UMax,
                                   const CagdSrfStruct *VMin,
                                   const CagdSrfStruct *VMax,
                                   const CagdSrfStruct *WMin,
                                   const CagdSrfStruct *WMax)


Description:

Computes the volumetric (trivariate) boolean sum as in MvarTrivarBoolSum but uses the 6 faces of a cube, as extracted from a face of an existing trivariate. In other words "TV = BoolSum2(TrivBndrySrfsFromTV(TV))".

Parameters:

UMin, UMax, VMin, VMax, WMin, WMax:	Surfaces to derive a trivariate volume for its interior.

Returned Value:

TrivTVStruct *: A trivariate volume boolean sum of Srf.

See Also:

MvarTrivarBoolSum MvarTrivarBoolOne MvarTrivarBoolSumRtnl

Keywords:

MvarTrivarBoolSum3

(mvtrivar.c:666)

Prototype:

TrivTVStruct *MvarTrivarBoolSum3(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdSrfStruct *Srf3, const CagdSrfStruct *Srf4, const CagdSrfStruct *Srf5, const CagdSrfStruct *Srf6)

Description:

Computes the volumetric (trivariate) boolean sum as in MvarTrivarBoolSum but reorient the surfaces automatically so they all align properly, following Srf1, that is not modified.

Parameters:

Srf1, Srf2, Srf3, Srf4, Srf5, Srf6:	Surfaces to derive a trivariate volume for its interior. If Srf5 or Srf6 are NULL, they are generated as surface Boolean sum, from V boundaries of Srf1/2/3/4. Srf5 and Srf6 are optional.

Returned Value:

TrivTVStruct *: A trivariate volume boolean sum of Srf.

See Also:

MvarTrivarBoolOne MvarTrivarBoolSum2

Keywords:

MvarTrivarBoolSumRtnl

(mvtrivar.c:1082)

Prototype:

TrivTVStruct *MvarTrivarBoolSumRtnl(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2, const CagdSrfStruct *Srf3, const CagdSrfStruct *Srf4, const CagdSrfStruct *Srf5, const CagdSrfStruct *Srf6)

Description:

Computes a volumetric (trivariate) boolean sum as in MvarTrivarBoolSum3. However, this function, for rational input srfs, will not raise the degrees at the cost of changing the internal parametrization.

Parameters:

Srf1, Srf2, Srf3, Srf4, Srf5, Srf6:	Surfaces to derive a trivariate volume for its interior. If Srf5 or Srf6 are NULL, they are generated as surface Boolean sum, from V boundaries of Srf1/2/3/4.

Returned Value:

TrivTVStruct *: A trivariate volume boolean sum of Srf.

See Also:

CagdBoolSumSrfRtnl MvarTrivarBoolSum MvarTrivarBoolSum3

Keywords:

Boolean sum surface constructors

MvarTrivarCubicTVFit

(mvtrivar.c:764)

Prototype:

TrivTVStruct *MvarTrivarCubicTVFit(const TrivTVStruct *TV)

Description:

Construct a tricubic Bezier trivariate that fits the input trivariate at corner points and match corner derivatives.

Parameters:

TV:	To approximate as a tricubic.

Returned Value:

TrivTVStruct *: A tricubic Bezier trivariate, fitting the corners positions and match corners tangents.

See Also:

MvarTrivarQuadraticTVFit CagdCubicSrfFit CagdCubicCrvFit

Keywords:

MvarTrivarHalfBoolSum

(mvtrivar.c:1308)

Prototype:

TrivTVStruct *MvarTrivarHalfBoolSum(const CagdSrfStruct *Srf1, const CagdSrfStruct *Srf2)

Description:

Computes a trivariate representing the half Boolean sum of the given surfaces, as follows: Srf1/2 are two surfaces having a shared boundary. Srf1/2 are reoriented so their shared boundary will be at VMin. The half Boolean sum is computed as follows:

      C(u) = Bndry(Srf2, VMin),  (the shared boundary)
      HalfBoolSumTV(u, v, w) = Srf1(u ,v) + Srf2(u, w) - C(u).


Parameters:


 Srf1, Srf2:  To compute half Boolean sum trivariate for.



Returned Value:


  TrivTVStruct *:   A trivariate volume half Boolean sum of Srf1, Srf2.



See Also:

  MvarTrivarBoolSum
  MvarTrivarBoolOne


Keywords:



 MvarTrivarListPreciseBBox 
  (mvarbbox.c:930)

Prototype:

  void MvarTrivarListPreciseBBox(const TrivTVStruct *Trivars,
                                 MvarBBoxStruct *BBox,
                                 CagdRType Tol)


Description:

Computes the precise bounding box for a list of trivariate freeform function.

Parameters:

Trivars:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

TrivTVListBBox MvarTrivarPreciseBBox

Keywords:

bbox bounding box

MvarTrivarPreciseBBox

(mvarbbox.c:863)

Prototype:

void MvarTrivarPreciseBBox(const TrivTVStruct *TV, MvarBBoxStruct *BBox, CagdRType Tol)

Description:

Computes the precise bounding box for a trivariate freeform function.

Parameters:

TV:	To compute a precise bounding box for.
BBox:	Where bounding information is to be saved.
Tol:	Tolerance of computations.

Returned Value:

void

See Also:

MvarMVBBox MvarMVPreciseBBox TrivTVBBox

Keywords:

bbox bounding box

MvarTrivarQuadraticTVFit

(mvtrivar.c:827)

Prototype:

TrivTVStruct *MvarTrivarQuadraticTVFit(const TrivTVStruct *TV)

Description:

Construct a triquadratic Bezier trivariate that fits the input trivariate corners points and aims for same corners tangent directions.

Parameters:

TV:	To approximate as a triquadratic.

Returned Value:

TrivTVStruct *: A triquadratic Bezier trivariate, fitting the end position and approximate tangent directions.

See Also:

MvarTrivarCubicTVFit CagdCubicSrfFit CagdCubicCrvFit

Keywords:

MvarTwoMVsMorphing

(mvarmrph.c:35)

Prototype:

MvarMVStruct *MvarTwoMVsMorphing(const MvarMVStruct *MV1, const MvarMVStruct *MV2, CagdRType Blend)

Description:

Given two compatible multi-variates (See function MvarMakeMVsCompatible), computes a convex blend between them according to Blend which must be between zero and one. Returned is the new blended multi-variates.

Parameters:

MV1, MV2:	The two multi-variates to blend.
Blend:	A parameter between zero and one.

Returned Value:

MvarMVStruct : MV2 Blend + MV1 * (1 - Blend).

See Also:

SymbTwoCrvsMorphing SymbTwoCrvsMorphingCornerCut SymbTwoCrvsMorphingMultiRes SymbTwoSrfsMorphing TrivTwoTVsMorphing MvarMakeMVsCompatible

Keywords:

morphing

MvarUniFuncsComputeLowerEnvelope

(mvlowenv.c:1125)

Prototype:

void MvarUniFuncsComputeLowerEnvelope(CagdCrvStruct *InputCurves, CagdCrvStruct **LowerEnvelope)

Description:

Given monotone univariate function curves, and their domain, compute the lower envelope. This is the main calling function for such curves.

Parameters:

InputCurves:	A CagdCrvStruct of univariate (non-rational) curves in R^1
LowerEnvelope:	CagdCrvStruct of lower envelope

Returned Value:

void

Keywords:

MvarUntrimComposeMVSrf

(mvcomps2.c:558)

Prototype:

CagdSrfStruct *MvarUntrimComposeMVSrf( const MvarMVStruct *MV, const CagdSrfStruct *Srfs, CagdQuadSrfWeightFuncType UntrimWeightFunc)

Description:

Compose a list of surfaces (Srfs) into a multivariate (MV), such that the surfaces are allowed to cross knot values of the mapping multivariate. The results are returned as untrimmed (tensor-product) surfaces, using the minimal-weight untrimming algorithm (with the weight provided by UntrimWeightFunc), or the line-sweep algorithm (if UntrimWeightFunc is NULL).

Parameters:

MV:	The mapping multivariate.
Srfs:	The surfaces to compose into MV.
UntrimWeightFunc:	The weight function for the untrimming, or NULL, for applying the line-sweep algorithm.

Returned Value:

CagdSrfStruct *: The composed surfaces, represented as tensor-product surfaces.

See Also:

MvarTrimComposeMVSrf MvarComposeMVMdl MvarComposeMVVModel

Keywords:

composition untrimming multivariates

MvarVecAdd

(mvar_vec.c:35)

Prototype:

void MvarVecAdd(MvarVecStruct *VRes, const MvarVecStruct *V1, const MvarVecStruct *V2)

Description:

Add two multivariate vectors.

Parameters:

VRes:	Result. Can be one of V1 or V2.
V1, V2:	Two input vectors.

Returned Value:

void

See Also:

MvarVecDotProd MvarVecSqrLength MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend

Keywords:

MvarVecAddScale

(mvar_vec.c:72)

Prototype:

void MvarVecAddScale(MvarVecStruct *VRes, const MvarVecStruct *V1, const MvarVecStruct *V2, CagdRType Scale2)

Description:

Add two multivariate vectors, second with scale: VRes = V1 + V2*Scale2.

Parameters:

VRes:	Result. Can be one of V1 or V2.
V1, V2:	Two input vectors.
Scale2:	Scaling factor of V2.

Returned Value:

void

See Also:

MvarVecDotProd MvarVecSqrLength MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend

Keywords:

MvarVecArrayFree

(mvar_gen.c:1193)

Prototype:

void MvarVecArrayFree(MvarVecStruct *MVVecArray, int Size)

Description:

Deallocates and frees a multi-variate vector array.

Parameters:

MVVecArray:	To be deallocated.
Size:	Of the deallocated array.

Returned Value:

void

See Also:

MvarVecArrayNew MvarVecFree MvarVecNew MvarVecFreeList

Keywords:

free

MvarVecArrayNew

(mvar_gen.c:1016)

Prototype:

MvarVecStruct *MvarVecArrayNew(int Size, int Dim)

Description:

Allocates the memory required for a new multi-variate vector array.

Parameters:

Size:	Size of multi-variate vector array to allocate.
Dim:	Number of dimensions of this multi-variate.

Returned Value:

MvarVecStruct *: An uninitialized multi-variate vector array.

See Also:

MvarVecArrayFree MvarVecFree MvarVecNew

Keywords:

MvarVecBlend

(mvar_vec.c:283)

Prototype:

void MvarVecBlend(MvarVecStruct *VRes, const MvarVecStruct *V1, const MvarVecStruct *V2, CagdRType t)

Description:

Compute the blend of the to given multivariate vectors as

      V1 * t + V2 * (1-t).


Parameters:


 VRes:    Result.  Can be one of V1 or V2.
 V1, V2:  Two input vectors to blend.
 t:       Blending factor.



Returned Value:


  void



See Also:

  MvarVecAdd
  MvarVecSqrLength
  MvarVecLength
  MvarVecScale
  MvarVecNormalize
  MvarVecDotProd


Keywords:



 MvarVecCmpTwoVectors 
  (mvar_pll.c:344)

Prototype:

  int MvarVecCmpTwoVectors(const CagdRType *V1,
                           const CagdRType *V2,
                           int Length,
                           CagdRType Eps)


Description:

A comparison function to examine if the given two vectors are the same.

Parameters:

V1, V2:	Two vectors to compare.
Length:	Of the two vectors.
Eps:	The tolerance of the comparison.

Returned Value:

int: 0 if identical, -1 or +1 if first point is less than/greater than second point, in lexicographic order over dimensions. 2 is returned if the dimensions are different.

See Also:

MvarPtDistTwoPoints MvarPtDistSqrTwoPoints MvarPtCmpTwoPoints

Keywords:

MvarVecCopy

(mvar_gen.c:1108)

Prototype:

MvarVecStruct *MvarVecCopy(const MvarVecStruct *Vec)

Description:

Allocates and duplicates all slots of a multi-variate vector structure.

Parameters:

Vec:	Multi-Variate vector to duplicate.

Returned Value:

MvarVecStruct *: Duplicated multi-variate vector.

Keywords:

MvarVecCopyList

(mvar_gen.c:1133)

Prototype:

MvarVecStruct *MvarVecCopyList(const MvarVecStruct *VecList)

Description:

Duplicates a list of multi-variate structures.

Parameters:

VecList:	List of multi-variates to duplicate.

Returned Value:

MvarVecStruct *: Duplicated list of multi-variates.

Keywords:

multi-variates

MvarVecDotProd

(mvar_vec.c:139)

Prototype:

CagdRType MvarVecDotProd(const MvarVecStruct *V1, const MvarVecStruct *V2)

Description:

Compute the dot product of two multivariate vectors.

Parameters:

V1, V2:	Two input vectors.

Returned Value:

CagdRType: The dot product.

See Also:

MvarVecAdd MvarVecSqrLength MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend

Keywords:

MvarVecFree

(mvar_gen.c:1165)

Prototype:

void MvarVecFree(MvarVecStruct *Vec)

Description:

Deallocates and frees all slots of a multi-variate vector structure.

Parameters:

Vec:	Multivariate vector to free.

Returned Value:

void

See Also:

MvarVecArrayNew MvarVecArrayFree MvarVecNew MvarVecFreeList

Keywords:

MvarVecFreeList

(mvar_gen.c:1223)

Prototype:

void MvarVecFreeList(MvarVecStruct *VecList)

Description:

Deallocates and frees a list of multi-variate vector structures.

Parameters:

VecList:	Multi-Variate vector list to free.

Returned Value:

void

See Also:

MvarVecArrayNew MvarVecArrayFree MvarVecNew MvarVecFree

Keywords:

MvarVecLength

(mvar_vec.c:225)

Prototype:

CagdRType MvarVecLength(const MvarVecStruct *V)

Description:

Compute the length of a multivariate vector.

Parameters:

V:	Vector to compute its length.

Returned Value:

CagdRType: Computed length.

See Also:

MvarVecAdd MvarVecDotProd MvarVecSqrLength MvarVecScale MvarVecNormalize MvarVecBlend

Keywords:

MvarVecNew

(mvar_gen.c:978)

Prototype:

MvarVecStruct *MvarVecNew(int Dim)

Description:

Allocates the memory required for a new multi-variate vector.

Parameters:

Dim:	Number of dimensions of this multi-variate.

Returned Value:

MvarVecStruct *: An uninitialized multi-variate vector.

See Also:

MvarVecArrayNew MvarVecFree

Keywords:

MvarVecNormalize

(mvar_vec.c:316)

Prototype:

int MvarVecNormalize(MvarVecStruct *V)

Description:

Normalize a given multivariate vector to a unit length, in place.

Parameters:

V:	Vector to normalize.

Returned Value:

int: TRUE if successful, FALSE if the input is the ZERO vector.

See Also:

MvarVecAdd MvarVecDotProd MvarVecSqrLength MvarVecLength MvarVecScale

Keywords:

MvarVecOrthogonal2

(mvar_vec.c:393)

Prototype:

int MvarVecOrthogonal2(MvarVecStruct *Dir, const MvarVecStruct *Vec1, const MvarVecStruct *Vec2)

Description:

Derives a unit vector Dir that is orthogonal to both Vec1, and Vec2. Note that in R^2 there is no such vector, in R^3 only one such vector and in R^n, n > 3, there are infinitly many of which we find one.

Parameters:

Dir:	Newly computed unit vector will be kept here.
Vec1, Vec2:	Two vectors we must be orthogonal to. Assumed unit length.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarVecOrthogonalize MvarVecSetOrthogonalize MvarVecWedgeProd

Keywords:

MvarVecOrthogonalize

(mvar_vec.c:347)

Prototype:

int MvarVecOrthogonalize(MvarVecStruct *Dir, const MvarVecStruct *Vec)

Description:

Updates Dir to be the closest vector to Dir that is orthogonal to Vec. In essence, apply a Graham Shmidt step. Vectors need not be unit size.

Parameters:

Dir:	Vector to update in place so it will be orthgoonal to Vec.
Vec:	Vector to make sure Dir is made orthogonal to.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarVecOrthogonal2 MvarVecSetOrthogonalize MvarVecWedgeProd

Keywords:

MvarVecRealloc

(mvar_gen.c:1062)

Prototype:

MvarVecStruct *MvarVecRealloc(MvarVecStruct *Vec, int NewDim)

Description:

Reallocates the memory that is required for a new dimension of a multi-variate vector.

Parameters:

Vec:	Multi-Variate vector to reallocate. Should not be used after this operation as it might be freed.
NewDim:	Number of new dimensions of this multi-variate vector.

Returned Value:

MvarVecStruct *: A reallocated multi-variate vector.

See Also:

MvarVecNew

Keywords:

MvarVecScale

(mvar_vec.c:248)

Prototype:

MvarVecStruct *MvarVecScale(MvarVecStruct *V, CagdRType ScaleFactor)

Description:

Scale a given multivariate vector V by a scaling factor ScaleFactor.

Parameters:

V:	Vector to scale, in place.
ScaleFactor:	Scaling factor to use.

Returned Value:

MvarVecStruct *: The input vector, scaled.

See Also:

MvarVecAdd MvarVecDotProd MvarVecSqrLength MvarVecLength MvarVecNormalize MvarVecBlend

Keywords:

MvarVecSetOrthogonalize

(mvar_vec.c:471)

Prototype:

int MvarVecSetOrthogonalize(const MvarVecStruct **Vecs, MvarVecStruct **OrthoVecs, int Size)

Description:

Update the given set of vectors to be of unit size and orthogonal to each other. Vectors are all assumed of the same dimension. In essence, apply a Graham Shmidt to all vectors.

Parameters:

Vecs:	Input vectors to make orthonormal.
OrthoVecs:	Output vectors that span the same (sub) space as vec but are orthogonal and unit length (orthognormal). Can be the same as Vecs.
Size:	Number of vectors in Vecs and OrthoVecs vectors of vectors.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

MvarVecOrthogonal MvarVecOrthogonal2 MvarVecWedgeProd

Keywords:

MvarVecSortAxis

(mvar_int.c:140)

Prototype:

MvarVecStruct *MvarVecSortAxis(MvarVecStruct *VecList, int Axis)

Description:

Sorts given list of points based on their increasing order in axis Axis. Sorting is done in place.

Parameters:

VecList:	List of points to sort.
Axis:	Axis to sort along: 1,2,3 for X,Y,Z.

Returned Value:

MvarVecStruct *: Sorted list of points, in place.

Keywords:

MvarVecSqrLength

(mvar_vec.c:173)

Prototype:

CagdRType MvarVecSqrLength(const MvarVecStruct *V)

Description:

Compute the length squared of a multivariate vector.

Parameters:

V:	Vector to compute its length.

Returned Value:

CagdRType: Computed length squared.

See Also:

MvarVecAdd MvarVecDotProd MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend MvarVecSqrLength2

Keywords:

MvarVecSqrLength2

(mvar_vec.c:196)

Prototype:

CagdRType MvarVecSqrLength2(const CagdRType *v, int Dim)

Description:

Compute the length squared of a multivariate vector.

Parameters:

v:	Vector to compute its length.
Dim:	Lentgth of vector v.

Returned Value:

CagdRType: Computed length squared.

See Also:

MvarVecAdd MvarVecDotProd MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend MvarVecSqrLength

Keywords:

MvarVecSub

(mvar_vec.c:107)

Prototype:

void MvarVecSub(MvarVecStruct *VRes, const MvarVecStruct *V1, const MvarVecStruct *V2)

Description:

Subtract two multivariate vectors.

Parameters:

VRes:	Result. Can be one of V1 or V2.
V1, V2:	Two input vectors.

Returned Value:

void

See Also:

MvarVecDotProd MvarVecSqrLength MvarVecLength MvarVecScale MvarVecNormalize MvarVecBlend MvarVecAdd

Keywords:

MvarVecWedgeProd

(mvar_vec.c:571)

Prototype:

CagdBType MvarVecWedgeProd(MvarVecStruct **Vectors, int Size, MvarVecStruct **NewVecs, int NewSize, CagdBType CheckDet, CagdRType *DetVal)

Description:

Computes an orthogonal complement (wedge product) of dimension NewSize-Size to the given set of Size vectors. Vectors is vector Vectors are in a higher dimensional linear space. of at list dimension NewSize.

Parameters:

Vectors:	The set of Size vectors, each of dimension larger than Size. This set of vectors is modified in place - it is made orthonormal.
Size:	The size of Vectors set.
NewVecs:	New vectors to allocate into here and update with orthogonal complement subspace of dimension newSize-Size. Should be able to hold NewSize-Size pointers to vectors.
NewSize:	The new size of the set Vectors and NewVecs together.
CheckDet:	When Size + NewSize == Dim, this flag indicates if the determinant of the Dim vectors is to be evaluated. Useful for orientation issues.
DetVal:	Output value, the computed determinant if CheckDet is TRUE.

Returned Value:

CagdBType: TRUE if successful, FALSE otherwise.

See Also:

MvarVecOrthogonal MvarVecOrthogonal2 MvarVecSetOrthogonalize

Keywords:

MvarVoronoiCrvCopy

(mvvorcrv.c:53)

Prototype:

MvarVoronoiCrvStruct *MvarVoronoiCrvCopy(MvarVoronoiCrvStruct *Crv)

Description:

Allocates and copies all slots of a MvarVoronoiCrvStruct structure.

Parameters:

Crv:	To be copied.

Returned Value:

MvarVoronoiCrvStruct *: A duplicate of Crv.

Keywords:

copy

MvarVoronoiCrvFree

(mvvorcrv.c:93)

Prototype:

void MvarVoronoiCrvFree(MvarVoronoiCrvStruct *Crv)

Description:

Deallocates a VoronoiCrv structure.

Parameters:

Crv:	Voronoi curve structure to free.

Returned Value:

void

Keywords:

allocation

MvarVoronoiCrvFreeList

(mvvorcrv.c:117)

Prototype:

void MvarVoronoiCrvFreeList(MvarVoronoiCrvStruct *CrvList)

Description:

Deallocates a VoronoiCrv list structure.

Parameters:

CrvList:	Voronoi curve list to free.

Returned Value:

void

Keywords:

allocation

MvarVoronoiCrvNew

(mvvorcrv.c:24)

Prototype:

MvarVoronoiCrvStruct *MvarVoronoiCrvNew(void)

Description:

Allocates and resets all slots of a MvarVoronoiCrvStruct structure.

Parameters:

None

Returned Value:

MvarVoronoiCrvStruct *: A VoronoiCrv structure.

Keywords:

allocation

MvarVoronoiCrvReverse

(mvvorcrv.c:141)

Prototype:

MvarVoronoiCrvStruct *MvarVoronoiCrvReverse(MvarVoronoiCrvStruct *Crv)

Description:

Reverses the t and r parameters of an MvarVoronoiCrvStruct structure.

Parameters:

Crv:	To be reversed.

Returned Value:

MvarVoronoiCrvStruct *: A single duplicate of Crv that is reversed.

Keywords:

MvarZero0DNumeric

(zrmv0d.c:1173)

Prototype:

MvarPtStruct *MvarZero0DNumeric(MvarPtStruct *ZeroPt, const MvarExprTreeEqnsStruct *Eqns, MvarMVStruct const * const *MVs, int NumMVs, CagdRType NumericTol, const CagdRType *InputMinDmn, const CagdRType *InputMaxDmn)

Description:

Apply a numerical improvement stage, as a first order minimization procedure of gradient computation and marching, in place.

Parameters:

ZeroPt:	Approximated solution, derived from a subdivision process, to improve in place.
Eqns:	The constraints are given as Equations, if not NULL.
MVs:	Alternatively, the constraints are given as MVS.
NumMVs:	If MVs is not NULL, this specifies size of the MVs vector.
NumericTol:	Tolerance of the numerical process. Tolerance is measured in the deviation of the scalar multivariates from their equality. Inequalities are ignored here. Points that fail to improve numerically are purged away.
InputMinDmn, InputMaxDmn:	Optional domain restriction. Can be NULL in which, the MVS/Eqns domains are used.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVs. Points that failed to improve are purged away.

See Also:

MvarMVsZeros MvarExprTreesZeros MvarExprTreeEqnsZeros MvarMVsZeros0DNumeric

Keywords:

MvarZeroC1DiscontSubdiv

(zrsolver.c:1987)

Prototype:

static MvarZeroPrblmStruct **MvarZeroC1DiscontSubdiv( MvarZeroPrblmStruct *Problem)

Description:

A preliminary recursive stage of the subdivision solver, invoked by the general solver - subdivides at the C1 discontinuity and solves recursively.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

MvarZeroPrblmStruct **: The array of two sub-problems.

See Also:

MvarZeroSolverInseparableProblem

Keywords:

MvarZeroEqnsHasMeshC1Discont

(zrsolver.c:2065)

Prototype:

CagdBType MvarZeroEqnsHasMeshC1Discont(MvarMVStruct * const *MVs, int NumOfMVs, int *JLoc, CagdRType *t)

Description:

Searches all MVs for parameter locations that are C1 discont. If found update JLoc and t to this finding and returns TRUE. Same functionality as MvarSSIHasC1Discont, but for any number of MVs, not necessarily Dim - 1.

Parameters:

MVs:	The system of equations.
NumOfMVs:	The number of equations.
JLoc:	The direction in the domain with C1 discont, if has one.
t:	The parameter at the C1 discont. if has one.

Returned Value:

CagdBType: TRUE if found a C1 discont., FALSE otherwise.

Keywords:

MvarZeroFilterSolutionSet

(zrmvaux0.c:998)

Prototype:

MvarPtStruct *MvarZeroFilterSolutionSet(MvarZeroPrblmStruct *Problem, MvarPtStruct *MVPts, const MvarMVStruct * const *MVs, const MvarConstraintType *Constraints, int NumOfMVs, IrtRType Tol, int CanHaveLoops, int SortSol, CagdBType InEqOnly, int SolDim)

Description:

Filters and purge solution points that are not satisfying some constraint in MVs. *

Parameters:

Problem:	Optional reference to the problem, in case we like to activate a call back verification function.
MVPts:	Solution points to filter.
MVs:	Constraints to test the solution points against.
Constraints:	Type of constraints.
NumOfMVs:	Also number of constraints.
Tol:	Tolerance the solution point must satisfy.
CanHaveLoops:	RUE if point data can form loops in which case first and last point will be identical (and should not be purged).
SortSol:	TRUE to sort solution set first, based on the 1st axis.
InEqOnly:	TRUE if inequality constraints should be checked only, FALSE if both equality and inequality should be checked.
SolDim:	Solutions' dimensions (0 for points, 1 for univariates, etc.).

Returned Value:

MvarPtStruct *: Filtered points that satisfy the given constraints.

See Also:

MvarZeroSolver

Keywords:

MvarZeroFirstSmoothUpdatesExpTr

(zrsolver.c:2384)

Prototype:

CagdBType MvarZeroFirstSmoothUpdatesExpTr(MvarZeroPrblmStruct *Problem)

Description:

Completes the construction of the ETs problem structure with the actions that are performed only once: when attaining a C1 smooth problem for the first time. Adds the gradients and the current MVs, later to be used in numeric step, and solves the problem on the boundary of the domain.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

CagdBType: TRUE if updates were successful, false otherwise.

Keywords:

MvarZeroFirstSmoothUpdatesMVs

(zrsolver.c:2243)

Prototype:

CagdBType MvarZeroFirstSmoothUpdatesMVs(MvarZeroPrblmStruct *Problem)

Description:

Completes the construction of the MVs problem structure with the actions that are performed only once: when attaining a C1 smooth problem for the first time, adds the gradients and the current MVs, later to be used in numeric step, and solves the problem on the boundary of the domain.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

CagdBType: TRUE if updates were successful, FALSE otherwise.

Keywords:

MvarZeroGenPtMidDmn

(zrsolver.c:2439)

Prototype:

MvarPtStruct *MvarZeroGenPtMidDmn(const MvarZeroPrblmStruct *Problem, int SingleSol)

Description:

Construct a point of the dimension as the given problem in the middle of its parametric domain.

Parameters:

Problem:	To construct a point in the middle of its domain.
SingleSol:	If TRUE, this point is a single solution it MV domain.

Returned Value:

MvarPtStruct *: The construct point in the middle of MV.

See Also:

MvarMVsZeros

Keywords:

MvarZeroGetRootsByKantorovich

(zrmvkant.c:711)

Prototype:

MvarPtStruct *MvarZeroGetRootsByKantorovich(MvarMVStruct **MVs, MvarConstraintType *Constraints, int NumOfMVs, int NumOfZeroMVs, int ApplyNormalConeTest, CagdRType SubdivTol, int Depth, CagdBType SameSpace, CagdRType ParamPerturb)

Description:

Handle all aspects of root-uniqueness using Kantorovich; return a candidate point where a unique root exists, and find the rest of the roots recursively, using MvarZeroMVsSubdiv.

Parameters:

MVs:	Vector of multivariate constraints.
Constraints:	Either an equality or an inequality type of constraint.
NumOfMVs:	Size of the MVs and Constraints vector.
NumOfZeroMVs:	umber of zero or equality constraints.
ApplyNormalConeTest:	TRUE to apply normal cones' single intersection tests.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
Depth:	Of subdivision recursion.
SameSpace:	True if all MVs share the same function space.
ParamPerturb:	he perturbation to applly to mid. subdivision location.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVs. NULL is returned.

See Also:

MvarMVsZeros

Keywords:

MvarZeroMVConstraintFail

(zrmvaux0.c:1171)

Prototype:

CagdBType MvarZeroMVConstraintFail(const MvarMVStruct *MV, MvarConstraintType Constraint)

Description:

Test if the given multivariate may satisfy the constraint. Examines the positivity/negativity of all coefficients in multivariate.

Parameters:

MV:	Multivariate to examine.
Constraint:	ype of constraint - zero, pos., neg.

Returned Value:

CagdBType: TRUE if constraint cannot be satisfied, FALSE otherwise.

See Also:

MvarZeroSolver

Keywords:

MvarZeroMVsSubdiv

(zrmvkant.c:847)

Prototype:

static MvarPtStruct *MvarZeroMVsSubdiv(MvarMVStruct **MVs, MvarConstraintType *Constraints, int NumOfMVs, int NumOfZeroMVs, int ApplyNormalConeTest, CagdRType SubdivTol, int Depth, CagdBType SameSpace, CagdRType ParamPerturb)

Description:

Approximate a solution to the set of constraints, if any, using the subdivision of the parametric domains of the MVs. Stops when the parametric domain is smaller than SubdivTol in all dimensions and returns a central point to that small multivariate patch. NOTE: The generic solver invokes this function only via the Kantorovich option (global flag set accordingly), otherwise this function is unused.

Parameters:

MVs:	Vector of multivariate constraints.
Constraints:	Either an equality or an inequality type of constraint.
NumOfMVs:	Size of the MVs and Constraints vector.
NumOfZeroMVs:	umber of zero or equality constraints.
ApplyNormalConeTest:	TRUE to apply normal cones' single intersection tests.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
Depth:	Of subdivision recursion.
SameSpace:	True if all MVs share the same function space.
ParamPerturb:	he perturbation to applly to mid. subdivision location.

Returned Value:

MvarPtStruct *: List of points on the solution set. Dimension of the points will be the same as the dimensions of all MVs.

See Also:

MvarMVsZeros

Keywords:

MvarZeroOrganizeETs0DProblem

(zret0d.c:123)

Prototype:

MvarExprTreeEqnsStruct *MvarZeroOrganizeETs0DProblem( const MvarExprTreeStruct * const *MVETs, int NumOfMVETs)

Description:

Copy the given expression trees and process and fetch common expressions out to a separated common expressions' vector, all within the returned expression tree equations structure.

Parameters:

MVETs:	Input mvar expression tree equations.
NumOfMVETs:	umber of input mvar expression tree equations, in MVETs.

Returned Value:

MvarExprTreeEqnsStruct *: Build set of equations with common exprs.

See Also:

MvarMVsZeros

Keywords:

MvarZeroOrganizeMVs0DProblem

(zrmv0d.c:105)

Prototype:

MvarMVStruct **MvarZeroOrganizeMVs0DProblem(const MvarMVStruct * const *MVs, MvarConstraintType *Constraints, int *NumOfMVs)

Description:

Preliminary organization and scaling actions of the objects composing a zero finding problem. Relevant to the MVs representation only. This routine is invoked by the problem structure construction routine, and should not be invoked when extracting a sub-problem from an existing one.

Parameters:

MVs:	Array of multivariates.
Constraints:	Equality or inequality constraints.
NumOfMVs:	Number of constraints (may be updated).

Returned Value:

MvarMVStruct **: The updated array of MVs to be used.

See Also:

MvarZeroSolverSetCallbackFcns0DMVs

Keywords:

MvarZeroOrganizeMVs1DProblem

(zrmv1d.c:109)

Prototype:

MvarMVStruct **MvarZeroOrganizeMVs1DProblem(const MvarMVStruct * const *MVs, MvarConstraintType *Constraints, int *NumOfMVs)

Description:

Some preliminary organization of the objects composing an MVs, 1D solution zero finding problem. This routine is invoked by the problem structure construction routine, and should not be invoked when extracting a sub-problem from an existing one.

Parameters:

MVs:	Array of multivariates.
Constraints:	Equality or inequality constraints.
NumOfMVs:	Number of constraints (may be updated).

Returned Value:

MvarMVStruct **: The updated array of MVs to be used.

See Also:

MvarZeroSolverSetCallbackFcns1DMVs

Keywords:

MvarZeroOrganizeMVs2DProblem

(zrmv2dTp.c:149)

Prototype:

MvarMVStruct **MvarZeroOrganizeMVs2DProblem(const MvarMVStruct * const *MVs, MvarConstraintType *Constraints, int *NumOfMVs)

Description:

Some preliminary organization of the objects composing an MVs, 1D solution zero finding problem. This routine is invoked by the problem structure construction routine, and should not be invoked when extracting a sub-problem from an existing one.

Parameters:

MVs:	Array of multivariates.
Constraints:	Equality or inequality constraints.
NumOfMVs:	Number of constraints (may be updated).

Returned Value:

MvarMVStruct **: The updated array of MVs to be used.

See Also:

MvarZeroSolverSetCallbackFcns2DMVs

Keywords:

MvarZeroSolveMatlabEqns

(zrmatlab.c:52)

Prototype:

MvarZeroSolutionStruct *MvarZeroSolveMatlabEqns( MvarMatlabEqStruct **Eqns, int NumOfEqns, int MaxVarsNum, CagdRType *MinDmn, CagdRType *MaxDmn, CagdRType NumericTol, CagdRType SubdivTol, CagdRType StepTol, MvarConstraintType *Constraints)

Description:

Convert a zero finding prolem from matlab form to the solver's problem and solve.

Parameters:

Eqns:	The constraints as recieved after the matlab parsing.
NumOfEqns:	The number of constraints.
MaxVarsNum:	he maximal number of unknowns appearing in the problem.
MinDmn:	The min end point of the domain in all directions. If NULL, considered as all zeros.
MaxDmn:	The max end point of the domain in all directions. If NULL, considered as all ones.
NumericTol:	he required numeric tolerance of the solution.
SubdivTol:	The subdivision tolerance.
StepTol:	The step size for numeric tracing of curves.
Constraints:	vector of constraints specifying equality/inequality.

Returned Value:

MvarZeroSolutionStruct *: The solution to the problem.

See Also:

MvarZeroSolver

Keywords:

MvarZeroSolver

(zrsolver.c:1820)

Prototype:

MvarZeroSolutionStruct *MvarZeroSolver(MvarZeroPrblmStruct *Problem)

Description:

This is a wrapper function for combining the zero set solver with the constraint system decomposition step. It tests the problem for criteria that determine that can't be decomposed, and based on the results it calls either MvarZeroSolverWithDecomposition (which uses constraint decomposition to solve the problem) or MvarZeroSolverInseparableProblem (which solves the problem as is).

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

MvarZeroSolutionStruct *: The point set (zero dimensional case) or piecewise linear approximation to the solution manifold (one/two dimensional case).

See Also:

MvarZeroSolverInseparableProblem MvarZeroSolverWithDecomposition

Keywords:

MvarZeroSolverGetDmnDim

(zrsolver.c:1955)

Prototype:

int MvarZeroSolverGetDmnDim(const MvarZeroPrblmStruct *Problem)

Description:

Extraction of the domain dimension of the MVs/ETs/other constraints in a zero finding problem.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

int: The dimension of the domain of the problem.

Keywords:

MvarZeroSolverInseparableProblem

(zrsolver.c:1477)

Prototype:

MvarZeroSolutionStruct *MvarZeroSolverInseparableProblem(MvarZeroPrblmStruct *Problem)

Description:

The general zero finding problem solver. Invokes various zero finding algorithms according to the function representations/solution set dim. The solver follows as generally as possible the following paradigm: 0. Try to rule out the possibility of a solution by examining the sign of all coefficients. . 1. Recursively subdivide until the problem is C1 smooth. 2. If can't rule out, Check if the topology is guaranteed. 3. If topology is guaranteed, improve/reconstruct numerically. 4. If not, or if numeric step failed subdivide and solve recursively. This function is typically invoked when the constraints are inseparable meaning all constraints depends on all variables, and the problem cannot be split into two or more sub-problems, with less variables each.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

MvarZeroSolutionStruct *: The point set (zero dimensional case) or piecewise linear approximation to the solution manifold (one/two dimensional case).

See Also:

MvarMVDDecomposeProblem MvarMVDMVSolvePlan MvarZeroSolverWithDecomposition

Keywords:

MvarZeroSolverIsMVZero

(zrsolver.c:2928)

Prototype:

CagdBType MvarZeroSolverIsMVZero(MvarMVStruct *MV, CagdRType NumericTol)

Description:

Tests if all coefficients of a multi-variate are zero, up to prescribed tolerance.

Parameters:

MV:	The (scalar valued) multi-variate to be tested.
NumericTol:	he tolerance under which a coefficient is considered zero.

Returned Value:

CagdBType: TRUE if all zeros, FALSE otherwise.

See Also:

MvarZeroMVConstraintFail

Keywords:

MvarZeroSolverPolyProject

(zrmv2dTp.c:1277)

Prototype:

MvarPolylineStruct *MvarZeroSolverPolyProject(MvarPolylineStruct *PolyList, int *Coords, int ProjDim)

Description:

Projecting a given list of polylines on any of its required coordinates, as specified by the Coords vector of length projDim which is a subset of input dimension.

Parameters:

PolyList:	A list of polylines to project.
Coords:	The required projection coordinates. Ordered vector.
ProjDim:	The dimension of the required result. Also the length of Coords.

Returned Value:

MvarPolylineStruct *: The new list of polylines.

Keywords:

MvarZeroSolverPrblmFree

(zrsolver.c:1257)

Prototype:

void MvarZeroSolverPrblmFree(MvarZeroPrblmStruct *Problem)

Description:

Deallocates and frees all slots of a problem structure of a zero finding problem. Constraints are never freed, since they are allocated externally. Note that some slots are freed only at depth zero, some are freed only at first C1 smooth instance.

Parameters:

Problem:	Problem structure to free.

Returned Value:

void

See Also:

MvarZeroSolverPrblmNew MvarZeroSolverSubProblem

Keywords:

MvarZeroSolverPrblmNew

(zrsolver.c:817)

Prototype:

MvarZeroPrblmStruct *MvarZeroSolverPrblmNew(const MvarMVStruct * const *MVs, const MvarExprTreeStruct * const *ETs, int NumOfConstraints, MvarConstraintType *Constraints, CagdRType SubdivTol, CagdRType NumericTol, CagdRType StepTol, CagdBType Solve2DBy0D)

Description:

Construction of a new zero finding problem structure. Allocates the memory and assigns slots that are already known upon construction. This routine should NOT be used when extracting a sub-problem from an existing problem (such as after domain reduction or subdivision): it should only be called at very first construction (SubdivDepth == 0). Scaling and organization takes place here that is not required for sub-problems.

Parameters:

MVs:	Array of multivariates, NULL for ETs representations. MVs[0] can optionally hold a string "_NoSubdivDirs" attribute that sets the direction(s) not to subdivide in. I.e. '11' means the two least (UV) directions are not to be subdivided at.
ETs:	Array of expression trees, NULL for MVs representations.
NumOfConstraints:	umber of constraints in the problem (Total).
Constraints:	ither an equality or an inequality type of constraint.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the constraints.
NumericTol:	Tolerance of the numeric stage.
StepTol:	In 1D numeric stages (curve tracing)- the step size used.
Solve2DBy0D:	temporary flag to indicate the use of the new 2D solver or not.

Returned Value:

MvarZeroPrblmStruct *: The new problem structure or NULL if error.

See Also:

MvarZeroSolverPrblmFree

Keywords:

MvarZeroSolverSetCallbackFcns0DExpTr

(zret0d.c:93)

Prototype:

void MvarZeroSolverSetCallbackFcns0DExpTr(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the Expression Trees representation, 0D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

See Also:

Keywords:

MvarZeroSolverSetCallbackFcns0DMVs

(zrmv0d.c:73)

Prototype:

void MvarZeroSolverSetCallbackFcns0DMVs(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the MVs representation, 0D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

See Also:

MvarZeroOrganizeMVs0DProblem

Keywords:

MvarZeroSolverSetCallbackFcns1DExpTr

(zret1d.c:62)

Prototype:

void MvarZeroSolverSetCallbackFcns1DExpTr(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the ETs representation, 1D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

See Also:

Keywords:

MvarZeroSolverSetCallbackFcns1DMVs

(zrmv1d.c:77)

Prototype:

void MvarZeroSolverSetCallbackFcns1DMVs(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the MVs representation, 1D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

See Also:

MvarZeroOrganizeMVs1DProblem

Keywords:

MvarZeroSolverSetCallbackFcns2DExpTr

(zret2d.c:62)

Prototype:

void MvarZeroSolverSetCallbackFcns2DExpTr(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the ETs representation, 2D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

See Also:

Keywords:

MvarZeroSolverSetCallbackFcns2DMVs

(zrmv2dTp.c:117)

Prototype:

void MvarZeroSolverSetCallbackFcns2DMVs(MvarZeroPrblmStruct *Problem)

Description:

Sets the callback functions for the MVs representation, 2D solution case.

Parameters:

Problem:	The zero finding problem to be solved.

Returned Value:

void

Keywords:

MvarZeroSolverSolutionFree

(zrsolver.c:1417)

Prototype:

void MvarZeroSolverSolutionFree(MvarZeroSolutionStruct *Solution, CagdBType FreeUnion)

Description:

Deallocates and frees all slots of a solution structure of a zero finding problem. NOTE: the T-Junction list is not freed, as it is always freed as part of the problem deallocation.

Parameters:

Solution:	Solution structure to free.
FreeUnion:	If TRUE, the points/polylines stored at in the solution are freed, otherwise they are not. This is useful for the cases of uniting solutions in place.

Returned Value:

void

See Also:

MvarZeroSolverSolutionNew

Keywords:

MvarZeroSolverSolutionNew

(zrsolver.c:1356)

Prototype:

MvarZeroSolutionStruct *MvarZeroSolverSolutionNew( MvarTriangleStruct *Tr, MvarPolylineStruct *Pl, MvarPtStruct *Pt, MvarZrSlvrRepresentationType Rep)

Description:

Allocates the memory required for a new solution structure of a zero finding problem.

Parameters:

Tr:	A list of triangles, or NULL if the representation is not such.
Pl:	A list of polylines, or NULL if the representation is not such.
Pt:	A list of points, or NULL if the representation is not such.
Rep:	The active representation required for the new solution.

Returned Value:

MvarZeroSolutionStruct *: The new solution or NULL if error.

See Also:

MvarZeroSolverSolutionFree

Keywords:

MvarZeroSolverSubProblem

(zrsolver.c:1161)

Prototype:

MvarZeroPrblmStruct *MvarZeroSolverSubProblem( MvarZeroPrblmStruct const *Problem, MvarMVStruct **MVs, MvarExprTreeEqnsStruct *Eqns, MvarZeroSolutionStruct *BoundarySol)

Description:

Construction of a new zero finding sub-problem structure from an existing problem, for the given constraints defined on the sub-domain (the result of subdivision or domain reduction). Note that there are slots that are only allocated once, while some are are allocated at all depths.

Parameters:

Problem:	The original problem, from which to extract the sub-problem.
MVs:	Array of multivariates, NULL if not MVs representation.
Eqns:	Struct of expression trees, NULL if not ETs representation.
BoundarySol:	he solution to the corresponding 2 * Dim problems of one dimension less, defined on the boundary of the new, smaller problem.

Returned Value:

MvarZeroPrblmStruct *: The sub-problem.

See Also:

MvarZeroSolverPrblmNew MvarZeroOrganizeMVs0DProblem MvarZeroOrganizeMVs1DProblem

Keywords:

MvarZeroSolverWithDecomposition

(zrdcm_main.c:1177)

Prototype:

MvarZeroSolutionStruct *MvarZeroSolverWithDecomposition( MvarZeroPrblmStruct *Problem)

Description:

Given a constrain problem, the function determines if constraint system decomposition can be applied to it, and then attempts to solve it. If constraint system decomposition is not possible, it uses the regular MvarZeroSolverInseparableProblem. Currently, only well-constrained systems with no inequality constraints can be solved with the decomposition step.

Parameters:

Problem:	The constraint problem to be solved.

Returned Value:

MvarZeroSolutionStruct *: The solution to the problem.

See Also:

MvarMVDDecomposeProblem MvarMVDMVSolvePlan MvarZeroSolverInseparableProblem

Keywords:

MvarZeroTJCopy

(zrmv2dTJ.c:93)

Prototype:

MvarZeroTJunctionStruct *MvarZeroTJCopy(const MvarZeroTJunctionStruct *TJ)

Description:

Copies a multi-variate T-Junction object.

Parameters:

TJ:	he T-Junction object to copy.

Returned Value:

MvarZeroTJunctionStruct *: The T-Junction copy.

See Also:

MvarZeroTJFree

Keywords:

MvarZeroTJCopyList

(zrmv2dTJ.c:126)

Prototype:

MvarZeroTJunctionStruct *MvarZeroTJCopyList( const MvarZeroTJunctionStruct *TJList)

Description:

Copies a list of multi-variate T-Junction objects.

Parameters:

TJList:	The T-Junction list to copy.

Returned Value:

MvarZeroTJunctionStruct *: The T-Junctions list copy.

See Also:

MvarZeroTJFree MvarZeroTJCopy

Keywords:

MvarZeroTJFree

(zrmv2dTJ.c:158)

Prototype:

void MvarZeroTJFree(MvarZeroTJunctionStruct *TJ)

Description:

Frees all slots of a multi-variate T-Junction structure.

Parameters:

TJ:	Multivariate T-Junction to free.

Returned Value:

void

See Also:

MvarZeroTJFreeList

Keywords:

MvarZeroTJFreeList

(zrmv2dTJ.c:188)

Prototype:

void MvarZeroTJFreeList(MvarZeroTJunctionStruct *TJList)

Description:

Deallocates and frees a list of T-Junction structures.

Parameters:

TJList:	Multivariate T-Junctions list to free.

Returned Value:

void

See Also:

MvarZeroTJFree

Keywords:

MvarZeroTJNew

(zrmv2dTJ.c:61)

Prototype:

MvarZeroTJunctionStruct *MvarZeroTJNew(const MvarPtStruct *TJPrev, const MvarPtStruct *TJPt, const MvarPtStruct *TJNext, const MvarPtStruct *OrigSplit)

Description:

Allocates the memory required for a new multi-variate T-Junction.

Parameters:

TJPrev:	The point before the junction.
TJPt:	The T-Junction point: A solution point.
TJNext:	The point after the junction.
OrigSplit:	The original curve split location, this is the TJ point, before it has been refined to the solution.

Returned Value:

MvarZeroTJunctionStruct *: the T-Junction.

See Also:

MvarZeroTJFree MvarZeroTJCopy

Keywords:

MvarZeroUpdateProblemDmnExpTr

(zrsolver.c:2171)

Prototype:

void MvarZeroUpdateProblemDmnExpTr(MvarZeroPrblmStruct *Problem)

Description:

Updates the problem with the domain and related data in the ETs case.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

void

Keywords:

MvarZeroUpdateProblemDmnMVs

(zrsolver.c:2116)

Prototype:

void MvarZeroUpdateProblemDmnMVs(MvarZeroPrblmStruct *Problem)

Description:

Updates the problem with the domain and related data in the MVs case.

Parameters:

Problem:	The zero finding problem structure.

Returned Value:

void

Keywords:

MvarZerosSubdivTolAction

(zrmv0d.c:960)

Prototype:

MvarZeroSubdivTolActionType MvarZerosSubdivTolAction( MvarZeroSubdivTolActionType SubdivTolAction)

Description:

Sets the action taken by the 0D solver when reaching a sub-domain of size less than subdivision tolerance.

Parameters:

SubdivTolAction:	New setting for the action type.

Returned Value:

MvarZeroSubdivTolActionType: Old setting for the action type.

See Also:

MvarZeroSolverInseparableProblem MvarZeroSolverSinglrSol0DMVs

Keywords:

MvarZrAlgAssignExpr

(mvarzral.c:191)

Prototype:

int MvarZrAlgAssignExpr(void *MVZrAlg, const char *Name, const char *Expr)

Description:

Insert an expression assignment into the structure.

Parameters:

MVZrAlg:	Structure to add a new assignmen to.
Name:	Of new assignment.
Expr:	The expression.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarZrAlgAssignMVVar

(mvarzral.c:291)

Prototype:

int MvarZrAlgAssignMVVar(void *MVZrAlg, const char *Name, CagdRType DmnMin, CagdRType DmnMax, const MvarMVStruct *MV)

Description:

Insert an MV variable assignment into the structure.

Parameters:

MVZrAlg:	Structure to add a new assignment to.
Name:	Name of this variable.
DmnMin, DmnMax:	Domain of this variable.
MV:	ZrAlg Multivariate representing this variable. Optional.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarZrAlgAssignNumVar

(mvarzral.c:241)

Prototype:

int MvarZrAlgAssignNumVar(void *MVZrAlg, const char *Name, CagdRType Val)

Description:

Insert a numeric variable into the structure.

Parameters:

MVZrAlg:	Structure to add a new assignmen to.
Name:	Of new assignment.
Val:	The numeric value.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

MvarZrAlgCreate

(mvarzral.c:90)

Prototype:

void *MvarZrAlgCreate()

Description:

Creates and allocate the structure to manipulate algebraic expressions.

Parameters:

None

Returned Value:

void *: The allocated algebraic expressions structure.

See Also:

Keywords:

MvarZrAlgDelete

(mvarzral.c:127)

Prototype:

void MvarZrAlgDelete(void *MVZrAlg)

Description:

Deallocates the structure to manipulate algebraic expressions.

Parameters:

MVZrAlg:	Structure to deallocate.

Returned Value:

void

See Also:

Keywords:

MvarZrAlgGenMVCode

(mvarzral.c:434)

Prototype:

int MvarZrAlgGenMVCode(void *MVZrAlg, const char *Expr, FILE *f)

Description:

Generate multivariate C Code sequence into designated file that represent the given expression Expr: 1. Using MVZrAlg, perform all possible substitutions. 2. Parse the result into a binary tree and then synthesize the C code to build a multivar with variables at the leaves fetched from MVZrAlg.

Parameters:

MVZrAlg:	Structure of variables and expressions.
Expr:	To parse into a multivariate C Code.
f:	Destination of synthesized C code.

Returned Value:

int: TRUE if successful, FALSE otherwise.

See Also:

Keywords:

_MvarIncBoundMeshIndices

(mvar_aux.c:1054)

Prototype:

int _MvarIncBoundMeshIndices(const MvarMVStruct *MV, int *Indices, int *LowerBound, int *UpperBound, int *Index)

Description:

Increment the index of the control mesh of the multivariate function by one, with given lower and upper bounds: LowerBound <= Idx < UpperBound. Should only be called via the macro MVAR_INC_BOUND_MESH_INDICES.

Parameters:

MV:	To increment Indices to its control mesh.
Indices:	To increment one step.
LowerBound:	inimal values to assume.
UpperBound:	ne above the maximal values to assume.
Index:	Index to increment.

Returned Value:

int: TRUE if Indices are in domain, FALSE if done.

See Also:

_MvarIncSkipMeshIndices _MvarIncSkipMeshIndices1st _MvarIncrementMeshIndices _MvarIncrementMeshOrderIndices

Keywords:

_MvarIncSkipMeshIndices

(mvar_aux.c:980)

Prototype:

int _MvarIncSkipMeshIndices(const MvarMVStruct *MV, int *Indices, int Dir, int *Index)

Description:

Increment the index of the control mesh of the multivariate function by one, skipping axis Dir. Should only be called via the macro MVAR_INC_SKIP_MESH_INDICES.

Parameters:

MV:	To increment Indices to its control mesh.
Indices:	To increment one step.
Dir:	To skip in the incrementation.
Index:	The total current index to be incremented as well, or zero if we wrapped around all incides.

Returned Value:

int: Current non negative Index if Indices are in domain, zero (FALSE) if done - out of the domain.

See Also:

_MvarIncBoundMeshIndices _MvarIncSkipMeshIndices1st _MvarIncrementMeshIndices _MvarIncrementMeshOrderIndices

Keywords:

_MvarIncSkipMeshIndices1st

(mvar_aux.c:937)

Prototype:

int _MvarIncSkipMeshIndices1st(const MvarMVStruct *MV, int *Indices)

Description:

Increment the index of the control mesh of the multivariate function by one, skipping axis Dir zero. Should only be called via the macro MVAR_INC_SKIP_MESH_INDICES_1ST.

Parameters:

MV:	To increment Indices to its control mesh.
Indices:	To increment one step.

Returned Value:

int: TRUE if Indices are in domain, FALSE if done.

See Also:

_MvarIncSkipMeshIndices _MvarIncBoundMeshIndices _MvarIncrementMeshIndices _MvarIncrementMeshOrderIndices

Keywords:

_MvarIncrementMeshIndices

(mvar_aux.c:854)

Prototype:

int _MvarIncrementMeshIndices(const MvarMVStruct *MV, int *Indices, int *Index)

Description:

Increment the index of the control mesh of the multivariate function by one. Should only be called via the macro MVAR_INCREMENT_MESH_INDICES.

Parameters:

MV:	To increment Indices to its control mesh.
Indices:	To increment one step.
Index:	The total current index to be incremented as well, or zero if we wrapped around all indices.

Returned Value:

int: The non zero advanced index if indices are in domain, zero if done (out of domain).

See Also:

_MvarIncSkipMeshIndices _MvarIncBoundMeshIndices _MvarIncSkipMeshIndices1st _MvarIncrementMeshOrderIndices

Keywords:

_MvarIncrementMeshOrderIndices

(mvar_aux.c:897)

Prototype:

int _MvarIncrementMeshOrderIndices(const MvarMVStruct *MV, int *Indices, int *Index)

Description:

Increment the index of the control mesh of the multivariate function by one. Should only be called via the macro MVAR_INCREMENT_MESH_ORDER_INDICES. This macro is useful when traversing a Bspline mesh for evaluation, Orders[i] control points in i'th dimension.

Parameters:

MV:	To increment Indices to its control mesh.
Indices:	To increment one step.
Index:	The total current index to be incremented as well, or zero if we wrapped around all incides.

Returned Value:

int: The non zero advanced index if indices are in domain, zero if done (out of domain).

See Also:

_MvarIncSkipMeshIndices _MvarIncBoundMeshIndices _MvarIncSkipMeshIndices1st

Keywords:

Crv1Inp, Crv2Inp:	wo curves to compute bisectors for. Assumes E2 curves.
Crv1Coerced:	.S.F.I.
Crv2Coerced:	.S.F.I.
F3:	The resulting bisector surface is stored here.
L1:	N.S.F.I.
L2:	N.S.F.I.
CC1:	N.S.F.I.
CC2:	N.S.F.I.

Bndry:	The curve to find the circles that is tangent to.
XBnd:	The range of x-coordinate of bounding box of Bndry.
YBnd:	The range of y-coordinate of bounding box of Bndry.
Radius:	The radius of the circle.
Dir:	The direction to project the circle center on.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.

Bndry:	The curve to find the circles that is tangent to.
InNrml:	Normal pointing in the interior of Bndry, or NULL.
Radius:	The radius of the circle.
Dir:	The direction of the line on which circle center must lie.
Pt:	A point through which the line passes.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.

Crv1, Crv2:	he two curves to find the circles that is tangent to both.
Radius:	Of all the circle(s) that is tangent to Crv1/2.
Tol:	Tolerance of approximation. Subdiv Tol of MV Zeros.

Srf:	A general surface to compute developable scroll from it to Crv.
Crv:	A general curve to compute developable scroll from it to Srf.
OrientField:	If exists, prescribes where to look for solutions of the next developable in the surface (u, v) space, along Crv params. Assumed to have the same parameterization as Crv.
CrvSizeReduction:	reduction in size of traced curve while ensuring the Tolerance, conservatively.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.
Euclidean:	TRUE to return the construct developable scroll(s) in the Euclidean space, FALSE to return the result in (u, v, t) space.

Pt:	Point in Euclidean space to compute the fixed distance curve(s) for.
Srf:	Surface to compute the fixed distance curve(s) on.
Dist:	Euclidean distance of the curves.
Step:	Step size during the numeric tracing.
SubdivTol:	The subdivision tolerance to use.
NumerTol:	The numerical tolerance to use.
LstSqrFit:	Number of control points to allow in fit, zero to disable.

P:	Point to measure its Hausdorff distance to curve Crv.
Crv:	Crv to measure its hausdorff distance to point Pt.
Param:	Where to return the parameter value with the maximal distance.
MinDist:	TRUE for minimal distance, FALSE for maximal.
Epsilon:	Tolerance of computation.

Srf:	The surface to find its nearest (farthest) point to Line.
LnPt:	A point on the line to consider.
LnDir:	The direction of the line to consider.
MinDist:	If TRUE nearest points is needed, if FALSE farthest.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.
ExtremeDistUV:	arameter value in the parameter space of Srf of the nearest (farthest) point to line Line.

P:	Point to measure its Hausdorff distance to surface Srf.
Srf:	Srf to measure its hausdorff distance to point Pt.
Param:	Where to return the parameter value with the maximal distance.
MinDist:	TRUE for minimal distance, FALSE for maximal.

CSrf:	The surface to find its extreme distance locations to Pt.
SrfPtPrepHandle:	If not NULL, holds pre-processed data to speed up the surface - points distance computations, for multiple surface - point tests (same surface for all points). See MvarDistSrfPointPrep and MvarDistSrfPointFree.
Pt:	The point to find the extreme distance locations from Srf.
InitialSol:	ptional initial guess for a solution in which case we aim to improve numerically to within NumericTol. If successful, this solution is returned (in place here and the return value). Otherwise, the full solver is invoked.
SubdivTol:	Tolerance of the first zero set finding subdivision stage.
NumericTol:	olerance of the second zero set finding numeric stage.

Crv:	The curve to project on Srf, orthogonally.
Srf:	The surface to project Crv on.
Tol:	Tolerance of the computation.

Srf1:	The surface to project from, orthogonally.
RVal:	The isoparametric value of the curve of Srf1 to project.
CrvT0:	Minimal parametric value of the curve region.
CrvT1:	Maximal parametric value of the curve region.
Dir:	Direction of isoparametric curve of S1.
Srf2:	The surface to project to.
Tol:	Computation tolerance.

CMV1, CMV2, CMV3:	he 3 bivariates to compute the tri-tangent lines for.
ETs:	To be populated with the computed ETs constraints.
Constraints:	To be populated with the constraints' types.

CMV1, CMV2, CMV3:	he 3 bivariates to compute the tri-tangent lines for.
MVs:	To be populated with the computed MVS constraints.
Constraints:	To be populated with the constraints' types.

CMV1, CMV2, CMV3:	The 3 multivariates to compute the tri-tangents for. If MV2 == MV3 == NULL, the self tri-tangents of MV1 are computed.
Orientation:	0 for no effect, -1 or +1 for a request to get opposite or similar normal orientation bi tangencies only.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Crv:	The curves to find the circles that is tangent to at two points.
CntrOnCrv:	The curve on which the center of circle should lie.
RadiusLB:	Lower-bound on radius of circle.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Crv1, Crv2:	The two curves to find the circles that is tangent to both. Can be the same curve for self-bisectors (turn ElimDiagonals on then).
Pt3:	The point through which circles should pass.
ElimDiagonals:	liminate diagonal solutions if TRUE.
RadiusLB:	Lower-bound on radius of circles.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Crv:	The curves to find the circles that is tangent to at three points.
RadiusLB:	Lower-bound on the radius of circles.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Crv1:	The input curve to which the circles should be tangent.
Pt2:	The point through which the circles should pass.
RadiusLB:	Lower-bound on radius of circle.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Crv1:	The curve to find the circles that is tangent to.
Pt2:	The point through which the circle should pass.
CntrOnCrv:	The curve on which the center of circle should lie.
RadiusLB:	Lower-bound on radius of circle.
SubdivTol:	Tolerance of the subdivision process. Tolerance is measured in the parametric space of the multivariates.
NumericTol:	Numeric tolerance of the numeric stage. The numeric stage is employed only if NumericTol < SubdivTol.

Srf:	Surface to compute the line distance to.
UV1, UV2:	The two points on Srf the prescribes the line.
ClosedDir:	If a valid direction the surface is to be treated as closed in that direction when examining the line segment.
Epsilon:	Tolerance of computation.

CSrf:	To compute the radial curvature lines for.
ViewDir:	View direction to consider.
SubdivTol:	Accuracy of the subdivision stage of the approximation.
NumerTol:	Accuracy of numeric approx.