0025124: [Feature request] Removal of continuity checks for offset geometries
[occt.git] / src / Geom2d / Geom2d_BSplineCurve.cdl
1 -- Created on: 1993-03-24
2 -- Created by: JCV
3 -- Copyright (c) 1993-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 -- xab : modified 15-Mar-95 : added cache mecanism to speed up
18 -- evaluation
19
20
21 class BSplineCurve from Geom2d inherits BoundedCurve from Geom2d
22
23         --- Purpose : Describes a BSpline curve.
24         -- A BSpline curve can be:
25         -- - uniform or non-uniform,
26         -- - rational or non-rational,
27         -- - periodic or non-periodic.
28         -- A BSpline curve is defined by:
29         -- - its degree; the degree for a
30         --   Geom2d_BSplineCurve is limited to a value (25)
31         --   which is defined and controlled by the system. This
32         --   value is returned by the function MaxDegree;
33         -- - its periodic or non-periodic nature;
34         -- - a table of poles (also called control points), with
35         --   their associated weights if the BSpline curve is
36         --   rational. The poles of the curve are "control points"
37         --   used to deform the curve. If the curve is
38         --   non-periodic, the first pole is the start point of the
39         --   curve, and the last pole is the end point of the
40         --   curve. The segment, which joins the first pole to the
41         --   second pole, is the tangent to the curve at its start
42         --   point, and the segment, which joins the last pole to
43         --   the second-from-last pole, is the tangent to the
44         --   curve at its end point. If the curve is periodic, these
45         --   geometric properties are not verified. It is more
46         --   difficult to give a geometric signification to the
47         --   weights but they are useful for providing exact
48         --   representations of the arcs of a circle or ellipse.
49         --   Moreover, if the weights of all the poles are equal,
50         --   the curve has a polynomial equation; it is
51         --   therefore a non-rational curve.
52         -- - a table of knots with their multiplicities. For a
53         --   Geom2d_BSplineCurve, the table of knots is an
54         --   increasing sequence of reals without repetition; the
55         --   multiplicities define the repetition of the knots. A
56         --   BSpline curve is a piecewise polynomial or rational
57         --   curve. The knots are the parameters of junction
58         --   points between two pieces. The multiplicity
59         --   Mult(i) of the knot Knot(i) of the BSpline
60         --   curve is related to the degree of continuity of the
61         --   curve at the knot Knot(i), which is equal to
62         --   Degree - Mult(i) where Degree is the
63         --   degree of the BSpline curve.
64         -- If the knots are regularly spaced (i.e. the difference
65         -- between two consecutive knots is a constant), three
66         -- specific and frequently used cases of knot distribution
67         -- can be identified:
68         -- - "uniform" if all multiplicities are equal to 1,
69         -- - "quasi-uniform" if all multiplicities are equal to 1,
70         --   except the first and the last knot which have a
71         --   multiplicity of Degree + 1, where Degree is
72         --   the degree of the BSpline curve,
73         -- - "Piecewise Bezier" if all multiplicities are equal to
74         --  Degree except the first and last knot which have
75         --   a multiplicity of Degree + 1, where Degree is
76         --   the degree of the BSpline curve. A curve of this
77         --   type is a concatenation of arcs of Bezier curves.
78         -- If the BSpline curve is not periodic:
79         -- - the bounds of the Poles and Weights tables are 1
80         --   and NbPoles, where NbPoles is the number of
81         --   poles of the BSpline curve,
82         -- - the bounds of the Knots and Multiplicities tables are
83         --   1 and NbKnots, where NbKnots is the number
84         --   of knots of the BSpline curve.
85         -- If the BSpline curve is periodic, and if there are k
86         -- periodic knots and p periodic poles, the period is:
87         -- period = Knot(k + 1) - Knot(1)
88         -- and the poles and knots tables can be considered as
89         -- infinite tables, such that:
90         -- - Knot(i+k) = Knot(i) + period
91         -- - Pole(i+p) = Pole(i)
92         -- Note: data structures of a periodic BSpline curve are
93         -- more complex than those of a non-periodic one.
94         -- Warnings :
95         --  In this class we consider that a weight value is zero if
96         --  Weight <= Resolution from package gp.
97         --  For two parametric values (or two knot values) U1, U2 we 
98         --  consider that U1 = U2 if Abs (U2 - U1) <= Epsilon (U1).
99         --  For two weights values W1, W2 we consider that W1 = W2 if
100         --  Abs (W2 - W1) <= Epsilon (W1).  The method Epsilon is
101         --  defined in the class Real from package Standard.
102         --  
103         -- References :
104         --  . A survey of curve and surface methods in CADG Wolfgang BOHM
105         --    CAGD 1 (1984)
106         --  . On de Boor-like algorithms and blossoming Wolfgang BOEHM
107         --    cagd 5 (1988)
108         --  . Blossoming and knot insertion algorithms for B-spline curves
109         --    Ronald N. GOLDMAN
110         --  . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA   
111         --  . Curves and Surfaces for Computer Aided Geometric Design,
112         --    a practical guide Gerald Farin
113
114
115 uses  Array1OfInteger      from TColStd,
116       Array1OfReal         from TColStd,
117       HArray1OfInteger     from TColStd,
118       HArray1OfReal        from TColStd,
119       Array1OfPnt2d        from TColgp,
120       Ax2d                 from gp, 
121       Pnt2d                from gp,
122       HArray1OfPnt2d       from TColgp,
123       Trsf2d               from gp,
124       Vec2d                from gp,
125       BSplKnotDistribution from GeomAbs,
126       Geometry             from Geom2d,
127       Shape                from GeomAbs,
128       Mutex                from Standard
129
130 raises ConstructionError   from Standard,
131        DimensionError      from Standard,
132        DomainError         from Standard,
133        OutOfRange          from Standard,
134        RangeError          from Standard,
135        NoSuchObject        from Standard,
136        UndefinedDerivative from Geom2d
137
138 is
139
140
141
142   Create (Poles          : Array1OfPnt2d   from TColgp; 
143           Knots          : Array1OfReal    from TColStd; 
144           Multiplicities : Array1OfInteger from TColStd; 
145           Degree         : Integer;
146           Periodic       : Boolean = Standard_False)
147           
148   returns BSplineCurve from Geom2d
149
150         ---Purpose :  Creates a  non-rational B_spline curve   on  the
151         --         basis <Knots, Multiplicities> of degree <Degree>.
152         -- The following conditions must be verified.
153         --  0 < Degree <= MaxDegree.
154         --  
155         --  Knots.Length() == Mults.Length() >= 2
156         --  
157         --  Knots(i) < Knots(i+1) (Knots are increasing)
158         --  
159         --  1 <= Mults(i) <= Degree
160         --  
161         --   On a non periodic curve the first and last multiplicities
162         --   may be Degree+1 (this is even recommanded if you want the
163         --   curve to start and finish on the first and last pole).
164         --   
165         --   On a periodic  curve the first  and  the last multicities
166         --   must be the same.
167         --   
168         --   on non-periodic curves
169         --   
170         --     Poles.Length() == Sum(Mults(i)) - Degree - 1 >= 2
171         --     
172         --   on periodic curves 
173         --   
174         --     Poles.Length() == Sum(Mults(i)) except the first or last
175
176   raises ConstructionError;
177
178         
179
180   Create (Poles          : Array1OfPnt2d   from TColgp; 
181           Weights        : Array1OfReal    from TColStd;
182           Knots          : Array1OfReal    from TColStd; 
183           Multiplicities : Array1OfInteger from TColStd; 
184           Degree         : Integer;
185           Periodic       : Boolean = Standard_False)
186           
187   returns BSplineCurve from Geom2d
188
189         ---Purpose : Creates  a rational B_spline  curve  on the basis
190         --         <Knots, Multiplicities> of degree <Degree>.
191         -- The following conditions must be verified.
192         --  0 < Degree <= MaxDegree.
193         --  
194         --  Knots.Length() == Mults.Length() >= 2
195         --  
196         --  Knots(i) < Knots(i+1) (Knots are increasing)
197         --  
198         --  1 <= Mults(i) <= Degree
199         --  
200         --   On a non periodic curve the first and last multiplicities
201         --   may be Degree+1 (this is even recommanded if you want the
202         --   curve to start and finish on the first and last pole).
203         --   
204         --   On a periodic  curve the first  and  the last multicities
205         --   must be the same.
206         --   
207         --   on non-periodic curves
208         --   
209         --     Poles.Length() == Sum(Mults(i)) - Degree - 1 >= 2
210         --     
211         --   on periodic curves 
212         --   
213         --     Poles.Length() == Sum(Mults(i)) except the first or last
214
215   raises ConstructionError;
216
217    
218   IncreaseDegree (me : mutable; Degree : Integer)
219   
220         ---Purpose: Increases the degree of this BSpline curve to
221         -- Degree. As a result, the poles, weights and
222         -- multiplicities tables are modified; the knots table is
223         -- not changed. Nothing is done if Degree is less than
224         -- or equal to the current degree.
225         -- Exceptions
226         -- Standard_ConstructionError if Degree is greater than
227         -- Geom2d_BSplineCurve::MaxDegree().
228   raises ConstructionError;
229        
230
231  IncreaseMultiplicity (me : mutable; Index : Integer; M : Integer)
232  
233         ---Purpose :Increases the multiplicity  of the knot <Index> to
234         --         <M>.   
235         --         
236         --         If   <M>   is   lower   or  equal   to  the current
237         --         multiplicity nothing is done. If <M> is higher than
238         --         the degree the degree is used.
239
240  raises OutOfRange;
241         
242         ---Purpose: If <Index> is not in [FirstUKnotIndex, LastUKnotIndex]
243
244
245   IncreaseMultiplicity (me : mutable; I1, I2 : Integer; M : Integer) 
246   
247         ---Purpose :Increases  the  multiplicities   of  the knots  in
248         --         [I1,I2] to <M>.
249         --         
250         --         For each knot if  <M>  is  lower  or equal  to  the
251         --         current multiplicity  nothing  is  done. If <M>  is
252         --         higher than the degree the degree is used.
253         -- As a result, the poles and weights tables of this curve are modified.
254         -- Warning
255         -- It is forbidden to modify the multiplicity of the first or
256         -- last knot of a non-periodic curve. Be careful as
257         -- Geom2d does not protect against this.
258         -- Exceptions
259         -- Standard_OutOfRange if either Index, I1 or I2 is
260         -- outside the bounds of the knots table.
261  raises OutOfRange;
262         
263
264   IncrementMultiplicity (me : mutable; I1, I2 : Integer; M : Integer) 
265   
266         ---Purpose : Increases by M the multiplicity of the knots of indexes
267         -- I1 to I2 in the knots table of this BSpline curve. For
268         -- each knot, the resulting multiplicity is limited to the
269         -- degree of this curve. If M is negative, nothing is done.
270         -- As a result, the poles and weights tables of this
271         -- BSpline curve are modified.
272         -- Warning
273         -- It is forbidden to modify the multiplicity of the first or
274         -- last knot of a non-periodic curve. Be careful as
275         -- Geom2d does not protect against this.
276         -- Exceptions
277         -- Standard_OutOfRange if I1 or I2 is outside the
278         -- bounds of the knots table.
279
280  raises OutOfRange;
281         
282
283   InsertKnot (me : mutable; 
284               U : Real; 
285               M : Integer = 1; 
286               ParametricTolerance : Real = 0.0); 
287   
288         ---Purpose: Inserts a knot value in the sequence of knots.  If
289         --          <U>  is an  existing knot     the multiplicity  is
290         --          increased by <M>.
291         --          
292         --          If U  is  not  on the parameter  range  nothing is
293         --          done.
294         --          
295         --          If the multiplicity is negative or null nothing is
296         --          done. The  new   multiplicity  is limited  to  the
297         --          degree.
298         --          
299         --          The  tolerance criterion  for  knots  equality  is
300         --          the max of Epsilon(U) and ParametricTolerance.
301         -- Warning
302         -- - If U is less than the first parameter or greater than
303         --   the last parameter of this BSpline curve, nothing is done.
304         -- - If M is negative or null, nothing is done.
305         -- - The multiplicity of a knot is limited to the degree of
306         --   this BSpline curve.
307   
308
309   InsertKnots (me : mutable; Knots : Array1OfReal    from TColStd; 
310                              Mults : Array1OfInteger from TColStd;
311                              ParametricTolerance : Real = 0.0;
312                              Add : Boolean = Standard_False);
313                              
314         ---Purpose: Inserts the values of the array Knots, with the
315         -- respective multiplicities given by the array Mults, into
316         -- the knots table of this BSpline curve.
317         -- If a value of the array Knots is an existing knot, its multiplicity is:
318         -- - increased by M, if Add is true, or
319         -- - increased to M, if Add is false (default value).
320         -- The tolerance criterion used for knot equality is the
321         -- larger of the values ParametricTolerance (defaulted
322         -- to 0.) and Standard_Real::Epsilon(U),
323         -- where U is the current knot value.
324         -- Warning
325         -- - For a value of the array Knots which is less than
326         --   the first parameter or greater than the last
327         --   parameter of this BSpline curve, nothing is done.
328         -- - For a value of the array Mults which is negative or
329         --   null, nothing is done.
330         -- - The multiplicity of a knot is limited to the degree of
331         --   this BSpline curve.
332                              
333
334
335   RemoveKnot(me : mutable; Index     : Integer; 
336                            M         : Integer;
337                            Tolerance : Real) returns Boolean
338                            
339         ---Purpose : Reduces the multiplicity of the knot of index Index
340         -- to M. If M is equal to 0, the knot is removed.
341         -- With a modification of this type, the array of poles is also modified.
342         -- Two different algorithms are systematically used to
343         -- compute the new poles of the curve. If, for each
344         -- pole, the distance between the pole calculated
345         -- using the first algorithm and the same pole
346         -- calculated using the second algorithm, is less than
347         -- Tolerance, this ensures that the curve is not
348         -- modified by more than Tolerance. Under these
349         -- conditions, true is returned; otherwise, false is returned.
350         -- A low tolerance is used to prevent modification of
351         -- the curve. A high tolerance is used to "smooth" the curve.
352         -- Exceptions
353         -- Standard_OutOfRange if Index is outside the
354         -- bounds of the knots table.
355      raises OutOfRange;
356      
357
358   InsertPoleAfter (me : mutable; Index : Integer; P : Pnt2d;
359                    Weight : Real = 1.0)
360         --- Purpose :
361         --  The new pole is inserted after the pole of range Index.
362         --  If the curve was non rational it can become rational.
363      raises ConstructionError,
364         --- Purpose :
365         --  Raised if the B-spline is NonUniform or PiecewiseBezier or if
366         --  Weight <= 0.0
367             OutOfRange;
368         --- Purpose : Raised if Index is not in the range [1, Number of Poles]
369
370
371   InsertPoleBefore (me : mutable; Index : Integer; P : Pnt2d; 
372                     Weight : Real  =  1.0)
373         --- Purpose :
374         --  The new pole is inserted before the pole of range Index.
375         --  If the curve was non rational it can become rational.
376      raises ConstructionError,
377         --- Purpose :
378         --  Raised if the B-spline is NonUniform or PiecewiseBezier or if
379         --  Weight <= 0.0
380             OutOfRange;
381         --- Purpose : Raised if Index is not in the range [1, Number of Poles]
382
383
384   RemovePole (me : mutable; Index : Integer)
385         --- Purpose :
386         --  Removes the pole of range Index
387         --  If the curve was rational it can become non rational.
388      raises ConstructionError,
389         --- Purpose :
390         --  Raised if the B-spline is NonUniform or PiecewiseBezier.
391         --  Raised if the number of poles of the B-spline curve is lower or 
392         --  equal to 2 before removing.
393             OutOfRange;
394         --- Purpose : Raised if Index is not in the range [1, Number of Poles]
395
396   Reverse (me : mutable);
397         --- Purpose : Reverses the orientation of this BSpline curve. As a result
398         -- - the knots and poles tables are modified;
399         -- - the start point of the initial curve becomes the end
400         --   point of the reversed curve;
401         -- - the end point of the initial curve becomes the start
402         --   point of the reversed curve.
403         
404
405   ReversedParameter(me; U : Real) returns Real;
406         ---Purpose: Computes the parameter on the reversed curve for
407         -- the point of parameter U on this BSpline curve.
408         -- The returned value is: UFirst + ULast - U,
409         -- where UFirst and ULast are the values of the
410         -- first and last parameters of this BSpline curve.
411
412
413   Segment (me : mutable; U1, U2 : Real)
414         ---Purpose : Modifies this BSpline curve by segmenting it
415         -- between U1 and U2. Either of these values can be
416         -- outside the bounds of the curve, but U2 must be greater than U1.
417         -- All data structure tables of this BSpline curve are
418         -- modified, but the knots located between U1 and U2
419         -- are retained. The degree of the curve is not modified.
420         -- Warnings :
421         --  Even if <me> is not closed it can become closed after the 
422         --  segmentation for example if U1 or U2 are out of the bounds 
423         --  of the curve <me> or if the curve makes loop.
424         --  After the segmentation the length of a curve can be null.
425         --        - The segmentation of a periodic curve over an
426         ---   interval corresponding to its period generates a
427         --  non-periodic curve with equivalent geometry.
428         --  Exceptions
429         -- Standard_DomainError if U2 is less than U1.
430     raises DomainError from Standard;
431         ---Purpose: raises if U2 < U1.
432
433
434   SetKnot (me : mutable; Index : Integer; K : Real)
435         --- Purpose :  Modifies this BSpline curve by assigning the value K
436         -- to the knot of index Index in the knots table. This is a
437         -- relatively local modification because K must be such that:
438         -- Knots(Index - 1) < K < Knots(Index + 1)
439         -- Exceptions
440         -- Standard_ConstructionError if:
441         -- - K is not such that:
442         -- Knots(Index - 1) < K < Knots(Index + 1)
443         -- - M is greater than the degree of this BSpline curve
444         --   or lower than the previous multiplicity of knot of
445         --   index Index in the knots table.
446         -- Standard_OutOfRange if Index is outside the bounds of the knots table.
447      raises ConstructionError,
448                     OutOfRange;
449
450
451   SetKnots (me : mutable; K : Array1OfReal from TColStd)
452         --- Purpose :  Modifies this BSpline curve by assigning the array
453         -- K to its knots table. The multiplicity of the knots is not modified.
454         -- Exceptions
455         -- Standard_ConstructionError if the values in the
456         -- array K are not in ascending order.
457         -- Standard_OutOfRange if the bounds of the array
458         -- K are not respectively 1 and the number of knots of this BSpline curve.
459      raises ConstructionError,
460                     OutOfRange;
461       
462
463   SetKnot (me : mutable; Index : Integer; K : Real; M : Integer)
464         --- Purpose : Modifies this BSpline curve by assigning the value K
465         -- to the knot of index Index in the knots table. This is a
466         -- relatively local modification because K must be such that:
467         -- Knots(Index - 1) < K < Knots(Index + 1)
468         -- The second syntax allows you also to increase the
469         -- multiplicity of the knot to M (but it is not possible to
470         -- decrease the multiplicity of the knot with this function).
471         -- Exceptions
472         -- Standard_ConstructionError if:
473         -- - K is not such that:
474         -- Knots(Index - 1) < K < Knots(Index + 1)
475         -- - M is greater than the degree of this BSpline curve
476         --   or lower than the previous multiplicity of knot of
477         --   index Index in the knots table.
478         -- Standard_OutOfRange if Index is outside the bounds of the knots table.
479      raises ConstructionError,
480                     OutOfRange;
481
482   PeriodicNormalization(me ;  U : in out Real) ; 
483        
484         ---Purpose : Computes the parameter normalized within the
485         -- "first" period of this BSpline curve, if it is periodic:
486         -- the returned value is in the range Param1 and
487         -- Param1 + Period, where:
488         -- - Param1 is the "first parameter", and
489         -- - Period the period of this BSpline curve.
490         --  Note: If this curve is not periodic, U is not modified.
491                  
492   SetPeriodic (me : mutable)
493         --- Purpose :Changes this BSpline curve into a periodic curve.
494         -- To become periodic, the curve must first be closed.
495         -- Next, the knot sequence must be periodic. For this,
496         -- FirstUKnotIndex and LastUKnotIndex are used to
497         -- compute I1 and I2, the indexes in the knots array
498         -- of the knots corresponding to the first and last
499         -- parameters of this BSpline curve.
500         -- The period is therefore Knot(I2) - Knot(I1).
501         -- Consequently, the knots and poles tables are modified.
502         -- Exceptions
503         -- Standard_ConstructionError if this BSpline curve is not closed.
504      raises ConstructionError;
505
506
507   SetOrigin (me : mutable; Index : Integer)
508         ---Purpose: Assigns the knot of index Index in the knots table as
509         -- the origin of this periodic BSpline curve. As a
510         -- consequence, the knots and poles tables are modified.
511         -- Exceptions
512         -- Standard_NoSuchObject if this curve is not periodic.
513         -- Standard_DomainError if Index is outside the
514         -- bounds of the knots table.
515     raises NoSuchObject,
516            DomainError;
517         
518
519   SetNotPeriodic (me : mutable);
520         --- Purpose : Changes this BSpline curve into a non-periodic
521         -- curve. If this curve is already non-periodic, it is not modified.
522         -- Note that the poles and knots tables are modified.
523         -- Warning
524         -- If this curve is periodic, as the multiplicity of the first
525         -- and last knots is not modified, and is not equal to
526         -- Degree + 1, where Degree is the degree of
527         -- this BSpline curve, the start and end points of the
528         -- curve are not its first and last poles.
529                 
530  
531   SetPole (me : mutable; Index : Integer; P : Pnt2d)
532         --- Purpose : Modifies this BSpline curve by assigning P to the
533         -- pole of index Index in the poles table.
534         -- Exceptions
535         -- Standard_OutOfRange if Index is outside the
536         -- bounds of the poles table.
537         -- Standard_ConstructionError if Weight is negative or null.
538      raises OutOfRange;
539       
540
541   SetPole (me : mutable; Index : Integer; P : Pnt2d; Weight : Real)
542         --- Purpose : Modifies this BSpline curve by assigning P to the
543         -- pole of index Index in the poles table.
544         -- The second syntax also allows you to modify the
545         -- weight of the modified pole, which becomes Weight.
546         -- In this case, if this BSpline curve is non-rational, it
547         -- can become rational and vice versa.
548         -- Exceptions
549         -- Standard_OutOfRange if Index is outside the
550         -- bounds of the poles table.
551         -- Standard_ConstructionError if Weight is negative or null.
552      raises OutOfRange,
553                   ConstructionError;
554         
555   SetWeight (me : mutable; Index : Integer; Weight : Real)
556         --- Purpose : Assigns the weight Weight to the pole of index Index of the poles table.
557         --  If the curve was non rational it can become rational.
558         --  If the curve was rational it can become non rational.
559         -- Exceptions
560         -- Standard_OutOfRange if Index is outside the
561         -- bounds of the poles table.
562         -- Standard_ConstructionError if Weight is negative or null.
563     raises OutOfRange,
564                   ConstructionError;
565
566   MovePoint (me : mutable; U: Real; P: Pnt2d; Index1, Index2: Integer;
567              FirstModifiedPole, LastModifiedPole: out Integer)
568         ---Purpose : Moves the point of parameter U of this BSpline
569         -- curve to P. Index1 and Index2 are the indexes in the
570         -- table of poles of this BSpline curve of the first and
571         -- last poles designated to be moved.
572         -- FirstModifiedPole and LastModifiedPole are the
573         -- indexes of the first and last poles, which are
574         -- effectively modified.
575         -- In the event of incompatibility between Index1,
576         -- Index2 and the value U:
577         -- - no change is made to this BSpline curve, and
578         -- - the FirstModifiedPole and LastModifiedPole are returned null.
579         -- Exceptions
580         -- Standard_OutOfRange if:
581         -- - Index1 is greater than or equal to Index2, or
582         -- - Index1 or Index2 is less than 1 or greater than the
583         --   number of poles of this BSpline curve.
584      raises OutOfRange;
585        
586
587     MovePointAndTangent (me : mutable; 
588                        U                 : Real; 
589                        P                 : Pnt2d; 
590                        Tangent           : Vec2d ;
591                        Tolerance         : Real ; 
592                        StartingCondition, 
593                        EndingCondition   : Integer; 
594                        ErrorStatus       : out Integer) 
595
596         ---Purpose : Move a point with parameter U to P.
597         -- and makes it tangent at U be Tangent.
598         -- StartingCondition = -1 means first can move
599         -- EndingCondition   = -1 means last point can move
600         -- StartingCondition = 0 means the first point cannot move
601         -- EndingCondition   = 0 means the last point cannot move
602         -- StartingCondition = 1 means the first point and tangent cannot move
603         -- EndingCondition   = 1 means the last point and tangent cannot move  
604         -- and so forth
605         -- ErrorStatus != 0 means that there are not enought degree of freedom
606         -- with the constrain to deform the curve accordingly
607         
608      raises OutOfRange;
609      
610     
611   IsCN (me; N : Integer)   returns Boolean
612         --- Purpose : Returns true if the degree of continuity of this
613         -- BSpline curve is at least N. A BSpline curve is at least GeomAbs_C0.
614         -- Exceptions Standard_RangeError if N is negative.
615           raises RangeError;
616       
617   IsG1 (me; theTf, theTl, theAngTol : Real) returns Boolean;
618         ---Purpose :
619                 --  Check if curve has at least G1 continuity in interval [theTf, theTl]
620         --  Returns true if IsCN(1)  
621         --  or 
622         --  angle betweem "left" and "right" first derivatives at
623         --  knots with C0 continuity is less then theAngTol
624                 --  only knots in interval [theTf, theTl] is checked
625
626   IsClosed (me)  returns Boolean;
627         --- Purpose :
628         --  Returns true if the distance between the first point and the 
629         --  last point of the curve is lower or equal to Resolution 
630         --  from package gp.
631         --  Warnings :
632         --  The first and the last point can be different from the first
633         --  pole and the last pole of the curve.
634
635
636   IsPeriodic (me)  returns Boolean;
637         --- Purpose : Returns True if the curve is periodic.
638
639
640   IsRational (me)  returns Boolean;
641         --- Purpose :
642         --  Returns True if the weights are not identical.
643         --  The tolerance criterion is Epsilon of the class Real.
644     
645   IsCacheValid(me;  Parameter : Real) returns Boolean
646   
647         ---Purpose :
648         --           Tells whether the Cache is valid for the
649         --           given parameter 
650         -- Warnings : the parameter must be normalized within
651         -- the period if the curve is periodic. Otherwise
652         -- the answer will be false
653         -- 
654         is static private;
655   
656   Continuity (me)  returns Shape from GeomAbs;
657         --- Purpose :
658         --  Returns the global continuity of the curve :
659         --  C0 : only geometric continuity,
660         --  C1 : continuity of the first derivative all along the Curve,
661         --  C2 : continuity of the second derivative all along the Curve,
662         --  C3 : continuity of the third derivative all along the Curve,
663         --  CN : the order of continuity is infinite.
664         --  For a B-spline curve of degree d if a knot Ui has a
665         --  multiplicity p the B-spline curve is only Cd-p continuous 
666         --  at Ui. So the global continuity of the curve can't be greater 
667         --  than Cd-p where p is the maximum multiplicity of the interior
668         --  Knots. In the interior of a knot span the curve is infinitely
669         --  continuously differentiable.
670
671
672   Degree (me)  returns Integer;
673         --- Purpose : Returns the degree of this BSpline curve.
674         --  In this class the degree of the basis normalized B-spline
675         --  functions cannot be greater than "MaxDegree"
676
677
678         --- Purpose : Computation of value and derivatives
679
680   D0 (me; U : Real; P : out Pnt2d);
681
682
683   D1 (me; U : Real; P : out Pnt2d; V1 : out Vec2d)
684      raises UndefinedDerivative;
685         --- Purpose : Raised if the continuity of the curve is not C1.
686
687
688   D2 (me; U : Real; P : out Pnt2d; V1, V2 : out Vec2d)
689      raises UndefinedDerivative;
690         --- Purpose : Raised if the continuity of the curve is not C2.
691
692
693   D3 (me; U : Real; P : out Pnt2d; V1, V2, V3 : out Vec2d)
694      raises UndefinedDerivative;
695         --- Purpose:  For this BSpline curve, computes
696         -- - the point P of parameter U, or
697         -- - the point P and one or more of the following values:
698         --   - V1, the first derivative vector,
699         --   - V2, the second derivative vector,
700         --   - V3, the third derivative vector.
701         -- Warning
702         -- On a point where the continuity of the curve is not the
703         -- one requested, these functions impact the part
704         -- defined by the parameter with a value greater than U,
705         -- i.e. the part of the curve to the "right" of the singularity.
706         --   Raises UndefinedDerivative if the continuity of the curve is not C3.
707     
708   DN (me; U : Real; N : Integer)  returns Vec2d
709         --- Purpose: For the point of parameter U of this BSpline curve,
710         -- computes the vector corresponding to the Nth derivative.
711         -- Warning
712         -- On a point where the continuity of the curve is not the
713         -- one requested, this function impacts the part defined
714         -- by the parameter with a value greater than U, i.e. the
715         -- part of the curve to the "right" of the singularity.
716         --    Raises  UndefinedDerivative if the continuity of the curve is not CN.
717         --   RangeError if N < 1.
718      raises  UndefinedDerivative,
719                   RangeError;
720
721         --- Purpose: The following functions computes the point of parameter U 
722         --  and the derivatives at this point on the B-spline curve 
723         --  arc defined between the knot FromK1 and the knot ToK2. 
724         --  U can be out of bounds [Knot (FromK1),  Knot (ToK2)] but
725         --  for the computation we only use the definition of the curve
726         --  between these two knots. This method is useful to compute 
727         --  local derivative, if the order of continuity of the whole 
728         --  curve is not greater enough.    Inside the parametric
729         --  domain Knot (FromK1), Knot (ToK2) the evaluations are
730         --  the same as if we consider the whole definition of the
731         --  curve. Of course the evaluations are different outside
732         --  this parametric domain.
733
734
735   LocalValue (me; U : Real; FromK1, ToK2 : Integer)   returns Pnt2d
736      raises DomainError,
737         --- Purpose : Raised if FromK1 = ToK2.
738             OutOfRange;
739         --- Purpose :
740         --  Raised if FromK1 and ToK2 are not in the range 
741         --  [FirstUKnotIndex, LastUKnotIndex].
742
743
744   LocalD0 (me; U : Real; FromK1, ToK2 : Integer; 
745            P : out Pnt2d)
746      raises UndefinedDerivative, OutOfRange;
747      
748      
749   LocalD1 (me; U : Real; FromK1, ToK2 : Integer; 
750            P : out Pnt2d; V1 : out Vec2d)
751      raises UndefinedDerivative,
752         --- Purpose :
753         --  Raised if the local continuity of the curve is not C1 
754         --  between the knot K1 and the knot K2. 
755             DomainError,
756         --- Purpose : Raised if FromK1 = ToK2.
757             OutOfRange;
758         --- Purpose :
759         --  Raised if FromK1 and ToK2 are not in the range 
760         --  [FirstUKnotIndex, LastUKnotIndex].
761
762
763   LocalD2 (me; U : Real; FromK1, ToK2 : Integer;
764            P : out Pnt2d; V1, V2 : out Vec2d)
765      raises UndefinedDerivative,
766         --- Purpose :
767         --  Raised if the local continuity of the curve is not C2 
768         --  between the knot K1 and the knot K2. 
769             DomainError,
770         --- Purpose : Raised if FromK1 = ToK2.
771             OutOfRange;
772         --- Purpose :
773         --  Raised if FromK1 and ToK2 are not in the range 
774         --  [FirstUKnotIndex, LastUKnotIndex].
775
776
777
778   LocalD3 (me; U : Real;  FromK1, ToK2 : Integer;
779            P : out Pnt2d; V1, V2, V3 : out Vec2d)
780      raises UndefinedDerivative,
781         --- Purpose :
782         --  Raised if the local continuity of the curve is not C3
783         --  between the knot K1 and the knot K2. 
784             DomainError,
785         --- Purpose : Raised if FromK1 = ToK2.
786             OutOfRange;
787         --- Purpose :
788         --  Raised if FromK1 and ToK2 are not in the range
789         --  [FirstUKnotIndex, LastUKnotIndex].
790
791
792   LocalDN (me; U : Real;  FromK1, ToK2 : Integer; N : Integer)  returns Vec2d
793      raises  UndefinedDerivative,
794         --- Purpose :
795         --  Raised if the local continuity of the curve is not CN
796         --  between the knot K1 and the knot K2. 
797             DomainError,
798         --- Purpose : Raised if FromK1 = ToK2.
799              RangeError,
800         --- Purpose : Raised if N < 1.
801              OutOfRange;
802         --- Purpose :
803         --  Raises if FromK1 and ToK2 are not in the range 
804         --  [FirstUKnotIndex, LastUKnotIndex].
805
806
807   EndPoint (me)   returns Pnt2d;
808         --- Purpose :
809         --  Returns the last point of the curve.
810         -- Warnings :
811         --  The last point of the curve is different from the last 
812         --  pole of the curve if the multiplicity of the last knot
813         --  is lower than Degree.
814
815
816   FirstUKnotIndex (me)   returns Integer;
817         --- Purpose :
818         --  For a B-spline curve the first parameter (which gives the start
819         --  point of the curve) is a knot value but if the multiplicity of
820         --  the first knot index is lower than Degree + 1 it is not the 
821         --  first knot of the curve. This method computes the index of the
822         --  knot corresponding to the first parameter.
823
824
825   FirstParameter (me)   returns Real;
826         --- Purpose :
827         --  Computes the parametric value of the start point of the curve.
828         --  It is a knot value.
829
830
831   Knot (me; Index : Integer)   returns Real
832         --- Purpose :
833         --  Returns the knot of range Index. When there is a knot 
834         --  with a multiplicity greater than 1 the knot is not repeated.
835         --  The method Multiplicity can be used to get the multiplicity 
836         --  of the Knot.
837      raises OutOfRange;
838         --- Purpose : Raised if Index < 1 or Index > NbKnots
839
840
841   Knots (me; K : out Array1OfReal from TColStd)
842         --- Purpose : returns the knot values of the B-spline curve;
843      raises DimensionError;
844         --- Purpose :
845         --  Raised if the length of K is not equal to the number of knots.
846
847
848   KnotSequence (me; K : out Array1OfReal from TColStd)
849         --- Purpose : Returns the knots sequence.
850         --  In this sequence the knots with a multiplicity greater than 1
851         --  are repeated. 
852         -- Example :
853         --  K = {k1, k1, k1, k2, k3, k3, k4, k4, k4}
854      raises DimensionError;
855         --- Purpose :
856         --  Raised if the length of K is not equal to NbPoles + Degree + 1
857
858
859
860   KnotDistribution (me) returns BSplKnotDistribution from GeomAbs;
861         --- Purpose :
862         --  Returns NonUniform or Uniform or QuasiUniform or PiecewiseBezier.
863         --  If all the knots differ by a positive constant from the 
864         --  preceding knot the BSpline Curve can be :
865         --  - Uniform if all the knots are of multiplicity 1,
866         --  - QuasiUniform if all the knots are of multiplicity 1 except for
867         --    the first and last knot which are of multiplicity Degree + 1,
868         --  - PiecewiseBezier if the first and last knots have multiplicity
869         --    Degree + 1 and if interior knots have multiplicity Degree
870         --    A piecewise Bezier with only two knots is a BezierCurve. 
871         --  else the curve is non uniform.
872         --  The tolerance criterion is Epsilon from class Real.
873
874
875   LastUKnotIndex (me)  returns Integer;
876         --- Purpose :
877         --  For a BSpline curve the last parameter (which gives the 
878         --  end point of the curve) is a knot value but if the 
879         --  multiplicity of the last knot index is lower than 
880         --  Degree + 1 it is not the last knot of the curve. This
881         --  method computes the index of the knot corresponding to
882         --  the last parameter.
883
884
885   LastParameter (me)   returns Real;
886         --- Purpose :
887         --  Computes the parametric value of the end point of the curve.
888         --  It is a knot value.
889
890
891   LocateU (me;
892            U                   : Real; 
893            ParametricTolerance : Real; 
894            I1, I2              : in out Integer;
895            WithKnotRepetition  : Boolean = Standard_False);
896         --- Purpose :
897         --  Locates the parametric value U in the sequence of knots.
898         --  If "WithKnotRepetition" is True we consider the knot's
899         --  representation with repetition of multiple knot value,
900         --  otherwise  we consider the knot's representation with
901         --  no repetition of multiple knot values.
902         --  Knots (I1) <= U <= Knots (I2)
903         --  . if I1 = I2  U is a knot value (the tolerance criterion 
904         --    ParametricTolerance is used).
905         --  . if I1 < 1  => U < Knots (1) - Abs(ParametricTolerance)
906         --  . if I2 > NbKnots => U > Knots (NbKnots) + Abs(ParametricTolerance)
907
908
909   Multiplicity (me; Index : Integer)   returns Integer
910         --- Purpose :
911         --  Returns the multiplicity of the knots of range Index.
912      raises OutOfRange;
913         --- Purpose : Raised if Index < 1 or Index > NbKnots
914
915
916   Multiplicities (me; M : out Array1OfInteger from TColStd)
917         --- Purpose :
918         --  Returns the multiplicity of the knots of the curve.
919      raises DimensionError;
920         --- Purpose :
921         --  Raised if the length of M is not equal to NbKnots.
922
923
924   NbKnots (me)  returns Integer;
925         --- Purpose :
926         --  Returns the number of knots. This method returns the number of 
927         --  knot without repetition of multiple knots.
928
929
930   NbPoles (me)  returns Integer;
931         --- Purpose : Returns the number of poles
932
933
934   Pole (me; Index : Integer)   returns Pnt2d
935         --- Purpose : Returns the pole of range Index.
936      raises OutOfRange;
937         --- Purpose : Raised if Index < 1 or Index > NbPoles.
938
939
940   Poles (me; P : out Array1OfPnt2d)
941         --- Purpose : Returns the poles of the B-spline curve;
942      raises DimensionError;
943         --- Purpose : 
944         --  Raised if the length of P is not equal to the number of poles.
945
946
947   StartPoint (me)  returns Pnt2d;
948         --- Purpose :
949         --  Returns the start point of the curve.
950         -- Warnings :
951         --  This point is different from the first pole of the curve if the
952         --  multiplicity of the first knot is lower than Degree.
953
954
955   Weight (me; Index : Integer)  returns Real  
956         --- Purpose : Returns the weight of the pole of range Index .
957      raises OutOfRange;
958         --- Purpose : Raised if Index < 1 or Index > NbPoles.
959
960
961   Weights (me; W : out Array1OfReal from TColStd)
962         --- Purpose : Returns the weights of the B-spline curve;
963      raises DimensionError;
964         --- Purpose :
965         --  Raised if the length of W is not equal to NbPoles.
966
967
968
969
970
971
972   Transform (me : mutable; T : Trsf2d);
973 ---Purpose: Applies the transformation T to this BSpline curve.
974
975   MaxDegree (myclass)  returns Integer;
976         --- Purpose :
977         --  Returns the value of the maximum degree of the normalized 
978         --  B-spline basis functions in this package.
979
980
981   Resolution(me          : mutable; 
982              ToleranceUV : Real;
983              UTolerance  : out Real); 
984         ---Purpose:  Computes for this BSpline curve the parametric
985         -- tolerance UTolerance for a given tolerance
986         -- Tolerance3D (relative to dimensions in the plane).
987         -- If f(t) is the equation of this BSpline curve,
988         -- UTolerance ensures that:
989         --           | t1 - t0| < Utolerance ===> 
990         --           |f(t1) - f(t0)| < ToleranceUV
991
992
993   Copy (me)  returns like me;
994         ---Purpose: Creates a new object which is a copy of this BSpline curve.  
995     
996   UpdateKnots(me : mutable)
997         ---Purpose: Recompute  the  flatknots,  the knotsdistribution, the continuity.
998   is static private;
999   
1000   InvalidateCache(me : mutable)
1001         ---Purpose : Invalidates the cache. This has to be private this has to be private
1002       is static private;
1003
1004   
1005   ValidateCache(me : mutable ; Parameter : Real) 
1006   
1007     is static private;
1008         ---Purpose : updates the cache and validates it
1009              
1010 fields
1011
1012   rational  : Boolean;
1013   periodic  : Boolean;
1014   knotSet   : BSplKnotDistribution from GeomAbs; 
1015   smooth    : Shape from GeomAbs;
1016   deg       : Integer;
1017   poles     : HArray1OfPnt2d from TColgp;
1018   weights   : HArray1OfReal from TColStd;
1019   flatknots : HArray1OfReal from TColStd;
1020   knots     : HArray1OfReal from TColStd;
1021   mults     : HArray1OfInteger from TColStd;
1022   cachepoles      : HArray1OfPnt2d     from TColgp;
1023   -- Taylor expansion of the poles function, in homogeneous
1024   -- form if the curve is rational. The taylor expansion
1025   -- is normalized so that the span corresponds to
1026   -- [0 1] see below
1027   cacheweights    : HArray1OfReal    from TColStd;
1028   -- Taylor expansion of the poles function, in homogeneous
1029   -- form if the curve is rational. The taylor expansion
1030   -- is normalized so that the span corresponds to
1031   -- [0 1] see below
1032   validcache      : Integer;
1033   -- = 1 the cache is valid 
1034   -- = 0 the cache is invalid
1035   parametercache    : Real;
1036   -- Parameter at which the Taylor expension is stored in 
1037   -- the cache
1038   spanlenghtcache   : Real;
1039   -- Since the Taylor expansion is normalized in the 
1040   -- cache to evaluate the cache one has to use
1041   -- (Parameter - refcache) * normcache 
1042   spanindexcache : Integer;
1043   -- the span for which the cache is valid if 
1044   -- validcache is 1 
1045
1046   -- usefull to evaluate the parametric resolution
1047   maxderivinv   : Real from Standard;
1048   maxderivinvok : Boolean from Standard;
1049
1050   myMutex       : Mutex from Standard;
1051   -- protected bspline-cache
1052
1053 end;