215b3ce8a4deb74787f1f76518ff97bb4237666b
[occt.git] / src / GeomAdaptor / GeomAdaptor_Curve.cxx
1 // Created on: 1993-04-29
2 // Created by: Bruno DUMORTIER
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 // 20/02/97 : PMN -> Positionement local sur BSpline (PRO6902)
18 // 10/07/97 : PMN -> Pas de calcul de resolution dans Nb(Intervals)(PRO9248)
19 // 20/10/97 : RBV -> traitement des offset curves
20
21 #define No_Standard_RangeError
22 #define No_Standard_OutOfRange
23
24
25 #include <Adaptor3d_HCurve.hxx>
26 #include <BSplCLib.hxx>
27 #include <BSplCLib_Cache.hxx>
28 #include <CSLib_Offset.hxx>
29 #include <Geom_BezierCurve.hxx>
30 #include <Geom_BSplineCurve.hxx>
31 #include <Geom_Circle.hxx>
32 #include <Geom_Curve.hxx>
33 #include <Geom_Ellipse.hxx>
34 #include <Geom_Hyperbola.hxx>
35 #include <Geom_Line.hxx>
36 #include <Geom_OffsetCurve.hxx>
37 #include <Geom_Parabola.hxx>
38 #include <Geom_TrimmedCurve.hxx>
39 #include <GeomAbs_Shape.hxx>
40 #include <GeomAdaptor_Curve.hxx>
41 #include <GeomAdaptor_HCurve.hxx>
42 #include <GeomAdaptor_Surface.hxx>
43 #include <gp_Circ.hxx>
44 #include <gp_Elips.hxx>
45 #include <gp_Hypr.hxx>
46 #include <gp_Lin.hxx>
47 #include <gp_Parab.hxx>
48 #include <gp_Pnt.hxx>
49 #include <gp_Vec.hxx>
50 #include <Precision.hxx>
51 #include <Standard_ConstructionError.hxx>
52 #include <Standard_DomainError.hxx>
53 #include <Standard_NoSuchObject.hxx>
54 #include <Standard_NotImplemented.hxx>
55 #include <Standard_NullObject.hxx>
56 #include <Standard_OutOfRange.hxx>
57 #include <TColgp_Array1OfPnt.hxx>
58 #include <TColStd_Array1OfInteger.hxx>
59 #include <TColStd_Array1OfReal.hxx>
60 #include <TColStd_HArray1OfInteger.hxx>
61
62 //#include <GeomConvert_BSplineCurveKnotSplitting.hxx>
63 #define myBspl Handle(Geom_BSplineCurve)::DownCast (myCurve)
64 #define PosTol Precision::PConfusion()/2
65
66 static const int maxDerivOrder = 3;
67 static const Standard_Real MinStep   = 1e-7;
68
69 static gp_Vec dummyDerivative; // used as empty value for unused derivatives in AdjustDerivative
70 // Recalculate derivatives in the singular point
71 // Returns true if the direction of derivatives is changed
72 static Standard_Boolean AdjustDerivative(
73     const Handle(Adaptor3d_HCurve)& theAdaptor, Standard_Integer theMaxDerivative, Standard_Real theU, gp_Vec& theD1,
74     gp_Vec& theD2 = dummyDerivative, gp_Vec& theD3 = dummyDerivative, gp_Vec& theD4 = dummyDerivative);
75
76
77 //=======================================================================
78 //function : LocalContinuity
79 //purpose  : Computes the Continuity of a BSplineCurve 
80 //           between the parameters U1 and U2
81 //           The continuity is C(d-m) 
82 //             with   d = degree, 
83 //                    m = max multiplicity of the Knots between U1 and U2
84 //=======================================================================
85
86 GeomAbs_Shape GeomAdaptor_Curve::LocalContinuity(const Standard_Real U1, 
87                                                  const Standard_Real U2) 
88      const 
89 {
90   Standard_NoSuchObject_Raise_if(myTypeCurve!=GeomAbs_BSplineCurve," ");
91   Standard_Integer Nb = myBspl->NbKnots();
92   Standard_Integer Index1 = 0;
93   Standard_Integer Index2 = 0;
94   Standard_Real newFirst, newLast;
95   TColStd_Array1OfReal    TK(1,Nb);
96   TColStd_Array1OfInteger TM(1,Nb);
97   myBspl->Knots(TK);
98   myBspl->Multiplicities(TM);
99   BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,U1,myBspl->IsPeriodic(),
100                             1,Nb,Index1,newFirst);
101   BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,U2,myBspl->IsPeriodic(),
102                             1,Nb,Index2,newLast);
103   if ( Abs(newFirst-TK(Index1+1))<Precision::PConfusion()) { 
104     if (Index1 < Nb) Index1++;
105   }
106   if ( Abs(newLast-TK(Index2))<Precision::PConfusion())
107     Index2--;
108   Standard_Integer MultMax;
109   // attention aux courbes peridiques.
110   if ( (myBspl->IsPeriodic()) && (Index1 == Nb) )
111     Index1 = 1;
112
113   if ( Index2 - Index1 <= 0) {
114     MultMax = 100;  // CN entre 2 Noeuds consecutifs
115   }
116   else {
117     MultMax = TM(Index1+1);
118     for(Standard_Integer i = Index1+1;i<=Index2;i++) {
119       if ( TM(i)>MultMax) MultMax=TM(i);
120     }
121     MultMax = myBspl->Degree() - MultMax;
122   }
123   if ( MultMax <= 0) {
124     return GeomAbs_C0;
125   }
126   else if ( MultMax == 1) {
127     return GeomAbs_C1;
128   } 
129   else if ( MultMax == 2) {
130     return GeomAbs_C2;
131   }
132   else if ( MultMax == 3) {
133     return GeomAbs_C3;
134   }
135   else { 
136     return GeomAbs_CN;
137   }
138 }
139
140
141 //=======================================================================
142 //function : Load
143 //purpose  : 
144 //=======================================================================
145
146 void GeomAdaptor_Curve::load(const Handle(Geom_Curve)& C,
147                              const Standard_Real UFirst,
148                              const Standard_Real ULast)
149 {
150   myFirst = UFirst;
151   myLast  = ULast;
152
153   if ( myCurve != C) {
154     myCurve = C;
155     
156     const Handle(Standard_Type)& TheType = C->DynamicType();
157     if ( TheType == STANDARD_TYPE(Geom_TrimmedCurve)) {
158       Load(Handle(Geom_TrimmedCurve)::DownCast (C)->BasisCurve(),UFirst,ULast);
159     }
160     else if ( TheType ==  STANDARD_TYPE(Geom_Circle)) {
161       myTypeCurve = GeomAbs_Circle;
162     }
163     else if ( TheType ==STANDARD_TYPE(Geom_Line)) {
164       myTypeCurve = GeomAbs_Line;
165     }
166     else if ( TheType == STANDARD_TYPE(Geom_Ellipse)) {
167       myTypeCurve = GeomAbs_Ellipse;
168     }
169     else if ( TheType == STANDARD_TYPE(Geom_Parabola)) {
170       myTypeCurve = GeomAbs_Parabola;
171     }
172     else if ( TheType == STANDARD_TYPE(Geom_Hyperbola)) {
173       myTypeCurve = GeomAbs_Hyperbola;
174     }
175     else if ( TheType == STANDARD_TYPE(Geom_BezierCurve)) {
176       myTypeCurve = GeomAbs_BezierCurve;
177     }
178     else if ( TheType == STANDARD_TYPE(Geom_BSplineCurve)) {
179       myTypeCurve = GeomAbs_BSplineCurve;
180       // Create cache for B-spline
181       myCurveCache = new BSplCLib_Cache(myBspl->Degree(), myBspl->IsPeriodic(), 
182         myBspl->KnotSequence(), myBspl->Poles(), myBspl->Weights());
183     }
184     else if ( TheType == STANDARD_TYPE(Geom_OffsetCurve)) {
185       myTypeCurve = GeomAbs_OffsetCurve;
186       // Create nested adaptor for base curve
187       Handle(Geom_Curve) aBase = Handle(Geom_OffsetCurve)::DownCast(myCurve)->BasisCurve();
188       myOffsetBaseCurveAdaptor = new GeomAdaptor_HCurve(aBase);
189     }
190     else {
191       myTypeCurve = GeomAbs_OtherCurve;
192     }
193   }
194 }  
195
196 //    --
197 //    --     Global methods - Apply to the whole curve.
198 //    --     
199
200 //=======================================================================
201 //function : Continuity
202 //purpose  : 
203 //=======================================================================
204
205 GeomAbs_Shape GeomAdaptor_Curve::Continuity() const 
206 {
207   if (myTypeCurve == GeomAbs_BSplineCurve)
208     return LocalContinuity(myFirst, myLast);
209
210   if (myTypeCurve == GeomAbs_OffsetCurve)
211   {
212     const GeomAbs_Shape S =
213       Handle(Geom_OffsetCurve)::DownCast (myCurve)->GetBasisCurveContinuity();
214     switch(S)
215     {
216       case GeomAbs_CN: return GeomAbs_CN;
217       case GeomAbs_C3: return GeomAbs_C2;
218       case GeomAbs_C2: return GeomAbs_C1;
219       case GeomAbs_C1: return GeomAbs_C0; 
220       case GeomAbs_G1: return GeomAbs_G1;
221       case GeomAbs_G2: return GeomAbs_G2;
222       default:
223         Standard_NoSuchObject::Raise("GeomAdaptor_Curve::Continuity");
224     }
225   }
226   else if (myTypeCurve == GeomAbs_OtherCurve) {
227     Standard_NoSuchObject::Raise("GeomAdaptor_Curve::Contunuity");
228   }
229
230   return GeomAbs_CN;
231 }
232
233 //=======================================================================
234 //function : NbIntervals
235 //purpose  : 
236 //=======================================================================
237
238 Standard_Integer GeomAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
239 {
240   Standard_Integer myNbIntervals = 1;
241   Standard_Integer NbSplit;
242   if (myTypeCurve == GeomAbs_BSplineCurve) {
243     Standard_Integer FirstIndex = myBspl->FirstUKnotIndex();
244     Standard_Integer LastIndex  = myBspl->LastUKnotIndex();
245     TColStd_Array1OfInteger Inter (1, LastIndex-FirstIndex+1);
246     if ( S > Continuity()) {
247       Standard_Integer Cont;
248       switch ( S) {
249       case GeomAbs_G1:
250       case GeomAbs_G2:
251         Standard_DomainError::Raise("GeomAdaptor_Curve::NbIntervals");
252         break;
253       case GeomAbs_C0:
254         myNbIntervals = 1;
255         break;
256       case GeomAbs_C1:
257       case GeomAbs_C2:
258       case GeomAbs_C3: 
259       case GeomAbs_CN: 
260         {
261           if      ( S == GeomAbs_C1) Cont = 1;
262           else if ( S == GeomAbs_C2) Cont = 2;
263           else if ( S == GeomAbs_C3) Cont = 3;
264           else                       Cont = myBspl->Degree();
265           Standard_Integer Degree = myBspl->Degree();
266           Standard_Integer NbKnots = myBspl->NbKnots();
267           TColStd_Array1OfInteger Mults (1, NbKnots);
268           myBspl->Multiplicities (Mults);
269           NbSplit = 1;
270           Standard_Integer Index   = FirstIndex;
271           Inter (NbSplit) = Index;
272           Index++;
273           NbSplit++;
274           while (Index < LastIndex) 
275             {
276               if (Degree - Mults (Index) < Cont) 
277                 {
278                   Inter (NbSplit) = Index;
279                   NbSplit++;
280                 }
281               Index++;
282             }
283           Inter (NbSplit) = Index;
284
285           Standard_Integer NbInt = NbSplit-1;
286           
287           Standard_Integer Nb = myBspl->NbKnots();
288           Standard_Integer Index1 = 0;
289           Standard_Integer Index2 = 0;
290           Standard_Real newFirst, newLast;
291           TColStd_Array1OfReal    TK(1,Nb);
292           TColStd_Array1OfInteger TM(1,Nb);
293           myBspl->Knots(TK);
294           myBspl->Multiplicities(TM);
295           BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,myFirst,
296                                     myBspl->IsPeriodic(),
297                                     1,Nb,Index1,newFirst);
298           BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,myLast,
299                                     myBspl->IsPeriodic(),
300                                     1,Nb,Index2,newLast);
301
302           // On decale eventuellement les indices  
303           // On utilise une "petite" tolerance, la resolution ne doit 
304           // servir que pour les tres longue courbes....(PRO9248)
305           Standard_Real Eps = Min(Resolution(Precision::Confusion()),
306                                   Precision::PConfusion()); 
307           if ( Abs(newFirst-TK(Index1+1))< Eps) Index1++;
308           if ( newLast-TK(Index2)> Eps) Index2++;
309           
310           myNbIntervals = 1;
311           for ( Standard_Integer i=1; i<=NbInt; i++)
312             if (Inter(i)>Index1 && Inter(i)<Index2) myNbIntervals++;
313         }
314         break;
315       }
316     }
317   }
318   
319   else if (myTypeCurve == GeomAbs_OffsetCurve) {
320     GeomAbs_Shape BaseS=GeomAbs_C0;
321     switch(S){
322     case GeomAbs_G1:
323     case GeomAbs_G2:
324       Standard_DomainError::Raise("GeomAdaptor_Curve::NbIntervals");
325       break;
326     case GeomAbs_C0: BaseS = GeomAbs_C1; break;
327     case GeomAbs_C1: BaseS = GeomAbs_C2; break;
328     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
329     default: BaseS = GeomAbs_CN;
330     }
331     GeomAdaptor_Curve C
332       (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
333     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
334     //                    the number of intervals obtained from the basis to
335     //              vvv   reflect parameter bounds
336     Standard_Integer iNbBasisInt = C.NbIntervals(BaseS), iInt;
337     if (iNbBasisInt>1)
338     {
339       TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
340       C.Intervals(rdfInter,BaseS);
341       for (iInt=1; iInt<=iNbBasisInt; iInt++)
342         if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
343           myNbIntervals++;
344     }
345     // akm 05/04/02 ^^^
346   }
347   return myNbIntervals;
348 }
349
350 //=======================================================================
351 //function : Intervals
352 //purpose  : 
353 //=======================================================================
354
355 void GeomAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
356                                   const GeomAbs_Shape S   ) const
357 {
358   Standard_Integer myNbIntervals = 1;
359   Standard_Integer NbSplit;
360   Standard_Real FirstParam = myFirst, LastParam = myLast;
361
362   if (myTypeCurve == GeomAbs_BSplineCurve) 
363     {
364       Standard_Integer FirstIndex = myBspl->FirstUKnotIndex();
365       Standard_Integer LastIndex  = myBspl->LastUKnotIndex();
366       TColStd_Array1OfInteger Inter (1, LastIndex-FirstIndex+1);
367       
368       if ( S > Continuity()) {
369         Standard_Integer Cont;
370         switch ( S) {
371         case GeomAbs_G1:
372         case GeomAbs_G2:
373           Standard_DomainError::Raise("Geom2dAdaptor_Curve::NbIntervals");
374           break;
375         case GeomAbs_C0:
376           myNbIntervals = 1;
377           break;
378         case GeomAbs_C1:
379         case GeomAbs_C2:
380         case GeomAbs_C3: 
381         case GeomAbs_CN: 
382           {
383             if      ( S == GeomAbs_C1) Cont = 1;
384             else if ( S == GeomAbs_C2) Cont = 2;
385             else if ( S == GeomAbs_C3) Cont = 3;
386             else                       Cont = myBspl->Degree();
387             Standard_Integer Degree = myBspl->Degree();
388             Standard_Integer NbKnots = myBspl->NbKnots();
389             TColStd_Array1OfInteger Mults (1, NbKnots);
390             myBspl->Multiplicities (Mults);
391             NbSplit = 1;
392             Standard_Integer Index   = FirstIndex;
393             Inter (NbSplit) = Index;
394             Index++;
395             NbSplit++;
396             while (Index < LastIndex) 
397               {
398                 if (Degree - Mults (Index) < Cont) 
399                   {
400                     Inter (NbSplit) = Index;
401                     NbSplit++;
402                   }
403                 Index++;
404               }
405             Inter (NbSplit) = Index;
406             Standard_Integer NbInt = NbSplit-1;
407             //        GeomConvert_BSplineCurveKnotSplitting Convector(myBspl, Cont);
408             //        Standard_Integer NbInt = Convector.NbSplits()-1;
409             //        TColStd_Array1OfInteger Inter(1,NbInt+1);
410             //        Convector.Splitting( Inter);
411             
412             Standard_Integer Nb = myBspl->NbKnots();
413             Standard_Integer Index1 = 0;
414             Standard_Integer Index2 = 0;
415             Standard_Real newFirst, newLast;
416             TColStd_Array1OfReal    TK(1,Nb);
417             TColStd_Array1OfInteger TM(1,Nb);
418             myBspl->Knots(TK);
419             myBspl->Multiplicities(TM);
420             BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,myFirst,
421                                       myBspl->IsPeriodic(),
422                                       1,Nb,Index1,newFirst);
423             BSplCLib::LocateParameter(myBspl->Degree(),TK,TM,myLast,
424                                       myBspl->IsPeriodic(),
425                                       1,Nb,Index2,newLast);
426             FirstParam = newFirst;
427             LastParam = newLast;
428             // On decale eventuellement les indices  
429             // On utilise une "petite" tolerance, la resolution ne doit 
430             // servir que pour les tres longue courbes....(PRO9248)
431             Standard_Real Eps = Min(Resolution(Precision::Confusion()),
432                                     Precision::PConfusion()); 
433             if ( Abs(newFirst-TK(Index1+1))< Eps) Index1++;
434             if ( newLast-TK(Index2)> Eps) Index2++;
435             
436             Inter( 1) = Index1;
437             myNbIntervals = 1;
438             for ( Standard_Integer i=1; i<=NbInt; i++) {
439               if (Inter(i) > Index1 && Inter(i)<Index2 ) {
440                 myNbIntervals++;
441                 Inter(myNbIntervals) = Inter(i);
442               }
443             }
444             Inter(myNbIntervals+1) = Index2;
445             
446             for (Standard_Integer I=1;I<=myNbIntervals+1;I++) {
447               T(I) = TK(Inter(I));
448             }
449           }
450           break;
451         }
452       }
453     }
454
455   else if (myTypeCurve == GeomAbs_OffsetCurve){
456     GeomAbs_Shape BaseS=GeomAbs_C0;
457     switch(S){
458     case GeomAbs_G1:
459     case GeomAbs_G2:
460       Standard_DomainError::Raise("GeomAdaptor_Curve::NbIntervals");
461       break;
462     case GeomAbs_C0: BaseS = GeomAbs_C1; break;
463     case GeomAbs_C1: BaseS = GeomAbs_C2; break;
464     case GeomAbs_C2: BaseS = GeomAbs_C3; break;
465     default: BaseS = GeomAbs_CN;
466     }
467     GeomAdaptor_Curve C
468       (Handle(Geom_OffsetCurve)::DownCast (myCurve)->BasisCurve());
469     // akm 05/04/02 (OCC278)  If our curve is trimmed we must recalculate 
470     //                    the array of intervals obtained from the basis to
471     //              vvv   reflect parameter bounds
472     Standard_Integer iNbBasisInt = C.NbIntervals(BaseS), iInt;
473     if (iNbBasisInt>1)
474     {
475       TColStd_Array1OfReal rdfInter(1,1+iNbBasisInt);
476       C.Intervals(rdfInter,BaseS);
477       for (iInt=1; iInt<=iNbBasisInt; iInt++)
478         if (rdfInter(iInt)>myFirst && rdfInter(iInt)<myLast)
479           T(++myNbIntervals)=rdfInter(iInt);
480     }
481     // old - myNbIntervals = C.NbIntervals(BaseS);
482     // old - C.Intervals(T, BaseS);
483     // akm 05/04/02 ^^^
484   }
485   
486   T( T.Lower() ) = FirstParam;
487   T( T.Lower() + myNbIntervals ) = LastParam;
488 }
489
490 //=======================================================================
491 //function : Trim
492 //purpose  : 
493 //=======================================================================
494
495 Handle(Adaptor3d_HCurve) GeomAdaptor_Curve::Trim(const Standard_Real First,
496                                                  const Standard_Real Last,
497                                                  const Standard_Real /*Tol*/) const
498 {
499   return Handle(GeomAdaptor_HCurve)(new GeomAdaptor_HCurve(myCurve,First,Last));
500 }
501
502
503 //=======================================================================
504 //function : IsClosed
505 //purpose  : 
506 //=======================================================================
507
508 Standard_Boolean GeomAdaptor_Curve::IsClosed() const
509 {
510   if (!Precision::IsPositiveInfinite(myLast) &&
511       !Precision::IsNegativeInfinite(myFirst))
512   {
513     const gp_Pnt Pd = Value(myFirst);
514     const gp_Pnt Pf = Value(myLast);
515     return (Pd.Distance(Pf) <= Precision::Confusion());
516   }
517   return Standard_False;
518 }
519
520 //=======================================================================
521 //function : IsPeriodic
522 //purpose  : 
523 //=======================================================================
524
525 Standard_Boolean GeomAdaptor_Curve::IsPeriodic() const 
526 {
527   return (myCurve->IsPeriodic()? IsClosed() : Standard_False);
528 }
529
530 //=======================================================================
531 //function : Period
532 //purpose  : 
533 //=======================================================================
534
535 Standard_Real GeomAdaptor_Curve::Period() const 
536 {
537   return myCurve->LastParameter() - myCurve->FirstParameter();
538 }
539
540 //=======================================================================
541 //function : RebuildCache
542 //purpose  : 
543 //=======================================================================
544 void GeomAdaptor_Curve::RebuildCache(const Standard_Real theParameter) const
545 {
546   myCurveCache->BuildCache(theParameter, myBspl->Degree(), 
547     myBspl->IsPeriodic(), myBspl->KnotSequence(), 
548     myBspl->Poles(), myBspl->Weights());
549 }
550
551 //=======================================================================
552 //function : Value
553 //purpose  : 
554 //=======================================================================
555
556 gp_Pnt GeomAdaptor_Curve::Value(const Standard_Real U) const
557 {
558   if (myTypeCurve == GeomAbs_BSplineCurve)
559     return ValueBSpline(U);
560   else if (myTypeCurve == GeomAbs_OffsetCurve)
561     return ValueOffset(U);
562   return myCurve->Value(U);
563 }
564
565 //=======================================================================
566 //function : ValueBSpline
567 //purpose  : 
568 //=======================================================================
569 gp_Pnt GeomAdaptor_Curve::ValueBSpline(const Standard_Real theU) const
570 {
571   if (theU == myFirst || theU == myLast)
572   {
573     Standard_Integer Ideb = 0, Ifin = 0;
574     if (theU == myFirst) {
575       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
576       if (Ideb<1) Ideb=1;
577       if (Ideb>=Ifin) Ifin = Ideb+1;
578     }
579     if (theU == myLast) {
580       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
581       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
582       if (Ideb>=Ifin) Ideb = Ifin-1;
583     }
584     return myBspl->LocalValue(theU, Ideb, Ifin);
585   }
586   else if (!myCurveCache.IsNull()) // use cached B-spline data
587   {
588     if (!myCurveCache->IsCacheValid(theU))
589       RebuildCache(theU);
590     gp_Pnt aRes;
591     myCurveCache->D0(theU, aRes);
592     return aRes;
593   }
594   return myCurve->Value(theU);
595 }
596
597 //=======================================================================
598 //function : ValueOffset
599 //purpose  : 
600 //=======================================================================
601 gp_Pnt GeomAdaptor_Curve::ValueOffset(const Standard_Real theU) const
602 {
603   gp_Pnt aP;
604   gp_Vec aV;
605   myOffsetBaseCurveAdaptor->D1(theU, aP, aV);
606   Standard_Boolean IsDirectionChange = Standard_False;
607   if(aV.SquareMagnitude() <= gp::Resolution())
608     IsDirectionChange = AdjustDerivative(myOffsetBaseCurveAdaptor, 1, theU, aV);
609
610   Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(myCurve);
611   Standard_Real anOffsetVal = anOffC->Offset();
612   const gp_Dir& anOffsetDir = anOffC->Direction();
613
614   CSLib_Offset::D0(aP, aV, anOffsetDir, anOffsetVal, IsDirectionChange, aP);
615   return aP;
616 }
617
618 //=======================================================================
619 //function : D0
620 //purpose  : 
621 //=======================================================================
622
623 void GeomAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
624 {
625   if (myTypeCurve == GeomAbs_BSplineCurve)
626     D0BSpline(U, P);
627   else if (myTypeCurve == GeomAbs_OffsetCurve)
628     D0Offset(U, P);
629   else
630     myCurve->D0(U, P);
631 }
632
633 //=======================================================================
634 //function : D0BSpline
635 //purpose  : 
636 //=======================================================================
637 void GeomAdaptor_Curve::D0BSpline(const Standard_Real theU, gp_Pnt& theP) const
638 {
639   if (theU == myFirst || theU == myLast) 
640   {
641     Standard_Integer Ideb = 0, Ifin = 0;
642     if (theU == myFirst) {
643       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
644       if (Ideb<1) Ideb=1;
645       if (Ideb>=Ifin) Ifin = Ideb+1;
646     }
647     if (theU == myLast) {
648       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
649       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
650       if (Ideb>=Ifin) Ideb = Ifin-1;
651     }
652     myBspl->LocalD0(theU, Ideb, Ifin, theP);
653     return;
654   }
655   else if (!myCurveCache.IsNull()) // use cached B-spline data
656   {
657     if (!myCurveCache->IsCacheValid(theU))
658       RebuildCache(theU);
659     myCurveCache->D0(theU, theP);
660     return;
661   }
662   myCurve->D0(theU, theP);
663 }
664
665 //=======================================================================
666 //function : D0Offset
667 //purpose  : 
668 //=======================================================================
669 void GeomAdaptor_Curve::D0Offset(const Standard_Real theU, gp_Pnt& theP) const
670 {
671   theP = ValueOffset(theU);
672 }
673
674 //=======================================================================
675 //function : D1
676 //purpose  : 
677 //=======================================================================
678
679 void GeomAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const 
680 {
681   if (myTypeCurve == GeomAbs_BSplineCurve)
682     D1BSpline(U, P, V);
683   else if (myTypeCurve == GeomAbs_OffsetCurve)
684     D1Offset(U, P, V);
685   else
686     myCurve->D1(U, P, V);
687 }
688
689 //=======================================================================
690 //function : D1BSpline
691 //purpose  : 
692 //=======================================================================
693 void GeomAdaptor_Curve::D1BSpline(const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV) const
694 {
695   if (theU == myFirst || theU == myLast) 
696   {
697     Standard_Integer Ideb = 0, Ifin = 0;
698     if (theU == myFirst) {
699       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
700       if (Ideb<1) Ideb=1;
701       if (Ideb>=Ifin) Ifin = Ideb+1;
702     }
703     if (theU == myLast) {
704       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
705       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
706       if (Ideb>=Ifin) Ideb = Ifin-1;
707     }
708     myBspl->LocalD1(theU, Ideb, Ifin, theP, theV);
709     return;
710   }
711   else if (!myCurveCache.IsNull()) // use cached B-spline data
712   {
713     if (!myCurveCache->IsCacheValid(theU))
714       RebuildCache(theU);
715     myCurveCache->D1(theU, theP, theV);
716     return;
717   }
718   myCurve->D1(theU, theP, theV);
719 }
720
721 //=======================================================================
722 //function : D1Offset
723 //purpose  : 
724 //=======================================================================
725 void GeomAdaptor_Curve::D1Offset(const Standard_Real theU, gp_Pnt& theP, gp_Vec& theV) const
726 {
727   gp_Vec aV2;
728   myOffsetBaseCurveAdaptor->D2 (theU, theP, theV, aV2);
729
730   Standard_Boolean IsDirectionChange = Standard_False;
731   if(theV.SquareMagnitude() <= gp::Resolution())
732     IsDirectionChange = AdjustDerivative(myOffsetBaseCurveAdaptor, 2, theU, theV, aV2);
733
734   Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(myCurve);
735   Standard_Real anOffsetVal = anOffC->Offset();
736   const gp_Dir& anOffsetDir = anOffC->Direction();
737   CSLib_Offset::D1(theP, theV, aV2, anOffsetDir, anOffsetVal, IsDirectionChange, theP, theV);
738 }
739
740
741 //=======================================================================
742 //function : D2
743 //purpose  : 
744 //=======================================================================
745
746 void GeomAdaptor_Curve::D2(const Standard_Real U, 
747                            gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const 
748 {
749   if (myTypeCurve == GeomAbs_BSplineCurve)
750     D2BSpline(U, P, V1, V2);
751   else if (myTypeCurve == GeomAbs_OffsetCurve)
752     D2Offset(U, P, V1, V2);
753   else
754     myCurve->D2(U, P, V1, V2);
755 }
756
757 //=======================================================================
758 //function : D2BSpline
759 //purpose  : 
760 //=======================================================================
761 void GeomAdaptor_Curve::D2BSpline(const Standard_Real theU, gp_Pnt& theP,
762                                   gp_Vec& theV1, gp_Vec& theV2) const
763 {
764   if (theU == myFirst || theU == myLast)
765   {
766     Standard_Integer Ideb = 0, Ifin = 0;
767     if (theU == myFirst) {
768       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
769       if (Ideb<1) Ideb=1;
770       if (Ideb>=Ifin) Ifin = Ideb+1;
771     }
772     if (theU == myLast) {
773       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
774       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
775       if (Ideb>=Ifin) Ideb = Ifin-1;
776     }
777     myBspl->LocalD2(theU, Ideb, Ifin, theP, theV1, theV2);
778     return;
779   }
780   else if (!myCurveCache.IsNull()) // use cached B-spline data
781   {
782     if (!myCurveCache->IsCacheValid(theU))
783       RebuildCache(theU);
784     myCurveCache->D2(theU, theP, theV1, theV2);
785     return;
786   }
787   myCurve->D2(theU, theP, theV1, theV2);
788 }
789
790 //=======================================================================
791 //function : D2Offset
792 //purpose  : 
793 //=======================================================================
794 void GeomAdaptor_Curve::D2Offset(const Standard_Real theU, gp_Pnt& theP,
795                                   gp_Vec& theV1, gp_Vec& theV2) const
796 {
797   gp_Vec V3;
798   myOffsetBaseCurveAdaptor->D3 (theU, theP, theV1, theV2, V3);
799
800   Standard_Boolean IsDirectionChange = Standard_False;
801   if(theV1.SquareMagnitude() <= gp::Resolution())
802     IsDirectionChange = AdjustDerivative(myOffsetBaseCurveAdaptor, 3, theU, theV1, theV2, V3);
803
804   Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(myCurve);
805   Standard_Real anOffsetVal = anOffC->Offset();
806   const gp_Dir& anOffsetDir = anOffC->Direction();
807   CSLib_Offset::D2(theP, theV1, theV2, V3, anOffsetDir, anOffsetVal, IsDirectionChange, theP, theV1, theV2);
808 }
809
810 //=======================================================================
811 //function : D3
812 //purpose  : 
813 //=======================================================================
814
815 void GeomAdaptor_Curve::D3(const Standard_Real U, 
816                            gp_Pnt& P, gp_Vec& V1, 
817                            gp_Vec& V2, gp_Vec& V3) const 
818 {
819   if (myTypeCurve == GeomAbs_BSplineCurve)
820     D3BSpline(U, P, V1, V2, V3);
821   else if (myTypeCurve == GeomAbs_OffsetCurve)
822     D3Offset(U, P, V1, V2, V3);
823   else
824     myCurve->D3(U, P, V1, V2, V3);
825 }
826
827 //=======================================================================
828 //function : D3BSpline
829 //purpose  : 
830 //=======================================================================
831 void GeomAdaptor_Curve::D3BSpline(const Standard_Real theU,
832                                   gp_Pnt& theP, gp_Vec& theV1,
833                                   gp_Vec& theV2, gp_Vec& theV3) const
834 {
835   if (theU == myFirst || theU == myLast)
836   {
837     Standard_Integer Ideb = 0, Ifin = 0;
838     if (theU == myFirst) {
839       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
840       if (Ideb<1) Ideb=1;
841       if (Ideb>=Ifin) Ifin = Ideb+1;
842     }
843     if (theU == myLast) {
844       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
845       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
846       if (Ideb>=Ifin) Ideb = Ifin-1;
847     }
848     myBspl->LocalD3(theU, Ideb, Ifin, theP, theV1, theV2, theV3);
849     return;
850   }
851   else if (!myCurveCache.IsNull()) // use cached B-spline data
852   {
853     if (!myCurveCache->IsCacheValid(theU))
854       RebuildCache(theU);
855     myCurveCache->D3(theU, theP, theV1, theV2, theV3);
856     return;
857   }
858   myCurve->D3(theU, theP, theV1, theV2, theV3);
859 }
860
861 //=======================================================================
862 //function : D3Offset
863 //purpose  : 
864 //=======================================================================
865 void GeomAdaptor_Curve::D3Offset(const Standard_Real theU,
866                                  gp_Pnt& theP, gp_Vec& theV1,
867                                  gp_Vec& theV2, gp_Vec& theV3) const
868 {
869   myOffsetBaseCurveAdaptor->D3 (theU, theP, theV1, theV2, theV3);
870   gp_Vec V4 = myOffsetBaseCurveAdaptor->DN(theU, 4);
871
872   Standard_Boolean IsDirectionChange = Standard_False;
873   if(theV1.SquareMagnitude() <= gp::Resolution())
874     IsDirectionChange = AdjustDerivative(myOffsetBaseCurveAdaptor, 4, theU, theV1, theV2, theV3, V4);
875
876   Handle(Geom_OffsetCurve) anOffC = Handle(Geom_OffsetCurve)::DownCast(myCurve);
877   Standard_Real anOffsetVal = anOffC->Offset();
878   const gp_Dir& anOffsetDir = anOffC->Direction();
879   CSLib_Offset::D3(theP, theV1, theV2, theV3, V4, anOffsetDir, anOffsetVal, IsDirectionChange,
880                    theP, theV1, theV2, theV3);
881 }
882
883 //=======================================================================
884 //function : DN
885 //purpose  : 
886 //=======================================================================
887
888 gp_Vec GeomAdaptor_Curve::DN(const Standard_Real    U, 
889                              const Standard_Integer N) const 
890 {
891   if (myTypeCurve == GeomAbs_BSplineCurve)
892     return DNBSpline(U, N);
893   else if (myTypeCurve == GeomAbs_OffsetCurve)
894     return DNOffset(U, N);
895
896   return myCurve->DN(U, N);
897 }
898
899 gp_Vec GeomAdaptor_Curve::DNBSpline(const Standard_Real    U,
900                                     const Standard_Integer N) const
901 {
902   if ((U==myFirst || U==myLast))
903   {
904     Standard_Integer Ideb = 0, Ifin = 0;
905     if (U==myFirst) {
906       myBspl->LocateU(myFirst, PosTol, Ideb, Ifin);
907       if (Ideb<1) Ideb=1;
908       if (Ideb>=Ifin) Ifin = Ideb+1;
909     }
910     if (U==myLast) {
911       myBspl->LocateU(myLast, PosTol, Ideb, Ifin);
912       if (Ifin>myBspl->NbKnots()) Ifin = myBspl->NbKnots();
913       if (Ideb>=Ifin) Ideb = Ifin-1;
914     } 
915     return myBspl->LocalDN( U, Ideb, Ifin, N);
916   }
917   return myCurve->DN( U, N);
918 }
919
920 gp_Vec GeomAdaptor_Curve::DNOffset(const Standard_Real    U,
921                                    const Standard_Integer N) const
922 {
923   gp_Pnt aPnt;
924   gp_Vec aVec, aVN;
925
926   switch (N)
927   {
928   case 1:
929     D1Offset(U, aPnt, aVN);
930     break;
931   case 2:
932     D2Offset(U, aPnt, aVec, aVN);
933     break;
934   case 3:
935     D3Offset(U, aPnt, aVec, aVec, aVN);
936     break;
937   default:
938     aVN = myCurve->DN(U, N);
939   }
940   return aVN;
941 }
942
943 //=======================================================================
944 //function : Resolution
945 //purpose  : 
946 //=======================================================================
947
948 Standard_Real GeomAdaptor_Curve::Resolution(const Standard_Real R3D) const
949 {
950   switch ( myTypeCurve) {
951   case GeomAbs_Line :
952     return R3D;
953   case GeomAbs_Circle: {
954     Standard_Real R = Handle(Geom_Circle)::DownCast (myCurve)->Circ().Radius();
955     if ( R > R3D/2. )
956       return 2*ASin(R3D/(2*R));
957     else
958       return 2*M_PI;
959   }
960   case GeomAbs_Ellipse: {
961     return R3D / Handle(Geom_Ellipse)::DownCast (myCurve)->MajorRadius();
962   }
963   case GeomAbs_BezierCurve: {
964     Standard_Real res;
965     Handle(Geom_BezierCurve)::DownCast (myCurve)->Resolution(R3D,res);
966     return res;
967   }
968   case GeomAbs_BSplineCurve: {
969     Standard_Real res;
970     Handle(Geom_BSplineCurve)::DownCast (myCurve)->Resolution(R3D,res);
971     return res;
972   }
973   default:
974     return Precision::Parametric(R3D);
975   }  
976 }
977
978
979 //    --
980 //    --     The following methods must  be called when GetType returned
981 //    --     the corresponding type.
982 //    --     
983
984 //=======================================================================
985 //function : Line
986 //purpose  : 
987 //=======================================================================
988
989 gp_Lin GeomAdaptor_Curve::Line() const 
990 {
991   Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Line, "");
992   return Handle(Geom_Line)::DownCast (myCurve)->Lin();  
993 }
994
995 //=======================================================================
996 //function : Circle
997 //purpose  : 
998 //=======================================================================
999
1000 gp_Circ  GeomAdaptor_Curve::Circle() const 
1001 {
1002   Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Circle, "");
1003   return Handle(Geom_Circle)::DownCast (myCurve)->Circ();
1004 }
1005
1006 //=======================================================================
1007 //function : Ellipse
1008 //purpose  : 
1009 //=======================================================================
1010
1011 gp_Elips GeomAdaptor_Curve::Ellipse() const 
1012 {
1013   Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Ellipse, "");
1014   return Handle(Geom_Ellipse)::DownCast (myCurve)->Elips();
1015 }
1016
1017 //=======================================================================
1018 //function : Hyperbola
1019 //purpose  : 
1020 //=======================================================================
1021
1022 gp_Hypr GeomAdaptor_Curve::Hyperbola() const 
1023 {
1024   Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Hyperbola, "");
1025   return Handle(Geom_Hyperbola)::DownCast (myCurve)->Hypr();  
1026 }
1027
1028 //=======================================================================
1029 //function : Parabola
1030 //purpose  : 
1031 //=======================================================================
1032
1033 gp_Parab GeomAdaptor_Curve::Parabola() const 
1034 {
1035   Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Parabola, "");
1036   return Handle(Geom_Parabola)::DownCast (myCurve)->Parab();
1037 }
1038
1039 //=======================================================================
1040 //function : Degree
1041 //purpose  : 
1042 //=======================================================================
1043
1044 Standard_Integer GeomAdaptor_Curve::Degree() const
1045 {
1046   if (myTypeCurve == GeomAbs_BezierCurve)
1047     return Handle(Geom_BezierCurve)::DownCast (myCurve)->Degree();
1048   else if (myTypeCurve == GeomAbs_BSplineCurve)
1049     return Handle(Geom_BSplineCurve)::DownCast (myCurve)->Degree();
1050   else
1051     Standard_NoSuchObject::Raise();
1052   // portage WNT 
1053   return 0;
1054 }
1055
1056 //=======================================================================
1057 //function : IsRational
1058 //purpose  : 
1059 //=======================================================================
1060
1061 Standard_Boolean GeomAdaptor_Curve::IsRational() const {
1062   switch( myTypeCurve) {
1063   case GeomAbs_BSplineCurve:
1064     return Handle(Geom_BSplineCurve)::DownCast (myCurve)->IsRational();
1065   case GeomAbs_BezierCurve:
1066     return Handle(Geom_BezierCurve)::DownCast (myCurve)->IsRational();
1067   default:
1068     return Standard_False;
1069   }
1070 }
1071
1072 //=======================================================================
1073 //function : NbPoles
1074 //purpose  : 
1075 //=======================================================================
1076
1077 Standard_Integer GeomAdaptor_Curve::NbPoles() const
1078 {
1079   if (myTypeCurve == GeomAbs_BezierCurve)
1080     return Handle(Geom_BezierCurve)::DownCast (myCurve)->NbPoles();
1081   else if (myTypeCurve == GeomAbs_BSplineCurve)
1082     return Handle(Geom_BSplineCurve)::DownCast (myCurve)->NbPoles();
1083   else
1084     Standard_NoSuchObject::Raise();
1085   // portage WNT
1086   return 0;
1087 }
1088
1089 //=======================================================================
1090 //function : NbKnots
1091 //purpose  : 
1092 //=======================================================================
1093
1094 Standard_Integer GeomAdaptor_Curve::NbKnots() const
1095 {
1096   if ( myTypeCurve != GeomAbs_BSplineCurve)
1097     Standard_NoSuchObject::Raise("GeomAdaptor_Curve::NbKnots");
1098   return Handle(Geom_BSplineCurve)::DownCast (myCurve)->NbKnots();
1099 }
1100
1101 //=======================================================================
1102 //function : Bezier
1103 //purpose  : 
1104 //=======================================================================
1105
1106 Handle(Geom_BezierCurve) GeomAdaptor_Curve::Bezier() const 
1107 {
1108  if ( myTypeCurve != GeomAbs_BezierCurve)
1109     Standard_NoSuchObject::Raise("GeomAdaptor_Curve::Bezier");
1110   return Handle(Geom_BezierCurve)::DownCast (myCurve);
1111 }
1112
1113 //=======================================================================
1114 //function : BSpline
1115 //purpose  : 
1116 //=======================================================================
1117
1118 Handle(Geom_BSplineCurve) GeomAdaptor_Curve::BSpline() const 
1119 {
1120  if ( myTypeCurve != GeomAbs_BSplineCurve)
1121     Standard_NoSuchObject::Raise("GeomAdaptor_Curve::BSpline");
1122
1123   return Handle(Geom_BSplineCurve)::DownCast (myCurve);
1124 }
1125
1126
1127 // ============= Auxiliary functions ===================
1128 Standard_Boolean AdjustDerivative(const Handle(Adaptor3d_HCurve)& theAdaptor, Standard_Integer theMaxDerivative,
1129                                   Standard_Real theU, gp_Vec& theD1, gp_Vec& theD2,
1130                                   gp_Vec& theD3, gp_Vec& theD4)
1131 {
1132   static const Standard_Real aTol = gp::Resolution();
1133
1134   Standard_Boolean IsDirectionChange = Standard_False;
1135   const Standard_Real anUinfium   = theAdaptor->FirstParameter();
1136   const Standard_Real anUsupremum = theAdaptor->LastParameter();
1137
1138   const Standard_Real DivisionFactor = 1.e-3;
1139   Standard_Real du;
1140   if((anUsupremum >= RealLast()) || (anUinfium <= RealFirst())) 
1141     du = 0.0;
1142   else
1143     du = anUsupremum - anUinfium;
1144
1145   const Standard_Real aDelta = Max(du * DivisionFactor, MinStep);
1146
1147   //Derivative is approximated by Taylor-series
1148   Standard_Integer anIndex = 1; //Derivative order
1149   gp_Vec V;
1150
1151   do
1152   {
1153     V =  theAdaptor->DN(theU, ++anIndex);
1154   }
1155   while((V.SquareMagnitude() <= aTol) && anIndex < maxDerivOrder);
1156
1157   Standard_Real u;
1158
1159   if(theU-anUinfium < aDelta)
1160     u = theU+aDelta;
1161   else
1162     u = theU-aDelta;
1163
1164   gp_Pnt P1, P2;
1165   theAdaptor->D0(Min(theU, u), P1);
1166   theAdaptor->D0(Max(theU, u), P2);
1167
1168   gp_Vec V1(P1, P2);
1169   IsDirectionChange = V.Dot(V1) < 0.0;
1170   Standard_Real aSign = IsDirectionChange ? -1.0 : 1.0;
1171
1172   theD1 = V * aSign;
1173   gp_Vec* aDeriv[3] = {&theD2, &theD3, &theD4};
1174   for (Standard_Integer i = 1; i < theMaxDerivative; i++)
1175     *(aDeriv[i-1]) = theAdaptor->DN(theU, anIndex + i) * aSign;
1176
1177   return IsDirectionChange;
1178 }