-- Created on: 1991-08-09 -- Created by: Jean Claude VAUTHIER -- Copyright (c) 1991-1999 Matra Datavision -- Copyright (c) 1999-2014 OPEN CASCADE SAS -- -- This file is part of Open CASCADE Technology software library. -- -- This library is free software; you can redistribute it and / or modify it -- under the terms of the GNU Lesser General Public version 2.1 as published -- by the Free Software Foundation, with special exception defined in the file -- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT -- distribution for complete text of the license and disclaimer of any warranty. -- -- Alternatively, this file may be used under the terms of Open CASCADE -- commercial license or contractual agreement. --Modified : RLE Aug 1993 Major modifications. -- 15-Mar-95 xab : added cache mecanism to speed up -- evaluation -- 25-Mar-95 xab : added Lagrange evaluator -- mei : modified 08-Jun-95 : added method MovePoint -- xab : modified 11-Mar-96 : added method MovePointAndTangent -- xab : modified 18-Mar-97 : added method to reparameterise a bspline -- jct : modified 15-Apr-97 : added method to extend a bspline package BSplCLib ---Purpose: BSplCLib B-spline curve Library. -- -- The BSplCLib package is a basic library for BSplines. It -- provides three categories of functions. -- -- * Management methods to process knots and multiplicities. -- -- * Multi-Dimensions spline methods. BSpline methods where -- poles have an arbitrary number of dimensions. They divides -- in two groups : -- -- - Global methods modifying the whole set of poles. The -- poles are described by an array of Reals and a -- Dimension. Example : Inserting knots. -- -- - Local methods computing points and derivatives. The -- poles are described by a pointer on a local array of -- Reals and a Dimension. The local array is modified. -- -- * 2D and 3D spline curves methods. -- -- Methods for 2d and 3d BSplines curves rational or not -- rational. -- -- Those methods have the following structure : -- -- - They extract the pole informations in a working array. -- -- - They process the working array with the -- multi-dimension methods. (for example a 3d rational -- curve is processed as a 4 dimension curve). -- -- - They get back the result in the original dimension. -- -- Note that the bspline surface methods found in the -- package BSplSLib uses the same structure and rely on -- BSplCLib. -- -- In the following list of methods the 2d and 3d curve -- methods will be described with the corresponding -- multi-dimension method. -- -- The 3d or 2d B-spline curve is defined with : -- -- . its control points : TColgp_Array1OfPnt(2d) Poles -- . its weights : TColStd_Array1OfReal Weights -- . its knots : TColStd_Array1OfReal Knots -- . its multiplicities : TColStd_Array1OfInteger Mults -- . its degree : Standard_Integer Degree -- . its periodicity : Standard_Boolean Periodic -- -- Warnings : -- The bounds of Poles and Weights should be the same. -- The bounds of Knots and Mults should be the same. -- -- Weights can be a null reference (BSplCLib::NoWeights()) -- the curve is non rational. -- -- Mults can be a null reference (BSplCLib::NoMults()) -- the knots are "flat" knots. -- -- KeyWords : -- B-spline curve, Functions, Library -- -- References : -- . A survey of curves and surfaces methods in CADG Wolfgang -- BOHM CAGD 1 (1984) -- . On de Boor-like algorithms and blossoming Wolfgang BOEHM -- cagd 5 (1988) -- . Blossoming and knot insertion algorithms for B-spline curves -- Ronald N. GOLDMAN -- . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA -- . Curves and Surfaces for Computer Aided Geometric Design, -- a practical guide Gerald Farin uses TColStd, gp, TColgp, math, GeomAbs is imported EvaluatorFunction ; ---Purpose: this is a one dimensional function -- typedef void (*EvaluatorFunction) ( -- Standard_Integer // Derivative Request -- Standard_Real * // StartEnd[2] -- Standard_Real // Parameter -- Standard_Real & // Result -- Standard_Integer &) ;// Error Code -- serves to multiply a given vectorial BSpline by a function enumeration KnotDistribution is NonUniform, Uniform; ---Purpose: This enumeration describes the repartition of the -- knots sequence. If all the knots differ by the -- same positive constant from the preceding knot the -- "KnotDistribution" is else it is -- enumeration MultDistribution is NonConstant, Constant, QuasiConstant; ---Purpose: This enumeration describes the form of the -- sequence of mutiplicities. MultDistribution is : -- -- Constant if all the multiplicities have the same -- value. -- -- QuasiConstant if all the internal knots have the -- same multiplicity and if the first and last knot -- have a different multiplicity. -- -- NonConstant in other cases. ------------------------------------------------------------- ------------------------------------------------------------- ---------- ---------- ---------- Knots and Multiplicities ---------- ---------- ---------- ------------------------------------------------------------- ------------------------------------------------------------- Hunt (XX : in Array1OfReal from TColStd; X : in Real; Iloc : in out Integer); ---Purpose: This routine searches the position of the real -- value X in the ordered set of real values XX. -- -- The elements in the table XX are either -- monotonically increasing or monotonically -- decreasing. -- -- The input value Iloc is used to initialize the -- algorithm : if Iloc is outside of the bounds -- [XX.Lower(), -- XX.Upper()] the bisection algorithm -- is used else the routine searches from a previous -- known position by increasing steps then converges -- by bisection. -- -- This routine is used to locate a knot value in a -- set of knots. -- ---References : Numerical Recipes in C (William H.Press, Brian -- P. Flannery, Saul A. Teukolsky, William T. -- Vetterling) FirstUKnotIndex (Degree : Integer; Mults : Array1OfInteger from TColStd) returns Integer; ---Purpose: Computes the index of the knots value which gives -- the start point of the curve. LastUKnotIndex (Degree : Integer; Mults : Array1OfInteger from TColStd) returns Integer; ---Purpose: Computes the index of the knots value which gives -- the end point of the curve. FlatIndex (Degree : Integer; Index : Integer; Mults : Array1OfInteger from TColStd; Periodic : Boolean) returns Integer; ---Purpose: Computes the index of the flats knots sequence -- corresponding to in the knots sequence -- which multiplicities are . LocateParameter (Degree : Integer; Knots : Array1OfReal from TColStd; Mults : Array1OfInteger from TColStd; U : Real; IsPeriodic : Boolean; FromK1 : Integer; ToK2 : Integer; KnotIndex : in out Integer; NewU : in out Real); ---Purpose: Locates the parametric value U in the knots -- sequence between the knot K1 and the knot K2. -- The value return in Index verifies. -- -- Knots(Index) <= U < Knots(Index + 1) -- if U <= Knots (K1) then Index = K1 -- if U >= Knots (K2) then Index = K2 - 1 -- -- If Periodic is True U may be modified to fit in -- the range Knots(K1), Knots(K2). In any case the -- correct value is returned in NewU. -- -- Warnings :Index is used as input data to initialize the -- searching function. -- Warning: Knots have to be "withe repetitions" LocateParameter (Degree : Integer; Knots : Array1OfReal from TColStd; U : Real; IsPeriodic : Boolean; FromK1 : Integer; ToK2 : Integer; KnotIndex : in out Integer; NewU : in out Real); ---Purpose: Locates the parametric value U in the knots -- sequence between the knot K1 and the knot K2. -- The value return in Index verifies. -- -- Knots(Index) <= U < Knots(Index + 1) -- if U <= Knots (K1) then Index = K1 -- if U >= Knots (K2) then Index = K2 - 1 -- -- If Periodic is True U may be modified to fit in -- the range Knots(K1), Knots(K2). In any case the -- correct value is returned in NewU. -- -- Warnings :Index is used as input data to initialize the -- searching function. -- Warning: Knots have to be "flat" LocateParameter (Knots : Array1OfReal from TColStd; U : Real; Periodic : Boolean; K1,K2 : Integer; Index : in out Integer; NewU : in out Real; Uf,Ue : Real) is private; ---Level: Internal LocateParameter (Degree : Integer; Knots : Array1OfReal from TColStd; Mults : Array1OfInteger from TColStd; U : Real; Periodic : Boolean; Index : in out Integer; NewU : in out Real); ---Level: Internal MaxKnotMult (Mults : Array1OfInteger from TColStd; K1, K2 : Integer) returns Integer; ---Purpose: Finds the greatest multiplicity in a set of knots -- between K1 and K2. Mults is the multiplicity -- associated with each knot value. MinKnotMult (Mults : Array1OfInteger from TColStd; K1, K2 : Integer) returns Integer; ---Purpose: Finds the lowest multiplicity in a set of knots -- between K1 and K2. Mults is the multiplicity -- associated with each knot value. NbPoles(Degree : Integer; Periodic : Boolean; Mults : Array1OfInteger from TColStd) returns Integer; ---Purpose: Returns the number of poles of the curve. Returns 0 if -- one of the multiplicities is incorrect. -- -- * Non positive. -- -- * Greater than Degree, or Degree+1 at the first and -- last knot of a non periodic curve. -- -- * The last periodicity on a periodic curve is not -- equal to the first. KnotSequenceLength(Mults : Array1OfInteger from TColStd; Degree : Integer; Periodic : Boolean) returns Integer; ---Purpose: Returns the length of the sequence of knots with -- repetition. -- -- Periodic : -- -- Sum(Mults(i), i = Mults.Lower(); i <= Mults.Upper()); -- -- Non Periodic : -- -- Sum(Mults(i); i = Mults.Lower(); i < Mults.Upper()) -- + 2 * Degree KnotSequence (Knots : Array1OfReal from TColStd; Mults : Array1OfInteger from TColStd; KnotSeq : in out Array1OfReal from TColStd); KnotSequence (Knots : Array1OfReal from TColStd; Mults : Array1OfInteger from TColStd; Degree : Integer; Periodic : Boolean; KnotSeq : in out Array1OfReal from TColStd); ---Purpose: Computes the sequence of knots KnotSeq with -- repetition of the knots of multiplicity greater -- than 1. -- -- Length of KnotSeq must be KnotSequenceLength(Mults,Degree,Periodic) KnotsLength( KnotSeq : Array1OfReal from TColStd; Periodic : Boolean = Standard_False) returns Integer; ---Purpose: Returns the length of the sequence of knots (and -- Mults) without repetition. Knots( KnotSeq : Array1OfReal from TColStd; Knots : out Array1OfReal from TColStd; Mults : out Array1OfInteger from TColStd; Periodic : Boolean = Standard_False); ---Purpose: Computes the sequence of knots Knots without -- repetition of the knots of multiplicity greater -- than 1. -- -- Length of and must be -- KnotsLength(KnotSequence,Periodic) KnotForm (Knots : Array1OfReal from TColStd; FromK1, ToK2 : Integer) returns KnotDistribution; ---Purpose: Analyses if the knots distribution is "Uniform" -- or "NonUniform" between the knot FromK1 and the -- knot ToK2. There is no repetition of knot in the -- knots'sequence . MultForm (Mults : Array1OfInteger from TColStd; FromK1, ToK2 : Integer) returns MultDistribution; ---Purpose: -- Analyses the distribution of multiplicities between -- the knot FromK1 and the Knot ToK2. KnotAnalysis (Degree : Integer; Periodic : Boolean; CKnots : Array1OfReal from TColStd; CMults : Array1OfInteger from TColStd; KnotForm : out BSplKnotDistribution from GeomAbs; MaxKnotMult: out Integer); ---Purpose: Analyzes the array of knots. -- Returns the form and the maximum knot multiplicity. Reparametrize (U1, U2 : Real; Knots : in out Array1OfReal from TColStd); ---Purpose: -- Reparametrizes a B-spline curve to [U1, U2]. -- The knot values are recomputed such that Knots (Lower) = U1 -- and Knots (Upper) = U2 but the knot form is not modified. -- Warnings : -- In the array Knots the values must be in ascending order. -- U1 must not be equal to U2 to avoid division by zero. Reverse (Knots : in out Array1OfReal from TColStd); ---Purpose: Reverses the array knots to become the knots -- sequence of the reversed curve. Reverse (Mults : in out Array1OfInteger from TColStd); ---Purpose: Reverses the array of multiplicities. Reverse (Poles : in out Array1OfPnt from TColgp; Last : Integer); ---Purpose: Reverses the array of poles. Last is the index of -- the new first pole. On a non periodic curve last -- is Poles.Upper(). On a periodic curve last is -- -- (number of flat knots - degree - 1) -- -- or -- -- (sum of multiplicities(but for the last) + degree -- - 1) Reverse (Poles : in out Array1OfPnt2d from TColgp; Last : Integer); ---Purpose: Reverses the array of poles. Reverse (Weights : in out Array1OfReal from TColStd; Last : Integer); ---Purpose: Reverses the array of poles. IsRational(Weights : Array1OfReal from TColStd; I1,I2 : Integer; Epsilon : Real = 0.0) returns Boolean; ---Purpose: -- Returns False if all the weights of the array -- between I1 an I2 are identic. Epsilon is used for -- comparing weights. If Epsilon is 0. the Epsilon of the -- first weight is used. MaxDegree returns Integer; ---Purpose: returns the degree maxima for a BSplineCurve. ---C++: inline Eval(U : Real; Degree : Integer; Knots : in out Real; Dimension : Integer; Poles : in out Real); ---Purpose: Perform the Boor algorithm to evaluate a point at -- parameter , with and . -- -- Poles is an array of Reals of size -- -- * +1 -- -- Containing the poles. At the end contains -- the current point. BoorScheme(U : Real; Degree : Integer; Knots : in out Real; Dimension : Integer; Poles : in out Real; Depth : Integer; Length : Integer); ---Purpose: Performs the Boor Algorithm at parameter with -- the given and the array of on the -- poles of dimension . The schema -- is computed until level on a basis of -- poles. -- -- * Knots is an array of reals of length : -- -- + -- -- * Poles is an array of reals of length : -- -- (2 * + 1) * -- -- The poles values must be set in the array at the -- positions. -- -- 0..Dimension, -- -- 2 * Dimension .. -- 3 * Dimension -- -- 4 * Dimension .. -- 5 * Dimension -- -- ... -- -- The results are found in the array poles depending -- on the Depth. (See the method GetPole). AntiBoorScheme(U : Real; Degree : Integer; Knots : in out Real; Dimension : Integer; Poles : in out Real; Depth : Integer; Length : Integer; Tolerance : Real) returns Boolean; ---Purpose: Compute the content of Pole before the BoorScheme. -- This method is used to remove poles. -- -- U is the poles to remove, Knots should contains the -- knots of the curve after knot removal. -- -- The first and last poles do not change, the other -- poles are computed by averaging two possible values. -- The distance between the two possible poles is -- computed, if it is higher than False is -- returned. Derivative(Degree : Integer; Knots : in out Real; Dimension : Integer; Length : Integer; Order : Integer; Poles : in out Real); ---Purpose: Computes the poles of the BSpline giving the -- derivatives of order . -- -- The formula for the first order is -- -- Pole(i) = Degree * (Pole(i+1) - Pole(i)) / -- (Knots(i+Degree+1) - Knots(i+1)) -- -- This formula is repeated (Degree is decremented at -- each step). Bohm(U : Real; Degree : Integer; N : Integer; Knots : in out Real; Dimension : Integer; Poles : in out Real); ---Purpose: Performs the Bohm Algorithm at parameter . This -- algorithm computes the value and all the derivatives -- up to order N (N <= Degree). -- -- is the original array of poles. -- -- The result in is the value and the -- derivatives. Poles[0] is the value, Poles[Degree] -- is the last derivative. NoWeights returns Array1OfReal from TColStd; ---Purpose: Used as argument for a non rational curve. -- ---C++: return & ---C++: inline NoMults returns Array1OfInteger from TColStd; ---Purpose: Used as argument for a flatknots evaluation. -- ---C++: return & ---C++: inline BuildKnots(Degree, Index : Integer; Periodic : Boolean; Knots : Array1OfReal from TColStd; Mults : Array1OfInteger from TColStd; LK : in out Real); ---Purpose: Stores in LK the usefull knots for the BoorSchem -- on the span Knots(Index) - Knots(Index+1) PoleIndex (Degree, Index : Integer; Periodic : Boolean; Mults : Array1OfInteger from TColStd) returns Integer; ---Purpose: Return the index of the first Pole to use on the -- span Mults(Index) - Mults(Index+1). This index -- must be added to Poles.Lower(). BuildEval(Degree,Index : Integer; Poles : Array1OfReal from TColStd; Weights : Array1OfReal from TColStd; LP : in out Real); BuildEval(Degree,Index : Integer; Poles : Array1OfPnt from TColgp; Weights : Array1OfReal from TColStd; LP : in out Real); BuildEval(Degree,Index : Integer; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd; LP : in out Real); ---Purpose: Copy in the poles and weights for the Eval -- scheme. starting from Poles(Poles.Lower()+Index) BuildBoor(Index,Length,Dimension : Integer; Poles : Array1OfReal from TColStd; LP : in out Real); ---Purpose: Copy in poles for Boor scheme. -- Starting from * , copy -- poles. BoorIndex(Index, Length, Depth : Integer) returns Integer; ---Purpose: Returns the index in the Boor result array of the -- poles . If the Boor algorithm was perform -- with and . GetPole(Index,Length,Depth,Dimension : Integer; LocPoles : in out Real; Position : in out Integer; Pole : in out Array1OfReal from TColStd); ---Purpose: Copy the pole at position in the Boor -- scheme of dimension to in -- the array . is updated. PrepareInsertKnots ( Degree : in Integer; Periodic : in Boolean; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; AddKnots : in Array1OfReal from TColStd; AddMults : in Array1OfInteger from TColStd; NbPoles : out Integer; NbKnots : out Integer; Epsilon : in Real; Add : in Boolean = Standard_True) returns Boolean; ---Purpose: Returns in the new number of poles -- and knots if the sequence of knots is inserted in the sequence . -- -- Epsilon is used to compare knots for equality. -- -- If Add is True the multiplicities on equal knots are -- added. -- -- If Add is False the max value of the multiplicities is -- kept. -- -- Return False if : -- The knew knots are knot increasing. -- The new knots are not in the range. InsertKnots ( Degree : in Integer; Periodic : in Boolean; Dimension : in Integer; Poles : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; AddKnots : in Array1OfReal from TColStd; AddMults : in Array1OfInteger from TColStd; NewPoles : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Epsilon : in Real; Add : in Boolean = Standard_True); InsertKnots ( Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; AddKnots : in Array1OfReal from TColStd; AddMults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Epsilon : in Real; Add : in Boolean = Standard_True); InsertKnots ( Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; AddKnots : in Array1OfReal from TColStd; AddMults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Epsilon : in Real; Add : in Boolean = Standard_True); ---Purpose: Insert a sequence of knots with -- multiplicities . must be a non -- decreasing sequence and verifies : -- -- Knots(Knots.Lower()) <= AddKnots(AddKnots.Lower()) -- Knots(Knots.Upper()) >= AddKnots(AddKnots.Upper()) -- -- The NewPoles and NewWeights arrays must have a length : -- Poles.Length() + Sum(AddMults()) -- -- When a knot to insert is identic to an existing knot the -- multiplicities are added. -- -- Epsilon is used to test knots for equality. -- -- When AddMult is negative or null the knot is not inserted. -- No multiplicity will becomes higher than the degree. -- -- The new Knots and Multiplicities are copied in -- and . -- -- All the New arrays should be correctly dimensioned. -- -- When all the new knots are existing knots, i.e. only the -- multiplicities will change it is safe to use the same -- arrays as input and output. InsertKnot ( UIndex : in Integer; U : in Real; UMult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights : out Array1OfReal from TColStd); InsertKnot ( UIndex : in Integer; U : in Real; UMult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights : out Array1OfReal from TColStd); ---Purpose: Insert a new knot U of multiplicity UMult in the -- knot sequence. -- -- The location of the new Knot should be given as an input -- data. UIndex locates the new knot U in the knot sequence -- and Knots (UIndex) < U < Knots (UIndex + 1). -- -- The new control points corresponding to this insertion are -- returned. Knots and Mults are not updated. RaiseMultiplicity ( KnotIndex : in Integer; Mult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights : out Array1OfReal from TColStd); RaiseMultiplicity ( KnotIndex : in Integer; Mult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights : out Array1OfReal from TColStd); ---Purpose: Raise the multiplicity of knot to . -- -- The new control points are returned. Knots and Mults are -- not updated. RemoveKnot ( Index : in Integer; Mult : in Integer; Degree : in Integer; Periodic : in Boolean; Dimension : in Integer; Poles : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Tolerance : Real) returns Boolean; RemoveKnot ( Index : in Integer; Mult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Tolerance : Real) returns Boolean; RemoveKnot ( Index : in Integer; Mult : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights : out Array1OfReal from TColStd; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; Tolerance : Real) returns Boolean; ---Purpose: Decrement the multiplicity of -- to . If is null the knot is -- removed. -- -- As there are two ways to compute the new poles -- the midlle will be used as long as the -- distance is lower than Tolerance. -- -- If a distance is bigger than tolerance the -- methods returns False and the new arrays are -- not modified. -- -- A low tolerance can be used to test if the -- knot can be removed without modifying the -- curve. -- -- A high tolerance can be used to "smooth" the -- curve. IncreaseDegreeCountKnots (Degree, NewDegree : Integer; Periodic : Boolean; Mults : Array1OfInteger from TColStd) returns Integer; ---Purpose: Returns the number of knots of a curve with -- multiplicities after elevating the degree from -- to . See the IncreaseDegree method -- for more comments. IncreaseDegree (Degree, NewDegree : in Integer; Periodic : in Boolean; Dimension : in Integer; Poles : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : in out Array1OfReal from TColStd; NewKnots : in out Array1OfReal from TColStd; NewMults : in out Array1OfInteger from TColStd); IncreaseDegree (Degree, NewDegree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : in out Array1OfPnt from TColgp; NewWeights : in out Array1OfReal from TColStd; NewKnots : in out Array1OfReal from TColStd; NewMults : in out Array1OfInteger from TColStd); IncreaseDegree (Degree, NewDegree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; NewPoles : in out Array1OfPnt2d from TColgp; NewWeights : in out Array1OfReal from TColStd; NewKnots : in out Array1OfReal from TColStd; NewMults : in out Array1OfInteger from TColStd); IncreaseDegree (NewDegree : in Integer; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; NewPoles : in out Array1OfPnt from TColgp; NewWeights : in out Array1OfReal from TColStd); ---Warning: To be used for Beziercurves ONLY!!! IncreaseDegree (NewDegree : in Integer; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; NewPoles : in out Array1OfPnt2d from TColgp; NewWeights : in out Array1OfReal from TColStd); ---Purpose: Increase the degree of a bspline (or bezier) curve -- of dimension form to -- . -- -- The number of poles in the new curve is : -- -- Poles.Length() + (NewDegree - Degree) * Number of spans -- -- Where the number of spans is : -- -- LastUKnotIndex(Mults) - FirstUKnotIndex(Mults) + 1 -- -- for a non-periodic curve -- -- And Knots.Length() - 1 for a periodic curve. -- -- The multiplicities of all knots are increased by -- the degree elevation. -- -- The new knots are usually the same knots with the -- exception of a non-periodic curve with the first -- and last multiplicity not equal to Degree+1 where -- knots are removed form the start and the bottom -- untils the sum of the multiplicities is equal to -- NewDegree+1 at the knots corresponding to the -- first and last parameters of the curve. -- -- Example : Suppose a curve of degree 3 starting -- with following knots and multiplicities : -- -- knot : 0. 1. 2. -- mult : 1 2 1 -- -- The FirstUKnot is 2. because the sum of -- multiplicities is Degree+1 : 1 + 2 + 1 = 4 = 3 + 1 -- -- i.e. the first parameter of the curve is 2. and -- will still be 2. after degree elevation. Let -- raises this curve to degree 4. The multiplicities -- are increased by 2. -- -- They become 2 3 2. But we need a sum of -- multiplicities of 5 at knot 2. So the first knot -- is removed and the new knots are : -- -- knot : 1. 2. -- mult : 3 2 -- -- The multipicity of the first knot may also be -- reduced if the sum is still to big. -- -- In the most common situations (periodic curve or -- curve with first and last multiplicities equals to -- Degree+1) the knots are knot changes. -- -- The method IncreaseDegreeCountKnots can be used to -- compute the new number of knots.\ -- ---Warning: To be used for Beziercurves ONLY!!! PrepareUnperiodize (Degree : in Integer from Standard; Mults : in Array1OfInteger from TColStd; NbKnots : out Integer from Standard; NbPoles : out Integer from Standard); ---Purpose: Set in and the number of Knots and -- Poles of the NotPeriodic Curve identical at the -- periodic curve with a degree , a -- knots-distribution with Multiplicities . Unperiodize (Degree : in Integer from Standard; Dimension : in Integer from Standard; Mults : in Array1OfInteger from TColStd; Knots : in Array1OfReal from TColStd; Poles : in Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewKnots : out Array1OfReal from TColStd; NewPoles : out Array1OfReal from TColStd); Unperiodize (Degree : in Integer from Standard; Mults : in Array1OfInteger from TColStd; Knots : in Array1OfReal from TColStd; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewKnots : out Array1OfReal from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights: out Array1OfReal from TColStd); Unperiodize (Degree : in Integer from Standard; Mults : in Array1OfInteger from TColStd; Knots : in Array1OfReal from TColStd; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewKnots : out Array1OfReal from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights: out Array1OfReal from TColStd); PrepareTrimming (Degree : in Integer from Standard; Periodic: in Boolean from Standard; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; U1 : in Real from Standard; U2 : in Real from Standard; NbKnots : out Integer from Standard; NbPoles : out Integer from Standard); ---Purpose: Set in and the number of Knots and -- Poles of the curve resulting of the trimming of the -- BSplinecurve definded with , , Trimming (Degree : in Integer from Standard; Periodic : in Boolean from Standard; Dimension : in Integer from Standard; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; Poles : in Array1OfReal from TColStd; U1 : in Real from Standard; U2 : in Real from Standard; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewPoles : out Array1OfReal from TColStd); Trimming (Degree : in Integer from Standard; Periodic : in Boolean from Standard; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; U1 : in Real from Standard; U2 : in Real from Standard; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewPoles : out Array1OfPnt from TColgp; NewWeights : out Array1OfReal from TColStd); Trimming (Degree : in Integer from Standard; Periodic : in Boolean from Standard; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; U1 : in Real from Standard; U2 : in Real from Standard; NewKnots : out Array1OfReal from TColStd; NewMults : out Array1OfInteger from TColStd; NewPoles : out Array1OfPnt2d from TColgp; NewWeights : out Array1OfReal from TColStd); ------------------------------------------------------------- ------------------------------------------------------------- ---------- ---------- ---------- Curve Evaluations ---------- ---------- ---------- ------------------------------------------------------------- ------------------------------------------------------------- D0(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfReal from TColStd; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Real); D0(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt from gp); D0(U : in Real; UIndex : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt2d from gp); D0(U : in Real; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt from gp); ---Warning: To be used for Beziercurves ONLY!!! D0(U : in Real; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt2d from gp); ---Warning: To be used for Beziercurves ONLY!!! D1(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfReal from TColStd; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Real; V : out Real); D1(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt from gp; V : out Vec from gp); D1(U : in Real; UIndex : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt2d from gp; V : out Vec2d from gp); D1(U : in Real; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt from gp; V : out Vec from gp); ---Warning: To be used for Beziercurves ONLY!!! D1(U : in Real; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt2d from gp; V : out Vec2d from gp); ---Warning: To be used for Beziercurves ONLY!!! D2(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfReal from TColStd; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Real; V1,V2 : out Real); D2(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt from gp; V1,V2 : out Vec from gp); D2(U : in Real; UIndex : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt2d from gp; V1,V2 : out Vec2d from gp); D2(U : in Real; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt from gp; V1,V2 : out Vec from gp); ---Warning: To be used for Beziercurves ONLY!!! D2(U : in Real; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt2d from gp; V1,V2 : out Vec2d from gp); ---Warning: To be used for Beziercurves ONLY!!! D3(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfReal from TColStd; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Real; V1,V2,V3 : out Real); D3(U : in Real; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt from gp; V1,V2,V3 : out Vec from gp); D3(U : in Real; UIndex : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; P : out Pnt2d from gp; V1,V2,V3 : out Vec2d from gp); D3(U : in Real; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt from gp; V1,V2,V3 : out Vec from gp); ---Warning: To be used for Beziercurves ONLY!!! D3(U : in Real; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt2d from gp; V1,V2,V3 : out Vec2d from gp); ---Warning: To be used for Beziercurves ONLY!!! DN(U : in Real; N : in Integer; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfReal from TColStd; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; VN : out Real); DN(U : in Real; N : in Integer; Index : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; VN : out Vec from gp); DN(U : in Real; N : in Integer; UIndex : in Integer; Degree : in Integer; Periodic : in Boolean; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; Knots : in Array1OfReal from TColStd; Mults : in Array1OfInteger from TColStd; V : out Vec2d from gp); DN(U : in Real; N : in Integer; Poles : in Array1OfPnt from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt from gp; VN : out Vec from gp); ---Warning: To be used for Beziercurves ONLY!!! DN(U : in Real; N : in Integer; Poles : in Array1OfPnt2d from TColgp; Weights : in Array1OfReal from TColStd; P : out Pnt2d from gp; VN : out Vec2d from gp); ---Purpose: The above functions compute values and -- derivatives in the following situations : -- -- * 3D, 2D and 1D -- -- * Rational or not Rational. -- -- * Knots and multiplicities or "flat knots" without -- multiplicities. -- -- * The is the the localization of the -- parameter in the knot sequence. If is out -- of range the correct value will be searched. -- -- -- VERY IMPORTANT!!! -- USE BSplCLib::NoWeights() as Weights argument for non -- rational curves computations. ---Warning: To be used for Beziercurves ONLY!!! EvalBsplineBasis(Side : in Integer ; DerivativeOrder : in Integer ; Order : in Integer ; FlatKnots : Array1OfReal from TColStd ; Parameter : in Real ; FirstNonZeroBsplineIndex : in out Integer ; BsplineBasis : in out Matrix from math) returns Integer ; ---Purpose: This evaluates the Bspline Basis at a -- given parameter Parameter up to the -- requested DerivativeOrder and store the -- result in the array BsplineBasis in the -- following fashion -- BSplineBasis(1,1) = -- value of first non vanishing -- Bspline function which has Index FirstNonZeroBsplineIndex -- BsplineBasis(1,2) = -- value of second non vanishing -- Bspline function which has Index -- FirstNonZeroBsplineIndex + 1 -- BsplineBasis(1,n) = -- value of second non vanishing non vanishing -- Bspline function which has Index -- FirstNonZeroBsplineIndex + n (n <= Order) -- BSplineBasis(2,1) = -- value of derivative of first non vanishing -- Bspline function which has Index FirstNonZeroBsplineIndex -- BSplineBasis(N,1) = -- value of Nth derivative of first non vanishing -- Bspline function which has Index FirstNonZeroBsplineIndex -- if N <= DerivativeOrder + 1 BuildBSpMatrix(Parameters : in Array1OfReal from TColStd; OrderArray : in Array1OfInteger from TColStd; FlatKnots : in Array1OfReal from TColStd; Degree : in Integer; Matrix : in out Matrix from math; UpperBandWidth : out Integer ; LowerBandWidth : out Integer) returns Integer ; ---Purpose: This Builds a fully blown Matrix of -- (ni) -- Bi (tj) -- -- with i and j within 1..Order + NumPoles -- The integer ni is the ith slot of the -- array OrderArray, tj is the jth slot of -- the array Parameters FactorBandedMatrix(Matrix : in out Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; PivotIndexProblem : out Integer) returns Integer ; ---Purpose: this factors the Banded Matrix in -- the LU form with a Banded storage of -- components of the L matrix -- WARNING : do not use if the Matrix is -- totally positive (It is the case for -- Bspline matrices build as above with -- parameters being the Schoenberg points SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; ArrayDimension : in Integer ; Array : in out Real) returns Integer ; ---Purpose: This solves the system Matrix.X = B -- with when Matrix is factored in LU form -- The Array is an seen as an -- Array[1..N][1..ArrayDimension] with N = -- the rank of the matrix Matrix. The -- result is stored in Array when each -- coordinate is solved that is B is the -- array whose values are -- B[i] = Array[i][p] for each p in 1..ArrayDimension SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; Array : in out Array1OfPnt2d from TColgp) returns Integer ; ---Purpose: This solves the system Matrix.X = B -- with when Matrix is factored in LU form -- The Array has the length of -- the rank of the matrix Matrix. The -- result is stored in Array when each -- coordinate is solved that is B is the -- array whose values are -- B[i] = Array[i][p] for each p in 1..ArrayDimension SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; Array : in out Array1OfPnt from TColgp) returns Integer ; ---Purpose: This solves the system Matrix.X = B -- with when Matrix is factored in LU form -- The Array has the length of -- the rank of the matrix Matrix. The -- result is stored in Array when each -- coordinate is solved that is B is the -- array whose values are -- B[i] = Array[i][p] for each p in 1..ArrayDimension SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; HomogenousFlag : in Boolean ; ArrayDimension : Integer ; Array : in out Real ; Weights : in out Real ) returns Integer ; SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; HomogenousFlag : in Boolean ; Array : in out Array1OfPnt2d from TColgp; Weights : in out Array1OfReal from TColStd ) returns Integer ; ---Purpose: This solves the system Matrix.X = B -- with when Matrix is factored in LU form -- The Array is an seen as an -- Array[1..N][1..ArrayDimension] with N = -- the rank of the matrix Matrix. The -- result is stored in Array when each -- coordinate is solved that is B is the -- array whose values are B[i] = -- Array[i][p] for each p in -- 1..ArrayDimension. If HomogeneousFlag == -- 0 the Poles are multiplied by the -- Weights uppon Entry and once -- interpolation is carried over the -- result of the poles are divided by the -- result of the interpolation of the -- weights. Otherwise if HomogenousFlag == 1 -- the Poles and Weigths are treated homogenously -- that is that those are interpolated as they -- are and result is returned without division -- by the interpolated weigths. SolveBandedSystem (Matrix : in Matrix from math ; UpperBandWidth : in Integer ; LowerBandWidth : in Integer ; HomogeneousFlag : in Boolean ; Array : in out Array1OfPnt from TColgp; Weights : in out Array1OfReal from TColStd ) returns Integer ; ---Purpose: This solves the system Matrix.X = B -- with when Matrix is factored in LU form -- The Array is an seen as an -- Array[1..N][1..ArrayDimension] with N = -- the rank of the matrix Matrix. The -- result is stored in Array when each -- coordinate is solved that is B is the -- array whose values are -- B[i] = Array[i][p] for each p in 1..ArrayDimension -- If HomogeneousFlag == -- 0 the Poles are multiplied by the -- Weights uppon Entry and once -- interpolation is carried over the -- result of the poles are divided by the -- result of the interpolation of the -- weights. Otherwise if HomogenousFlag == 1 -- the Poles and Weigths are treated homogenously -- that is that those are interpolated as they -- are and result is returned without division -- by the interpolated weigths. MergeBSplineKnots(Tolerance : Real from Standard ; StartValue : Real from Standard ; EndValue : Real from Standard ; Degree1 : Integer from Standard ; Knots1 : Array1OfReal from TColStd ; Mults1 : Array1OfInteger from TColStd ; Degree2 : Integer from Standard ; Knots2 : Array1OfReal from TColStd ; Mults2 : Array1OfInteger from TColStd ; NumPoles : in out Integer ; NewKnots : in out HArray1OfReal from TColStd ; NewMults : in out HArray1OfInteger from TColStd) ; ---Purpose: Merges two knot vector by setting the starting and -- ending values to StartValue and EndValue FunctionReparameterise(Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; PolesDimension : Integer ; Poles : in out Real ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Real ; Status : in out Integer) ; ---Purpose: This function will compose a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] with a -- function a(t) which is assumed to satisfy the -- following: -- -- 1. F(a(t)) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots -- -- 2. a(t) defines a differentiable -- isomorphism between the range of FlatKnots to the range -- of BSplineFlatKnots which is the -- same as the range of F(t) -- -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of F(a(t)) FunctionReparameterise( Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfReal from TColStd ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfReal from TColStd ; Status : in out Integer) ; ---Purpose: This function will compose a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] with a -- function a(t) which is assumed to satisfy the -- following: -- -- 1. F(a(t)) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots -- -- 2. a(t) defines a differentiable -- isomorphism between the range of FlatKnots to the range -- of BSplineFlatKnots which is the -- same as the range of F(t) -- -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of F(a(t)) FunctionReparameterise( Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt from TColgp ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfPnt from TColgp ; Status : in out Integer) ; ---Purpose: this will compose a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] with a -- function a(t) which is assumed to satisfy the -- following : 1. F(a(t)) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots -- 2. a(t) defines a differentiable -- isomorphism between the range of FlatKnots to the range -- of BSplineFlatKnots which is the -- same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of F(a(t)) FunctionReparameterise( Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt2d from TColgp ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfPnt2d from TColgp ; Status : in out Integer) ; ---Purpose: this will compose a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] with a -- function a(t) which is assumed to satisfy the -- following : 1. F(a(t)) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots -- 2. a(t) defines a differentiable -- isomorphism between the range of FlatKnots to the range -- of BSplineFlatKnots which is the -- same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of F(a(t)) FunctionMultiply(Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; PolesDimension : Integer ; Poles : in out Real ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Real ; Status : in out Integer) ; ---Purpose: this will multiply a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] by a -- function a(t) which is assumed to satisfy the -- following : 1. a(t) * F(t) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots 2. the range of a(t) -- is the same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of a(t)*F(t) FunctionMultiply(Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfReal from TColStd ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfReal from TColStd ; Status : in out Integer) ; ---Purpose: this will multiply a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] by a -- function a(t) which is assumed to satisfy the -- following : 1. a(t) * F(t) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots 2. the range of a(t) -- is the same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of a(t)*F(t) FunctionMultiply(Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt2d from TColgp ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfPnt2d from TColgp ; Status : in out Integer) ; ---Purpose: this will multiply a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] by a -- function a(t) which is assumed to satisfy the -- following : 1. a(t) * F(t) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots 2. the range of a(t) -- is the same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of a(t)*F(t) FunctionMultiply(Function : EvaluatorFunction from BSplCLib ; BSplineDegree : Integer ; BSplineFlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt from TColgp ; FlatKnots : Array1OfReal from TColStd ; NewDegree : Integer ; NewPoles : in out Array1OfPnt from TColgp ; Status : in out Integer) ; ---Purpose: this will multiply a given Vectorial BSpline F(t) -- defined by its BSplineDegree and BSplineFlatKnotsl, -- its Poles array which are coded as an array of Real -- of the form [1..NumPoles][1..PolesDimension] by a -- function a(t) which is assumed to satisfy the -- following : 1. a(t) * F(t) is a polynomial BSpline -- that can be expressed exactly as a BSpline of degree -- NewDegree on the knots FlatKnots 2. the range of a(t) -- is the same as the range of F(t) -- Warning: it is -- the caller's responsability to insure that conditions -- 1. and 2. above are satisfied : no check whatsoever -- is made in this method -- Status will return 0 if OK else it will return the pivot index -- of the matrix that was inverted to compute the multiplied -- BSpline : the method used is interpolation at Schoenenberg -- points of a(t)*F(t) Eval(U : Real; PeriodicFlag : Boolean ; DerivativeRequest : Integer ; ExtrapMode : in out Integer ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; ArrayDimension : Integer ; Poles : in out Real ; Result : in out Real) ; ---Purpose: Perform the De Boor algorithm to evaluate a point at -- parameter , with and . -- -- Poles is an array of Reals of size -- -- * +1 -- -- Containing the poles. At the end contains -- the current point. Poles Contain all the poles of -- the BsplineCurve, Knots also Contains all the knots -- of the BsplineCurve. ExtrapMode has two slots [0] = -- Degree used to extrapolate before the first knot [1] -- = Degre used to extrapolate after the last knot has -- to be between 1 and Degree Eval(U : Real; PeriodicFlag : Boolean ; DerivativeRequest : Integer ; ExtrapMode : in out Integer ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; ArrayDimension : Integer ; Poles : in out Real ; Weights : in out Real ; PolesResult : in out Real ; WeightsResult : in out Real) ; ---Purpose: Perform the De Boor algorithm to evaluate a point at -- parameter , with and . -- Evaluates by multiplying the Poles by the Weights and -- gives the homogeneous result in PolesResult that is -- the results of the evaluation of the numerator once it -- has been multiplied by the weights and in -- WeightsResult one has the result of the evaluation of -- the denominator -- -- Warning: and must be dimensionned -- properly. Eval(U : Real; PeriodicFlag : Boolean ; HomogeneousFlag : Boolean ; ExtrapMode : in out Integer ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp ; Weight : in out Real) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point Eval(U : Real; PeriodicFlag : Boolean ; HomogeneousFlag : Boolean ; ExtrapMode : in out Integer ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp ; Weight : in out Real) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point -- TangExtendToConstraint(FlatKnots : Array1OfReal from TColStd ; C1Coefficient : Real ; NumPoles : in Integer ; Poles : in out Real ; Dimension : Integer ; Degree : Integer ; ConstraintPoint : Array1OfReal from TColStd ; Continuity : Integer ; After : Boolean ; NbPolesResult : in out Integer ; NbKnotsRsult : in out Integer ; KnotsResult : in out Real ; PolesResult : in out Real) ; ---Purpose: Extend a BSpline nD using the tangency map -- is the coefficient of reparametrisation -- must be equal to 1, 2 or 3. -- must be greater or equal than + 1. -- -- Warning: and must be dimensionned -- properly. CacheD0(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp) ; ---Purpose: Perform the evaluation of the of the cache -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- this just evaluates the current point -- the CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effects CacheD0(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- ththe CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effectsis just evaluates the current point CoefsD0(U : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp) ; ---Purpose: Calls CacheD0 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CoefsD0(U : Real; Poles : Array1OfPnt2d from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp) ; ---Purpose: Calls CacheD0 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CacheD1(U : Real; Degree : Integer; CacheParameter: Real; SpanLenght : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp ; Vec : out Vec from gp) ; ---Purpose: Perform the evaluation of the of the cache -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- this just evaluates the current point -- the CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effects CacheD1(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp ; Vec : out Vec2d from gp) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- ththe CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effectsis just evaluates the current point CoefsD1(U : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp; Vec : out Vec from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CoefsD1(U : Real; Poles : Array1OfPnt2d from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp; Vec : out Vec2d from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CacheD2(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp ; Vec1,Vec2 : out Vec from gp) ; ---Purpose: Perform the evaluation of the of the cache -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- this just evaluates the current point -- the CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effects CacheD2(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp ; Vec1,Vec2 : out Vec2d from gp) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- ththe CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effectsis just evaluates the current point CoefsD2(U : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp; Vec1,Vec2 : out Vec from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CoefsD2(U : Real; Poles : Array1OfPnt2d from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp; Vec1,Vec2 : out Vec2d from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CacheD3(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp ; Vec1,Vec2,Vec3 : out Vec from gp) ; ---Purpose: Perform the evaluation of the of the cache -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- this just evaluates the current point -- the CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effects CacheD3(U : Real; Degree : Integer; CacheParameter : Real; SpanLenght : Real; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp ; Vec1,Vec2,Vec3 : out Vec2d from gp) ; ---Purpose: Perform the evaluation of the Bspline Basis -- and then multiplies by the weights -- this just evaluates the current point -- the parameter must be normalized between -- the 0 and 1 for the span. -- The Cache must be valid when calling this -- routine. Geom Package will insure that. -- and then multiplies by the weights -- ththe CacheParameter is where the Cache was -- constructed the SpanLength is to normalize -- the polynomial in the cache to avoid bad conditioning -- effectsis just evaluates the current point CoefsD3(U : Real; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt from gp; Vec1,Vec2,Vec3: out Vec from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline CoefsD3(U : Real; Poles : Array1OfPnt2d from TColgp ; Weights : Array1OfReal from TColStd ; Point : out Pnt2d from gp; Vec1,Vec2,Vec3: out Vec2d from gp) ; ---Purpose: Calls CacheD1 for Bezier Curves Arrays computed with -- the method PolesCoefficients. -- Warning: To be used for Beziercurves ONLY!!! ---C++: inline BuildCache(U : Real; InverseOfSpanDomain : Real; PeriodicFlag : Boolean ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt from TColgp; Weights : Array1OfReal from TColStd ; CachePoles : in out Array1OfPnt from TColgp; CacheWeights : in out Array1OfReal from TColStd) ; ---Purpose: Perform the evaluation of the Taylor expansion -- of the Bspline normalized between 0 and 1. -- If rational computes the homogeneous Taylor expension -- for the numerator and stores it in CachePoles BuildCache(U : Real; InverseOfSpanDomain : Real; PeriodicFlag : Boolean ; Degree : Integer; FlatKnots : Array1OfReal from TColStd ; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; CachePoles : in out Array1OfPnt2d from TColgp; CacheWeights : in out Array1OfReal from TColStd) ; ---Purpose: Perform the evaluation of the Taylor expansion -- of the Bspline normalized between 0 and 1. -- If rational computes the homogeneous Taylor expension -- for the numerator and stores it in CachePoles PolesCoefficients(Poles : Array1OfPnt2d from TColgp; CachePoles : in out Array1OfPnt2d from TColgp); ---Warning: To be used for Beziercurves ONLY!!! ---C++: inline PolesCoefficients(Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd ; CachePoles : in out Array1OfPnt2d from TColgp; CacheWeights : in out Array1OfReal from TColStd) ; ---Warning: To be used for Beziercurves ONLY!!! PolesCoefficients(Poles : Array1OfPnt from TColgp; CachePoles : in out Array1OfPnt from TColgp); ---Warning: To be used for Beziercurves ONLY!!! ---C++: inline PolesCoefficients(Poles : Array1OfPnt from TColgp; Weights : Array1OfReal from TColStd ; CachePoles : in out Array1OfPnt from TColgp; CacheWeights : in out Array1OfReal from TColStd) ; ---Purpose: Encapsulation of BuildCache to perform the -- evaluation of the Taylor expansion for beziercurves -- at parameter 0. -- Warning: To be used for Beziercurves ONLY!!! FlatBezierKnots (Degree: Integer) returns Real; ---Purpose: Returns pointer to statically allocated array representing -- flat knots for bezier curve of the specified degree. -- Raises OutOfRange if Degree > MaxDegree() ---C++: return const & BuildSchoenbergPoints(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : in out Array1OfReal from TColStd) ; ---Purpose: builds the Schoenberg points from the flat knot -- used to interpolate a BSpline since the -- BSpline matrix is invertible. Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; Poles : in out Array1OfPnt from TColgp ; InversionProblem : out Integer) ; ---Purpose: Performs the interpolation of the data given in -- the Poles array according to the requests in -- ContactOrderArray that is : if -- ContactOrderArray(i) has value d it means that -- Poles(i) containes the dth derivative of the -- function to be interpolated. The length L of the -- following arrays must be the same : -- Parameters, ContactOrderArray, Poles, -- The length of FlatKnots is Degree + L + 1 -- Warning: -- the method used to do that interpolation is -- gauss elimination WITHOUT pivoting. Thus if the -- diagonal is not dominant there is no guarantee -- that the algorithm will work. Nevertheless for -- Cubic interpolation or interpolation at Scheonberg -- points the method will work -- The InversionProblem will report 0 if there was no -- problem else it will give the index of the faulty -- pivot Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; Poles : in out Array1OfPnt2d from TColgp ; InversionProblem : out Integer) ; ---Purpose: Performs the interpolation of the data given in -- the Poles array according to the requests in -- ContactOrderArray that is : if -- ContactOrderArray(i) has value d it means that -- Poles(i) containes the dth derivative of the -- function to be interpolated. The length L of the -- following arrays must be the same : -- Parameters, ContactOrderArray, Poles, -- The length of FlatKnots is Degree + L + 1 -- Warning: -- the method used to do that interpolation is -- gauss elimination WITHOUT pivoting. Thus if the -- diagonal is not dominant there is no guarantee -- that the algorithm will work. Nevertheless for -- Cubic interpolation at knots or interpolation at Scheonberg -- points the method will work. -- The InversionProblem w -- ll report 0 if there was no -- problem else it will give the index of the faulty -- pivot Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; Poles : in out Array1OfPnt from TColgp ; Weights : in out Array1OfReal from TColStd ; InversionProblem : out Integer) ; ---Purpose: Performs the interpolation of the data given in -- the Poles array according to the requests in -- ContactOrderArray that is : if -- ContactOrderArray(i) has value d it means that -- Poles(i) containes the dth derivative of the -- function to be interpolated. The length L of the -- following arrays must be the same : -- Parameters, ContactOrderArray, Poles, -- The length of FlatKnots is Degree + L + 1 -- Warning: -- the method used to do that interpolation is -- gauss elimination WITHOUT pivoting. Thus if the -- diagonal is not dominant there is no guarantee -- that the algorithm will work. Nevertheless for -- Cubic interpolation at knots or interpolation at Scheonberg -- points the method will work. -- The InversionProblem will report 0 if there was no -- problem else it will give the index of the faulty -- pivot -- -- Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; Poles : in out Array1OfPnt2d from TColgp ; Weights : in out Array1OfReal from TColStd ; InversionProblem : out Integer) ; ---Purpose: Performs the interpolation of the data given in -- the Poles array according to the requests in -- ContactOrderArray that is : if -- ContactOrderArray(i) has value d it means that -- Poles(i) containes the dth derivative of the -- function to be interpolated. The length L of the -- following arrays must be the same : -- Parameters, ContactOrderArray, Poles, -- The length of FlatKnots is Degree + L + 1 -- Warning: -- the method used to do that interpolation is -- gauss elimination WITHOUT pivoting. Thus if the -- diagonal is not dominant there is no guarantee -- that the algorithm will work. Nevertheless for -- Cubic interpolation at knots or interpolation at Scheonberg -- points the method will work. -- The InversionProblem w -- ll report 0 if there was no -- problem else it will give the i Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; ArrayDimension : Integer ; Poles : in out Real ; InversionProblem : out Integer) ; ---Purpose: Performs the interpolation of the data given in -- the Poles array according to the requests in -- ContactOrderArray that is : if -- ContactOrderArray(i) has value d it means that -- Poles(i) containes the dth derivative of the -- function to be interpolated. The length L of the -- following arrays must be the same : -- Parameters, ContactOrderArray -- The length of FlatKnots is Degree + L + 1 -- The PolesArray is an seen as an -- Array[1..N][1..ArrayDimension] with N = tge length -- of the parameters array -- Warning: -- the method used to do that interpolation is -- gauss elimination WITHOUT pivoting. Thus if the -- diagonal is not dominant there is no guarantee -- that the algorithm will work. Nevertheless for -- Cubic interpolation or interpolation at Scheonberg -- points the method will work -- The InversionProblem will report 0 if there was no -- problem else it will give the index of the faulty -- pivot -- Interpolate(Degree : Integer ; FlatKnots : Array1OfReal from TColStd ; Parameters : Array1OfReal from TColStd ; ContactOrderArray : Array1OfInteger from TColStd ; ArrayDimension : Integer ; Poles : in out Real ; Weights : in out Real ; InversionProblem : out Integer) ; MovePoint(U : Real; -- parameter of the point Displ : Vec2d from gp; -- translation vector of the point Index1 : Integer; -- first movable pole Index2 : Integer; -- last movable pole Degree : Integer; Rational : Boolean; Poles : Array1OfPnt2d from TColgp; Weights : Array1OfReal from TColStd; FlatKnots : Array1OfReal from TColStd; FirstIndex : in out Integer; -- first pole modified LastIndex : in out Integer; -- last pole modified NewPoles : in out Array1OfPnt2d from TColgp); -- new poles ---Purpose: Find the new poles which allows an old point (with a -- given u as parameter) to reach a new position -- Index1 and Index2 indicate the range of poles we can move -- (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side -- don't enter (1,NbPoles) -> error: rigid move -- (2, NbPoles-1) -> the ends are enforced -- (3, NbPoles-2) -> the ends and the tangency are enforced -- if Problem in BSplineBasis calculation, no change for the curve -- and FirstIndex, LastIndex = 0 MovePoint(U : Real; -- parameter of the point Displ : Vec from gp; -- translation vector of the point Index1 : Integer; -- first movable pole Index2 : Integer; -- last movable pole Degree : Integer; Rational : Boolean; Poles : Array1OfPnt from TColgp; Weights : Array1OfReal from TColStd; FlatKnots : Array1OfReal from TColStd; FirstIndex : in out Integer; -- first pole modified LastIndex : in out Integer; -- last pole modified NewPoles : in out Array1OfPnt from TColgp); -- new poles ---Purpose: Find the new poles which allows an old point (with a -- given u as parameter) to reach a new position -- Index1 and Index2 indicate the range of poles we can move -- (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side -- don't enter (1,NbPoles) -> error: rigid move -- (2, NbPoles-1) -> the ends are enforced -- (3, NbPoles-2) -> the ends and the tangency are enforced -- if Problem in BSplineBasis calculation, no change for the curve -- and FirstIndex, LastIndex = 0 MovePointAndTangent(U : Real ; ArrayDimension : Integer ; Delta : in out Real ; DeltaDerivative : in out Real ; Tolerance : Real ; Degree : Integer ; Rational : Boolean ; StartingCondition : Integer ; EndingCondition : Integer ; Poles : in out Real ; Weights : Array1OfReal from TColStd; FlatKnots : Array1OfReal from TColStd; NewPoles : in out Real ; ErrorStatus : in out Integer) ; ---Purpose: This is the dimension free version of the utility -- U is the parameter must be within the first FlatKnots and the -- last FlatKnots Delta is the amount the curve has to be moved -- DeltaDerivative is the amount the derivative has to be moved. -- Delta and DeltaDerivative must be array of dimension -- ArrayDimension Degree is the degree of the BSpline and the -- FlatKnots are the knots of the BSpline Starting Condition if = -- -1 means the starting point of the curve can move -- = 0 means the -- starting point of the cuve cannot move but tangen starting -- point of the curve cannot move -- = 1 means the starting point and tangents cannot move -- = 2 means the starting point tangent and curvature cannot move -- = ... -- Same holds for EndingCondition -- Poles are the poles of the curve -- Weights are the weights of the curve if Rational = Standard_True -- NewPoles are the poles of the deformed curve -- ErrorStatus will be 0 if no error happened -- 1 if there are not enough knots/poles -- the imposed conditions -- The way to solve this problem is to add knots to the BSpline -- If StartCondition = 1 and EndCondition = 1 then you need at least -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need -- have at least 2 internal knots. MovePointAndTangent(U : Real ; Delta : Vec from gp ; DeltaDerivative : Vec from gp ; Tolerance : Real ; Degree : Integer ; Rational : Boolean ; StartingCondition : Integer ; EndingCondition : Integer ; Poles : Array1OfPnt from TColgp ; Weights : Array1OfReal from TColStd; FlatKnots : Array1OfReal from TColStd; NewPoles : in out Array1OfPnt from TColgp ; ErrorStatus : in out Integer) ; ---Purpose: This is the dimension free version of the utility -- U is the parameter must be within the first FlatKnots and the -- last FlatKnots Delta is the amount the curve has to be moved -- DeltaDerivative is the amount the derivative has to be moved. -- Delta and DeltaDerivative must be array of dimension -- ArrayDimension Degree is the degree of the BSpline and the -- FlatKnots are the knots of the BSpline Starting Condition if = -- -1 means the starting point of the curve can move -- = 0 means the -- starting point of the cuve cannot move but tangen starting -- point of the curve cannot move -- = 1 means the starting point and tangents cannot move -- = 2 means the starting point tangent and curvature cannot move -- = ... -- Same holds for EndingCondition -- Poles are the poles of the curve -- Weights are the weights of the curve if Rational = Standard_True -- NewPoles are the poles of the deformed curve -- ErrorStatus will be 0 if no error happened -- 1 if there are not enough knots/poles -- the imposed conditions -- The way to solve this problem is to add knots to the BSpline -- If StartCondition = 1 and EndCondition = 1 then you need at least -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need -- have at least 2 internal knots. MovePointAndTangent(U : Real ; Delta : Vec2d from gp ; DeltaDerivative : Vec2d from gp ; Tolerance : Real ; Degree : Integer ; Rational : Boolean ; StartingCondition : Integer ; EndingCondition : Integer ; Poles : Array1OfPnt2d from TColgp ; Weights : Array1OfReal from TColStd ; FlatKnots : Array1OfReal from TColStd ; NewPoles : in out Array1OfPnt2d from TColgp ; ErrorStatus : in out Integer) ; ---Purpose: This is the dimension free version of the utility -- U is the parameter must be within the first FlatKnots and the -- last FlatKnots Delta is the amount the curve has to be moved -- DeltaDerivative is the amount the derivative has to be moved. -- Delta and DeltaDerivative must be array of dimension -- ArrayDimension Degree is the degree of the BSpline and the -- FlatKnots are the knots of the BSpline Starting Condition if = -- -1 means the starting point of the curve can move -- = 0 means the -- starting point of the cuve cannot move but tangen starting -- point of the curve cannot move -- = 1 means the starting point and tangents cannot move -- = 2 means the starting point tangent and curvature cannot move -- = ... -- Same holds for EndingCondition -- Poles are the poles of the curve -- Weights are the weights of the curve if Rational = Standard_True -- NewPoles are the poles of the deformed curve -- ErrorStatus will be 0 if no error happened -- 1 if there are not enough knots/poles -- the imposed conditions -- The way to solve this problem is to add knots to the BSpline -- If StartCondition = 1 and EndCondition = 1 then you need at least -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need -- have at least 2 internal knots. Resolution( PolesArray : in out Real ; ArrayDimension : Integer ; NumPoles : Integer ; Weights : in Array1OfReal from TColStd; FlatKnots : in Array1OfReal from TColStd; Degree : in Integer; Tolerance3D : Real from Standard ; UTolerance : out Real from Standard) ; ---Purpose: -- given a tolerance in 3D space returns a -- tolerance in U parameter space such that -- all u1 and u0 in the domain of the curve f(u) -- | u1 - u0 | < UTolerance and -- we have |f (u1) - f (u0)| < Tolerance3D Resolution( Poles : in Array1OfPnt from TColgp ; Weights : in Array1OfReal from TColStd ; NumPoles : in Integer from Standard ; FlatKnots : in Array1OfReal from TColStd ; Degree : in Integer from Standard ; Tolerance3D : Real from Standard ; UTolerance : out Real from Standard) ; ---Purpose: -- given a tolerance in 3D space returns a -- tolerance in U parameter space such that -- all u1 and u0 in the domain of the curve f(u) -- | u1 - u0 | < UTolerance and -- we have |f (u1) - f (u0)| < Tolerance3D Resolution( Poles : in Array1OfPnt2d from TColgp ; Weights : in Array1OfReal from TColStd ; NumPoles : in Integer from Standard ; FlatKnots : in Array1OfReal from TColStd ; Degree : in Integer ; Tolerance3D : Real from Standard ; UTolerance : out Real from Standard) ; ---Purpose: -- given a tolerance in 3D space returns a -- tolerance in U parameter space such that -- all u1 and u0 in the domain of the curve f(u) -- | u1 - u0 | < UTolerance and -- we have |f (u1) - f (u0)| < Tolerance3D end BSplCLib;