7129af78866f6eb76c2085d343a0afbab2f2ed99
[occt.git] / src / BSplCLib / BSplCLib.cdl
1 -- File:        BSplCLib.cdl
2 -- Created:     Fri Aug  9 15:12:53 1991
3 -- Author:      Jean Claude VAUTHIER
4 ---Copyright:    Matra Datavision 1991, 1992
5 --               
6 --Modified : RLE Aug   1993  Major modifications.  
7 --  15-Mar-95  xab : added cache mecanism to speed up 
8 --  evaluation
9 --  25-Mar-95  xab : added Lagrange evaluator
10 -- mei : modified 08-Jun-95 : added method MovePoint
11 -- xab : modified 11-Mar-96 : added method MovePointAndTangent
12 -- xab : modified 18-Mar-97 : added method to reparameterise a bspline 
13 -- jct : modified 15-Apr-97 : added method to extend a bspline 
14
15 package BSplCLib
16
17     ---Purpose:  BSplCLib   B-spline curve Library.
18     --  
19     --  The BSplCLib package is  a basic library  for BSplines. It
20     --  provides three categories of functions.
21     --  
22     --  * Management methods to  process knots and multiplicities.
23     --  
24     --  * Multi-Dimensions  spline methods.  BSpline methods where
25     --  poles have an arbitrary number of dimensions. They divides
26     --  in two groups :
27     --  
28     --    - Global methods modifying the  whole set of  poles. The
29     --    poles are    described   by an array   of   Reals and  a
30     --    Dimension. Example : Inserting knots.
31     --    
32     --    - Local methods  computing  points and derivatives.  The
33     --    poles  are described by a pointer  on  a local array  of
34     --    Reals and a Dimension. The local array is modified.
35     --  
36     --  *  2D  and 3D spline   curves  methods.
37     --  
38     --    Methods  for 2d and 3d BSplines  curves  rational or not
39     --    rational. 
40     --    
41     --    Those methods have the following structure :
42     --    
43     --     - They extract the pole informations in a working array.
44     --     
45     --     -  They      process the  working   array    with   the
46     --     multi-dimension  methods. (for example  a  3d  rational
47     --     curve is processed as a 4 dimension curve).
48     --     
49     --     - They get back the result in the original dimension.
50     --     
51     --     Note that the  bspline   surface methods found   in the
52     --     package BSplSLib  uses  the same  structure and rely on
53     --     BSplCLib.
54     --     
55     --     In the following list  of methods the  2d and 3d  curve
56     --     methods   will be  described   with  the  corresponding
57     --     multi-dimension method.
58     --  
59     --  The 3d or 2d B-spline curve is defined with :
60     --  
61     --  . its control points : TColgp_Array1OfPnt(2d)        Poles
62     --  . its weights        : TColStd_Array1OfReal          Weights
63     --  . its knots          : TColStd_Array1OfReal          Knots 
64     --  . its multiplicities : TColStd_Array1OfInteger       Mults
65     --  . its degree         : Standard_Integer              Degree
66     --  . its periodicity    : Standard_Boolean              Periodic   
67     --
68     -- Warnings :
69     --  The bounds of Poles and Weights should be the same.
70     --  The bounds of Knots and Mults   should be the same.
71     --  
72     --  Weights can be a null reference (BSplCLib::NoWeights())
73     --  the curve is non rational.
74     --  
75     --  Mults can be a null reference   (BSplCLib::NoMults())
76     --  the knots are "flat" knots.
77     --  
78     -- KeyWords :
79     --  B-spline curve, Functions, Library
80     --  
81     -- References :
82     --  . A survey of curves and surfaces methods in CADG Wolfgang 
83     --    BOHM CAGD 1 (1984)
84     --  . On de Boor-like algorithms and blossoming Wolfgang BOEHM
85     --    cagd 5 (1988)
86     --  . Blossoming and knot insertion algorithms for B-spline curves
87     --    Ronald N. GOLDMAN
88     --  . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA   
89     --  . Curves and Surfaces for Computer Aided Geometric Design,
90     --    a practical guide Gerald Farin
91
92 uses TColStd, gp, TColgp, math
93
94
95 is
96
97     imported EvaluatorFunction ;
98     ---Purpose: this is a one dimensional function 
99     --  typedef  void (*EvaluatorFunction)  (
100     --  Standard_Integer     // Derivative Request
101     --  Standard_Real    *   // StartEnd[2] 
102     --  Standard_Real        // Parameter
103     --  Standard_Real    &   // Result
104     --  Standard_Integer &) ;// Error Code
105     --  serves to multiply a given vectorial BSpline by a function 
106
107     enumeration KnotDistribution is NonUniform, Uniform;
108     ---Purpose: This enumeration describes the repartition of the
109     --         knots  sequence.   If all the knots  differ  by the
110     --         same positive constant from the  preceding knot the
111     --         "KnotDistribution" is    <Uniform>    else   it  is
112     --         <NonUniform>
113
114     enumeration MultDistribution is NonConstant, Constant, QuasiConstant;
115     ---Purpose:  This   enumeration describes the   form  of  the
116     --         sequence of mutiplicities.  MultDistribution is :
117     --          
118     --            Constant if all the multiplicities have the same
119     --            value.
120     --          
121     --            QuasiConstant if all the internal knots have the
122     --            same multiplicity and if the first and last knot
123     --            have  a different  multiplicity.  
124     --            
125     --            NonConstant in other cases.
126
127         -------------------------------------------------------------
128         -------------------------------------------------------------
129         ----------                                         ----------
130         ----------          Knots and Multiplicities       ----------
131         ----------                                         ----------
132         -------------------------------------------------------------
133         -------------------------------------------------------------
134
135     Hunt (XX   : in Array1OfReal from TColStd;
136           X    : in Real;
137           Iloc : in out Integer);
138     ---Purpose:  This routine searches the position of the real
139     --         value X in  the ordered set of  real  values XX.
140     --         
141     --         The  elements   in   the  table    XX  are   either
142     --         monotonically    increasing     or    monotonically
143     --         decreasing.
144     --         
145     --         The input   value Iloc is    used to initialize the
146     --         algorithm  :  if  Iloc  is outside  of   the bounds
147     --         [XX.Lower(), -- XX.Upper()] the bisection algorithm
148     --         is used else  the routine searches from  a previous
149     --         known position  by increasing steps  then converges
150     --         by bisection.
151     --         
152     --         This  routine is used to  locate a  knot value in a
153     --         set of knots.
154     --         
155     ---References : Numerical Recipes in C (William H.Press, Brian
156     --            P.  Flannery,  Saul   A.  Teukolsky, William  T.
157     --            Vetterling)
158
159     FirstUKnotIndex (Degree : Integer;
160                      Mults  : Array1OfInteger from TColStd)
161     returns Integer;
162     ---Purpose: Computes the index of the knots value which gives
163     --         the start point of the curve.
164      
165
166     LastUKnotIndex (Degree : Integer;
167                     Mults  : Array1OfInteger from TColStd)
168     returns Integer;
169     ---Purpose: Computes the index of the knots value which gives
170     --         the end point of the curve.
171      
172     FlatIndex (Degree : Integer;
173                Index  : Integer;
174                Mults  : Array1OfInteger from TColStd;
175                Periodic : Boolean)
176     returns Integer;
177     ---Purpose: Computes the index  of  the  flats knots  sequence
178     --          corresponding  to  <Index> in  the  knots sequence
179     --          which multiplicities are <Mults>.
180      
181     LocateParameter (Degree     : Integer; 
182                      Knots      : Array1OfReal from TColStd; 
183                      Mults      : Array1OfInteger from TColStd;
184                      U          : Real; 
185                      IsPeriodic : Boolean;
186                      FromK1     : Integer;
187                      ToK2       : Integer;
188                      KnotIndex  : in out Integer;
189                      NewU       : in out Real);
190     ---Purpose:  Locates  the parametric value    U  in the knots
191     --         sequence  between  the  knot K1   and the knot  K2.
192     --         The value return in Index verifies.
193     --  
194     --          Knots(Index) <= U < Knots(Index + 1)
195     --          if U <= Knots (K1) then Index = K1
196     --          if U >= Knots (K2) then Index = K2 - 1
197     --          
198     --          If Periodic is True U  may be  modified  to fit in
199     --          the range  Knots(K1), Knots(K2).  In any case  the
200     --          correct value is returned in NewU.
201     --  
202     --  Warnings :Index is used  as input   data to initialize  the
203     --          searching  function.
204     --  Warning: Knots have to be "withe repetitions"
205                      
206     LocateParameter (Degree     : Integer; 
207                      Knots      : Array1OfReal from TColStd; 
208                      U          : Real; 
209                      IsPeriodic : Boolean;
210                      FromK1     : Integer;
211                      ToK2       : Integer;
212                      KnotIndex  : in out Integer;
213                      NewU       : in out Real);
214     ---Purpose:  Locates  the parametric value    U  in the knots
215     --         sequence  between  the  knot K1   and the knot  K2.
216     --         The value return in Index verifies.
217     --  
218     --          Knots(Index) <= U < Knots(Index + 1)
219     --          if U <= Knots (K1) then Index = K1
220     --          if U >= Knots (K2) then Index = K2 - 1
221     --          
222     --          If Periodic is True U  may be  modified  to fit in
223     --          the range  Knots(K1), Knots(K2).  In any case  the
224     --          correct value is returned in NewU.
225     --  
226     --  Warnings :Index is used  as input   data to initialize  the
227     --          searching  function.
228     --  Warning: Knots have to be "flat"
229
230     LocateParameter (Knots    : Array1OfReal from TColStd; 
231                      U        : Real; 
232                      Periodic : Boolean;
233                      K1,K2    : Integer;
234                      Index    : in out Integer;
235                      NewU     : in out Real;
236                      Uf,Ue    : Real)
237     is private;     
238     ---Level: Internal  
239                    
240     LocateParameter (Degree   : Integer;
241                      Knots    : Array1OfReal    from TColStd; 
242                      Mults    : Array1OfInteger from TColStd;
243                      U        : Real; 
244                      Periodic : Boolean;
245                      Index    : in out Integer;
246                      NewU     : in out Real);
247     ---Level: Internal
248
249     MaxKnotMult (Mults  : Array1OfInteger from TColStd;
250                  K1, K2 : Integer)
251     returns Integer;  
252     ---Purpose: Finds the greatest multiplicity in a set of knots
253     --         between  K1  and K2.   Mults  is  the  multiplicity
254     --         associated with each knot value.
255
256     MinKnotMult (Mults  : Array1OfInteger from TColStd;
257                  K1, K2 : Integer)
258     returns Integer;  
259     ---Purpose: Finds the lowest multiplicity in  a  set of knots
260     --         between   K1  and K2.   Mults is  the  multiplicity
261     --         associated with each knot value.
262
263     NbPoles(Degree   : Integer;
264             Periodic : Boolean;
265             Mults    : Array1OfInteger from TColStd) 
266     returns Integer;
267     ---Purpose: Returns the number of poles of the curve. Returns 0 if
268     --          one of the multiplicities is incorrect.
269     --          
270     --          * Non positive.
271     --          
272     --          * Greater than Degree,  or  Degree+1  at the first and
273     --          last knot of a non periodic curve.
274     --          
275     --          *  The  last periodicity  on  a periodic  curve is not
276     --          equal to the first.
277
278     KnotSequenceLength(Mults    : Array1OfInteger from TColStd;
279                        Degree   : Integer;
280                        Periodic : Boolean)
281     returns Integer;
282     ---Purpose: Returns the length  of the sequence  of knots with
283     --          repetition.
284     --          
285     --          Periodic :
286     --          
287     --          Sum(Mults(i), i = Mults.Lower(); i <= Mults.Upper());
288     --          
289     --          Non Periodic :
290     --          
291     --          Sum(Mults(i); i = Mults.Lower(); i < Mults.Upper())
292     --          + 2 * Degree
293
294     KnotSequence (Knots    : Array1OfReal from TColStd; 
295                   Mults    : Array1OfInteger from TColStd;
296                   KnotSeq  : in out Array1OfReal from TColStd);
297                 
298     KnotSequence (Knots    : Array1OfReal from TColStd; 
299                   Mults    : Array1OfInteger from TColStd;
300                   Degree   : Integer;
301                   Periodic : Boolean;
302                   KnotSeq  : in out Array1OfReal from TColStd);
303     ---Purpose: Computes  the  sequence   of knots KnotSeq  with
304     --         repetition  of the  knots  of multiplicity  greater
305     --         than 1.
306     --  
307     --  Length of KnotSeq must be KnotSequenceLength(Mults,Degree,Periodic)
308
309     KnotsLength( KnotSeq  :  Array1OfReal from TColStd; 
310                  Periodic  :  Boolean  =  Standard_False) 
311     returns  Integer; 
312     ---Purpose: Returns the  length  of the   sequence of  knots  (and
313     --          Mults)  without repetition.
314            
315     Knots( KnotSeq  :  Array1OfReal from TColStd; 
316            Knots    :  out Array1OfReal from TColStd; 
317            Mults    :  out Array1OfInteger from TColStd; 
318            Periodic  :  Boolean  =  Standard_False);
319     ---Purpose:  Computes  the  sequence   of knots Knots  without
320     --         repetition  of the  knots  of multiplicity  greater
321     --         than 1.
322     --  
323     --       Length  of <Knots> and  <Mults> must be 
324     --    KnotsLength(KnotSequence,Periodic)
325
326     KnotForm  (Knots : Array1OfReal from TColStd;
327                FromK1, ToK2 : Integer)
328     returns KnotDistribution;
329     ---Purpose: Analyses if the  knots distribution is "Uniform"
330     --         or  "NonUniform" between  the  knot  FromK1 and the
331     --         knot ToK2.  There is  no repetition of  knot in the
332     --         knots'sequence <Knots>.
333
334     MultForm  (Mults : Array1OfInteger from TColStd;
335                FromK1, ToK2 : Integer)
336     returns MultDistribution;
337     ---Purpose:
338     --  Analyses the distribution of multiplicities between
339     --  the knot FromK1 and the Knot ToK2.
340
341     Reparametrize (U1, U2 : Real;
342                    Knots : in out Array1OfReal from TColStd);
343     ---Purpose:
344     --  Reparametrizes a B-spline curve to [U1, U2].
345     --  The knot values are recomputed such that Knots (Lower) = U1
346     --  and Knots (Upper) = U2   but the knot form is not modified. 
347     --   Warnings :
348     --  In the array Knots the values must be in ascending order.
349     --  U1 must not be equal to U2 to avoid division by zero.
350
351
352     Reverse (Knots : in out Array1OfReal from TColStd);
353     ---Purpose: Reverses  the  array   knots  to  become  the knots
354     --          sequence of the reversed curve. 
355         
356     Reverse (Mults : in out Array1OfInteger from TColStd);
357     ---Purpose: Reverses  the  array of multiplicities.
358         
359     Reverse (Poles    : in out Array1OfPnt  from TColgp;
360              Last     : Integer);
361     ---Purpose: Reverses the array of poles. Last is the  index of
362     --          the new first pole. On  a  non periodic curve last
363     --          is Poles.Upper(). On a periodic curve last is 
364     --          
365     --          (number of flat knots - degree - 1) 
366     --          
367     --          or
368     --          
369     --          (sum of multiplicities(but  for the last) + degree
370     --          - 1)
371
372     Reverse (Poles    : in out Array1OfPnt2d  from TColgp;
373              Last     : Integer);
374     ---Purpose: Reverses the array of poles.
375
376     Reverse (Weights  : in out Array1OfReal  from TColStd;
377              Last     : Integer);
378     ---Purpose: Reverses the array of poles.
379
380     IsRational(Weights : Array1OfReal from TColStd;
381                I1,I2   : Integer;
382                Epsilon : Real = 0.0) returns Boolean;
383     ---Purpose: 
384     --   Returns False if all the weights  of the  array <Weights>
385     --   between   I1 an I2   are  identic.   Epsilon  is used for
386     --   comparing  weights. If Epsilon  is 0. the  Epsilon of the
387     --   first weight is used.
388
389     MaxDegree  returns Integer;
390     ---Purpose: returns the degree maxima for a BSplineCurve.
391     ---C++: inline
392
393     Eval(U         : Real;
394          Degree    : Integer;
395          Knots     : in out Real;
396          Dimension : Integer;
397          Poles     : in out Real);
398     ---Purpose: Perform the Boor  algorithm  to  evaluate a point at
399     --          parameter <U>, with <Degree> and <Dimension>.
400     --          
401     --          Poles is  an array of  Reals of size 
402     --          
403     --          <Dimension> *  <Degree>+1
404     --          
405     --          Containing  the poles.  At  the end <Poles> contains
406     --          the current point.
407
408     BoorScheme(U         : Real;
409                Degree    : Integer;
410                Knots     : in out Real;
411                Dimension : Integer;
412                Poles     : in out Real;
413                Depth     : Integer;
414                Length    : Integer);
415     ---Purpose: Performs the  Boor Algorithm  at  parameter <U> with
416     --          the given <Degree> and the  array of <Knots> on  the
417     --          poles <Poles> of dimension  <Dimension>.  The schema
418     --          is  computed  until  level  <Depth>  on a   basis of
419     --          <Length+1> poles.
420     --          
421     --          * Knots is an array of reals of length :
422     --          
423     --            <Length> + <Degree>
424     --          
425     --          * Poles is an array of reals of length :
426     --          
427     --           (2 * <Length> + 1) * <Dimension> 
428     --           
429     --           The poles values  must be  set  in the array at the
430     --           positions. 
431     --           
432     --            0..Dimension, 
433     --            
434     --            2 * Dimension ..  
435     --            3 * Dimension
436     --            
437     --            4  * Dimension ..  
438     --            5  * Dimension
439     --            
440     --            ...
441     --            
442     --            The results are found in the array poles depending
443     --            on the Depth. (See the method GetPole).
444
445     AntiBoorScheme(U         : Real;
446                    Degree    : Integer;
447                    Knots     : in out Real;
448                    Dimension : Integer;
449                    Poles     : in out Real;
450                    Depth     : Integer;
451                    Length    : Integer;
452                    Tolerance : Real) returns Boolean;
453     ---Purpose: Compute  the content of  Pole before the BoorScheme.
454     --          This method is used to remove poles. 
455     --          
456     --          U is the poles to  remove, Knots should contains the
457     --          knots of the curve after knot removal.
458     --          
459     --          The first  and last poles  do not  change, the other
460     --          poles are computed by averaging two possible values.
461     --          The distance between  the  two   possible  poles  is
462     --          computed, if it  is higher than <Tolerance> False is
463     --          returned.
464
465     Derivative(Degree    : Integer;
466                Knots     : in out Real;
467                Dimension : Integer;
468                Length    : Integer;
469                Order     : Integer;
470                Poles     : in out Real);
471     ---Purpose: Computes   the   poles of  the    BSpline  giving the
472     --          derivatives of order <Order>.
473     --          
474     --          The formula for the first order is
475     --          
476     --          Pole(i) = Degree * (Pole(i+1) - Pole(i)) / 
477     --                             (Knots(i+Degree+1) - Knots(i+1))
478     --                             
479     --          This formula  is repeated  (Degree  is decremented at
480     --          each step).
481
482     Bohm(U         : Real;
483          Degree    : Integer;
484          N         : Integer;
485          Knots     : in out Real;
486          Dimension : Integer;
487          Poles     : in out Real);
488     ---Purpose: Performs the Bohm  Algorithm at  parameter <U>. This
489     --          algorithm computes the value and all the derivatives
490     --          up to order N (N <= Degree).
491     --          
492     --          <Poles> is the original array of poles.
493     --          
494     --          The   result in  <Poles>  is    the value and    the
495     --          derivatives.  Poles[0] is  the value,  Poles[Degree]
496     --          is the last  derivative.
497
498     
499     NoWeights returns Array1OfReal from TColStd;
500     ---Purpose: Used as argument for a non rational curve.
501     --          
502     ---C++: return &
503     ---C++: inline
504     
505     NoMults  returns Array1OfInteger from TColStd;
506     ---Purpose: Used as argument for a flatknots evaluation.
507     --          
508     ---C++: return &
509     ---C++: inline
510
511     BuildKnots(Degree, Index : Integer;
512                Periodic   : Boolean;
513                Knots      : Array1OfReal    from TColStd;
514                Mults      : Array1OfInteger from TColStd;
515                LK         : in out Real);
516     ---Purpose: Stores in LK  the usefull knots  for the BoorSchem
517     --          on the span Knots(Index) - Knots(Index+1)
518           
519     PoleIndex (Degree, Index : Integer;
520                Periodic   : Boolean;
521                Mults      : Array1OfInteger from TColStd)
522     returns Integer;
523     ---Purpose: Return the index of the  first Pole to  use on the
524     --          span  Mults(Index)  - Mults(Index+1).  This  index
525     --          must be added to Poles.Lower().
526           
527     BuildEval(Degree,Index : Integer;
528               Poles      : Array1OfReal    from TColStd;
529               Weights    : Array1OfReal    from TColStd;
530               LP         : in out Real);
531
532     BuildEval(Degree,Index : Integer;
533               Poles      : Array1OfPnt     from TColgp;
534               Weights    : Array1OfReal    from TColStd;
535               LP         : in out Real);
536
537     BuildEval(Degree,Index : Integer;
538               Poles      : Array1OfPnt2d   from TColgp;
539               Weights    : Array1OfReal    from TColStd;
540               LP         : in out Real);
541     ---Purpose: Copy in <LP>  the poles and  weights for  the Eval
542     --          scheme. starting from  Poles(Poles.Lower()+Index)
543
544     BuildBoor(Index,Length,Dimension : Integer;
545               Poles      : Array1OfReal    from TColStd;
546               LP         : in out Real);
547     ---Purpose: Copy in <LP>  poles for <Dimension>  Boor  scheme.
548     --          Starting  from    <Index>     *  <Dimension>, copy
549     --          <Length+1> poles.
550
551
552     BoorIndex(Index, Length, Depth : Integer)
553     returns Integer;
554     ---Purpose: Returns the index in  the Boor result array of the
555     --          poles <Index>. If  the Boor  algorithm was perform
556     --          with <Length> and <Depth>.
557
558     GetPole(Index,Length,Depth,Dimension : Integer;
559             LocPoles : in out Real;
560             Position : in out Integer;
561             Pole     : in out Array1OfReal from TColStd);
562     ---Purpose: Copy  the  pole at  position  <Index>  in  the Boor
563     --          scheme of   dimension <Dimension> to  <Position> in
564     --          the array <Pole>. <Position> is updated.
565
566     PrepareInsertKnots (
567      Degree     : in Integer; 
568      Periodic   : in Boolean;
569      Knots      : in Array1OfReal    from TColStd;
570      Mults      : in Array1OfInteger from TColStd;
571      AddKnots   : in Array1OfReal    from TColStd;
572      AddMults   : in Array1OfInteger from TColStd;
573      NbPoles    : out Integer;
574      NbKnots    : out Integer;
575      Epsilon    : in Real;
576      Add        : in Boolean = Standard_True) 
577     returns Boolean;
578     ---Purpose: Returns in <NbPoles, NbKnots> the  new number of poles
579     --          and  knots    if  the  sequence   of  knots <AddKnots,
580     --          AddMults> is inserted in the sequence <Knots, Mults>.
581     --          
582     --          Epsilon is used to compare knots for equality.
583     --          
584     --          If Add is True  the multiplicities on  equal knots are
585     --          added. 
586     --          
587     --          If Add is False the max value of the multiplicities is
588     --          kept. 
589     --          
590     --          Return False if :
591     --            The knew knots are knot increasing.
592     --            The new knots are not in the range.
593
594     InsertKnots (
595      Degree     : in Integer; 
596      Periodic   : in Boolean;
597      Dimension  : in Integer;
598      Poles      : in Array1OfReal     from TColStd;
599      Knots      : in Array1OfReal     from TColStd;
600      Mults      : in Array1OfInteger  from TColStd;
601      AddKnots   : in Array1OfReal     from TColStd;
602      AddMults   : in Array1OfInteger  from TColStd;
603      NewPoles   : out Array1OfReal    from TColStd;
604      NewKnots   : out Array1OfReal    from TColStd;
605      NewMults   : out Array1OfInteger from TColStd;
606      Epsilon    : in Real;
607      Add        : in Boolean = Standard_True);
608     
609     InsertKnots (
610      Degree     : in Integer; 
611      Periodic   : in Boolean;
612      Poles      : in Array1OfPnt      from TColgp;
613      Weights    : in Array1OfReal     from TColStd;
614      Knots      : in Array1OfReal     from TColStd;
615      Mults      : in Array1OfInteger  from TColStd;
616      AddKnots   : in Array1OfReal     from TColStd;
617      AddMults   : in Array1OfInteger  from TColStd;
618      NewPoles   : out Array1OfPnt     from TColgp;
619      NewWeights : out Array1OfReal    from TColStd;
620      NewKnots   : out Array1OfReal    from TColStd;
621      NewMults   : out Array1OfInteger from TColStd;
622      Epsilon    : in Real;
623      Add        : in Boolean = Standard_True);
624
625     InsertKnots (
626      Degree     : in Integer; 
627      Periodic   : in Boolean;
628      Poles      : in Array1OfPnt2d    from TColgp;
629      Weights    : in Array1OfReal     from TColStd;
630      Knots      : in Array1OfReal     from TColStd;
631      Mults      : in Array1OfInteger  from TColStd;
632      AddKnots   : in Array1OfReal     from TColStd;
633      AddMults   : in Array1OfInteger  from TColStd;
634      NewPoles   : out Array1OfPnt2d   from TColgp;
635      NewWeights : out Array1OfReal    from TColStd;
636      NewKnots   : out Array1OfReal    from TColStd;
637      NewMults   : out Array1OfInteger from TColStd;
638      Epsilon    : in Real;
639      Add        : in Boolean = Standard_True);
640     ---Purpose: Insert   a  sequence  of  knots <AddKnots> with
641     --  multiplicities   <AddMults>. <AddKnots>   must  be a   non
642     --  decreasing sequence and verifies :
643     --  
644     --  Knots(Knots.Lower()) <= AddKnots(AddKnots.Lower())
645     --  Knots(Knots.Upper()) >= AddKnots(AddKnots.Upper())
646     --  
647     --  The NewPoles and NewWeights arrays must have a length :
648     --    Poles.Length() + Sum(AddMults())
649     --    
650     --  When a knot  to insert is identic  to an existing knot the
651     --  multiplicities   are added. 
652     --  
653     --  Epsilon is used to test knots for equality.
654     --  
655     --  When AddMult is negative or null the knot is not inserted.
656     --  No multiplicity will becomes higher than the degree.
657     --  
658     --  The new Knots and Multiplicities  are copied in <NewKnots>
659     --  and  <NewMults>. 
660     --  
661     --  All the New arrays should be correctly dimensioned.
662     --  
663     --  When all  the new knots  are existing knots, i.e. only the
664     --  multiplicities  will  change it is   safe to  use the same
665     --  arrays as input and output.
666
667     InsertKnot (
668      UIndex     : in Integer;
669      U          : in Real; 
670      UMult      : in Integer; 
671      Degree     : in Integer; 
672      Periodic   : in Boolean;
673      Poles      : in Array1OfPnt     from TColgp;
674      Weights    : in Array1OfReal    from TColStd;
675      Knots      : in Array1OfReal    from TColStd;
676      Mults      : in Array1OfInteger from TColStd;
677      NewPoles   : out Array1OfPnt    from TColgp;
678      NewWeights : out Array1OfReal   from TColStd);
679
680     InsertKnot   (
681      UIndex     : in Integer;
682      U          : in Real;
683      UMult      : in Integer; 
684      Degree     : in Integer;
685      Periodic   : in Boolean;
686      Poles      : in Array1OfPnt2d   from TColgp;
687      Weights    : in Array1OfReal    from TColStd;
688      Knots      : in Array1OfReal    from TColStd; 
689      Mults      : in Array1OfInteger from TColStd;
690      NewPoles   : out Array1OfPnt2d  from TColgp;
691      NewWeights : out Array1OfReal   from TColStd);
692     ---Purpose: Insert a new knot U of multiplicity UMult in the
693     --  knot sequence.
694     --  
695     --  The  location of the new Knot  should be given as an input
696     --  data.  UIndex locates the new knot U  in the knot sequence
697     --  and Knots (UIndex) < U < Knots (UIndex + 1).
698     --  
699     --  The new control points corresponding to this insertion are
700     --  returned. Knots and Mults are not updated.
701     
702     RaiseMultiplicity (
703      KnotIndex  : in Integer; 
704      Mult       : in Integer;
705      Degree     : in Integer;
706      Periodic   : in Boolean;
707      Poles      : in Array1OfPnt     from TColgp;
708      Weights    : in Array1OfReal    from TColStd;
709      Knots      : in Array1OfReal    from TColStd; 
710      Mults      : in Array1OfInteger from TColStd; 
711      NewPoles   : out Array1OfPnt    from TColgp;
712      NewWeights : out Array1OfReal   from TColStd);
713
714     RaiseMultiplicity (
715      KnotIndex  : in Integer; 
716      Mult       : in Integer;
717      Degree     : in Integer;
718      Periodic   : in Boolean;
719      Poles      : in Array1OfPnt2d   from TColgp;
720      Weights    : in Array1OfReal    from TColStd;
721      Knots      : in Array1OfReal    from TColStd; 
722      Mults      : in Array1OfInteger from TColStd; 
723      NewPoles   : out Array1OfPnt2d  from TColgp;
724      NewWeights : out Array1OfReal   from TColStd);
725     ---Purpose: Raise the multiplicity of knot to <UMult>.
726     --  
727     --  The new control points  are  returned. Knots and Mults are
728     --  not updated.
729
730     RemoveKnot (
731      Index      : in Integer;
732      Mult       : in Integer; 
733      Degree     : in Integer; 
734      Periodic   : in Boolean;
735      Dimension  : in Integer;
736      Poles      : in Array1OfReal     from TColStd;
737      Knots      : in Array1OfReal     from TColStd;
738      Mults      : in Array1OfInteger  from TColStd;
739      NewPoles   : out Array1OfReal    from TColStd;
740      NewKnots   : out Array1OfReal    from TColStd;
741      NewMults   : out Array1OfInteger from TColStd;
742      Tolerance  : Real)  returns Boolean;
743      
744     RemoveKnot (
745      Index      : in Integer;
746      Mult       : in Integer; 
747      Degree     : in Integer; 
748      Periodic   : in Boolean;
749      Poles      : in Array1OfPnt      from TColgp;
750      Weights    : in Array1OfReal     from TColStd;
751      Knots      : in Array1OfReal     from TColStd;
752      Mults      : in Array1OfInteger  from TColStd;
753      NewPoles   : out Array1OfPnt     from TColgp;
754      NewWeights : out Array1OfReal    from TColStd;
755      NewKnots   : out Array1OfReal    from TColStd;
756      NewMults   : out Array1OfInteger from TColStd;
757      Tolerance  : Real)  returns Boolean;
758
759     RemoveKnot (
760      Index      : in Integer;
761      Mult       : in Integer; 
762      Degree     : in Integer; 
763      Periodic   : in Boolean;
764      Poles      : in Array1OfPnt2d    from TColgp;
765      Weights    : in Array1OfReal     from TColStd;
766      Knots      : in Array1OfReal     from TColStd;
767      Mults      : in Array1OfInteger  from TColStd;
768      NewPoles   : out Array1OfPnt2d   from TColgp;
769      NewWeights : out Array1OfReal    from TColStd;
770      NewKnots   : out Array1OfReal    from TColStd;
771      NewMults   : out Array1OfInteger from TColStd;
772      Tolerance  : Real)  returns Boolean;
773     ---Purpose: Decrement the  multiplicity  of <Knots(Index)>
774     --          to <Mult>. If <Mult>   is  null the   knot  is
775     --          removed. 
776     --          
777     --          As there are two ways to compute the new poles
778     --          the midlle   will  be used  as  long    as the
779     --          distance is lower than Tolerance.
780     --          
781     --          If a  distance is  bigger  than  tolerance the
782     --          methods returns False  and  the new arrays are
783     --          not modified.
784     --          
785     --          A low  tolerance can be  used  to test  if the
786     --          knot  can be  removed  without  modifying  the
787     --          curve. 
788     --          
789     --          A high tolerance  can be used  to "smooth" the 
790     --          curve.
791     
792     
793     IncreaseDegreeCountKnots (Degree, NewDegree : Integer;
794                               Periodic          : Boolean;
795                               Mults             : Array1OfInteger from TColStd)
796     returns Integer;
797     ---Purpose: Returns the   number   of  knots   of  a  curve   with
798     --          multiplicities <Mults> after elevating the degree from
799     --          <Degree> to <NewDegree>. See the IncreaseDegree method
800     --          for more comments.
801
802     IncreaseDegree  (Degree, 
803                      NewDegree   : in Integer;
804                      Periodic    : in Boolean;
805                      Dimension   : in Integer;
806                      Poles       : in Array1OfReal        from TColStd; 
807                      Knots       : in Array1OfReal        from TColStd; 
808                      Mults       : in Array1OfInteger     from TColStd; 
809                      NewPoles    : in out Array1OfReal    from TColStd;
810                      NewKnots    : in out Array1OfReal    from TColStd; 
811                      NewMults    : in out Array1OfInteger from TColStd); 
812
813     IncreaseDegree  (Degree, 
814                      NewDegree   : in Integer;
815                      Periodic    : in Boolean;
816                      Poles       : in Array1OfPnt         from TColgp; 
817                      Weights     : in Array1OfReal        from TColStd;
818                      Knots       : in Array1OfReal        from TColStd; 
819                      Mults       : in Array1OfInteger     from TColStd; 
820                      NewPoles    : in out Array1OfPnt     from TColgp; 
821                      NewWeights  : in out Array1OfReal    from TColStd;
822                      NewKnots    : in out Array1OfReal    from TColStd; 
823                     NewMults    : in out Array1OfInteger from TColStd); 
824
825     IncreaseDegree  (Degree, 
826                      NewDegree   : in Integer;
827                      Periodic    : in Boolean;
828                      Poles       : in Array1OfPnt2d       from TColgp; 
829                      Weights     : in Array1OfReal        from TColStd;
830                      Knots       : in Array1OfReal        from TColStd; 
831                      Mults       : in Array1OfInteger     from TColStd; 
832                      NewPoles    : in out Array1OfPnt2d   from TColgp; 
833                      NewWeights  : in out Array1OfReal    from TColStd;
834                      NewKnots    : in out Array1OfReal    from TColStd; 
835                      NewMults    : in out Array1OfInteger from TColStd); 
836
837
838     IncreaseDegree  (NewDegree   : in Integer;
839                      Poles       : in Array1OfPnt         from TColgp; 
840                      Weights     : in Array1OfReal        from TColStd;
841                      NewPoles    : in out Array1OfPnt     from TColgp; 
842                      NewWeights  : in out Array1OfReal    from TColStd);
843     ---Warning: To be used for Beziercurves ONLY!!!
844
845     IncreaseDegree  (NewDegree   : in Integer;
846                      Poles       : in Array1OfPnt2d       from TColgp; 
847                      Weights     : in Array1OfReal        from TColStd;
848                      NewPoles    : in out Array1OfPnt2d   from TColgp; 
849                      NewWeights  : in out Array1OfReal    from TColStd);
850     ---Purpose: Increase the degree of a bspline (or bezier) curve
851     --          of   dimension  <Dimension>  form <Degree>      to
852     --          <NewDegree>.
853     --          
854     --          The number of poles in the new curve is :
855     --          
856     --           Poles.Length() + (NewDegree - Degree) * Number of spans
857     --           
858     --          Where the number of spans is :
859     --          
860     --           LastUKnotIndex(Mults) - FirstUKnotIndex(Mults) + 1
861     --           
862     --           for a non-periodic curve
863     --           
864     --           And Knots.Length() - 1 for a periodic curve.
865     --          
866     --          The multiplicities of all  knots  are increased by
867     --          the degree elevation.
868     --           
869     --          The new knots are usually  the same knots with the
870     --          exception of  a non-periodic curve with  the first
871     --          and last multiplicity not  equal to Degree+1 where
872     --          knots are removed  form the start  and the  bottom
873     --          untils the sum of the  multiplicities is  equal to
874     --          NewDegree+1  at the  knots   corresponding  to the
875     --          first and last parameters of the curve.
876     --          
877     --          Example  :  Suppose a  curve  of degree 3 starting
878     --          with following knots and multiplicities :
879     --          
880     --          knot : 0.  1.  2.
881     --          mult : 1   2   1
882     --          
883     --          The  FirstUKnot is  2.     because the   sum    of
884     --          multiplicities is Degree+1 : 1 + 2 + 1 = 4 = 3 + 1
885     --          
886     --          i.e. the first parameter  of the  curve is  2. and
887     --          will still be   2.  after degree  elevation.   Let
888     --          raises this curve to degree 4.  The multiplicities
889     --          are increased by 2.
890     --          
891     --          They   become 2 3  2.   But     we need a   sum of
892     --          multiplicities  of 5 at knot  2. So the first knot
893     --          is removed and the new knots are :
894     --          
895     --          knot : 1.  2.
896     --          mult : 3   2
897     --          
898     --          The multipicity   of the first  knot may   also be
899     --          reduced if the sum is still to big.
900     --          
901     --          In the  most common situations (periodic  curve or
902     --          curve with first and last multiplicities equals to
903     --          Degree+1) the knots are knot changes.
904     --          
905     --          The method IncreaseDegreeCountKnots can be used to
906     --          compute the new number of knots.\
907     --
908     ---Warning: To be used for Beziercurves ONLY!!!
909
910     PrepareUnperiodize (Degree  : in  Integer         from Standard;
911                         Mults   : in  Array1OfInteger from TColStd;
912                         NbKnots : out Integer         from Standard; 
913                         NbPoles : out Integer         from Standard);
914     ---Purpose: Set in <NbKnots> and <NbPolesToAdd> the number of Knots and
915     --          Poles   of  the NotPeriodic  Curve   identical  at the
916     --          periodic     curve with    a  degree    <Degree>  ,  a
917     --          knots-distribution with Multiplicities <Mults>.
918
919     Unperiodize (Degree    : in  Integer         from Standard;
920                  Dimension : in  Integer         from Standard;
921                  Mults     : in  Array1OfInteger from TColStd;
922                  Knots     : in  Array1OfReal    from TColStd;
923                  Poles     : in  Array1OfReal    from TColStd;
924                  NewMults  : out Array1OfInteger from TColStd;
925                  NewKnots  : out Array1OfReal    from TColStd;
926                  NewPoles  : out Array1OfReal    from TColStd);
927                
928     Unperiodize (Degree    : in  Integer         from Standard;
929                  Mults     : in  Array1OfInteger from TColStd;
930                  Knots     : in  Array1OfReal    from TColStd;
931                  Poles     : in  Array1OfPnt     from TColgp;
932                  Weights   : in  Array1OfReal    from TColStd;
933                  NewMults  : out Array1OfInteger from TColStd;
934                  NewKnots  : out Array1OfReal    from TColStd;
935                  NewPoles  : out Array1OfPnt     from TColgp;
936                  NewWeights: out Array1OfReal    from TColStd);
937                
938     Unperiodize (Degree    : in  Integer         from Standard;
939                  Mults     : in  Array1OfInteger from TColStd;
940                  Knots     : in  Array1OfReal    from TColStd;
941                  Poles     : in  Array1OfPnt2d   from TColgp;
942                  Weights   : in  Array1OfReal    from TColStd;
943                  NewMults  : out Array1OfInteger from TColStd;
944                  NewKnots  : out Array1OfReal    from TColStd;
945                  NewPoles  : out Array1OfPnt2d   from TColgp;
946                  NewWeights: out Array1OfReal    from TColStd);
947                
948
949     PrepareTrimming (Degree  : in  Integer         from Standard;
950                      Periodic: in  Boolean         from Standard;
951                      Knots   : in  Array1OfReal    from TColStd;
952                      Mults   : in  Array1OfInteger from TColStd;
953                      U1      : in  Real            from Standard;
954                      U2      : in  Real            from Standard;
955                      NbKnots : out Integer         from Standard; 
956                      NbPoles : out Integer         from Standard);
957     ---Purpose: Set in <NbKnots> and <NbPoles> the number of Knots and
958     --          Poles of the  curve resulting  of  the trimming of the
959     --          BSplinecurve definded with <degree>, <knots>, <mults>
960
961     Trimming (Degree     : in  Integer         from Standard;
962               Periodic   : in  Boolean         from Standard;
963               Dimension  : in  Integer         from Standard;
964               Knots      : in  Array1OfReal    from TColStd;
965               Mults      : in  Array1OfInteger from TColStd;
966               Poles      : in  Array1OfReal    from TColStd;
967               U1         : in  Real            from Standard;
968               U2         : in  Real            from Standard;
969               NewKnots   : out Array1OfReal    from TColStd;
970               NewMults   : out Array1OfInteger from TColStd;
971               NewPoles   : out Array1OfReal    from TColStd);
972
973
974     Trimming (Degree     : in  Integer         from Standard;
975               Periodic   : in  Boolean         from Standard;
976               Knots      : in  Array1OfReal    from TColStd;
977               Mults      : in  Array1OfInteger from TColStd;
978               Poles      : in  Array1OfPnt     from TColgp;
979               Weights    : in  Array1OfReal    from TColStd;
980               U1         : in  Real            from Standard;
981               U2         : in  Real            from Standard;
982               NewKnots   : out Array1OfReal    from TColStd;
983               NewMults   : out Array1OfInteger from TColStd;
984               NewPoles   : out Array1OfPnt     from TColgp;
985               NewWeights : out Array1OfReal    from TColStd);
986
987
988     Trimming (Degree     : in  Integer         from Standard;
989               Periodic   : in  Boolean         from Standard;
990               Knots      : in  Array1OfReal    from TColStd;
991               Mults      : in  Array1OfInteger from TColStd;
992               Poles      : in  Array1OfPnt2d   from TColgp;
993               Weights    : in  Array1OfReal    from TColStd;
994               U1         : in  Real            from Standard;
995               U2         : in  Real            from Standard;
996               NewKnots   : out Array1OfReal    from TColStd;
997               NewMults   : out Array1OfInteger from TColStd;
998               NewPoles   : out Array1OfPnt2d   from TColgp;
999               NewWeights : out Array1OfReal    from TColStd);
1000
1001
1002
1003
1004
1005     -------------------------------------------------------------
1006     -------------------------------------------------------------
1007     ----------                                     ----------
1008     ----------      Curve Evaluations              ----------
1009     ----------                                     ----------
1010     -------------------------------------------------------------
1011     -------------------------------------------------------------
1012     
1013     D0(U        : in Real;
1014        Index    : in Integer; 
1015        Degree   : in Integer; 
1016        Periodic : in Boolean;
1017        Poles    : in Array1OfReal    from TColStd;
1018        Weights  : in Array1OfReal    from TColStd;
1019        Knots    : in Array1OfReal    from TColStd;
1020        Mults    : in Array1OfInteger from TColStd;
1021        P        : out Real);
1022      
1023     D0(U        : in Real;
1024        Index    : in Integer; 
1025        Degree   : in Integer; 
1026        Periodic : in Boolean;
1027        Poles    : in Array1OfPnt     from TColgp; 
1028        Weights  : in Array1OfReal    from TColStd;
1029        Knots    : in Array1OfReal    from TColStd;
1030        Mults    : in Array1OfInteger from TColStd;
1031        P        : out Pnt from gp);
1032      
1033     D0(U        : in Real;
1034        UIndex   : in Integer; 
1035        Degree   : in Integer; 
1036        Periodic : in Boolean;
1037        Poles    : in Array1OfPnt2d   from TColgp; 
1038        Weights  : in Array1OfReal    from TColStd;
1039        Knots    : in Array1OfReal    from TColStd;
1040        Mults    : in Array1OfInteger from TColStd;
1041        P        : out Pnt2d from gp);
1042      
1043     D0(U        : in Real;
1044        Poles    : in Array1OfPnt     from TColgp; 
1045        Weights  : in Array1OfReal    from TColStd;
1046        P        : out Pnt from gp);
1047     ---Warning: To be used for Beziercurves ONLY!!!
1048
1049     D0(U        : in Real;
1050        Poles    : in Array1OfPnt2d   from TColgp; 
1051        Weights  : in Array1OfReal    from TColStd;
1052        P        : out Pnt2d from gp);
1053     ---Warning: To be used for Beziercurves ONLY!!!
1054      
1055     D1(U        : in Real;
1056        Index    : in Integer; 
1057        Degree   : in Integer; 
1058        Periodic : in Boolean;
1059        Poles    : in Array1OfReal    from TColStd; 
1060        Weights  : in Array1OfReal    from TColStd;
1061        Knots    : in Array1OfReal    from TColStd;
1062        Mults    : in Array1OfInteger from TColStd;
1063        P        : out Real;
1064        V        : out Real);
1065        
1066     D1(U        : in Real;
1067        Index    : in Integer; 
1068        Degree   : in Integer; 
1069        Periodic : in Boolean;
1070        Poles    : in Array1OfPnt     from TColgp; 
1071        Weights  : in Array1OfReal    from TColStd;
1072        Knots    : in Array1OfReal    from TColStd;
1073        Mults    : in Array1OfInteger from TColStd;
1074        P        : out Pnt from gp;
1075        V        : out Vec from gp);
1076        
1077     D1(U        : in Real;
1078        UIndex   : in Integer; 
1079        Degree   : in Integer; 
1080        Periodic : in Boolean;
1081        Poles    : in Array1OfPnt2d   from TColgp; 
1082        Weights  : in Array1OfReal    from TColStd;
1083        Knots    : in Array1OfReal    from TColStd;
1084        Mults    : in Array1OfInteger from TColStd;
1085        P        : out Pnt2d from gp;
1086        V        : out Vec2d from gp);
1087      
1088     D1(U        : in Real;
1089        Poles    : in Array1OfPnt     from TColgp; 
1090        Weights  : in Array1OfReal    from TColStd;
1091        P        : out Pnt from gp;
1092        V        : out Vec from gp);
1093     ---Warning: To be used for Beziercurves ONLY!!!
1094
1095     D1(U        : in Real;
1096        Poles    : in Array1OfPnt2d   from TColgp; 
1097        Weights  : in Array1OfReal    from TColStd;
1098        P        : out Pnt2d from gp;
1099        V        : out Vec2d from gp);
1100     ---Warning: To be used for Beziercurves ONLY!!!
1101
1102     D2(U        : in Real;
1103        Index    : in Integer; 
1104        Degree   : in Integer; 
1105        Periodic : in Boolean;
1106        Poles    : in Array1OfReal    from TColStd; 
1107        Weights  : in Array1OfReal    from TColStd;
1108        Knots    : in Array1OfReal    from TColStd;
1109        Mults    : in Array1OfInteger from TColStd;
1110        P        : out Real;
1111        V1,V2    : out Real);
1112      
1113     D2(U        : in Real;
1114        Index    : in Integer; 
1115        Degree   : in Integer; 
1116        Periodic : in Boolean;
1117        Poles    : in Array1OfPnt     from TColgp; 
1118        Weights  : in Array1OfReal    from TColStd;
1119        Knots    : in Array1OfReal    from TColStd;
1120        Mults    : in Array1OfInteger from TColStd;
1121        P        : out Pnt from gp;
1122        V1,V2    : out Vec from gp);
1123      
1124     D2(U        : in Real;
1125        UIndex   : in Integer; 
1126        Degree   : in Integer; 
1127        Periodic : in Boolean;
1128        Poles    : in Array1OfPnt2d   from TColgp; 
1129        Weights  : in Array1OfReal    from TColStd;
1130        Knots    : in Array1OfReal    from TColStd;
1131        Mults    : in Array1OfInteger from TColStd;
1132        P        : out Pnt2d from gp;
1133        V1,V2    : out Vec2d from gp);
1134      
1135     D2(U        : in Real;
1136        Poles    : in Array1OfPnt     from TColgp; 
1137        Weights  : in Array1OfReal    from TColStd;
1138        P        : out Pnt from gp;
1139        V1,V2    : out Vec from gp);
1140     ---Warning: To be used for Beziercurves ONLY!!!
1141
1142     D2(U        : in Real;
1143        Poles    : in Array1OfPnt2d   from TColgp; 
1144        Weights  : in Array1OfReal    from TColStd;
1145        P        : out Pnt2d from gp;
1146        V1,V2    : out Vec2d from gp);
1147     ---Warning: To be used for Beziercurves ONLY!!!
1148
1149     D3(U        : in Real;
1150        Index    : in Integer; 
1151        Degree   : in Integer; 
1152        Periodic : in Boolean;
1153        Poles    : in Array1OfReal    from TColStd; 
1154        Weights  : in Array1OfReal    from TColStd;
1155        Knots    : in Array1OfReal    from TColStd;
1156        Mults    : in Array1OfInteger from TColStd;
1157        P        : out Real;
1158        V1,V2,V3 : out Real);
1159      
1160     D3(U        : in Real;
1161        Index    : in Integer; 
1162        Degree   : in Integer; 
1163        Periodic : in Boolean;
1164        Poles    : in Array1OfPnt     from TColgp; 
1165        Weights  : in Array1OfReal    from TColStd;
1166        Knots    : in Array1OfReal    from TColStd;
1167        Mults    : in Array1OfInteger from TColStd;
1168        P        : out Pnt from gp;
1169        V1,V2,V3 : out Vec from gp);
1170      
1171     D3(U        : in Real;
1172        UIndex   : in Integer; 
1173        Degree   : in Integer; 
1174        Periodic : in Boolean;
1175        Poles    : in Array1OfPnt2d   from TColgp; 
1176        Weights  : in Array1OfReal    from TColStd;
1177        Knots    : in Array1OfReal    from TColStd;
1178        Mults    : in Array1OfInteger from TColStd;
1179        P        : out Pnt2d from gp;
1180        V1,V2,V3 : out Vec2d from gp);
1181        
1182     D3(U        : in Real;
1183        Poles    : in Array1OfPnt     from TColgp; 
1184        Weights  : in Array1OfReal    from TColStd;
1185        P        : out Pnt from gp;
1186        V1,V2,V3 : out Vec from gp);
1187     ---Warning: To be used for Beziercurves ONLY!!!
1188
1189     D3(U        : in Real;
1190        Poles    : in Array1OfPnt2d   from TColgp; 
1191        Weights  : in Array1OfReal    from TColStd;
1192        P        : out Pnt2d from gp;
1193        V1,V2,V3 : out Vec2d from gp);
1194     ---Warning: To be used for Beziercurves ONLY!!!
1195
1196     DN(U        : in Real;
1197        N        : in Integer;
1198        Index    : in Integer; 
1199        Degree   : in Integer; 
1200        Periodic : in Boolean;
1201        Poles    : in Array1OfReal    from TColStd; 
1202        Weights  : in Array1OfReal    from TColStd;
1203        Knots    : in Array1OfReal    from TColStd;
1204        Mults    : in Array1OfInteger from TColStd;
1205        VN       : out Real);
1206      
1207     DN(U        : in Real;
1208        N        : in Integer;
1209        Index    : in Integer; 
1210        Degree   : in Integer; 
1211        Periodic : in Boolean;
1212        Poles    : in Array1OfPnt     from TColgp; 
1213        Weights  : in Array1OfReal    from TColStd;
1214        Knots    : in Array1OfReal    from TColStd;
1215        Mults    : in Array1OfInteger from TColStd;
1216        VN       : out Vec from gp);
1217      
1218     DN(U        : in Real;
1219        N        : in Integer;
1220        UIndex   : in Integer; 
1221        Degree   : in Integer; 
1222        Periodic : in Boolean;
1223        Poles    : in Array1OfPnt2d   from TColgp; 
1224        Weights  : in Array1OfReal    from TColStd;
1225        Knots    : in Array1OfReal    from TColStd;
1226        Mults    : in Array1OfInteger from TColStd;
1227        V        : out Vec2d from gp);
1228      
1229     DN(U        : in Real;
1230        N        : in Integer;
1231        Poles    : in Array1OfPnt     from TColgp; 
1232        Weights  : in Array1OfReal    from TColStd;
1233        P        : out Pnt from gp;
1234        VN       : out Vec from gp);
1235     ---Warning: To be used for Beziercurves ONLY!!!
1236
1237     DN(U        : in Real;
1238        N        : in Integer;
1239        Poles    : in Array1OfPnt2d   from TColgp; 
1240        Weights  : in Array1OfReal    from TColStd;
1241        P        : out Pnt2d from gp;
1242        VN       : out Vec2d from gp);
1243     ---Purpose:  The  above  functions  compute   values and
1244     --         derivatives in the following situations :
1245     --         
1246     --         * 3D, 2D and 1D
1247     --         
1248     --         * Rational or not Rational. 
1249     --         
1250     --         * Knots  and multiplicities or "flat knots" without
1251     --         multiplicities.
1252     --         
1253     --         * The  <Index>  is   the the  localization  of  the
1254     --         parameter in the knot sequence.  If <Index> is  out
1255     --         of range the correct value will be searched.
1256     --         
1257     --         
1258     --         VERY IMPORTANT!!!
1259     --         USE  BSplCLib::NoWeights()  as Weights argument for non
1260     --         rational curves computations.
1261     ---Warning: To be used for Beziercurves ONLY!!!
1262
1263     EvalBsplineBasis(Side                       : in Integer ;
1264                      DerivativeOrder            : in Integer ;
1265                      Order                      : in Integer ;
1266                      FlatKnots                  : Array1OfReal from TColStd ;
1267                      Parameter                  : in Real    ;
1268                      FirstNonZeroBsplineIndex   : in out Integer ;
1269                      BsplineBasis               : in out Matrix from math)
1270
1271     returns Integer  ; 
1272     ---Purpose: This  evaluates  the Bspline  Basis  at  a
1273     --          given  parameter  Parameter   up   to  the
1274     --          requested   DerivativeOrder  and store the
1275     --          result  in the  array BsplineBasis  in the
1276     --          following   fashion  
1277     --          BSplineBasis(1,1)   =  
1278     --          value of first non vanishing 
1279     --          Bspline function which has Index FirstNonZeroBsplineIndex 
1280     --            BsplineBasis(1,2)   = 
1281     --            value of second non vanishing 
1282     --          Bspline   function which  has   Index
1283     --          FirstNonZeroBsplineIndex + 1
1284     --          BsplineBasis(1,n)   = 
1285     --            value of second non vanishing non vanishing
1286     --          Bspline   function which  has   Index
1287     --          FirstNonZeroBsplineIndex + n (n <= Order) 
1288     --          BSplineBasis(2,1)   =  
1289     --          value of derivative of first non vanishing 
1290     --          Bspline function which has Index FirstNonZeroBsplineIndex 
1291     --            BSplineBasis(N,1)   =  
1292     --          value of Nth derivative of first non vanishing 
1293     --          Bspline function which has Index FirstNonZeroBsplineIndex
1294     --          if N <= DerivativeOrder + 1
1295
1296     BuildBSpMatrix(Parameters   : in Array1OfReal from TColStd;
1297                    OrderArray   : in Array1OfInteger from TColStd;
1298                    FlatKnots    : in Array1OfReal from TColStd;
1299                    Degree       : in Integer;
1300                    Matrix       : in out Matrix from math;
1301                    UpperBandWidth : out Integer ;
1302                    LowerBandWidth : out Integer) returns Integer ;
1303     ---Purpose: This Builds   a fully  blown   Matrix of
1304     --            (ni)
1305     --          Bi    (tj)  
1306     --          
1307     --          with i  and j within 1..Order + NumPoles
1308     --          The  integer ni is   the ith slot of the
1309     --          array OrderArray, tj is the jth slot of
1310     --          the array Parameters
1311     
1312     FactorBandedMatrix(Matrix            : in out Matrix from math ;
1313                        UpperBandWidth    : in Integer ;
1314                        LowerBandWidth    : in Integer ;
1315                        PivotIndexProblem : out Integer) returns Integer ; 
1316     ---Purpose: this  factors  the Banded Matrix in
1317     --         the LU form with a Banded storage of 
1318     --         components of the L matrix 
1319     --         WARNING : do not use if the Matrix is
1320     --         totally positive (It is the case for
1321     --         Bspline matrices build as above with
1322     --         parameters being the Schoenberg points
1323
1324     SolveBandedSystem (Matrix : in Matrix from math ;
1325                        UpperBandWidth    : in Integer ;
1326                        LowerBandWidth    : in Integer ;
1327                        ArrayDimension    : in Integer ;
1328                        Array             : in out Real)
1329     returns Integer ;
1330     ---Purpose: This solves  the system Matrix.X =  B
1331     --         with when Matrix is factored in LU form
1332     --         The  Array   is    an   seen   as    an
1333     --         Array[1..N][1..ArrayDimension] with N =
1334     --         the  rank  of the  matrix  Matrix.  The
1335     --         result is stored   in Array  when  each
1336     --         coordinate is  solved that is  B is the
1337     --         array whose values are 
1338     --         B[i] = Array[i][p] for each p in 1..ArrayDimension
1339                     
1340     SolveBandedSystem (Matrix : in Matrix from math ;
1341                        UpperBandWidth    : in Integer ;
1342                        LowerBandWidth    : in Integer ;
1343                        Array             : in out Array1OfPnt2d from TColgp)  
1344     returns Integer ;
1345     ---Purpose: This solves  the system Matrix.X =  B
1346     --         with when Matrix is factored in LU form
1347     --         The  Array   has the length of  
1348     --         the  rank  of the  matrix  Matrix.  The
1349     --         result is stored   in Array  when  each
1350     --         coordinate is  solved that is  B is the
1351     --         array whose values are 
1352     --         B[i] = Array[i][p] for each p in 1..ArrayDimension
1353
1354     SolveBandedSystem (Matrix : in Matrix from math ;
1355                        UpperBandWidth    : in Integer ;
1356                        LowerBandWidth    : in Integer ;
1357                        Array             : in out Array1OfPnt   from TColgp)  
1358     returns Integer ;
1359     ---Purpose: This solves  the system Matrix.X =  B
1360     --         with when Matrix is factored in LU form
1361     --         The  Array   has the length of 
1362     --         the  rank  of the  matrix  Matrix.  The
1363     --         result is stored   in Array  when  each
1364     --         coordinate is  solved that is  B is the
1365     --         array whose values are 
1366     --         B[i] = Array[i][p] for each p in 1..ArrayDimension
1367
1368     SolveBandedSystem (Matrix : in Matrix from math ;
1369                        UpperBandWidth    : in Integer ;
1370                        LowerBandWidth    : in Integer ;
1371                        HomogenousFlag    : in Boolean ;
1372                        ArrayDimension    : Integer ; 
1373                        Array             : in out Real ;
1374                        Weights           : in out Real ) 
1375     returns Integer ;
1376
1377     SolveBandedSystem (Matrix : in Matrix from math ;
1378                        UpperBandWidth    : in Integer ;
1379                        LowerBandWidth    : in Integer ;
1380                        HomogenousFlag    : in Boolean ;
1381                        Array             : in out Array1OfPnt2d from TColgp; 
1382                        Weights           : in out Array1OfReal from TColStd  ) 
1383     returns Integer ;
1384     ---Purpose: This solves the  system Matrix.X =  B
1385     --         with when Matrix is factored in LU form
1386     --         The    Array   is    an   seen  as   an
1387     --         Array[1..N][1..ArrayDimension] with N =
1388     --         the  rank  of  the  matrix Matrix.  The
1389     --         result is  stored   in Array when  each
1390     --         coordinate is  solved that is B  is the
1391     --         array  whose   values     are   B[i]  =
1392     --         Array[i][p]       for     each  p    in
1393     --         1..ArrayDimension. If  HomogeneousFlag ==
1394     --         0  the  Poles  are  multiplied by   the
1395     --         Weights   uppon   Entry   and      once
1396     --         interpolation   is    carried  over the
1397     --         result of the  poles are divided by the
1398     --         result of   the   interpolation of  the
1399     --         weights. Otherwise if HomogenousFlag == 1
1400     --         the Poles and Weigths are treated homogenously 
1401     --         that is that those are interpolated as they
1402     --         are and result is returned without division
1403     --         by the interpolated weigths.
1404
1405     SolveBandedSystem (Matrix : in Matrix from math ;
1406                        UpperBandWidth    : in Integer ;
1407                        LowerBandWidth    : in Integer ;
1408                        HomogeneousFlag   : in Boolean ;
1409                        Array             : in out Array1OfPnt   from TColgp; 
1410                        Weights           : in out Array1OfReal from TColStd )
1411     returns Integer ;
1412     ---Purpose: This solves  the system Matrix.X =  B
1413     --         with when Matrix is factored in LU form
1414     --         The  Array   is    an   seen   as    an
1415     --         Array[1..N][1..ArrayDimension] with N =
1416     --         the  rank  of the  matrix  Matrix.  The
1417     --         result is stored   in Array  when  each
1418     --         coordinate is  solved that is  B is the
1419     --         array whose values are 
1420     --         B[i] = Array[i][p] for each p in 1..ArrayDimension
1421     --         If  HomogeneousFlag ==
1422     --         0  the  Poles  are  multiplied by   the
1423     --         Weights   uppon   Entry   and      once
1424     --         interpolation   is    carried  over the
1425     --         result of the  poles are divided by the
1426     --         result of   the   interpolation of  the
1427     --         weights. Otherwise if HomogenousFlag == 1
1428     --         the Poles and Weigths are treated homogenously 
1429     --         that is that those are interpolated as they
1430     --         are and result is returned without division
1431     --         by the interpolated weigths.
1432
1433     MergeBSplineKnots(Tolerance         : Real from Standard  ;
1434                       StartValue        : Real from Standard  ;
1435                       EndValue          : Real from Standard  ;
1436                       Degree1           : Integer from Standard ;
1437                       Knots1            : Array1OfReal    from TColStd ;
1438                       Mults1            : Array1OfInteger from TColStd ;
1439                       Degree2           : Integer from Standard ;
1440                       Knots2            : Array1OfReal    from TColStd ;
1441                       Mults2            : Array1OfInteger from TColStd ;
1442                       NumPoles          : in out Integer ;
1443                       NewKnots          : in out HArray1OfReal    from TColStd ;
1444                       NewMults          : in out HArray1OfInteger from TColStd) ;
1445     ---Purpose:  Merges  two knot vector by   setting the starting and
1446     --          ending values to StartValue and EndValue 
1447
1448     FunctionReparameterise(Function            : EvaluatorFunction from BSplCLib ;          
1449                      BSplineDegree       : Integer ;
1450                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1451                      PolesDimension      : Integer ;
1452                      Poles               : in out Real ;
1453                      
1454                      FlatKnots           : Array1OfReal from TColStd ;
1455                      NewDegree           : Integer ;
1456                      NewPoles            : in out Real ;
1457                      Status              : in out Integer) ;
1458     ---Purpose: This function will compose  a given Vectorial BSpline F(t)
1459      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1460      --          its Poles  array which are coded as  an array of Real
1461      --          of  the  form  [1..NumPoles][1..PolesDimension] with  a
1462      --          function     a(t) which is   assumed to   satisfy the
1463      --          following: 
1464      --
1465      --       1. F(a(t))  is a polynomial BSpline
1466      --          that can be expressed  exactly as a BSpline of degree
1467      --          NewDegree on the knots FlatKnots 
1468      --
1469      --       2. a(t) defines a differentiable
1470      --          isomorphism between the range of FlatKnots to the range
1471      --          of BSplineFlatKnots which is the 
1472      --          same as the  range of F(t)  
1473      --
1474      --  Warning: it is
1475      --          the caller's responsability to insure that conditions
1476      --          1. and  2. above are  satisfied : no check whatsoever
1477      --          is made in this method 
1478      --
1479      -- Status will return 0 if OK else it will return the pivot index 
1480      --        of the matrix that was inverted to compute the multiplied
1481      --        BSpline : the method used is interpolation at Schoenenberg
1482      --        points of F(a(t))             
1483      
1484     FunctionReparameterise(
1485                      Function            : EvaluatorFunction from BSplCLib ;          
1486                      BSplineDegree       : Integer ;
1487                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1488                      Poles               : Array1OfReal from TColStd ;
1489                      
1490                      FlatKnots           : Array1OfReal from TColStd ;
1491                      NewDegree           : Integer ;
1492                      NewPoles            : in out Array1OfReal from TColStd ;
1493                      Status              : in out Integer) ;
1494      ---Purpose: This function will compose  a given Vectorial BSpline F(t)
1495      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1496      --          its Poles  array which are coded as  an array of Real
1497      --          of  the  form  [1..NumPoles][1..PolesDimension] with  a
1498      --          function     a(t) which is   assumed to   satisfy the
1499      --          following: 
1500      --
1501      --       1. F(a(t))  is a polynomial BSpline
1502      --          that can be expressed  exactly as a BSpline of degree
1503      --          NewDegree on the knots FlatKnots 
1504      --
1505      --       2. a(t) defines a differentiable
1506      --          isomorphism between the range of FlatKnots to the range
1507      --          of BSplineFlatKnots which is the 
1508      --          same as the  range of F(t)  
1509      --
1510      --  Warning: it is
1511      --          the caller's responsability to insure that conditions
1512      --          1. and  2. above are  satisfied : no check whatsoever
1513      --          is made in this method 
1514      --
1515      -- Status will return 0 if OK else it will return the pivot index 
1516      --        of the matrix that was inverted to compute the multiplied
1517      --        BSpline : the method used is interpolation at Schoenenberg
1518      --        points of F(a(t)) 
1519      
1520     FunctionReparameterise( Function            : EvaluatorFunction from BSplCLib ;          
1521                      BSplineDegree       : Integer ;
1522                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1523                      Poles               : Array1OfPnt from TColgp ;
1524                      
1525                      FlatKnots           : Array1OfReal from TColStd ;
1526                      NewDegree           : Integer ;
1527                      NewPoles            : in out Array1OfPnt from TColgp ;
1528                      Status              : in out Integer) ;
1529      ---Purpose: this will compose  a given Vectorial BSpline F(t)
1530      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1531      --          its Poles  array which are coded as  an array of Real
1532      --          of  the  form  [1..NumPoles][1..PolesDimension] with  a
1533      --          function     a(t) which is   assumed to   satisfy the
1534      --          following  : 1. F(a(t))  is a polynomial BSpline
1535      --          that can be expressed  exactly as a BSpline of degree
1536      --          NewDegree on the knots FlatKnots 
1537      --                       2. a(t) defines a differentiable
1538      --          isomorphism between the range of FlatKnots to the range
1539      --          of BSplineFlatKnots which is the 
1540      --          same as the  range of F(t)  
1541      --  Warning: it is
1542      --          the caller's responsability to insure that conditions
1543      --          1. and  2. above are  satisfied : no check whatsoever
1544      --          is made in this method 
1545      -- Status will return 0 if OK else it will return the pivot index 
1546      --        of the matrix that was inverted to compute the multiplied
1547      --        BSpline : the method used is interpolation at Schoenenberg
1548      --        points of F(a(t))        
1549  
1550      FunctionReparameterise(
1551                      Function            : EvaluatorFunction from BSplCLib ;          
1552                      BSplineDegree       : Integer ;
1553                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1554                      Poles               : Array1OfPnt2d from TColgp ;
1555                      
1556                      FlatKnots           : Array1OfReal from TColStd ;
1557                      NewDegree           : Integer ;
1558                      NewPoles            : in out Array1OfPnt2d from TColgp ;
1559                      Status              : in out Integer) ;     
1560      ---Purpose: this will compose  a given Vectorial BSpline F(t)
1561      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1562      --          its Poles  array which are coded as  an array of Real
1563      --          of  the  form  [1..NumPoles][1..PolesDimension] with  a
1564      --          function     a(t) which is   assumed to   satisfy the
1565      --          following  : 1. F(a(t))  is a polynomial BSpline
1566      --          that can be expressed  exactly as a BSpline of degree
1567      --          NewDegree on the knots FlatKnots 
1568      --                       2. a(t) defines a differentiable
1569      --          isomorphism between the range of FlatKnots to the range
1570      --          of BSplineFlatKnots which is the 
1571      --          same as the  range of F(t)  
1572      --  Warning: it is
1573      --          the caller's responsability to insure that conditions
1574      --          1. and  2. above are  satisfied : no check whatsoever
1575      --          is made in this method 
1576      -- Status will return 0 if OK else it will return the pivot index 
1577      --        of the matrix that was inverted to compute the multiplied
1578      --        BSpline : the method used is interpolation at Schoenenberg
1579      --        points of F(a(t))             
1580
1581     FunctionMultiply(Function            : EvaluatorFunction from BSplCLib ;          
1582                      BSplineDegree       : Integer ;
1583                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1584                      PolesDimension      : Integer ;
1585                      Poles               : in out Real ;
1586                      FlatKnots           : Array1OfReal from TColStd ;
1587                      NewDegree           : Integer ;
1588                      NewPoles            : in out Real ;
1589                      Status              : in out Integer) ;
1590      ---Purpose: this will  multiply a given Vectorial BSpline F(t)
1591      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1592      --          its Poles  array which are coded as  an array of Real
1593      --          of  the  form  [1..NumPoles][1..PolesDimension] by  a
1594      --          function     a(t) which is   assumed to   satisfy the
1595      --          following  : 1. a(t)  * F(t)  is a polynomial BSpline
1596      --          that can be expressed  exactly as a BSpline of degree
1597      --          NewDegree on the knots FlatKnots 2. the range of a(t)
1598      --           is the same as the  range of F(t)  
1599      --  Warning: it is
1600      --          the caller's responsability to insure that conditions
1601      --          1. and  2. above are  satisfied : no check whatsoever
1602      --          is made in this method 
1603      -- Status will return 0 if OK else it will return the pivot index 
1604      --        of the matrix that was inverted to compute the multiplied
1605      --        BSpline : the method used is interpolation at Schoenenberg
1606      --        points of a(t)*F(t) 
1607
1608     FunctionMultiply(Function            : EvaluatorFunction from BSplCLib ;          
1609                      BSplineDegree       : Integer ;
1610                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1611                      Poles               : Array1OfReal from TColStd ;
1612                      FlatKnots           : Array1OfReal from TColStd ;
1613                      NewDegree           : Integer ;
1614                      NewPoles            : in out Array1OfReal from TColStd ;
1615                      Status              : in out Integer) ;
1616      ---Purpose: this will  multiply a given Vectorial BSpline F(t)
1617      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1618      --          its Poles  array which are coded as  an array of Real
1619      --          of  the  form  [1..NumPoles][1..PolesDimension] by  a
1620      --          function     a(t) which is   assumed to   satisfy the
1621      --          following  : 1. a(t)  * F(t)  is a polynomial BSpline
1622      --          that can be expressed  exactly as a BSpline of degree
1623      --          NewDegree on the knots FlatKnots 2. the range of a(t)
1624      --           is the same as the  range of F(t)  
1625      --  Warning: it is
1626      --          the caller's responsability to insure that conditions
1627      --          1. and  2. above are  satisfied : no check whatsoever
1628      --          is made in this method 
1629      -- Status will return 0 if OK else it will return the pivot index 
1630      --        of the matrix that was inverted to compute the multiplied
1631      --        BSpline : the method used is interpolation at Schoenenberg
1632      --        points of a(t)*F(t) 
1633
1634     FunctionMultiply(Function            : EvaluatorFunction from BSplCLib ;          
1635                      BSplineDegree       : Integer ;
1636                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1637                      Poles               : Array1OfPnt2d from TColgp ;
1638                      FlatKnots           : Array1OfReal from TColStd ;
1639                      NewDegree           : Integer ;
1640                      NewPoles            : in out Array1OfPnt2d from TColgp ;
1641                      Status              : in out Integer) ;
1642      ---Purpose: this will  multiply a given Vectorial BSpline F(t)
1643      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1644      --          its Poles  array which are coded as  an array of Real
1645      --          of  the  form  [1..NumPoles][1..PolesDimension] by  a
1646      --          function     a(t) which is   assumed to   satisfy the
1647      --          following  : 1. a(t)  * F(t)  is a polynomial BSpline
1648      --          that can be expressed  exactly as a BSpline of degree
1649      --          NewDegree on the knots FlatKnots 2. the range of a(t)
1650      --           is the same as the  range of F(t)  
1651      --  Warning: it is
1652      --          the caller's responsability to insure that conditions
1653      --          1. and  2. above are  satisfied : no check whatsoever
1654      --          is made in this method 
1655      -- Status will return 0 if OK else it will return the pivot index 
1656      --        of the matrix that was inverted to compute the multiplied
1657      --        BSpline : the method used is interpolation at Schoenenberg
1658      --        points of a(t)*F(t) 
1659
1660     FunctionMultiply(Function            : EvaluatorFunction from BSplCLib ;          
1661                      BSplineDegree       : Integer ;
1662                      BSplineFlatKnots    : Array1OfReal from TColStd ;
1663                      Poles               : Array1OfPnt from TColgp ;
1664                      FlatKnots           : Array1OfReal from TColStd ;
1665                      NewDegree           : Integer ;
1666                      NewPoles            : in out Array1OfPnt from TColgp ;
1667                      Status              : in out Integer) ;
1668      ---Purpose: this will  multiply a given Vectorial BSpline F(t)
1669      --          defined  by its  BSplineDegree and BSplineFlatKnotsl,
1670      --          its Poles  array which are coded as  an array of Real
1671      --          of  the  form  [1..NumPoles][1..PolesDimension] by  a
1672      --          function     a(t) which is   assumed to   satisfy the
1673      --          following  : 1. a(t)  * F(t)  is a polynomial BSpline
1674      --          that can be expressed  exactly as a BSpline of degree
1675      --          NewDegree on the knots FlatKnots 2. the range of a(t)
1676      --           is the same as the  range of F(t)  
1677      --  Warning: it is
1678      --          the caller's responsability to insure that conditions
1679      --          1. and  2. above are  satisfied : no check whatsoever
1680      --          is made in this method 
1681      -- Status will return 0 if OK else it will return the pivot index 
1682      --        of the matrix that was inverted to compute the multiplied
1683      --        BSpline : the method used is interpolation at Schoenenberg
1684      --        points of a(t)*F(t) 
1685
1686     Eval(U                 : Real;
1687          PeriodicFlag      : Boolean ;
1688          DerivativeRequest : Integer ;
1689          ExtrapMode        : in out Integer ;
1690          Degree            : Integer;
1691          FlatKnots         : Array1OfReal from TColStd ;
1692          ArrayDimension    : Integer ;
1693          Poles             : in out Real ;
1694          Result            : in out Real) ; 
1695     ---Purpose: Perform the De Boor   algorithm  to  evaluate a point at
1696     --          parameter <U>, with <Degree> and <Dimension>.
1697     --          
1698     --          Poles is  an array of  Reals of size 
1699     --          
1700     --          <Dimension> *  <Degree>+1
1701     --          
1702     --          Containing the  poles.  At  the end <Poles> contains
1703     --          the current point.   Poles Contain all  the poles of
1704     --          the BsplineCurve, Knots  also Contains all the knots
1705     --          of the BsplineCurve.  ExtrapMode has two slots [0] =
1706     --          Degree used to extrapolate before the first knot [1]
1707     --          = Degre used to  extrapolate after the last knot has
1708     --          to be between 1 and  Degree
1709
1710     Eval(U                 : Real;
1711          PeriodicFlag      : Boolean ;
1712          DerivativeRequest : Integer ;
1713          ExtrapMode        : in out Integer ;
1714          Degree            : Integer;
1715          FlatKnots         : Array1OfReal from TColStd ;
1716          ArrayDimension    : Integer ;
1717          Poles             : in out Real ;
1718          Weights           : in out Real ;
1719          PolesResult       : in out Real ;
1720          WeightsResult     : in out Real) ;
1721     ---Purpose: Perform the  De Boor algorithm  to evaluate a point at
1722     --          parameter   <U>,  with   <Degree>    and  <Dimension>.
1723     --          Evaluates by multiplying the  Poles by the Weights and
1724     --          gives  the homogeneous  result  in PolesResult that is
1725     --          the results of the evaluation of the numerator once it
1726     --          has     been  multiplied   by  the     weights and  in
1727     --          WeightsResult one has  the result of the evaluation of
1728     --          the denominator
1729     --          
1730     --  Warning:   <PolesResult> and <WeightsResult>  must be   dimensionned
1731     --          properly.
1732
1733     Eval(U                 : Real;
1734          PeriodicFlag      : Boolean ;
1735          HomogeneousFlag   : Boolean ;
1736          ExtrapMode        : in out Integer ;
1737          Degree            : Integer;
1738          FlatKnots         : Array1OfReal from TColStd ;
1739          Poles             : Array1OfPnt   from TColgp;
1740          Weights           : Array1OfReal    from TColStd ;
1741          Point             : out Pnt from gp ;
1742          Weight            : in out Real) ;
1743     ---Purpose: Perform the evaluation of the Bspline Basis 
1744     --          and then multiplies by the weights
1745     --          this just evaluates the current point
1746
1747     Eval(U                 : Real;
1748          PeriodicFlag      : Boolean ;
1749          HomogeneousFlag   : Boolean ;
1750          ExtrapMode        : in out Integer ;
1751          Degree            : Integer;
1752          FlatKnots         : Array1OfReal from TColStd ;
1753          Poles             : Array1OfPnt2d   from TColgp;
1754          Weights           : Array1OfReal    from TColStd ;
1755          Point             : out Pnt2d from gp ;
1756          Weight            : in out Real) ;
1757     ---Purpose: Perform the evaluation of the Bspline Basis 
1758     --          and then multiplies by the weights
1759     --          this just evaluates the current point
1760     --          
1761
1762     TangExtendToConstraint(FlatKnots         : Array1OfReal from TColStd ;
1763                            C1Coefficient     : Real ;
1764                            NumPoles          : in Integer ;
1765                            Poles             : in out Real ;
1766                            Dimension         : Integer ;
1767                            Degree            : Integer ;
1768                            ConstraintPoint   : Array1OfReal from TColStd ;
1769                            Continuity        : Integer ;
1770                            After             : Boolean ;
1771                            NbPolesResult     : in out Integer ; 
1772                            NbKnotsRsult      : in out Integer ;
1773                            KnotsResult       : in out Real ;
1774                            PolesResult       : in out Real) ;
1775     ---Purpose: Extend a BSpline nD using the tangency map
1776     --          <C1Coefficient> is the coefficient of reparametrisation
1777     --          <Continuity> must be equal to 1, 2 or 3.
1778     --          <Degree> must be greater or equal than <Continuity> + 1.
1779     --          
1780     --  Warning:   <KnotsResult> and <PolesResult>  must be   dimensionned
1781     --          properly.
1782
1783     CacheD0(U              : Real;
1784             Degree         : Integer;
1785             CacheParameter : Real;
1786             SpanLenght     : Real;
1787             Poles          : Array1OfPnt     from TColgp  ;
1788             Weights        : Array1OfReal    from TColStd ;
1789             Point          : out Pnt from gp) ;
1790     ---Purpose: Perform the evaluation of the of the cache
1791     --          the parameter must be normalized between
1792     --          the 0 and 1 for the span.
1793     --          The Cache must be valid when calling this
1794     --          routine. Geom Package will insure that. 
1795     --          and then multiplies by the weights
1796     --          this just evaluates the current point
1797     --          the CacheParameter is where the Cache was
1798     --          constructed the SpanLength is to normalize
1799     --          the polynomial in the cache to avoid bad conditioning
1800     --          effects
1801
1802     CacheD0(U              : Real;
1803             Degree          : Integer;
1804             CacheParameter  : Real;
1805             SpanLenght      : Real;
1806             Poles           : Array1OfPnt2d   from TColgp;
1807             Weights         : Array1OfReal    from TColStd ;
1808             Point           : out Pnt2d from gp) ;
1809     ---Purpose: Perform the evaluation of the Bspline Basis 
1810     --          and then multiplies by the weights
1811     --          this just evaluates the current point
1812     --          the parameter must be normalized between
1813     --          the 0 and 1 for the span.
1814     --          The Cache must be valid when calling this
1815     --          routine. Geom Package will insure that. 
1816     --          and then multiplies by the weights
1817     --          ththe CacheParameter is where the Cache was
1818     --          constructed the SpanLength is to normalize
1819     --          the polynomial in the cache to avoid bad conditioning
1820     --          effectsis just evaluates the current point
1821     
1822     CoefsD0(U             : Real;
1823             Poles         : Array1OfPnt     from TColgp  ;
1824             Weights       : Array1OfReal    from TColStd ;
1825             Point         : out Pnt from gp) ;
1826     ---Purpose: Calls CacheD0 for Bezier  Curves Arrays computed with
1827     --          the method PolesCoefficients. 
1828     --  Warning: To be used for Beziercurves ONLY!!!
1829     ---C++: inline
1830   
1831     CoefsD0(U             : Real;
1832             Poles         : Array1OfPnt2d   from TColgp  ;
1833             Weights       : Array1OfReal    from TColStd ;
1834             Point         : out Pnt2d from gp) ;
1835     ---Purpose: Calls CacheD0 for Bezier  Curves Arrays computed with
1836     --          the method PolesCoefficients. 
1837     --  Warning: To be used for Beziercurves ONLY!!!
1838     ---C++: inline
1839     
1840     CacheD1(U             : Real;
1841             Degree        : Integer;
1842             CacheParameter: Real;
1843             SpanLenght    : Real;
1844             Poles         : Array1OfPnt     from TColgp  ;
1845             Weights       : Array1OfReal    from TColStd ;
1846             Point         : out Pnt from gp ;
1847             Vec           : out Vec from gp) ;
1848     ---Purpose: Perform the evaluation of the of the cache
1849     --          the parameter must be normalized between
1850     --          the 0 and 1 for the span.
1851     --          The Cache must be valid when calling this
1852     --          routine. Geom Package will insure that. 
1853     --          and then multiplies by the weights
1854     --          this just evaluates the current point
1855     --          the CacheParameter is where the Cache was
1856     --          constructed the SpanLength is to normalize
1857     --          the polynomial in the cache to avoid bad conditioning
1858     --          effects
1859
1860     CacheD1(U              : Real;
1861             Degree         : Integer;
1862             CacheParameter : Real;
1863             SpanLenght     : Real;
1864             Poles          : Array1OfPnt2d   from TColgp;
1865             Weights        : Array1OfReal    from TColStd ;
1866             Point          : out Pnt2d from gp ;
1867             Vec            : out Vec2d from gp) ;
1868     ---Purpose: Perform the evaluation of the Bspline Basis 
1869     --          and then multiplies by the weights
1870     --          this just evaluates the current point
1871     --          the parameter must be normalized between
1872     --          the 0 and 1 for the span.
1873     --          The Cache must be valid when calling this
1874     --          routine. Geom Package will insure that. 
1875     --          and then multiplies by the weights
1876     --          ththe CacheParameter is where the Cache was
1877     --          constructed the SpanLength is to normalize
1878     --          the polynomial in the cache to avoid bad conditioning
1879     --          effectsis just evaluates the current point
1880
1881     CoefsD1(U             : Real;
1882             Poles         : Array1OfPnt     from TColgp  ;
1883             Weights       : Array1OfReal    from TColStd ;
1884             Point         : out Pnt from gp;
1885             Vec           : out Vec from gp) ;
1886     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
1887     --          the method PolesCoefficients. 
1888     --  Warning: To be used for Beziercurves ONLY!!!
1889     ---C++: inline
1890
1891     CoefsD1(U             : Real;
1892             Poles         : Array1OfPnt2d     from TColgp  ;
1893             Weights       : Array1OfReal    from TColStd ;
1894             Point         : out Pnt2d from gp;
1895             Vec           : out Vec2d from gp) ;
1896     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
1897     --          the method PolesCoefficients. 
1898     --  Warning: To be used for Beziercurves ONLY!!!
1899     ---C++: inline
1900
1901     CacheD2(U             : Real;
1902             Degree            : Integer;
1903             CacheParameter    : Real;
1904             SpanLenght        : Real;
1905             Poles             : Array1OfPnt     from TColgp  ;
1906             Weights           : Array1OfReal    from TColStd ;
1907             Point             : out Pnt from gp ;
1908             Vec1,Vec2         : out Vec from gp) ;
1909     ---Purpose: Perform the evaluation of the of the cache
1910     --          the parameter must be normalized between
1911     --          the 0 and 1 for the span.
1912     --          The Cache must be valid when calling this
1913     --          routine. Geom Package will insure that. 
1914     --          and then multiplies by the weights
1915     --          this just evaluates the current point
1916     --          the CacheParameter is where the Cache was
1917     --          constructed the SpanLength is to normalize
1918     --          the polynomial in the cache to avoid bad conditioning
1919     --          effects
1920
1921     CacheD2(U              : Real;
1922             Degree         : Integer;
1923             CacheParameter : Real;
1924             SpanLenght     : Real;
1925             Poles          : Array1OfPnt2d   from TColgp;
1926             Weights        : Array1OfReal    from TColStd ;
1927             Point          : out Pnt2d from gp ;
1928             Vec1,Vec2      : out Vec2d from gp) ;
1929     ---Purpose: Perform the evaluation of the Bspline Basis 
1930     --          and then multiplies by the weights
1931     --          this just evaluates the current point
1932     --          the parameter must be normalized between
1933     --          the 0 and 1 for the span.
1934     --          The Cache must be valid when calling this
1935     --          routine. Geom Package will insure that. 
1936     --          and then multiplies by the weights
1937     --          ththe CacheParameter is where the Cache was
1938     --          constructed the SpanLength is to normalize
1939     --          the polynomial in the cache to avoid bad conditioning
1940     --          effectsis just evaluates the current point
1941
1942     CoefsD2(U             : Real;
1943             Poles         : Array1OfPnt     from TColgp  ;
1944             Weights       : Array1OfReal    from TColStd ;
1945             Point         : out Pnt from gp;
1946             Vec1,Vec2     : out Vec from gp) ;
1947     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
1948     --          the method PolesCoefficients. 
1949     --  Warning: To be used for Beziercurves ONLY!!!
1950     ---C++: inline
1951
1952     CoefsD2(U             : Real;
1953             Poles         : Array1OfPnt2d     from TColgp  ;
1954             Weights       : Array1OfReal    from TColStd ;
1955             Point         : out Pnt2d from gp;
1956             Vec1,Vec2     : out Vec2d from gp) ;
1957     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
1958     --          the method PolesCoefficients. 
1959     --  Warning: To be used for Beziercurves ONLY!!!
1960     ---C++: inline
1961
1962
1963     CacheD3(U              : Real;
1964             Degree         : Integer;
1965             CacheParameter : Real;
1966             SpanLenght     : Real;
1967             Poles          : Array1OfPnt     from TColgp  ;
1968             Weights        : Array1OfReal    from TColStd ;
1969             Point          : out Pnt from gp ;
1970             Vec1,Vec2,Vec3 : out Vec from gp) ;
1971     ---Purpose: Perform the evaluation of the of the cache
1972     --          the parameter must be normalized between
1973     --          the 0 and 1 for the span.
1974     --          The Cache must be valid when calling this
1975     --          routine. Geom Package will insure that. 
1976     --          and then multiplies by the weights
1977     --          this just evaluates the current point
1978     --          the CacheParameter is where the Cache was
1979     --          constructed the SpanLength is to normalize
1980     --          the polynomial in the cache to avoid bad conditioning
1981     --          effects
1982
1983     CacheD3(U              : Real;
1984             Degree         : Integer;
1985             CacheParameter : Real;
1986             SpanLenght     : Real;
1987             Poles          : Array1OfPnt2d   from TColgp;
1988             Weights        : Array1OfReal    from TColStd ;
1989             Point          : out Pnt2d from gp ;
1990             Vec1,Vec2,Vec3 : out Vec2d from gp) ;
1991     ---Purpose: Perform the evaluation of the Bspline Basis 
1992     --          and then multiplies by the weights
1993     --          this just evaluates the current point
1994     --          the parameter must be normalized between
1995     --          the 0 and 1 for the span.
1996     --          The Cache must be valid when calling this
1997     --          routine. Geom Package will insure that. 
1998     --          and then multiplies by the weights
1999     --          ththe CacheParameter is where the Cache was
2000     --          constructed the SpanLength is to normalize
2001     --          the polynomial in the cache to avoid bad conditioning
2002     --          effectsis just evaluates the current point
2003
2004     CoefsD3(U             : Real;
2005             Poles         : Array1OfPnt     from TColgp  ;
2006             Weights       : Array1OfReal    from TColStd ;
2007             Point         : out Pnt from gp;
2008             Vec1,Vec2,Vec3: out Vec from gp) ;
2009     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
2010     --          the method PolesCoefficients. 
2011     --  Warning: To be used for Beziercurves ONLY!!!
2012     ---C++: inline
2013
2014     CoefsD3(U             : Real;
2015             Poles         : Array1OfPnt2d     from TColgp  ;
2016             Weights       : Array1OfReal    from TColStd ;
2017             Point         : out Pnt2d from gp;
2018             Vec1,Vec2,Vec3: out Vec2d from gp) ;
2019     ---Purpose: Calls CacheD1 for Bezier  Curves Arrays computed with
2020     --          the method PolesCoefficients. 
2021     --  Warning: To be used for Beziercurves ONLY!!!
2022     ---C++: inline
2023
2024     BuildCache(U                   : Real;
2025                InverseOfSpanDomain : Real;
2026                PeriodicFlag        : Boolean ;
2027                Degree              : Integer;
2028                FlatKnots           : Array1OfReal  from TColStd ;
2029                Poles               : Array1OfPnt   from TColgp;
2030                Weights             : Array1OfReal    from TColStd ;
2031                CachePoles          : in out Array1OfPnt   from TColgp;
2032                CacheWeights        : in out Array1OfReal    from TColStd)   ;
2033     ---Purpose: Perform the evaluation of the Taylor expansion
2034     --          of the Bspline normalized between 0 and 1.
2035     --          If rational computes the homogeneous Taylor expension
2036     --          for the numerator and stores it in CachePoles
2037
2038     BuildCache(U                   : Real;
2039                InverseOfSpanDomain : Real;
2040                PeriodicFlag        : Boolean ;
2041                Degree              : Integer;
2042                FlatKnots           : Array1OfReal    from TColStd ;
2043                Poles               : Array1OfPnt2d   from TColgp;
2044                Weights             : Array1OfReal    from TColStd ;
2045                CachePoles          : in out Array1OfPnt2d   from TColgp;
2046                CacheWeights        : in out Array1OfReal    from TColStd)   ;
2047     ---Purpose: Perform the evaluation of the Taylor expansion
2048     --          of the Bspline normalized between 0 and 1.
2049     --          If rational computes the homogeneous Taylor expension
2050     --          for the numerator and stores it in CachePoles
2051
2052     PolesCoefficients(Poles         : Array1OfPnt2d   from TColgp;
2053                       CachePoles    : in out Array1OfPnt2d   from TColgp);
2054     ---Warning: To be used for Beziercurves ONLY!!!
2055     ---C++: inline
2056          
2057     PolesCoefficients(Poles         : Array1OfPnt2d   from TColgp;
2058                       Weights       : Array1OfReal    from TColStd ;
2059                       CachePoles    : in out Array1OfPnt2d   from TColgp;
2060                       CacheWeights  : in out Array1OfReal    from TColStd)   ;
2061     ---Warning: To be used for Beziercurves ONLY!!!
2062          
2063     PolesCoefficients(Poles         : Array1OfPnt   from TColgp;
2064                       CachePoles    : in out Array1OfPnt   from TColgp);
2065     ---Warning: To be used for Beziercurves ONLY!!!
2066     ---C++: inline
2067
2068     PolesCoefficients(Poles         : Array1OfPnt   from TColgp;
2069                       Weights       : Array1OfReal    from TColStd ;
2070                       CachePoles    : in out Array1OfPnt   from TColgp;
2071                       CacheWeights  : in out Array1OfReal    from TColStd)   ;
2072     ---Purpose: Encapsulation   of  BuildCache    to   perform   the
2073     --          evaluation  of the Taylor expansion for beziercurves
2074     --          at parameter 0.
2075     --  Warning: To be used for Beziercurves ONLY!!!
2076
2077     FlatBezierKnots (Degree: Integer) returns Real;
2078     ---Purpose: Returns pointer to statically allocated array representing 
2079     --          flat knots for bezier curve of the specified degree.
2080     --          Raises OutOfRange if Degree > MaxDegree()
2081     ---C++: return const &
2082
2083     BuildSchoenbergPoints(Degree    : Integer ;
2084                           FlatKnots :  Array1OfReal from TColStd ;
2085                           Parameters : in out Array1OfReal from TColStd)  ; 
2086     ---Purpose: builds the Schoenberg points from the flat knot
2087     --          used to interpolate a BSpline since the 
2088     --          BSpline matrix is invertible.
2089       
2090     Interpolate(Degree : Integer ;
2091                 FlatKnots         : Array1OfReal    from TColStd ;
2092                 Parameters        : Array1OfReal    from TColStd ;
2093                 ContactOrderArray : Array1OfInteger from TColStd ;
2094                 Poles             : in out  Array1OfPnt    from TColgp ;
2095                 InversionProblem  : out Integer) ;
2096     ---Purpose: Performs the interpolation of  the data given in
2097     --          the Poles  array  according  to the  requests in
2098     --          ContactOrderArray    that is      :           if
2099     --          ContactOrderArray(i) has value  d it means  that
2100     --          Poles(i)   containes the dth  derivative of  the
2101     --          function to be interpolated. The length L of the
2102     --          following arrays must be the same :
2103     --          Parameters, ContactOrderArray, Poles,
2104     --          The length of FlatKnots is Degree + L + 1
2105     --  Warning: 
2106     --          the method used to do that interpolation is 
2107     --          gauss elimination WITHOUT pivoting. Thus if the
2108     --          diagonal is not dominant there is no guarantee
2109     --          that the algorithm will work. Nevertheless for
2110     --          Cubic interpolation or interpolation at Scheonberg
2111     --          points the method will work
2112     --          The InversionProblem will report 0 if there was no
2113     --          problem else it will give the index of the faulty
2114     --          pivot
2115
2116     Interpolate(Degree            : Integer ;
2117                 FlatKnots         : Array1OfReal    from TColStd ;
2118                 Parameters        : Array1OfReal    from TColStd ;
2119                 ContactOrderArray : Array1OfInteger from TColStd ;
2120                 Poles             : in out  Array1OfPnt2d    from TColgp ;
2121                 InversionProblem  : out Integer) ;
2122     ---Purpose: Performs the interpolation of  the data given in
2123     --          the Poles  array  according  to the  requests in
2124     --          ContactOrderArray    that is      :           if
2125     --          ContactOrderArray(i) has value  d it means  that
2126     --          Poles(i)   containes the dth  derivative of  the
2127     --          function to be interpolated. The length L of the
2128     --          following arrays must be the same :
2129     --          Parameters, ContactOrderArray, Poles,
2130     --          The length of FlatKnots is Degree + L + 1
2131     --  Warning: 
2132     --          the method used to do that interpolation is 
2133     --          gauss elimination WITHOUT pivoting. Thus if the
2134     --          diagonal is not dominant there is no guarantee
2135     --          that the algorithm will work. Nevertheless for
2136     --          Cubic interpolation at knots or interpolation at Scheonberg
2137     --          points the method will work.
2138     --          The InversionProblem w
2139     --          ll report 0 if there was no
2140     --          problem else it will give the index of the faulty
2141     --          pivot
2142
2143     Interpolate(Degree : Integer ;
2144                 FlatKnots         : Array1OfReal    from TColStd ;
2145                 Parameters        : Array1OfReal    from TColStd ;
2146                 ContactOrderArray : Array1OfInteger from TColStd ;
2147                 Poles             : in out  Array1OfPnt    from TColgp   ; 
2148                 Weights           : in out  Array1OfReal    from TColStd  ;  
2149                 InversionProblem  : out Integer) ;
2150     ---Purpose: Performs the interpolation of  the data given in
2151     --          the Poles  array  according  to the  requests in
2152     --          ContactOrderArray    that is      :           if
2153     --          ContactOrderArray(i) has value  d it means  that
2154     --          Poles(i)   containes the dth  derivative of  the
2155     --          function to be interpolated. The length L of the
2156     --          following arrays must be the same :
2157     --          Parameters, ContactOrderArray, Poles,
2158     --          The length of FlatKnots is Degree + L + 1
2159     --  Warning: 
2160     --          the method used to do that interpolation is 
2161     --          gauss elimination WITHOUT pivoting. Thus if the
2162     --          diagonal is not dominant there is no guarantee
2163     --          that the algorithm will work. Nevertheless for
2164     --          Cubic interpolation at knots or interpolation at Scheonberg
2165     --          points the method will work.
2166     --          The InversionProblem will report 0 if there was no
2167     --          problem else it will give the index of the faulty
2168     --          pivot
2169     --          
2170     -- 
2171
2172     Interpolate(Degree            : Integer ;
2173                 FlatKnots         : Array1OfReal    from TColStd ;
2174                 Parameters        : Array1OfReal    from TColStd ;
2175                 ContactOrderArray : Array1OfInteger from TColStd ;
2176                 Poles             : in out  Array1OfPnt2d    from TColgp ; 
2177                 Weights           : in out  Array1OfReal from TColStd  ;
2178                 InversionProblem  : out Integer) ;
2179     ---Purpose: Performs the interpolation of  the data given in
2180     --          the Poles  array  according  to the  requests in
2181     --          ContactOrderArray    that is      :           if
2182     --          ContactOrderArray(i) has value  d it means  that
2183     --          Poles(i)   containes the dth  derivative of  the
2184     --          function to be interpolated. The length L of the
2185     --          following arrays must be the same :
2186     --          Parameters, ContactOrderArray, Poles,
2187     --          The length of FlatKnots is Degree + L + 1
2188     --  Warning: 
2189     --          the method used to do that interpolation is 
2190     --          gauss elimination WITHOUT pivoting. Thus if the
2191     --          diagonal is not dominant there is no guarantee
2192     --          that the algorithm will work. Nevertheless for
2193     --          Cubic interpolation at knots or interpolation at Scheonberg
2194     --          points the method will work.
2195     --          The InversionProblem w
2196     --          ll report 0 if there was no
2197     --          problem else it will give the i      
2198
2199     Interpolate(Degree : Integer ;
2200                 FlatKnots         : Array1OfReal    from TColStd ;
2201                 Parameters        : Array1OfReal    from TColStd ;
2202                 ContactOrderArray : Array1OfInteger from TColStd ;
2203                 ArrayDimension    : Integer ;
2204                 Poles             : in out Real  ;
2205                 InversionProblem  : out Integer) ;
2206     ---Purpose: Performs the interpolation of  the data given in
2207     --          the Poles  array  according  to the  requests in
2208     --          ContactOrderArray    that is      :           if
2209     --          ContactOrderArray(i) has value  d it means  that
2210     --          Poles(i)   containes the dth  derivative of  the
2211     --          function to be interpolated. The length L of the
2212     --          following arrays must be the same :
2213     --          Parameters, ContactOrderArray
2214     --          The length of FlatKnots is Degree + L + 1
2215     --          The  PolesArray   is    an   seen   as    an
2216     --          Array[1..N][1..ArrayDimension] with N = tge length
2217     --          of the parameters array
2218     --  Warning: 
2219     --          the method used to do that interpolation is 
2220     --          gauss elimination WITHOUT pivoting. Thus if the
2221     --          diagonal is not dominant there is no guarantee
2222     --          that the algorithm will work. Nevertheless for
2223     --          Cubic interpolation or interpolation at Scheonberg
2224     --          points the method will work
2225     --          The InversionProblem will report 0 if there was no
2226     --          problem else it will give the index of the faulty
2227     --          pivot
2228     --          
2229
2230     Interpolate(Degree : Integer ;
2231                 FlatKnots         : Array1OfReal    from TColStd ;
2232                 Parameters        : Array1OfReal    from TColStd ;
2233                 ContactOrderArray : Array1OfInteger from TColStd ;
2234                 ArrayDimension    : Integer ;
2235                 Poles             : in out Real  ;
2236                 Weights           : in out Real  ;
2237                 InversionProblem  : out Integer) ;
2238                   
2239     MovePoint(U            : Real;          -- parameter of the point
2240               Displ        : Vec2d from gp; -- translation vector of the point
2241               Index1       : Integer;       -- first movable pole
2242               Index2       : Integer;       -- last movable pole
2243               Degree       : Integer; 
2244               Rational     : Boolean;
2245               Poles        : Array1OfPnt2d   from TColgp;
2246               Weights      : Array1OfReal    from TColStd;
2247               FlatKnots    : Array1OfReal    from TColStd;
2248               FirstIndex   : in out Integer;       -- first pole modified
2249               LastIndex    : in out Integer;       -- last pole modified
2250               NewPoles     : in out Array1OfPnt2d  from TColgp); -- new poles
2251     ---Purpose: Find the new poles which allows  an old point (with a
2252     --          given  u as parameter) to reach a new position
2253     --          Index1 and Index2 indicate the range of poles we can move
2254     --          (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
2255     --                     don't enter (1,NbPoles) -> error: rigid move
2256     --          (2, NbPoles-1) -> the ends are enforced
2257     --          (3, NbPoles-2) -> the ends and the tangency are enforced
2258     --    if Problem in BSplineBasis calculation, no change for the curve
2259     --    and FirstIndex, LastIndex = 0
2260
2261     MovePoint(U            : Real;          -- parameter of the point
2262               Displ        : Vec from gp;   -- translation vector of the point
2263               Index1       : Integer;       -- first movable pole
2264               Index2       : Integer;       -- last movable pole
2265               Degree       : Integer; 
2266               Rational     : Boolean;
2267               Poles        : Array1OfPnt     from TColgp;
2268               Weights      : Array1OfReal    from TColStd;
2269               FlatKnots    : Array1OfReal    from TColStd;
2270               FirstIndex   : in out Integer;       -- first pole modified
2271               LastIndex   : in out Integer;       -- last pole modified
2272               NewPoles     : in out Array1OfPnt    from TColgp); -- new poles
2273     ---Purpose: Find the new poles which allows  an old point (with a
2274     --          given  u as parameter) to reach a new position
2275     --          Index1 and Index2 indicate the range of poles we can move
2276     --          (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
2277     --                     don't enter (1,NbPoles) -> error: rigid move
2278     --          (2, NbPoles-1) -> the ends are enforced
2279     --          (3, NbPoles-2) -> the ends and the tangency are enforced
2280     --    if Problem in BSplineBasis calculation, no change for the curve
2281     --    and FirstIndex, LastIndex = 0
2282
2283     MovePointAndTangent(U                 : Real        ;
2284                         ArrayDimension    : Integer     ;
2285                         Delta             : in out Real ;  
2286                         DeltaDerivative   : in out Real ;
2287                         Tolerance         : Real        ;
2288                         Degree            : Integer     ; 
2289                         Rational          : Boolean     ;
2290                         StartingCondition : Integer     ;
2291                         EndingCondition   : Integer     ;
2292                         Poles        : in out Real      ;
2293                         Weights      : Array1OfReal           from TColStd;
2294                         FlatKnots    : Array1OfReal           from TColStd;
2295                         NewPoles     : in out Real      ;
2296                         ErrorStatus  : in out Integer)  ;
2297     ---Purpose: This is the dimension free version of the utility
2298     -- U is the parameter  must be within the  first FlatKnots and the
2299     -- last FlatKnots  Delta is the amount the  curve has  to be moved
2300     -- DeltaDerivative is the  amount the derivative  has to be moved.
2301     -- Delta  and   DeltaDerivative   must be    array   of  dimension
2302     -- ArrayDimension  Degree  is the degree  of   the BSpline and the
2303     -- FlatKnots are the knots of the BSpline  Starting Condition if =
2304     -- -1 means the starting point of the curve can move 
2305     -- = 0 means the
2306     -- starting  point  of the cuve  cannot  move but  tangen  starting
2307     -- point of the curve cannot move
2308     -- = 1 means the starting point and tangents cannot move 
2309     -- = 2 means the starting point tangent and curvature cannot move
2310     -- = ...
2311     -- Same holds for EndingCondition
2312     -- Poles are the poles of the curve
2313     -- Weights are the weights of the curve if Rational = Standard_True
2314     -- NewPoles are the poles of the deformed curve 
2315     -- ErrorStatus will be 0 if no error happened
2316     --                     1 if there are not enough knots/poles
2317     --                          the imposed conditions
2318     -- The way to solve this problem is to add knots to the BSpline 
2319     -- If StartCondition = 1 and EndCondition = 1 then you need at least
2320     -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need
2321     -- have at least 2 internal knots.
2322
2323     MovePointAndTangent(U                 : Real        ;
2324                         Delta             : Vec from gp ;
2325                         DeltaDerivative   : Vec from gp ;
2326                         Tolerance         : Real        ;
2327                         Degree            : Integer     ; 
2328                         Rational          : Boolean     ;
2329                         StartingCondition : Integer     ;
2330                         EndingCondition   : Integer     ;
2331                         Poles        : Array1OfPnt  from TColgp           ;
2332                         Weights      : Array1OfReal           from TColStd;
2333                         FlatKnots    : Array1OfReal           from TColStd;
2334                         NewPoles     : in out Array1OfPnt from TColgp      ;
2335                         ErrorStatus  : in out Integer)  ;
2336     ---Purpose: This is the dimension free version of the utility
2337     -- U is the parameter  must be within the  first FlatKnots and the
2338     -- last FlatKnots  Delta is the amount the  curve has  to be moved
2339     -- DeltaDerivative is the  amount the derivative  has to be moved.
2340     -- Delta  and   DeltaDerivative   must be    array   of  dimension
2341     -- ArrayDimension  Degree  is the degree  of   the BSpline and the
2342     -- FlatKnots are the knots of the BSpline  Starting Condition if =
2343     -- -1 means the starting point of the curve can move 
2344     -- = 0 means the
2345     -- starting  point  of the cuve  cannot  move but  tangen  starting
2346     -- point of the curve cannot move
2347     -- = 1 means the starting point and tangents cannot move 
2348     -- = 2 means the starting point tangent and curvature cannot move
2349     -- = ...
2350     -- Same holds for EndingCondition
2351     -- Poles are the poles of the curve
2352     -- Weights are the weights of the curve if Rational = Standard_True
2353     -- NewPoles are the poles of the deformed curve 
2354     -- ErrorStatus will be 0 if no error happened
2355     --                     1 if there are not enough knots/poles
2356     --                          the imposed conditions
2357     -- The way to solve this problem is to add knots to the BSpline 
2358     -- If StartCondition = 1 and EndCondition = 1 then you need at least
2359     -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need
2360     -- have at least 2 internal knots.
2361
2362     MovePointAndTangent(U                 : Real          ;
2363                         Delta             : Vec2d from gp ;
2364                         DeltaDerivative   : Vec2d from gp ;
2365                         Tolerance         : Real          ;
2366                         Degree            : Integer       ; 
2367                         Rational          : Boolean       ;
2368                         StartingCondition : Integer       ;
2369                         EndingCondition   : Integer       ;
2370                         Poles        : Array1OfPnt2d        from TColgp    ;
2371                         Weights      : Array1OfReal         from TColStd   ;
2372                         FlatKnots    : Array1OfReal         from TColStd   ;
2373                         NewPoles     : in out Array1OfPnt2d from TColgp    ;
2374                         ErrorStatus  : in out Integer)  ;
2375     ---Purpose: This is the dimension free version of the utility
2376     -- U is the parameter  must be within the  first FlatKnots and the
2377     -- last FlatKnots  Delta is the amount the  curve has  to be moved
2378     -- DeltaDerivative is the  amount the derivative  has to be moved.
2379     -- Delta  and   DeltaDerivative   must be    array   of  dimension
2380     -- ArrayDimension  Degree  is the degree  of   the BSpline and the
2381     -- FlatKnots are the knots of the BSpline  Starting Condition if =
2382     -- -1 means the starting point of the curve can move 
2383     -- = 0 means the
2384     -- starting  point  of the cuve  cannot  move but  tangen  starting
2385     -- point of the curve cannot move
2386     -- = 1 means the starting point and tangents cannot move 
2387     -- = 2 means the starting point tangent and curvature cannot move
2388     -- = ...
2389     -- Same holds for EndingCondition
2390     -- Poles are the poles of the curve
2391     -- Weights are the weights of the curve if Rational = Standard_True
2392     -- NewPoles are the poles of the deformed curve 
2393     -- ErrorStatus will be 0 if no error happened
2394     --                     1 if there are not enough knots/poles
2395     --                          the imposed conditions
2396     -- The way to solve this problem is to add knots to the BSpline 
2397     -- If StartCondition = 1 and EndCondition = 1 then you need at least
2398     -- 4 + 2 = 6 poles so for example to have a C1 cubic you will need
2399     -- have at least 2 internal knots.
2400
2401     Resolution(  PolesArray       : in out Real ;
2402                  ArrayDimension   : Integer     ;
2403                  NumPoles         : Integer     ;
2404                  Weights          : in Array1OfReal    from TColStd;
2405                  FlatKnots        : in Array1OfReal    from TColStd;
2406                  Degree           : in Integer;
2407                  Tolerance3D      : Real     from Standard  ;
2408                  UTolerance       : out Real from Standard) ;
2409     ---Purpose: 
2410     --          given a tolerance in 3D space returns a 
2411     --          tolerance    in U parameter space such that
2412     --          all u1 and u0 in the domain of the curve f(u) 
2413     --          | u1 - u0 | < UTolerance and 
2414     --          we have |f (u1) - f (u0)| < Tolerance3D
2415
2416     Resolution(  Poles            : in Array1OfPnt  from TColgp  ;
2417                  Weights          : in Array1OfReal from TColStd ;
2418                  NumPoles         : in Integer from Standard     ;
2419                  FlatKnots        : in Array1OfReal from TColStd ;
2420                  Degree           : in Integer from Standard     ;
2421                  Tolerance3D      : Real     from Standard  ;
2422                  UTolerance       : out Real from Standard) ;
2423     ---Purpose: 
2424     --          given a tolerance in 3D space returns a 
2425     --          tolerance    in U parameter space such that
2426     --          all u1 and u0 in the domain of the curve f(u) 
2427     --          | u1 - u0 | < UTolerance and 
2428     --          we have |f (u1) - f (u0)| < Tolerance3D
2429
2430     Resolution(  Poles            : in Array1OfPnt2d from TColgp  ;
2431                  Weights          : in Array1OfReal  from TColStd ;
2432                  NumPoles         : in Integer from Standard      ;
2433                  FlatKnots        : in Array1OfReal  from TColStd ;
2434                  Degree           : in Integer              ;
2435                  Tolerance3D      : Real     from Standard  ;
2436                  UTolerance       : out Real from Standard) ;
2437     ---Purpose: 
2438     --          given a tolerance in 3D space returns a 
2439     --          tolerance    in U parameter space such that
2440     --          all u1 and u0 in the domain of the curve f(u) 
2441     --          | u1 - u0 | < UTolerance and 
2442     --          we have |f (u1) - f (u0)| < Tolerance3D
2443
2444 end BSplCLib;
2445