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