db9f68eb67f70b49c90c1a738d51810093dc0fe8
[occt.git] / src / Geom2d / Geom2d_BSplineCurve.cxx
1 // Created on: 1993-03-25
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 //Avril 1991 : constructeurs + methodes de lecture.
18 //Mai 1991   : revue des specifs + debut de realisation des classes tool =>
19 //             implementation des methodes Set et calcul du point courant.
20 //Juillet 1991 : voir egalement File Geom2d_BSplineCurve_1.cxx
21 //Juin    1992 : mise a plat des valeurs nodales - amelioration des
22 //               performances sur calcul du point courant
23
24 //RLE Aug 1993  Remove Swaps, Init methods, Remove typedefs
25 //  14-Mar-96 : xab implemented MovePointAndTangent
26
27 //SAMTECH Jan 2002 : add text to Raise()
28
29 #define No_Standard_OutOfRange
30
31 #include <Geom2d_BSplineCurve.ixx>
32 #include <gp.hxx>
33 #include <BSplCLib.hxx>
34 #include <BSplCLib_KnotDistribution.hxx>
35 #include <BSplCLib_MultDistribution.hxx>
36 #include <Standard_NotImplemented.hxx>
37 #include <Standard_ConstructionError.hxx>
38 #include <Standard_OutOfRange.hxx>
39
40 //=======================================================================
41 //function : CheckCurveData
42 //purpose  : Internal use only
43 //=======================================================================
44
45 static void CheckCurveData
46 (const TColgp_Array1OfPnt2d&         CPoles,
47  const TColStd_Array1OfReal&       CKnots,
48  const TColStd_Array1OfInteger&    CMults,
49  const Standard_Integer            Degree,
50  const Standard_Boolean            Periodic)
51 {
52   if (Degree < 1 || Degree > Geom2d_BSplineCurve::MaxDegree()) {
53     Standard_ConstructionError::Raise("BSpline curve : invalid degree");  
54   }
55   
56   if (CPoles.Length() < 2)                Standard_ConstructionError::Raise("BSpline curve : at least 2 poles required");
57   if (CKnots.Length() != CMults.Length()) Standard_ConstructionError::Raise("BSpline curve : Knot and Mult array size mismatch");
58   
59   for (Standard_Integer I = CKnots.Lower(); I < CKnots.Upper(); I++) {
60     if (CKnots (I+1) - CKnots (I) <= Epsilon (Abs(CKnots (I)))) {
61       Standard_ConstructionError::Raise("BSpline curve : Knots interval values too close");
62     }
63   }
64   
65   if (CPoles.Length() != BSplCLib::NbPoles(Degree,Periodic,CMults))
66     Standard_ConstructionError::Raise("BSpline curve : # Poles and degree mismatch");
67 }
68
69 //=======================================================================
70 //function : Rational
71 //purpose  : check rationality of an array of weights
72 //=======================================================================
73
74 static Standard_Boolean Rational(const TColStd_Array1OfReal& W)
75 {
76   Standard_Integer i, n = W.Length();
77   Standard_Boolean rat = Standard_False;
78   for (i = 1; i < n; i++) {
79     rat =  Abs(W(i) - W(i+1)) > gp::Resolution();
80     if (rat) break;
81   }
82   return rat;
83 }
84
85 //=======================================================================
86 //function : Copy
87 //purpose  : 
88 //=======================================================================
89
90 Handle(Geom2d_Geometry) Geom2d_BSplineCurve::Copy() const
91 {
92   Handle(Geom2d_BSplineCurve) C;
93   if (IsRational()) 
94     C = new Geom2d_BSplineCurve(poles->Array1(),
95                                 weights->Array1(),
96                                 knots->Array1(),
97                                 mults->Array1(),
98                                 deg,periodic);
99   else
100     C = new Geom2d_BSplineCurve(poles->Array1(),
101                                 knots->Array1(),
102                                 mults->Array1(),
103                                 deg,periodic);
104   return C;
105 }
106
107 //=======================================================================
108 //function : Geom2d_BSplineCurve
109 //purpose  : 
110 //=======================================================================
111
112 Geom2d_BSplineCurve::Geom2d_BSplineCurve
113 (const TColgp_Array1OfPnt2d&     Poles,
114  const TColStd_Array1OfReal&     Knots,
115  const TColStd_Array1OfInteger&  Mults,
116  const Standard_Integer          Degree,
117  const Standard_Boolean          Periodic) :
118  rational(Standard_False),
119  periodic(Periodic),
120  deg(Degree),
121  maxderivinvok(Standard_False)
122 {
123   // check
124   
125   CheckCurveData (Poles,
126                   Knots,
127                   Mults,
128                   Degree,
129                   Periodic);
130
131
132   // copy arrays
133
134   poles =  new TColgp_HArray1OfPnt2d(1,Poles.Length());
135   poles->ChangeArray1() = Poles;
136
137   knots = new TColStd_HArray1OfReal(1,Knots.Length());
138   knots->ChangeArray1() = Knots;
139
140   mults = new TColStd_HArray1OfInteger(1,Mults.Length());
141   mults->ChangeArray1() = Mults;
142
143   UpdateKnots();
144   cachepoles = new TColgp_HArray1OfPnt2d(1,Degree + 1);
145   parametercache = 0.0e0 ;
146   spanlenghtcache = 0.0e0 ;
147   spanindexcache = 0 ;
148 }
149
150 //=======================================================================
151 //function : Geom2d_BSplineCurve
152 //purpose  : 
153 //=======================================================================
154
155 Geom2d_BSplineCurve::Geom2d_BSplineCurve
156 (const TColgp_Array1OfPnt2d&      Poles,
157  const TColStd_Array1OfReal&    Weights,
158  const TColStd_Array1OfReal&    Knots,
159  const TColStd_Array1OfInteger& Mults,
160  const Standard_Integer         Degree,
161  const Standard_Boolean         Periodic)  :
162  rational(Standard_True),
163  periodic(Periodic),
164  deg(Degree),
165  maxderivinvok(Standard_False)
166
167 {
168
169   // check
170   
171   CheckCurveData (Poles,
172                   Knots,
173                   Mults,
174                   Degree,
175                   Periodic);
176
177   if (Weights.Length() != Poles.Length())
178     Standard_ConstructionError::Raise("Geom2d_BSplineCurve :Weights and Poles array size mismatch");
179
180   Standard_Integer i;
181   for (i = Weights.Lower(); i <= Weights.Upper(); i++) {
182     if (Weights(i) <= gp::Resolution()) {
183       Standard_ConstructionError::Raise("Geom2d_BSplineCurve: Weights values too small");
184     }
185   }
186   
187   // check really rational
188   rational = Rational(Weights);
189   
190   // copy arrays
191   
192   poles =  new TColgp_HArray1OfPnt2d(1,Poles.Length());
193   poles->ChangeArray1() = Poles;
194   cachepoles = new TColgp_HArray1OfPnt2d(1,Degree + 1);
195   if (rational) {
196     weights =  new TColStd_HArray1OfReal(1,Weights.Length());
197     weights->ChangeArray1() = Weights;
198     cacheweights  = new TColStd_HArray1OfReal(1,Degree + 1);
199   }
200
201   knots = new TColStd_HArray1OfReal(1,Knots.Length());
202   knots->ChangeArray1() = Knots;
203
204   mults = new TColStd_HArray1OfInteger(1,Mults.Length());
205   mults->ChangeArray1() = Mults;
206
207   UpdateKnots();
208
209   parametercache = 0.0e0 ;
210   spanlenghtcache = 0.0e0 ;
211   spanindexcache = 0 ;
212 }
213
214 //=======================================================================
215 //function : MaxDegree
216 //purpose  : 
217 //=======================================================================
218
219 Standard_Integer Geom2d_BSplineCurve::MaxDegree () 
220
221   return BSplCLib::MaxDegree(); 
222 }
223
224 //=======================================================================
225 //function : IncreaseDegree
226 //purpose  : 
227 //=======================================================================
228
229 void Geom2d_BSplineCurve::IncreaseDegree
230 (const Standard_Integer Degree)
231 {
232   if (Degree == deg) return;
233
234   if (Degree < deg || Degree > Geom2d_BSplineCurve::MaxDegree()) {
235     Standard_ConstructionError::Raise("BSpline curve : IncreaseDegree : bad degree value");
236   }
237
238   Standard_Integer FromK1 = FirstUKnotIndex ();
239   Standard_Integer ToK2   = LastUKnotIndex  ();
240   
241   Standard_Integer Step   = Degree - deg;
242   
243   Handle(TColgp_HArray1OfPnt2d) npoles = new
244     TColgp_HArray1OfPnt2d(1,poles->Length() + Step * (ToK2-FromK1));
245
246   Standard_Integer nbknots = BSplCLib::IncreaseDegreeCountKnots
247     (deg,Degree,periodic,mults->Array1());
248
249   Handle(TColStd_HArray1OfReal) nknots = 
250     new TColStd_HArray1OfReal(1,nbknots);
251
252   Handle(TColStd_HArray1OfInteger) nmults = 
253     new TColStd_HArray1OfInteger(1,nbknots);
254   
255   Handle(TColStd_HArray1OfReal) nweights;
256   
257   if (IsRational()) {
258     
259     nweights = new TColStd_HArray1OfReal(1,npoles->Upper());
260     
261     BSplCLib::IncreaseDegree
262       (deg,Degree, periodic,
263        poles->Array1(),weights->Array1(),
264        knots->Array1(),mults->Array1(),
265        npoles->ChangeArray1(),nweights->ChangeArray1(),
266        nknots->ChangeArray1(),nmults->ChangeArray1());
267   }
268   else {
269
270     BSplCLib::IncreaseDegree
271       (deg,Degree, periodic,
272        poles->Array1(),
273        *((TColStd_Array1OfReal*) NULL),
274        knots->Array1(),mults->Array1(),
275        npoles->ChangeArray1(),
276        *((TColStd_Array1OfReal*) NULL),
277        nknots->ChangeArray1(),nmults->ChangeArray1());
278   }
279
280   deg     = Degree;
281   poles   = npoles;
282   weights = nweights;
283   knots   = nknots;
284   mults   = nmults;
285   UpdateKnots();
286 }
287
288 //=======================================================================
289 //function : IncreaseMultiplicity
290 //purpose  : 
291 //=======================================================================
292
293 void Geom2d_BSplineCurve::IncreaseMultiplicity
294 (const Standard_Integer Index,
295  const Standard_Integer M)
296 {
297   TColStd_Array1OfReal k(1,1);
298   k(1) = knots->Value(Index);
299   TColStd_Array1OfInteger m(1,1);
300   m(1) = M - mults->Value(Index);
301   InsertKnots(k,m,Epsilon(1.),Standard_True);
302 }
303
304 //=======================================================================
305 //function : IncreaseMultiplicity
306 //purpose  : 
307 //=======================================================================
308
309 void Geom2d_BSplineCurve::IncreaseMultiplicity
310 (const Standard_Integer I1,
311  const Standard_Integer I2,
312  const Standard_Integer M)
313 {
314   Handle(TColStd_HArray1OfReal) tk = knots;
315   TColStd_Array1OfReal k((knots->Array1())(I1),I1,I2);
316   TColStd_Array1OfInteger m(I1,I2);
317   Standard_Integer i;
318   for (i = I1; i <= I2; i++)
319     m(i) = M - mults->Value(i);
320   InsertKnots(k,m,Epsilon(1.),Standard_True);
321 }
322
323 //=======================================================================
324 //function : IncrementMultiplicity
325 //purpose  : 
326 //=======================================================================
327
328 void Geom2d_BSplineCurve::IncrementMultiplicity
329 (const Standard_Integer I1,
330  const Standard_Integer I2,
331  const Standard_Integer Step)
332 {
333   Handle(TColStd_HArray1OfReal) tk = knots;
334   TColStd_Array1OfReal    k((knots->Array1())(I1),I1,I2);
335   TColStd_Array1OfInteger m(I1,I2);
336   m.Init(Step);
337   InsertKnots(k,m,Epsilon(1.),Standard_True);
338 }
339
340 //=======================================================================
341 //function : InsertKnot
342 //purpose  : 
343 //=======================================================================
344
345 void Geom2d_BSplineCurve::InsertKnot
346 (const Standard_Real U, 
347  const Standard_Integer M, 
348  const Standard_Real ParametricTolerance)
349 {
350   TColStd_Array1OfReal k(1,1);
351   k(1) = U;
352   TColStd_Array1OfInteger m(1,1);
353   m(1) = M;
354   InsertKnots(k,m,ParametricTolerance);
355 }
356
357 //=======================================================================
358 //function : InsertKnots
359 //purpose  : 
360 //=======================================================================
361 void  Geom2d_BSplineCurve::InsertKnots(const TColStd_Array1OfReal& Knots, 
362                                        const TColStd_Array1OfInteger& Mults,
363                                        const Standard_Real Epsilon,
364                                        const Standard_Boolean Add)
365 {
366   // Check and compute new sizes
367   Standard_Integer nbpoles,nbknots;
368
369   if (!BSplCLib::PrepareInsertKnots(deg,periodic,
370                                     knots->Array1(),mults->Array1(),
371                                     Knots,Mults,nbpoles,nbknots,Epsilon,Add))
372     Standard_ConstructionError::Raise("Geom2d_BSplineCurve::InsertKnots");
373
374   if (nbpoles == poles->Length()) return;
375
376   Handle(TColgp_HArray1OfPnt2d)      npoles = new TColgp_HArray1OfPnt2d(1,nbpoles);
377   Handle(TColStd_HArray1OfReal)    nknots = knots;
378   Handle(TColStd_HArray1OfInteger) nmults = mults;
379
380   if (nbknots != knots->Length()) {
381     nknots  = new TColStd_HArray1OfReal(1,nbknots);
382     nmults = new TColStd_HArray1OfInteger(1,nbknots);
383   }
384
385   if (rational) {
386     Handle(TColStd_HArray1OfReal) nweights = 
387       new TColStd_HArray1OfReal(1,nbpoles);
388     BSplCLib::InsertKnots(deg,periodic,
389                           poles->Array1(), weights->Array1(),
390                           knots->Array1(), mults->Array1(),
391                           Knots, Mults,
392                           npoles->ChangeArray1(), nweights->ChangeArray1(),
393                           nknots->ChangeArray1(), nmults->ChangeArray1(),
394                           Epsilon,Add);
395     weights = nweights;
396   }
397   else {
398     BSplCLib::InsertKnots(deg,periodic,
399                           poles->Array1(),
400                           *((TColStd_Array1OfReal*) NULL),
401                           knots->Array1(), mults->Array1(),
402                           Knots, Mults,
403                           npoles->ChangeArray1(),
404                           *((TColStd_Array1OfReal*) NULL),
405                           nknots->ChangeArray1(), nmults->ChangeArray1(),
406                           Epsilon,Add);
407   }
408
409   poles = npoles;
410   knots = nknots;
411   mults = nmults;
412   UpdateKnots();
413
414 }
415
416 //=======================================================================
417 //function : RemoveKnot
418 //purpose  : 
419 //=======================================================================
420
421 Standard_Boolean  Geom2d_BSplineCurve::RemoveKnot
422 (const Standard_Integer Index,
423  const Standard_Integer M, 
424  const Standard_Real Tolerance)
425 {
426   if (M < 0) return Standard_True;
427
428   Standard_Integer I1  = FirstUKnotIndex ();
429   Standard_Integer I2  = LastUKnotIndex  ();
430
431   if (Index < I1 || Index > I2)  {
432     Standard_OutOfRange::Raise("BSpline curve : RemoveKnot : index out of range");
433   }
434   
435   const TColgp_Array1OfPnt2d & oldpoles   = poles->Array1();
436   
437   Standard_Integer step = mults->Value(Index) - M;
438   if (step <= 0) return Standard_True;
439   
440   Handle(TColgp_HArray1OfPnt2d) npoles =
441     new TColgp_HArray1OfPnt2d(1,oldpoles.Length()-step);
442   
443   Handle(TColStd_HArray1OfReal)    nknots  = knots;
444   Handle(TColStd_HArray1OfInteger) nmults  = mults;
445   
446   if (M == 0) {
447     nknots = new TColStd_HArray1OfReal(1,knots->Length()-1);
448     nmults = new TColStd_HArray1OfInteger(1,knots->Length()-1);
449   }
450   
451   if (IsRational()) {
452     Handle(TColStd_HArray1OfReal) nweights = 
453       new TColStd_HArray1OfReal(1,npoles->Length());
454     if (!BSplCLib::RemoveKnot
455         (Index, M, deg, periodic,
456          poles->Array1(),weights->Array1(), 
457          knots->Array1(),mults->Array1(),
458          npoles->ChangeArray1(), nweights->ChangeArray1(),
459          nknots->ChangeArray1(),nmults->ChangeArray1(),
460          Tolerance))
461       return Standard_False;
462     weights = nweights;
463   }
464   else {
465     if (!BSplCLib::RemoveKnot
466         (Index, M, deg, periodic,
467          poles->Array1(),
468          *((TColStd_Array1OfReal*) NULL),
469          knots->Array1(),mults->Array1(),
470          npoles->ChangeArray1(),
471          *((TColStd_Array1OfReal*) NULL),
472          nknots->ChangeArray1(),nmults->ChangeArray1(),
473          Tolerance))
474       return Standard_False;
475   }
476   
477   poles = npoles;
478   knots = nknots;
479   mults = nmults;
480   
481   UpdateKnots();
482   maxderivinvok = 0;
483   return Standard_True;
484 }
485
486 //=======================================================================
487 //function : InsertPoleAfter
488 //purpose  : 
489 //=======================================================================
490
491 void Geom2d_BSplineCurve::InsertPoleAfter
492 (const Standard_Integer Index,
493  const gp_Pnt2d& P,
494  const Standard_Real Weight)
495 {
496   if (Index < 0 || Index > poles->Length())  Standard_OutOfRange::Raise("BSpline curve : InsertPoleAfter: Index and #pole mismatch");
497
498   if (Weight <= gp::Resolution())     Standard_ConstructionError::Raise("BSpline curve : InsertPoleAfter: Weight too small");
499
500   if (knotSet == GeomAbs_NonUniform || knotSet == GeomAbs_PiecewiseBezier) {
501     Standard_ConstructionError::Raise("BSpline curve : InsertPoleAfter : bad knotSet type");
502   }
503
504   const TColStd_Array1OfReal& cknots   = knots->Array1();
505   Standard_Integer nbknots = cknots.Length();
506
507   Handle(TColStd_HArray1OfReal) nknots =  
508     new TColStd_HArray1OfReal(1,nbknots+1);
509
510   TColStd_Array1OfReal& newknots = nknots->ChangeArray1();
511
512   Standard_Integer i;
513   for (i = 1; i < nbknots; i++) {
514     newknots (i) = cknots(i);
515   }
516   
517   newknots (nbknots+1) = 2 * newknots (nbknots) - newknots(nbknots-1);
518   
519   Handle(TColStd_HArray1OfInteger) nmults =
520     new TColStd_HArray1OfInteger(1,nbknots+1);
521
522   TColStd_Array1OfInteger& newmults     = nmults->ChangeArray1();
523   const TColStd_Array1OfInteger& cmults = mults->Array1();
524
525   for (i = 2; i <= nbknots; i++) newmults (i) = 1;
526   newmults (1)         =  cmults(1);
527   newmults (nbknots+1) =  cmults(nbknots+1);
528   
529   const TColgp_Array1OfPnt2d& cpoles = poles->Array1();
530   Standard_Integer nbpoles = cpoles.Length();
531   Handle(TColgp_HArray1OfPnt2d) npoles = 
532     new TColgp_HArray1OfPnt2d(1, nbpoles+1);
533   TColgp_Array1OfPnt2d& newpoles = npoles->ChangeArray1();
534
535   // insert the pole
536
537   for (i = 1; i <= Index; i++)
538     newpoles(i) = cpoles(i);
539
540   newpoles(Index+1) = P;
541
542   for (i = Index+1; i <= nbpoles; i++)
543     newpoles(i+1) = cpoles(i);
544
545   // Insert the weight
546
547   Handle(TColStd_HArray1OfReal) nweights;
548   Standard_Boolean rat = IsRational() || Abs(Weight-1.) > gp::Resolution();
549   
550   if (rat) {
551     nweights = new TColStd_HArray1OfReal(1,nbpoles+1);
552     TColStd_Array1OfReal& newweights = nweights->ChangeArray1();
553
554     for (i = 1; i <= Index; i++)
555       if (IsRational())
556         newweights(i) = weights->Value(i);
557       else
558         newweights(i) = 1.;
559     
560     newweights(Index+1) = Weight;
561
562     for (i = Index+1; i <= nbpoles; i++)
563       if (IsRational())
564         newweights(i+1) = weights->Value(i);
565       else
566         newweights(i+1) = 1.;
567   }
568   
569   poles   = npoles;
570   weights = nweights;
571   knots   = nknots;
572   mults   = nmults;
573   maxderivinvok = 0;
574   UpdateKnots();
575 }
576
577 //=======================================================================
578 //function : InsertPoleBefore
579 //purpose  : 
580 //=======================================================================
581
582 void Geom2d_BSplineCurve::InsertPoleBefore
583 (const Standard_Integer Index,
584  const gp_Pnt2d& P,
585  const Standard_Real Weight)
586 {
587   InsertPoleAfter(Index-1,P,Weight);
588 }
589
590 //=======================================================================
591 //function : RemovePole
592 //purpose  : 
593 //=======================================================================
594
595 void Geom2d_BSplineCurve::RemovePole
596 (const Standard_Integer Index)
597 {
598   if (Index < 1 || Index > poles->Length())  Standard_OutOfRange::Raise("BSpline curve :RemovePole : Index and #pole mismatch");
599
600   if (poles->Length() <= 2)           Standard_ConstructionError::Raise("BSpline curve : RemovePole : #pole is already minimum");
601
602   if (knotSet == GeomAbs_NonUniform || knotSet == GeomAbs_PiecewiseBezier) 
603     Standard_ConstructionError::Raise("BSpline curve : RemovePole: bad knotSet type");
604
605   Standard_Integer i;
606   Handle(TColStd_HArray1OfReal) nknots =
607     new TColStd_HArray1OfReal(1,knots->Length()-1);
608   TColStd_Array1OfReal& newknots = nknots->ChangeArray1();
609
610   Handle(TColStd_HArray1OfInteger) nmults =
611     new TColStd_HArray1OfInteger(1,mults->Length()-1);
612   TColStd_Array1OfInteger& newmults = nmults->ChangeArray1();
613
614   for (i = 1; i < newknots.Length(); i++) {
615     newknots (i) = knots->Value (i);
616     newmults (i) = 1;
617   }
618   newmults(1) = mults->Value(1);
619   newknots(newknots.Upper()) = knots->Value (knots->Upper());
620   newmults(newmults.Upper()) = mults->Value (mults->Upper());
621
622
623   Handle(TColgp_HArray1OfPnt2d) npoles =
624     new TColgp_HArray1OfPnt2d(1, poles->Upper()-1);
625   TColgp_Array1OfPnt2d& newpoles = npoles->ChangeArray1();
626
627   for (i = 1; i < Index; i++)
628     newpoles(i) = poles->Value(i);
629   for (i = Index; i < newpoles.Length(); i++)
630     newpoles(i) = poles->Value(i+1);
631
632   Handle(TColStd_HArray1OfReal) nweights;
633   if (IsRational()) {
634     nweights = new TColStd_HArray1OfReal(1,newpoles.Length());
635     TColStd_Array1OfReal& newweights = nweights->ChangeArray1();
636     for (i = 1; i < Index; i++)
637       newweights(i) = weights->Value(i);
638     for (i = Index; i < newweights.Length(); i++)
639       newweights(i) = weights->Value(i+1);
640   }
641
642   poles   = npoles;
643   weights = nweights;
644   knots   = nknots;
645   mults   = nmults;
646   UpdateKnots();
647 }
648
649 //=======================================================================
650 //function : Reverse
651 //purpose  : 
652 //=======================================================================
653
654 void Geom2d_BSplineCurve::Reverse ()
655
656   BSplCLib::Reverse(knots->ChangeArray1());
657   BSplCLib::Reverse(mults->ChangeArray1());
658   Standard_Integer last;
659   if (periodic)
660     last = flatknots->Upper() - deg - 1;
661   else
662     last = poles->Upper();
663   BSplCLib::Reverse(poles->ChangeArray1(),last);
664   if (rational)
665     BSplCLib::Reverse(weights->ChangeArray1(),last);
666   UpdateKnots();
667 }
668
669 //=======================================================================
670 //function : ReversedParameter
671 //purpose  : 
672 //=======================================================================
673
674 Standard_Real Geom2d_BSplineCurve::ReversedParameter( const Standard_Real U) const
675 {
676   return (FirstParameter() + LastParameter() - U);
677 }
678
679 //=======================================================================
680 //function : Segment
681 //purpose  : 
682 //=======================================================================
683 void Geom2d_BSplineCurve::Segment(const Standard_Real aU1,
684                                   const Standard_Real aU2)
685 {
686   Standard_DomainError_Raise_if ( aU2 < aU1, "Geom2d_BSplineCurve::Segment");
687   //
688   Standard_Real AbsUMax = Max(Abs(FirstParameter()),Abs(LastParameter()));
689   Standard_Real Eps = Epsilon(AbsUMax);
690   Standard_Real NewU1, NewU2;
691   Standard_Real U, DU=0;
692   Standard_Integer i, k, index;
693   //
694   //f
695   // Checking the input bounds aUj (j=1,2). 
696   // For the case when aUj==knot(i), 
697   // in order to prevent the insertion of a new knot that will be too closed 
698   // to the existing knot,  
699   // we assign Uj=knot(i)
700   Standard_Integer n1, n2;
701   Standard_Real U1, U2;
702   //
703   U1=aU1;
704   U2=aU2;
705   n1=knots->Lower();
706   n2=knots->Upper();
707   for (i=n1; i<=n2; ++i) {
708     U=knots->Value(i);
709     if (Abs(U-aU1)<=Eps) {
710       U1=U;
711     }
712     else if (Abs(U-aU2)<=Eps) {
713       U2=U;
714     }
715   }
716   // Henceforward we use U1, U2 as bounds of the segment
717   //t
718   // 
719   TColStd_Array1OfReal    Knots(1,2);
720   TColStd_Array1OfInteger Mults(1,2);
721   //
722   // define param ditance to keep (eap, Apr 18 2002, occ311)
723   if (periodic) {
724     Standard_Real Period = LastParameter() - FirstParameter();
725     DU = U2 - U1;
726     while (DU > Period) {
727       DU -= Period;
728     }
729     if (DU <= Epsilon(Period)) {
730       DU = Period;
731     }
732   }
733   //
734   index = 0;
735   BSplCLib::LocateParameter(deg,knots->Array1(),mults->Array1(),
736                             U1,periodic,knots->Lower(),knots->Upper(),
737                             index,NewU1);
738   index = 0;
739   BSplCLib::LocateParameter(deg,knots->Array1(),mults->Array1(),
740                             U2,periodic,knots->Lower(),knots->Upper(),
741                             index,NewU2);
742   Knots(1) = Min( NewU1, NewU2);
743   Knots(2) = Max( NewU1, NewU2);
744   Mults(1) = Mults( 2) = deg;
745   InsertKnots(Knots, Mults, Eps);
746   
747   if (periodic) { // set the origine at NewU1
748     index = 0;
749     BSplCLib::LocateParameter(deg,knots->Array1(),mults->Array1(),
750                               U1,periodic,knots->Lower(),knots->Upper(),
751                               index,U);
752     // Eps = Epsilon(knots->Value(index+1));
753     if ( Abs(knots->Value(index+1)-U) <= Eps) {
754       index++;
755     }
756     SetOrigin(index);
757     SetNotPeriodic();
758     NewU2 = NewU1 + DU;
759   }
760
761   // compute index1 and index2 to set the new knots and mults 
762   Standard_Integer index1 = 0, index2 = 0;
763   Standard_Integer FromU1 = knots->Lower();
764   Standard_Integer ToU2   = knots->Upper();
765   BSplCLib::LocateParameter(deg,knots->Array1(),mults->Array1(),
766                             NewU1,periodic,FromU1,ToU2,index1,U);
767   BSplCLib::LocateParameter(deg,knots->Array1(),mults->Array1(),
768                             NewU2,periodic,FromU1,ToU2,index2,U);
769   // Eps = Epsilon(knots->Value(index2+1));
770   if ( Abs(knots->Value(index2+1)-U) <= Eps){
771     index2++;
772   }
773   
774   Standard_Integer nbknots = index2 - index1 + 1;
775
776   Handle(TColStd_HArray1OfReal) 
777     nknots = new TColStd_HArray1OfReal(1,nbknots);
778   Handle(TColStd_HArray1OfInteger) 
779     nmults = new TColStd_HArray1OfInteger(1,nbknots);
780
781   // to restore changed U1
782   if (DU > 0) {// if was periodic
783     DU = NewU1 - U1;
784   }
785   //
786   k = 1;
787   //
788   for ( i = index1; i<= index2; i++) {
789     nknots->SetValue(k, knots->Value(i) - DU);
790     nmults->SetValue(k, mults->Value(i));
791     k++;
792   }
793   nmults->SetValue(      1, deg + 1);
794   nmults->SetValue(nbknots, deg + 1);
795
796
797   // compute index1 and index2 to set the new poles and weights
798   Standard_Integer pindex1 
799     = BSplCLib::PoleIndex(deg,index1,periodic,mults->Array1());
800   Standard_Integer pindex2 
801     = BSplCLib::PoleIndex(deg,index2,periodic,mults->Array1());
802
803   pindex1++;
804   pindex2 = Min( pindex2+1, poles->Length());
805
806   Standard_Integer nbpoles  = pindex2 - pindex1 + 1;
807
808   Handle(TColStd_HArray1OfReal) 
809     nweights = new TColStd_HArray1OfReal(1,nbpoles);
810   Handle(TColgp_HArray1OfPnt2d)
811     npoles = new TColgp_HArray1OfPnt2d(1,nbpoles);
812
813   k = 1;
814   if ( rational) {
815     nweights = new TColStd_HArray1OfReal( 1, nbpoles);
816     for ( i = pindex1; i <= pindex2; i++) {
817       npoles->SetValue(k, poles->Value(i));
818       nweights->SetValue(k, weights->Value(i));
819       k++;
820     }
821   }
822   else {
823     for ( i = pindex1; i <= pindex2; i++) {
824       npoles->SetValue(k, poles->Value(i));
825       k++;
826     }
827   }
828
829   knots = nknots;
830   mults = nmults;
831   poles = npoles;
832   if (rational){ 
833     weights = nweights;
834   }
835   UpdateKnots();
836 }
837
838 //=======================================================================
839 //function : SetKnot
840 //purpose  : 
841 //=======================================================================
842
843 void Geom2d_BSplineCurve::SetKnot
844 (const Standard_Integer Index,
845  const Standard_Real K)
846 {
847   if (Index < 1 || Index > knots->Length())     Standard_OutOfRange::Raise("BSpline curve : SetKnot:  Index and #pole mismatch");
848   Standard_Real DK = Abs(Epsilon (K));
849   if (Index == 1) { 
850     if (K >= knots->Value(2) - DK) Standard_ConstructionError::Raise("BSpline curve :SetKnot :K out of range");
851   }
852   else if (Index == knots->Length()) {
853     if (K <= knots->Value (knots->Length()-1) + DK)  {
854       Standard_ConstructionError::Raise("BSpline curve : SetKnot : K out of range");
855     }
856   }
857   else {
858     if (K <= knots->Value(Index-1) + DK ||
859         K >= knots->Value(Index+1) - DK ) {
860       Standard_ConstructionError::Raise("BSpline curve : SetKnot: K out of range");
861     }
862   }
863   if (K != knots->Value (Index)) {
864     knots->SetValue (Index, K);
865     maxderivinvok = 0;
866     UpdateKnots();
867   }
868 }
869
870 //=======================================================================
871 //function : SetKnots
872 //purpose  : 
873 //=======================================================================
874
875 void Geom2d_BSplineCurve::SetKnots
876 (const TColStd_Array1OfReal& K)
877 {
878   CheckCurveData(poles->Array1(),K,mults->Array1(),deg,periodic);
879   knots->ChangeArray1() = K;
880   maxderivinvok = 0;
881   UpdateKnots();
882 }
883
884 //=======================================================================
885 //function : SetKnot
886 //purpose  : 
887 //=======================================================================
888
889 void Geom2d_BSplineCurve::SetKnot
890 (const Standard_Integer Index,
891  const Standard_Real K,
892  const Standard_Integer M)
893 {
894   IncreaseMultiplicity (Index, M);
895   SetKnot (Index, K);
896 }
897
898 //=======================================================================
899 //function : SetPeriodic
900 //purpose  : 
901 //=======================================================================
902
903 void Geom2d_BSplineCurve::SetPeriodic ()
904 {
905   Standard_Integer first = FirstUKnotIndex();
906   Standard_Integer last  = LastUKnotIndex();
907
908   Handle(TColStd_HArray1OfReal) tk = knots;
909   TColStd_Array1OfReal    cknots((knots->Array1())(first),first,last);
910   knots = new TColStd_HArray1OfReal(1,cknots.Length());
911   knots->ChangeArray1() = cknots;
912
913   Handle(TColStd_HArray1OfInteger) tm = mults;
914   TColStd_Array1OfInteger cmults((mults->Array1())(first),first,last);
915   cmults(first) = cmults(last) = Min(deg, Max( cmults(first), cmults(last)));
916   mults = new TColStd_HArray1OfInteger(1,cmults.Length());
917   mults->ChangeArray1() = cmults;
918
919   // compute new number of poles;
920   Standard_Integer nbp = BSplCLib::NbPoles(deg,Standard_True,cmults);
921   
922   Handle(TColgp_HArray1OfPnt2d) tp = poles;
923   TColgp_Array1OfPnt2d cpoles((poles->Array1())(1),1,nbp);
924   poles = new TColgp_HArray1OfPnt2d(1,nbp);
925   poles->ChangeArray1() = cpoles;
926   
927   if (rational) {
928     Handle(TColStd_HArray1OfReal) tw = weights;
929     TColStd_Array1OfReal cweights((weights->Array1())(1),1,nbp);
930     weights = new TColStd_HArray1OfReal(1,nbp);
931     weights->ChangeArray1() = cweights;
932   }
933
934   periodic = Standard_True;
935   
936   maxderivinvok = 0;
937   UpdateKnots();
938 }
939
940 //=======================================================================
941 //function : SetOrigin
942 //purpose  : 
943 //=======================================================================
944
945 void Geom2d_BSplineCurve::SetOrigin(const Standard_Integer Index)
946 {
947   Standard_NoSuchObject_Raise_if( !periodic,
948                                  "Geom2d_BSplineCurve::SetOrigin");
949   Standard_Integer i,k;
950   Standard_Integer first = FirstUKnotIndex();
951   Standard_Integer last  = LastUKnotIndex();
952
953   Standard_DomainError_Raise_if( (Index < first) || (Index > last),
954                                 "Geom2d_BSplineCurve::SetOrigine");
955
956   Standard_Integer nbknots = knots->Length();
957   Standard_Integer nbpoles = poles->Length();
958
959   Handle(TColStd_HArray1OfReal) nknots = 
960     new TColStd_HArray1OfReal(1,nbknots);
961   TColStd_Array1OfReal& newknots = nknots->ChangeArray1();
962
963   Handle(TColStd_HArray1OfInteger) nmults =
964     new TColStd_HArray1OfInteger(1,nbknots);
965   TColStd_Array1OfInteger& newmults = nmults->ChangeArray1();
966
967   // set the knots and mults
968   Standard_Real period = knots->Value(last) - knots->Value(first);
969   k = 1;
970   for ( i = Index; i <= last ; i++) {
971     newknots(k) = knots->Value(i);
972     newmults(k) = mults->Value(i);
973     k++;
974   }
975   for ( i = first+1; i <= Index; i++) {
976     newknots(k) = knots->Value(i) + period;
977     newmults(k) = mults->Value(i);
978     k++;
979   }
980
981   Standard_Integer index = 1;
982   for (i = first+1; i <= Index; i++) 
983     index += mults->Value(i);
984
985   // set the poles and weights
986   Handle(TColgp_HArray1OfPnt2d) npoles =
987     new TColgp_HArray1OfPnt2d(1,nbpoles);
988   Handle(TColStd_HArray1OfReal) nweights =
989     new TColStd_HArray1OfReal(1,nbpoles);
990   TColgp_Array1OfPnt2d & newpoles   = npoles->ChangeArray1();
991   TColStd_Array1OfReal & newweights = nweights->ChangeArray1();
992   first = poles->Lower();
993   last  = poles->Upper();
994   if ( rational) {
995     k = 1;
996     for ( i = index; i <= last; i++) {
997       newpoles(k)   = poles->Value(i);
998       newweights(k) = weights->Value(i);
999       k++;
1000     }
1001     for ( i = first; i < index; i++) {
1002       newpoles(k)   = poles->Value(i);
1003       newweights(k) = weights->Value(i);
1004       k++;
1005     }
1006   }
1007   else {
1008     k = 1;
1009     for ( i = index; i <= last; i++) {
1010       newpoles(k) = poles->Value(i);
1011       k++;
1012     }
1013     for ( i = first; i < index; i++) {
1014       newpoles(k) = poles->Value(i);
1015       k++;
1016     }
1017   }
1018
1019   poles = npoles;
1020   knots = nknots;
1021   mults = nmults;
1022   if (rational) 
1023     weights = nweights;
1024   maxderivinvok = 0;
1025   UpdateKnots();
1026 }
1027
1028 //=======================================================================
1029 //function : SetNotPeriodic
1030 //purpose  : 
1031 //=======================================================================
1032
1033 void Geom2d_BSplineCurve::SetNotPeriodic () 
1034
1035   if (periodic) {
1036     Standard_Integer NbKnots, NbPoles;
1037     BSplCLib::PrepareUnperiodize( deg, mults->Array1(),NbKnots,NbPoles);
1038     
1039     Handle(TColgp_HArray1OfPnt2d) npoles 
1040       = new TColgp_HArray1OfPnt2d(1,NbPoles);
1041     
1042     Handle(TColStd_HArray1OfReal) nknots 
1043       = new TColStd_HArray1OfReal(1,NbKnots);
1044     
1045     Handle(TColStd_HArray1OfInteger) nmults
1046       = new TColStd_HArray1OfInteger(1,NbKnots);
1047     
1048     Handle(TColStd_HArray1OfReal) nweights;
1049     
1050     if (IsRational()) {
1051       
1052       nweights = new TColStd_HArray1OfReal(1,NbPoles);
1053       
1054       BSplCLib::Unperiodize
1055         (deg,mults->Array1(),knots->Array1(),poles->Array1(),
1056          weights->Array1(),nmults->ChangeArray1(),
1057          nknots->ChangeArray1(),npoles->ChangeArray1(),
1058          nweights->ChangeArray1());
1059       
1060     }
1061     else {
1062       
1063       BSplCLib::Unperiodize
1064         (deg,mults->Array1(),knots->Array1(),poles->Array1(),
1065          *((TColStd_Array1OfReal*) NULL),nmults->ChangeArray1(),
1066          nknots->ChangeArray1(),npoles->ChangeArray1(),
1067          *((TColStd_Array1OfReal*) NULL));
1068       
1069     }
1070     poles   = npoles;
1071     weights = nweights;
1072     mults   = nmults;
1073     knots   = nknots;
1074     periodic = Standard_False;
1075     maxderivinvok = 0;
1076     UpdateKnots();
1077   }
1078 }
1079
1080 //=======================================================================
1081 //function : SetPole
1082 //purpose  : 
1083 //=======================================================================
1084
1085 void Geom2d_BSplineCurve::SetPole
1086 (const Standard_Integer Index,
1087  const gp_Pnt2d& P)
1088 {
1089   if (Index < 1 || Index > poles->Length()) Standard_OutOfRange::Raise("BSpline curve : SetPole : index and #pole mismatch");
1090   poles->SetValue (Index, P);
1091   maxderivinvok = 0;
1092   InvalidateCache();
1093 }
1094
1095 //=======================================================================
1096 //function : SetPole
1097 //purpose  : 
1098 //=======================================================================
1099
1100 void Geom2d_BSplineCurve::SetPole
1101 (const Standard_Integer Index,
1102  const gp_Pnt2d& P,
1103  const Standard_Real W)
1104 {
1105   SetPole(Index,P);
1106   SetWeight(Index,W);
1107 }
1108
1109 //=======================================================================
1110 //function : SetWeight
1111 //purpose  : 
1112 //=======================================================================
1113
1114 void Geom2d_BSplineCurve::SetWeight
1115 (const Standard_Integer Index,
1116  const Standard_Real W)
1117 {
1118   if (Index < 1 || Index > poles->Length())   Standard_OutOfRange::Raise("BSpline curve : SetWeight: Index and #pole mismatch");
1119
1120   if (W <= gp::Resolution ())     Standard_ConstructionError::Raise("BSpline curve : SetWeight: Weight too small");
1121
1122
1123   Standard_Boolean rat = IsRational() || (Abs(W - 1.) > gp::Resolution());
1124
1125   if ( rat) { 
1126     if (rat && !IsRational()) {
1127       weights = new TColStd_HArray1OfReal(1,poles->Length());
1128       weights->Init(1.);
1129     }
1130     
1131     weights->SetValue (Index, W);
1132     
1133     if (IsRational()) {
1134       rat = Rational(weights->Array1());
1135       if (!rat) weights.Nullify();
1136     }
1137     
1138     rational = !weights.IsNull();
1139   }
1140   
1141   maxderivinvok = 0;
1142   InvalidateCache() ;
1143 }
1144
1145 //=======================================================================
1146 //function : MovePoint
1147 //purpose  : 
1148 //=======================================================================
1149
1150 void Geom2d_BSplineCurve::MovePoint(const Standard_Real U,
1151                                     const gp_Pnt2d& P,
1152                                     const Standard_Integer Index1,
1153                                     const Standard_Integer Index2,
1154                                     Standard_Integer& FirstModifiedPole,
1155                                     Standard_Integer& LastmodifiedPole)
1156 {
1157   if (Index1 < 1 || Index1 > poles->Length() || 
1158       Index2 < 1 || Index2 > poles->Length() || Index1 > Index2) {
1159     Standard_OutOfRange::Raise("BSpline curve :  MovePoint: Index and #pole mismatch");
1160   }
1161   TColgp_Array1OfPnt2d npoles(1, poles->Length());
1162   gp_Pnt2d P0;
1163   D0(U, P0);
1164   gp_Vec2d Displ(P0, P);
1165   BSplCLib::MovePoint(U, Displ, Index1, Index2, deg, rational, poles->Array1(), 
1166                       weights->Array1(), flatknots->Array1(), 
1167                       FirstModifiedPole, LastmodifiedPole, npoles);
1168   if (FirstModifiedPole) {
1169     poles->ChangeArray1() = npoles;
1170     maxderivinvok = 0;
1171     InvalidateCache() ;
1172   }
1173 }
1174
1175 //=======================================================================
1176 //function : MovePointAndTangent
1177 //purpose  : 
1178 //=======================================================================
1179
1180 void Geom2d_BSplineCurve::
1181 MovePointAndTangent(const Standard_Real    U,
1182                     const gp_Pnt2d&        P,
1183                     const gp_Vec2d&        Tangent,
1184                     const Standard_Real    Tolerance,
1185                     const Standard_Integer StartingCondition,
1186                     const Standard_Integer EndingCondition,
1187                     Standard_Integer&      ErrorStatus) 
1188 {
1189   Standard_Integer ii ;
1190   if (IsPeriodic()) {
1191     //
1192     // for the time being do not deal with periodic curves
1193     //
1194     SetNotPeriodic() ;
1195   }
1196   TColgp_Array1OfPnt2d new_poles(1, poles->Length());
1197   gp_Pnt2d P0;
1198   
1199
1200   gp_Vec2d delta_derivative;
1201   D1(U, P0,
1202      delta_derivative) ;
1203   gp_Vec2d delta(P0, P);
1204   for (ii = 1 ; ii <= 2 ; ii++) {
1205     delta_derivative.SetCoord(ii, 
1206                               Tangent.Coord(ii)- delta_derivative.Coord(ii)) ;
1207   }
1208   BSplCLib::MovePointAndTangent(U,
1209                                 delta,
1210                                 delta_derivative,
1211                                 Tolerance,
1212                                 deg,
1213                                 rational,
1214                                 StartingCondition,
1215                                 EndingCondition,
1216                                 poles->Array1(), 
1217                                 weights->Array1(), 
1218                                 flatknots->Array1(), 
1219                                 new_poles,
1220                                 ErrorStatus) ;
1221   if (!ErrorStatus) {
1222     poles->ChangeArray1() = new_poles;
1223     maxderivinvok = 0;
1224     InvalidateCache() ;
1225   }
1226 }
1227
1228 //=======================================================================
1229 //function : UpdateKnots
1230 //purpose  : 
1231 //=======================================================================
1232
1233 void Geom2d_BSplineCurve::UpdateKnots()
1234 {
1235
1236   rational = !weights.IsNull();
1237
1238   Standard_Integer MaxKnotMult = 0;
1239   BSplCLib::KnotAnalysis (deg,
1240                 periodic,
1241                 knots->Array1(), 
1242                 mults->Array1(), 
1243                 knotSet, MaxKnotMult);
1244   
1245   if (knotSet == GeomAbs_Uniform && !periodic)  {
1246     flatknots = knots;
1247   }
1248   else {
1249     flatknots = new TColStd_HArray1OfReal 
1250       (1, BSplCLib::KnotSequenceLength(mults->Array1(),deg,periodic));
1251
1252     BSplCLib::KnotSequence (knots->Array1(), 
1253                             mults->Array1(),
1254                             deg,periodic,
1255                             flatknots->ChangeArray1());
1256   }
1257   
1258   if (MaxKnotMult == 0)  smooth = GeomAbs_CN;
1259   else {
1260     switch (deg - MaxKnotMult) {
1261     case 0 :   smooth = GeomAbs_C0;   break;
1262     case 1 :   smooth = GeomAbs_C1;   break;
1263     case 2 :   smooth = GeomAbs_C2;   break;
1264     case 3 :   smooth = GeomAbs_C3;   break;
1265       default :  smooth = GeomAbs_C3;   break;
1266     }
1267   }
1268   InvalidateCache() ;
1269 }
1270
1271 //=======================================================================
1272 //function : Invalidate the Cache
1273 //purpose  : as the name says
1274 //=======================================================================
1275
1276 void Geom2d_BSplineCurve::InvalidateCache() 
1277 {
1278   validcache = 0 ;
1279 }
1280
1281 //=======================================================================
1282 //function : check if the Cache is valid
1283 //purpose  : as the name says
1284 //=======================================================================
1285
1286 Standard_Boolean Geom2d_BSplineCurve::IsCacheValid
1287 (const Standard_Real  U)  const 
1288 {
1289   //Roman Lygin 26.12.08, see comments in Geom_BSplineCurve::IsCacheValid()
1290   Standard_Real aDelta = U - parametercache;
1291
1292   return ( validcache &&
1293       (aDelta >= 0.0e0) &&
1294       ((aDelta < spanlenghtcache) || (spanindexcache == flatknots->Upper() - deg)) );
1295 }
1296
1297 //=======================================================================
1298 //function : Normalizes the parameters if the curve is periodic
1299 //purpose  : that is compute the cache so that it is valid
1300 //=======================================================================
1301
1302 void Geom2d_BSplineCurve::PeriodicNormalization(Standard_Real&  Parameter) const 
1303 {
1304   Standard_Real Period ;
1305
1306   if (periodic) {
1307     Period = flatknots->Value(flatknots->Upper() - deg) - flatknots->Value (deg + 1) ;
1308     while (Parameter > flatknots->Value(flatknots->Upper()-deg)) {
1309       Parameter -= Period ;
1310     }
1311     while (Parameter < flatknots->Value((deg + 1))) {
1312       Parameter +=  Period ;
1313     }
1314   }
1315 }
1316
1317 //=======================================================================
1318 //function : Validate the Cache
1319 //purpose  : that is compute the cache so that it is valid
1320 //=======================================================================
1321
1322 void Geom2d_BSplineCurve::ValidateCache(const Standard_Real  Parameter) 
1323 {
1324   Standard_Real NewParameter ;
1325   Standard_Integer LocalIndex = 0 ;
1326   //
1327   // check if the degree did not change
1328   //
1329   if (cachepoles->Upper() < deg + 1) {
1330     cachepoles = new TColgp_HArray1OfPnt2d(1,deg + 1);
1331     if (rational) {
1332       cacheweights  = new TColStd_HArray1OfReal(1,deg + 1);
1333     }
1334   }
1335
1336   BSplCLib::LocateParameter(deg,
1337                             (flatknots->Array1()),
1338                             (BSplCLib::NoMults()),
1339                             Parameter,
1340                             periodic,
1341                             LocalIndex,
1342                             NewParameter);
1343   spanindexcache = LocalIndex ;
1344   if (Parameter == flatknots->Value(LocalIndex + 1)) {
1345     
1346     LocalIndex += 1 ;
1347     parametercache = flatknots->Value(LocalIndex) ;
1348     if (LocalIndex == flatknots->Upper() - deg) {
1349       //
1350       // for the last span if the parameter is outside of 
1351       // the domain of the curve than use the last knot
1352       // and normalize with the last span Still set the
1353       // spanindexcache to flatknots->Upper() - deg so that
1354       // the IsCacheValid will know for sure we are extending
1355       // the Bspline 
1356       //
1357       
1358       spanlenghtcache = flatknots->Value(LocalIndex - 1) - parametercache ;
1359     }
1360     else {
1361       spanlenghtcache = flatknots->Value(LocalIndex + 1) - parametercache ;
1362     }
1363   }
1364   else {
1365     parametercache = flatknots->Value(LocalIndex) ;
1366     spanlenghtcache = flatknots->Value(LocalIndex + 1) - parametercache ;
1367   }
1368   
1369   if  (rational) {
1370     BSplCLib::BuildCache(parametercache,
1371                          spanlenghtcache,
1372                          periodic,
1373                          deg,
1374                          (flatknots->Array1()),
1375                          poles->Array1(),
1376                          weights->Array1(),
1377                          cachepoles->ChangeArray1(),
1378                          cacheweights->ChangeArray1()) ;
1379   }
1380   else {
1381     BSplCLib::BuildCache(parametercache,
1382                          spanlenghtcache,
1383                          periodic,
1384                          deg,
1385                          (flatknots->Array1()),
1386                          poles->Array1(),
1387                          *((TColStd_Array1OfReal*) NULL),
1388                          cachepoles->ChangeArray1(),
1389                          *((TColStd_Array1OfReal*) NULL)) ;
1390   }
1391   validcache = 1 ;
1392 }
1393