0025124: [Feature request] Removal of continuity checks for offset geometries
[occt.git] / src / Geom2d / Geom2d_BSplineCurve_1.cxx
1 // Created on: 1991-07-05
2 // Created by: JCV
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // 03-02-97 : pmn ->LocateU sur Periodic (PRO6963), 
18 //            bon appel a LocateParameter (PRO6973) et mise en conformite avec
19 //            le cdl de LocateU, lorsque U est un noeud (PRO6988)
20
21 #define No_Standard_OutOfRange
22 #define No_Standard_DimensionError
23
24 #include <Geom2d_BSplineCurve.jxx>
25 #include <BSplCLib.hxx>
26 #include <gp.hxx>
27
28 #include <Geom2d_UndefinedDerivative.hxx>
29 #include <Standard_DimensionError.hxx>
30 #include <Standard_OutOfRange.hxx>
31 #include <Standard_DomainError.hxx>
32 #include <Standard_RangeError.hxx>
33 #include <Standard_Mutex.hxx>
34
35 #define  POLES    (poles->Array1())
36 #define  KNOTS    (knots->Array1())
37 #define  FKNOTS   (flatknots->Array1())
38 #define  FMULTS   (BSplCLib::NoMults())
39
40 //=======================================================================
41 //function : IsCN
42 //purpose  : 
43 //=======================================================================
44
45 Standard_Boolean Geom2d_BSplineCurve::IsCN ( const Standard_Integer N) const
46 {
47   Standard_RangeError_Raise_if
48     (N < 0, "Geom2d_BSplineCurve::IsCN");
49
50   switch (smooth) {
51   case GeomAbs_CN : return Standard_True;
52   case GeomAbs_C0 : return N <= 0;
53   case GeomAbs_G1 : return N <= 0;
54   case GeomAbs_C1 : return N <= 1;
55   case GeomAbs_G2 : return N <= 1;
56   case GeomAbs_C2 : return N <= 2;
57   case GeomAbs_C3 : 
58     return N <= 3 ? Standard_True :
59            N <= deg - BSplCLib::MaxKnotMult (mults->Array1(), mults->Lower() + 1, mults->Upper() - 1);
60   default:
61     return Standard_False;
62   }
63 }
64 //=======================================================================
65 //function : IsG1
66 //purpose  : 
67 //=======================================================================
68
69 Standard_Boolean Geom2d_BSplineCurve::IsG1 ( const Standard_Real theTf,
70                                            const Standard_Real theTl,
71                                            const Standard_Real theAngTol) const
72 {
73
74   if(IsCN(1))
75   {
76     return Standard_True;
77   }
78
79   Standard_Integer  start = FirstUKnotIndex()+1,
80                     finish = LastUKnotIndex()-1;
81   Standard_Integer aDeg = Degree();
82   for(Standard_Integer aNKnot = start; aNKnot <= finish; aNKnot++)
83   {
84     const Standard_Real aTpar = Knot(aNKnot);
85
86     if(aTpar < theTf)
87       continue;
88     if(aTpar > theTl)
89       break;
90
91     Standard_Integer mult = Multiplicity(aNKnot);
92     if (mult < aDeg)
93       continue;
94
95     gp_Pnt2d aP1, aP2;
96     gp_Vec2d aV1, aV2;
97     LocalD1(aTpar, aNKnot-1, aNKnot, aP1, aV1);
98     LocalD1(aTpar, aNKnot, aNKnot+1, aP2, aV2);
99
100     if((aV1.SquareMagnitude() <= gp::Resolution()) ||
101         aV2.SquareMagnitude() <= gp::Resolution())
102     {
103       return Standard_False;
104     }
105
106     if(Abs(aV1.Angle(aV2)) > theAngTol)
107       return Standard_False;
108   }
109
110   if(!IsPeriodic())
111     return Standard_True;
112
113   const Standard_Real aFirstParam = FirstParameter(),
114                       aLastParam = LastParameter();
115
116   if( ((aFirstParam - theTf)*(theTl - aFirstParam) < 0.0) &&
117       ((aLastParam - theTf)*(theTl - aLastParam) < 0.0))
118   {
119     //Range [theTf, theTl] does not intersect curve bounadries
120     return Standard_True;
121   }
122
123   //Curve is closed or periodic and range [theTf, theTl]
124   //intersect curve boundary. Therefore, it is necessary to 
125   //check if curve is smooth in its first and last point.
126
127   gp_Pnt2d aP;
128   gp_Vec2d aV1, aV2;
129   D1(Knot(FirstUKnotIndex()), aP, aV1);
130   D1(Knot(LastUKnotIndex()), aP, aV2);
131
132   if((aV1.SquareMagnitude() <= gp::Resolution()) ||
133       aV2.SquareMagnitude() <= gp::Resolution())
134   {
135     return Standard_False;
136   }
137
138   if(Abs(aV1.Angle(aV2)) > theAngTol)
139     return Standard_False;
140
141
142   return Standard_True;
143
144 }
145
146 //=======================================================================
147 //function : IsClosed
148 //purpose  : 
149 //=======================================================================
150
151 Standard_Boolean Geom2d_BSplineCurve::IsClosed () const
152 { return (StartPoint().Distance (EndPoint())) <= gp::Resolution (); }
153
154
155
156 //=======================================================================
157 //function : IsPeriodic
158 //purpose  : 
159 //=======================================================================
160
161 Standard_Boolean Geom2d_BSplineCurve::IsPeriodic () const
162 { return periodic; }
163
164 //=======================================================================
165 //function : Continuity
166 //purpose  : 
167 //=======================================================================
168
169 GeomAbs_Shape Geom2d_BSplineCurve::Continuity () const
170 { return smooth; }
171
172 //=======================================================================
173 //function : Degree
174 //purpose  : 
175 //=======================================================================
176
177 Standard_Integer Geom2d_BSplineCurve::Degree () const
178 { return deg; }
179
180
181 //=======================================================================
182 //function : D0
183 //purpose  : 
184 //=======================================================================
185
186 void Geom2d_BSplineCurve::D0 ( const Standard_Real U, 
187                               gp_Pnt2d& P) const
188 {
189   Standard_Real NewU(U);
190   PeriodicNormalization(NewU);
191
192   Geom2d_BSplineCurve* MyCurve = (Geom2d_BSplineCurve *) this;
193   Standard_Mutex::Sentry aSentry(MyCurve->myMutex);
194
195   if (!IsCacheValid(NewU))
196     MyCurve->ValidateCache(NewU);
197   
198   if(rational)
199   {
200     BSplCLib::CacheD0(NewU,
201                       deg,
202                       parametercache,
203                       spanlenghtcache,
204                       (cachepoles->Array1()),
205                       cacheweights->Array1(),
206                       P) ;
207   }
208   else {
209     BSplCLib::CacheD0(NewU,
210                       deg,
211                       parametercache,
212                       spanlenghtcache,
213                       (cachepoles->Array1()),
214                       BSplCLib::NoWeights(),
215                       P) ;
216   }
217 }
218
219
220 //=======================================================================
221 //function : D1
222 //purpose  : 
223 //=======================================================================
224
225 void Geom2d_BSplineCurve::D1 (const Standard_Real U,
226                               gp_Pnt2d& P,
227                               gp_Vec2d& V1) const
228 {
229   Standard_Real NewU(U);
230   PeriodicNormalization(NewU);
231
232   Geom2d_BSplineCurve* MyCurve = (Geom2d_BSplineCurve *) this;
233   Standard_Mutex::Sentry aSentry(MyCurve->myMutex);
234
235   if (!IsCacheValid(NewU))
236     MyCurve->ValidateCache(NewU);
237   
238   if(rational)
239   {
240     BSplCLib::CacheD1(NewU,
241                       deg,
242                       parametercache,
243                       spanlenghtcache,
244                       (cachepoles->Array1()),
245                       cacheweights->Array1(),
246                       P,
247                       V1) ;
248   }
249   else {
250     BSplCLib::CacheD1(NewU,
251                       deg,
252                       parametercache,
253                       spanlenghtcache,
254                       (cachepoles->Array1()),
255                       BSplCLib::NoWeights(),
256                       P,
257                       V1) ;
258   }
259 }
260
261 //=======================================================================
262 //function : D2
263 //purpose  : 
264 //=======================================================================
265
266 void Geom2d_BSplineCurve::D2 (const Standard_Real U ,
267                               gp_Pnt2d& P ,
268                               gp_Vec2d& V1,
269                               gp_Vec2d& V2 ) const
270 {
271   Standard_Real NewU(U);
272   PeriodicNormalization(NewU);
273
274   Geom2d_BSplineCurve* MyCurve = (Geom2d_BSplineCurve *) this;
275   Standard_Mutex::Sentry aSentry(MyCurve->myMutex);
276
277   if (!IsCacheValid(NewU))
278     MyCurve->ValidateCache(NewU);
279   
280   if(rational)
281   {
282     BSplCLib::CacheD2(NewU,
283                       deg,
284                       parametercache,
285                       spanlenghtcache,
286                       (cachepoles->Array1()),
287                       cacheweights->Array1(),
288                       P,
289                       V1,
290                       V2) ;
291   }
292   else {
293     BSplCLib::CacheD2(NewU,
294                       deg,
295                       parametercache,
296                       spanlenghtcache,
297                       (cachepoles->Array1()),
298                       BSplCLib::NoWeights(),
299                       P,
300                       V1,
301                       V2) ;
302   }
303 }
304
305 //=======================================================================
306 //function : D3
307 //purpose  : 
308 //=======================================================================
309
310 void Geom2d_BSplineCurve::D3  (const Standard_Real U ,
311                                gp_Pnt2d& P ,
312                                gp_Vec2d& V1,
313                                gp_Vec2d& V2,
314                                gp_Vec2d& V3 ) const
315 {
316   Standard_Real NewU(U);
317   PeriodicNormalization(NewU);
318
319   Geom2d_BSplineCurve* MyCurve = (Geom2d_BSplineCurve *) this;
320   Standard_Mutex::Sentry aSentry(MyCurve->myMutex);
321
322   if (!IsCacheValid(NewU))
323     MyCurve->ValidateCache(NewU);
324   
325   if(rational)
326   {
327     BSplCLib::CacheD3(NewU,
328                       deg,
329                       parametercache,
330                       spanlenghtcache,
331                       (cachepoles->Array1()),
332                       cacheweights->Array1(),
333                       P,
334                       V1,
335                       V2,
336                       V3) ;
337   }
338   else {
339     BSplCLib::CacheD3(NewU,
340                       deg,
341                       parametercache,
342                       spanlenghtcache,
343                       (cachepoles->Array1()),
344                       BSplCLib::NoWeights(),
345                       P,
346                       V1,
347                       V2,
348                       V3) ;
349   }
350 }
351
352 //=======================================================================
353 //function : DN
354 //purpose  : 
355 //=======================================================================
356
357 gp_Vec2d Geom2d_BSplineCurve::DN  (const Standard_Real    U,
358                                    const Standard_Integer N ) const
359 {
360   gp_Vec2d V;
361
362   if ( rational ) {
363     BSplCLib::DN(U,N,0,deg,periodic,POLES,
364                  weights->Array1(),
365                  FKNOTS,FMULTS,V);
366   }
367   else {  
368     BSplCLib::DN(U,N,0,deg,periodic,POLES,
369                  *((TColStd_Array1OfReal*) NULL),
370                  FKNOTS,FMULTS,V);
371   }
372   return V;
373 }
374
375 //=======================================================================
376 //function : EndPoint
377 //purpose  : 
378 //=======================================================================
379
380 gp_Pnt2d Geom2d_BSplineCurve::EndPoint () const
381
382   if (mults->Value (knots->Upper ()) == deg + 1) 
383     return poles->Value (poles->Upper());
384   else
385     return Value(LastParameter());
386 }
387
388 //=======================================================================
389 //function : FirstUKnotIndex
390 //purpose  : 
391 //=======================================================================
392
393 Standard_Integer Geom2d_BSplineCurve::FirstUKnotIndex () const
394
395   if (periodic) return 1;
396   else return BSplCLib::FirstUKnotIndex (deg, mults->Array1()); 
397 }
398
399 //=======================================================================
400 //function : FirstParameter
401 //purpose  : 
402 //=======================================================================
403
404 Standard_Real Geom2d_BSplineCurve::FirstParameter () const
405 {
406   return flatknots->Value (deg+1); 
407 }
408
409 //=======================================================================
410 //function : Knot
411 //purpose  : 
412 //=======================================================================
413
414 Standard_Real Geom2d_BSplineCurve::Knot (const Standard_Integer Index) const
415 {
416   Standard_OutOfRange_Raise_if
417     (Index < 1 || Index > knots->Length(), "Geom2d_BSplineCurve::Knot");
418   return knots->Value (Index);
419 }
420
421 //=======================================================================
422 //function : KnotDistribution
423 //purpose  : 
424 //=======================================================================
425
426 GeomAbs_BSplKnotDistribution Geom2d_BSplineCurve::KnotDistribution () const
427
428   return knotSet; 
429 }
430
431 //=======================================================================
432 //function : Knots
433 //purpose  : 
434 //=======================================================================
435
436 void Geom2d_BSplineCurve::Knots (TColStd_Array1OfReal& K) const
437 {
438   Standard_DimensionError_Raise_if
439     (K.Length() != knots->Length(), "Geom2d_BSplineCurve::Knots");
440   K = knots->Array1();
441 }
442
443 //=======================================================================
444 //function : KnotSequence
445 //purpose  : 
446 //=======================================================================
447
448 void Geom2d_BSplineCurve::KnotSequence (TColStd_Array1OfReal& K) const
449 {
450   Standard_DimensionError_Raise_if
451     (K.Length() != flatknots->Length(), "Geom2d_BSplineCurve::KnotSequence");
452   K = flatknots->Array1();
453 }
454
455 //=======================================================================
456 //function : LastUKnotIndex
457 //purpose  : 
458 //=======================================================================
459
460 Standard_Integer Geom2d_BSplineCurve::LastUKnotIndex() const
461 {
462   if (periodic) return knots->Length();
463   else return BSplCLib::LastUKnotIndex (deg, mults->Array1()); 
464 }
465
466 //=======================================================================
467 //function : LastParameter
468 //purpose  : 
469 //=======================================================================
470
471 Standard_Real Geom2d_BSplineCurve::LastParameter () const
472 {
473   return flatknots->Value (flatknots->Upper()-deg); 
474 }
475
476 //=======================================================================
477 //function : LocalValue
478 //purpose  : 
479 //=======================================================================
480
481 gp_Pnt2d Geom2d_BSplineCurve::LocalValue
482 (const Standard_Real    U,
483  const Standard_Integer FromK1,
484  const Standard_Integer ToK2)   const
485 {
486   gp_Pnt2d P;
487   LocalD0(U,FromK1,ToK2,P);
488   return P;
489 }
490
491 //=======================================================================
492 //function : LocalD0
493 //purpose  : 
494 //=======================================================================
495
496 void  Geom2d_BSplineCurve::LocalD0
497 (const Standard_Real    U,
498  const Standard_Integer FromK1,
499  const Standard_Integer ToK2,
500  gp_Pnt2d& P)   const
501 {
502   Standard_DomainError_Raise_if (FromK1 == ToK2,
503                                  "Geom2d_BSplineCurve::LocalValue");
504
505   Standard_Real u = U;
506   Standard_Integer index = 0;
507   BSplCLib::LocateParameter(deg, FKNOTS, U, periodic,FromK1,ToK2, index,u);
508   index = BSplCLib::FlatIndex(deg,index,mults->Array1(),periodic);
509
510   if ( rational ) {
511     BSplCLib::D0(u,index,deg,periodic,POLES,
512                  weights->Array1(),
513                  FKNOTS,FMULTS,P);
514   }
515   else {
516     BSplCLib::D0(u,index,deg,periodic,POLES,
517                  *((TColStd_Array1OfReal*) NULL),
518                  FKNOTS,FMULTS,P);
519   }
520 }
521
522 //=======================================================================
523 //function : LocalD1
524 //purpose  : 
525 //=======================================================================
526
527 void Geom2d_BSplineCurve::LocalD1 (const Standard_Real    U,
528                                    const Standard_Integer FromK1,
529                                    const Standard_Integer ToK2,
530                                    gp_Pnt2d&    P, 
531                                    gp_Vec2d&    V1)    const
532 {
533   Standard_DomainError_Raise_if (FromK1 == ToK2,
534                                  "Geom2d_BSplineCurve::LocalD1");
535   
536   Standard_Real u = U;
537   Standard_Integer index = 0;
538   BSplCLib::LocateParameter(deg, FKNOTS, U, periodic, FromK1,ToK2, index, u);
539   index = BSplCLib::FlatIndex(deg,index,mults->Array1(),periodic);
540   
541   if (rational) {
542     BSplCLib::D1(u,index,deg,periodic,POLES,
543                  weights->Array1(),
544                  FKNOTS,FMULTS,P,V1);
545   }
546   else {
547     BSplCLib::D1(u,index,deg,periodic,POLES,
548                  *((TColStd_Array1OfReal*) NULL),
549                  FKNOTS,FMULTS,P,V1);
550   }
551 }
552
553 //=======================================================================
554 //function : LocalD2
555 //purpose  : 
556 //=======================================================================
557
558 void Geom2d_BSplineCurve::LocalD2
559 (const Standard_Real    U,
560  const Standard_Integer FromK1,
561  const Standard_Integer ToK2, 
562  gp_Pnt2d&    P,
563  gp_Vec2d&    V1,
564  gp_Vec2d&    V2) const
565 {
566   Standard_DomainError_Raise_if (FromK1 == ToK2,
567                                  "Geom2d_BSplineCurve::LocalD2");
568   
569   Standard_Real u = U;
570   Standard_Integer index = 0;
571   BSplCLib::LocateParameter(deg, FKNOTS, U, periodic, FromK1,ToK2, index, u);
572   index = BSplCLib::FlatIndex(deg,index,mults->Array1(),periodic);
573   
574   if ( rational ) {
575     BSplCLib::D2(u,index,deg,periodic,POLES,
576                  weights->Array1(),
577                  FKNOTS,FMULTS,P,V1,V2);
578   }
579   else {
580     BSplCLib::D2(u,index,deg,periodic,POLES,
581                  *((TColStd_Array1OfReal*) NULL),
582                  FKNOTS,FMULTS,P,V1,V2);
583   }
584 }
585
586 //=======================================================================
587 //function : LocalD3
588 //purpose  : 
589 //=======================================================================
590
591 void Geom2d_BSplineCurve::LocalD3
592 (const Standard_Real    U,
593  const Standard_Integer FromK1,
594  const Standard_Integer ToK2, 
595  gp_Pnt2d&    P,
596  gp_Vec2d&    V1,
597  gp_Vec2d&    V2,
598  gp_Vec2d&    V3) const
599 {
600   Standard_DomainError_Raise_if (FromK1 == ToK2,
601                                  "Geom2d_BSplineCurve::LocalD3");
602   
603   Standard_Real u = U;
604   Standard_Integer index = 0;
605   BSplCLib::LocateParameter(deg, FKNOTS, U, periodic, FromK1,ToK2, index, u);
606   index = BSplCLib::FlatIndex(deg,index,mults->Array1(),periodic);
607   
608   if ( rational ) {
609     BSplCLib::D3(u,index,deg,periodic,POLES,
610                  weights->Array1(),
611                  FKNOTS,FMULTS,P,V1,V2,V3);
612   }
613   else {
614     BSplCLib::D3(u,index,deg,periodic,POLES,
615                  *((TColStd_Array1OfReal*) NULL),
616                  FKNOTS,FMULTS,P,V1,V2,V3);
617   }
618 }
619
620 //=======================================================================
621 //function : LocalDN
622 //purpose  : 
623 //=======================================================================
624
625 gp_Vec2d Geom2d_BSplineCurve::LocalDN
626 (const Standard_Real    U,
627  const Standard_Integer FromK1,
628  const Standard_Integer ToK2,
629  const Standard_Integer N      ) const
630 {
631   Standard_DomainError_Raise_if (FromK1 == ToK2,
632                                  "Geom2d_BSplineCurve::LocalD3");
633   
634   Standard_Real u = U;
635   Standard_Integer index = 0;
636   BSplCLib::LocateParameter(deg, FKNOTS, U, periodic, FromK1,ToK2, index, u);
637   index = BSplCLib::FlatIndex(deg,index,mults->Array1(),periodic);
638   
639   gp_Vec2d V;
640
641   if ( rational ) {
642     BSplCLib::DN(u,N,index,deg,periodic,POLES,
643                  weights->Array1(),
644                  FKNOTS,FMULTS,V);
645   }
646   else {
647     BSplCLib::DN(u,N,index,deg,periodic,POLES,
648                  *((TColStd_Array1OfReal*) NULL),
649                  FKNOTS,FMULTS,V);
650   }
651   return V;
652 }
653
654 //=======================================================================
655 //function : Multiplicity
656 //purpose  : 
657 //=======================================================================
658
659 Standard_Integer Geom2d_BSplineCurve::Multiplicity 
660 (const Standard_Integer Index) const
661 {
662   Standard_OutOfRange_Raise_if (Index < 1 || Index > mults->Length(),
663                                 "Geom2d_BSplineCurve::Multiplicity");
664   return mults->Value (Index);
665 }
666
667 //=======================================================================
668 //function : Multiplicities
669 //purpose  : 
670 //=======================================================================
671
672 void Geom2d_BSplineCurve::Multiplicities (TColStd_Array1OfInteger& M) const
673 {
674   Standard_DimensionError_Raise_if (M.Length() != mults->Length(),
675                                     "Geom2d_BSplineCurve::Multiplicities");
676   M = mults->Array1();
677 }
678
679 //=======================================================================
680 //function : NbKnots
681 //purpose  : 
682 //=======================================================================
683
684 Standard_Integer Geom2d_BSplineCurve::NbKnots () const
685 { return knots->Length(); }
686
687 //=======================================================================
688 //function : NbPoles
689 //purpose  : 
690 //=======================================================================
691
692 Standard_Integer Geom2d_BSplineCurve::NbPoles () const
693 { return poles->Length(); }
694
695 //=======================================================================
696 //function : Pole
697 //purpose  : 
698 //=======================================================================
699
700 gp_Pnt2d Geom2d_BSplineCurve::Pole (const Standard_Integer Index) const
701 {
702   Standard_OutOfRange_Raise_if (Index < 1 || Index > poles->Length(),
703                                 "Geom2d_BSplineCurve::Pole");
704   return poles->Value (Index);      
705 }
706
707 //=======================================================================
708 //function : Poles
709 //purpose  : 
710 //=======================================================================
711
712 void Geom2d_BSplineCurve::Poles (TColgp_Array1OfPnt2d& P) const
713 {
714   Standard_DimensionError_Raise_if (P.Length() != poles->Length(),
715                                     "Geom2d_BSplineCurve::Poles");
716   P = poles->Array1();
717 }
718
719 //=======================================================================
720 //function : StartPoint
721 //purpose  : 
722 //=======================================================================
723
724 gp_Pnt2d Geom2d_BSplineCurve::StartPoint () const
725 {
726   if (mults->Value (1) == deg + 1)  
727     return poles->Value (1);
728   else 
729     return Value(FirstParameter());
730 }
731
732 //=======================================================================
733 //function : Weight
734 //purpose  : 
735 //=======================================================================
736
737 Standard_Real Geom2d_BSplineCurve::Weight
738 (const Standard_Integer Index) const
739 {
740   Standard_OutOfRange_Raise_if (Index < 1 || Index > poles->Length(),
741                                 "Geom2d_BSplineCurve::Weight");
742   if (IsRational())
743     return weights->Value (Index);
744   else
745     return 1.;
746 }
747
748 //=======================================================================
749 //function : Weights
750 //purpose  : 
751 //=======================================================================
752
753 void Geom2d_BSplineCurve::Weights
754 (TColStd_Array1OfReal& W) const
755 {
756   Standard_DimensionError_Raise_if (W.Length() != poles->Length(),
757                                     "Geom2d_BSplineCurve::Weights");
758   if (IsRational())
759     W = weights->Array1();
760   else {
761     Standard_Integer i;
762     for (i = W.Lower(); i <= W.Upper(); i++)
763       W(i) = 1.;
764   }
765 }
766
767 //=======================================================================
768 //function : IsRational
769 //purpose  : 
770 //=======================================================================
771
772 Standard_Boolean Geom2d_BSplineCurve::IsRational () const
773
774   return !weights.IsNull(); 
775
776
777 //=======================================================================
778 //function : Transform
779 //purpose  : 
780 //=======================================================================
781
782 void Geom2d_BSplineCurve::Transform
783 (const gp_Trsf2d& T)
784 {
785   TColgp_Array1OfPnt2d & CPoles = poles->ChangeArray1();
786   for (Standard_Integer I = 1; I <= CPoles.Length(); I++)  
787     CPoles (I).Transform (T);
788
789   InvalidateCache();
790   //  maxderivinvok = 0;
791 }
792
793 //=======================================================================
794 //function : LocateU
795 //purpose  : 
796 //=======================================================================
797
798 void Geom2d_BSplineCurve::LocateU
799 (const Standard_Real    U, 
800  const Standard_Real    ParametricTolerance, 
801  Standard_Integer&      I1,
802  Standard_Integer&      I2,
803  const Standard_Boolean WithKnotRepetition) const
804 {
805   Standard_Real NewU = U;
806   Handle(TColStd_HArray1OfReal) TheKnots;
807   if (WithKnotRepetition)  TheKnots = flatknots;
808   else                     TheKnots = knots;
809   
810   const TColStd_Array1OfReal & CKnots = TheKnots->Array1();
811
812   PeriodicNormalization(NewU); //Attention a la periode
813   Standard_Real UFirst = CKnots (1);
814   Standard_Real ULast  = CKnots (CKnots.Length());
815   Standard_Real PParametricTolerance = Abs(ParametricTolerance);
816   if (Abs (NewU - UFirst) <= PParametricTolerance) { I1 = I2 = 1; }
817   else if (Abs (NewU - ULast) <= PParametricTolerance) { 
818     I1 = I2 = CKnots.Length();
819   }
820   else if (NewU < UFirst) {
821     I2 = 1;
822     I1 = 0;
823   }
824   else if (NewU > ULast) {
825     I1 = CKnots.Length();
826     I2 = I1 + 1;
827   }
828   else {
829     I1 = 1;
830     BSplCLib::Hunt (CKnots, NewU, I1);
831     while ( Abs( CKnots(I1+1) - NewU) <= PParametricTolerance) I1++;
832     if ( Abs( CKnots(I1) - NewU) <= PParametricTolerance) {
833       I2 = I1;
834     }
835     else {
836       I2 = I1 + 1;
837     }
838   }
839 }
840
841 //=======================================================================
842 //function : Resolution
843 //purpose  : 
844 //=======================================================================
845
846 void Geom2d_BSplineCurve::Resolution(const Standard_Real ToleranceUV,
847                                      Standard_Real &     UTolerance) 
848 {
849   Standard_Integer ii ;  
850   if(!maxderivinvok){
851     if ( periodic) {
852       Standard_Integer NbKnots, NbPoles;
853       BSplCLib::PrepareUnperiodize( deg, 
854                                    mults->Array1(),
855                                    NbKnots,
856                                    NbPoles);
857       TColgp_Array1OfPnt2d    new_poles(1,NbPoles) ;
858       TColStd_Array1OfReal  new_weights(1,NbPoles) ;
859       for(ii = 1 ; ii <= NbPoles ; ii++) {
860         new_poles(ii) = poles->Array1()(((ii-1) % poles->Length()) + 1) ;
861       }
862       if (rational) {
863         for(ii = 1 ; ii <= NbPoles ; ii++) {
864           new_weights(ii) = weights->Array1()(((ii-1) % poles->Length()) + 1) ;
865         }
866         BSplCLib::Resolution(new_poles,
867                              new_weights,
868                              new_poles.Length(),
869                              flatknots->Array1(),
870                              deg,
871                              1.,
872                              maxderivinv) ;
873       }
874       else {
875         BSplCLib::Resolution(new_poles,
876                              *((TColStd_Array1OfReal*) NULL),
877                              new_poles.Length(),
878                              flatknots->Array1(),
879                              deg,
880                              1.,
881                              maxderivinv) ;
882       }
883     }
884     else {
885       if (rational) {
886         BSplCLib::Resolution(poles->Array1(),
887                              weights->Array1(),
888                              poles->Length(),
889                              flatknots->Array1(),
890                              deg,
891                              1.,
892                              maxderivinv) ;
893       }
894       else {
895         BSplCLib::Resolution(poles->Array1(),
896                              *((TColStd_Array1OfReal*) NULL),
897                              poles->Length(),
898                              flatknots->Array1(),
899                              deg,
900                              1.,
901                              maxderivinv) ;
902       }
903     }
904     maxderivinvok = 1;
905   } 
906   UTolerance = ToleranceUV * maxderivinv; 
907 }
908