0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Geom / Geom_OsculatingSurface.cxx
1 // Copyright (c) 1999-2014 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14
15 #include <BSplSLib.hxx>
16 #include <Convert_GridPolynomialToPoles.hxx>
17 #include <Geom_BezierSurface.hxx>
18 #include <Geom_BSplineSurface.hxx>
19 #include <Geom_OsculatingSurface.hxx>
20 #include <Geom_Surface.hxx>
21 #include <PLib.hxx>
22 #include <Precision.hxx>
23 #include <TColgp_Array1OfPnt.hxx>
24 #include <TColgp_Array2OfPnt.hxx>
25 #include <TColgp_Array2OfVec.hxx>
26 #include <TColgp_HArray2OfPnt.hxx>
27 #include <TColStd_Array1OfInteger.hxx>
28 #include <TColStd_Array1OfReal.hxx>
29 #include <TColStd_HArray1OfInteger.hxx>
30 #include <TColStd_HArray1OfReal.hxx>
31 #include <TColStd_HArray2OfInteger.hxx>
32
33 IMPLEMENT_STANDARD_RTTIEXT(Geom_OsculatingSurface,Standard_Transient)
34
35 //=======================================================================
36 //function : Geom_OffsetOsculatingSurface
37 //purpose  : 
38 //=======================================================================
39 Geom_OsculatingSurface::Geom_OsculatingSurface()
40 : myTol(0.0),
41   myAlong(1,4)    
42 {
43   myAlong.Init(Standard_False);
44 }
45 //=======================================================================
46 //function : Geom_OffsetOsculatingSurface
47 //purpose  : 
48 //=======================================================================
49
50 Geom_OsculatingSurface::Geom_OsculatingSurface(const Handle(Geom_Surface)& BS, 
51   const Standard_Real Tol)
52   : myAlong(1,4)
53 {
54   Init(BS,Tol);
55 }
56
57 //=======================================================================
58 //function : Init
59 //purpose  : 
60 //=======================================================================
61
62 void Geom_OsculatingSurface::Init(const Handle(Geom_Surface)& BS,
63   const Standard_Real Tol)
64 {
65   ClearOsculFlags();
66   myTol=Tol; 
67   Standard_Real TolMin=0.;//consider all singularities below Tol, not just above 1.e-12 (id23943)
68   Standard_Boolean OsculSurf = Standard_True;
69   myBasisSurf = Handle(Geom_Surface)::DownCast(BS->Copy());
70   myOsculSurf1 = new Geom_HSequenceOfBSplineSurface();
71   myOsculSurf2 = new Geom_HSequenceOfBSplineSurface();
72   if ((BS->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) || 
73     (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface)))) 
74   {
75     Standard_Real U1=0,U2=0,V1=0,V2=0;
76
77     Standard_Integer i = 1;
78     BS->Bounds(U1,U2,V1,V2);
79     myAlong.SetValue(1,IsQPunctual(BS,V1,GeomAbs_IsoV,TolMin,Tol));
80     myAlong.SetValue(2,IsQPunctual(BS,V2,GeomAbs_IsoV,TolMin,Tol));
81     myAlong.SetValue(3,IsQPunctual(BS,U1,GeomAbs_IsoU,TolMin,Tol));
82     myAlong.SetValue(4,IsQPunctual(BS,U2,GeomAbs_IsoU,TolMin,Tol));
83 #ifdef OCCT_DEBUG
84     std::cout<<myAlong(1)<<std::endl<<myAlong(2)<<std::endl<<myAlong(3)<<std::endl<<myAlong(4)<<std::endl;
85 #endif
86     if (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4)) 
87     {
88       Handle(Geom_BSplineSurface) InitSurf, L,S;
89       if (BS->IsKind(STANDARD_TYPE(Geom_BezierSurface))) 
90       {
91         Handle(Geom_BezierSurface) BzS = Handle(Geom_BezierSurface)::DownCast(BS);
92         TColgp_Array2OfPnt P(1,BzS->NbUPoles(),1,BzS->NbVPoles());
93         TColStd_Array1OfReal UKnots(1,2);
94         TColStd_Array1OfReal VKnots(1,2);
95         TColStd_Array1OfInteger UMults(1,2);
96         TColStd_Array1OfInteger VMults(1,2);
97         for (i=1;i<=2;i++)
98         {
99           UKnots.SetValue(i,(i-1));
100           VKnots.SetValue(i,(i-1));
101           UMults.SetValue(i,BzS->UDegree()+1);
102           VMults.SetValue(i,BzS->VDegree()+1);
103         }
104         BzS->Poles(P);
105         InitSurf = new Geom_BSplineSurface(P,UKnots,VKnots,
106           UMults,VMults,
107           BzS->UDegree(),
108           BzS->VDegree(),
109           BzS->IsUPeriodic(),
110           BzS->IsVPeriodic());
111       }
112       else 
113       {
114         InitSurf = Handle(Geom_BSplineSurface)::DownCast(myBasisSurf);
115       }
116 #ifdef OCCT_DEBUG
117       std::cout<<"UDEG: "<<InitSurf->UDegree()<<std::endl;
118       std::cout<<"VDEG: "<<InitSurf->VDegree()<<std::endl;
119 #endif
120
121       if(IsAlongU() && IsAlongV()) ClearOsculFlags();
122       //      Standard_ConstructionError_Raise_if((IsAlongU() && IsAlongV()),"Geom_OsculatingSurface");
123       if ((IsAlongU() && InitSurf->VDegree()>1) ||
124         (IsAlongV() && InitSurf->UDegree()>1)) 
125       {
126         myKdeg = new TColStd_HSequenceOfInteger();
127         Standard_Integer k=0;
128         Standard_Boolean IsQPunc;
129         Standard_Integer UKnot,VKnot;
130         if (myAlong(1) || myAlong(2)) 
131         {
132           for (i=1;i<InitSurf->NbUKnots();i++) 
133           {
134             if (myAlong(1)) 
135             {
136               S = InitSurf; k=0; IsQPunc=Standard_True;
137               UKnot=i;
138               VKnot=1;
139               while(IsQPunc) 
140               {
141                 OsculSurf  = BuildOsculatingSurface(V1,UKnot,VKnot,S,L);
142                 if(!OsculSurf) break;
143                 k++;
144 #ifdef OCCT_DEBUG
145                 std::cout<<"1.k = "<<k<<std::endl;
146 #endif
147                 IsQPunc=IsQPunctual(L,V1,GeomAbs_IsoV,0.,Tol);
148                 UKnot=1;
149                 VKnot=1;
150                 S=L;
151
152               }
153               if (OsculSurf)
154                 myOsculSurf1->Append(L);
155               else
156                 ClearOsculFlags(); //myAlong.SetValue(1,Standard_False);
157               if (myAlong(2) && OsculSurf) 
158               {
159                 S = InitSurf; k=0; IsQPunc=Standard_True;
160                 UKnot=i;
161                 VKnot=InitSurf->NbVKnots()-1;
162
163                 while(IsQPunc) 
164                 {
165                   OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
166                   if(!OsculSurf) break;
167                   k++;
168 #ifdef OCCT_DEBUG
169                   std::cout<<"2.k = "<<k<<std::endl;
170 #endif
171                   IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
172                   UKnot=1;
173                   VKnot=1;
174                   S=L;
175                 }
176                 if(OsculSurf)
177                 {
178                   myOsculSurf2->Append(L);
179                   myKdeg->Append(k);
180                 }
181               } 
182             }
183             else 
184               //if (myAlong(2)) 
185             {
186               S = InitSurf; k=0; IsQPunc=Standard_True;
187               UKnot=i;
188               VKnot=InitSurf->NbVKnots()-1;
189               while(IsQPunc) 
190               {
191                 OsculSurf = BuildOsculatingSurface(V2,UKnot,VKnot,S,L);
192                 if(!OsculSurf) break;
193                 k++;
194 #ifdef OCCT_DEBUG
195                 std::cout<<"2.k = "<<k<<std::endl;
196 #endif
197                 IsQPunc=IsQPunctual(L,V2,GeomAbs_IsoV,0.,Tol);
198                 UKnot=1;
199                 VKnot=1;
200                 S=L;
201
202               }
203               if(OsculSurf)
204               {
205                 myOsculSurf2->Append(L);
206                 myKdeg->Append(k);
207               }
208               else
209                 ClearOsculFlags(); //myAlong.SetValue(2,Standard_False);
210             }
211           }
212         }
213         if (myAlong(3) || myAlong(4)) 
214         {
215           for (i=1;i<InitSurf->NbVKnots();i++) 
216           {
217             if (myAlong(3)) 
218             {
219               S = InitSurf; k=0; IsQPunc=Standard_True;
220               UKnot=1;
221               VKnot=i;
222               while(IsQPunc) 
223               {
224                 OsculSurf = BuildOsculatingSurface(U1,UKnot,VKnot,S,L);
225                 if(!OsculSurf) break;
226                 k++;
227 #ifdef OCCT_DEBUG
228                 std::cout<<"1.k = "<<k<<std::endl;
229 #endif
230                 IsQPunc=IsQPunctual(L,U1,GeomAbs_IsoU,0.,Tol);
231                 UKnot=1;
232                 VKnot=1;
233                 S=L;
234               }
235               if(OsculSurf)
236                 myOsculSurf1->Append(L);
237               else
238                 ClearOsculFlags(); //myAlong.SetValue(3,Standard_False);
239               if (myAlong(4) && OsculSurf )
240               {
241                 S = InitSurf; k=0; IsQPunc=Standard_True;
242                 UKnot=InitSurf->NbUKnots()-1;
243                 VKnot=i;
244                 while(IsQPunc) 
245                 {
246                   OsculSurf  = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
247                   if(!OsculSurf) break;
248                   k++;
249 #ifdef OCCT_DEBUG
250                   std::cout<<"2.k = "<<k<<std::endl;
251 #endif
252                   IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
253                   UKnot=1;
254                   VKnot=1;
255                   S=L;
256                 }
257                 if(OsculSurf)
258                 {
259                   myOsculSurf2->Append(L);
260                   myKdeg->Append(k);
261                 }
262               }
263             }
264             else 
265             {
266               S = InitSurf; k=0; IsQPunc=Standard_True;
267               UKnot=InitSurf->NbUKnots()-1;
268               VKnot=i;
269               while(IsQPunc) 
270               {
271                 OsculSurf  = BuildOsculatingSurface(U2,UKnot,VKnot,S,L);
272                 if(!OsculSurf) break;
273                 k++;
274 #ifdef OCCT_DEBUG
275                 std::cout<<"2.k = "<<k<<std::endl;
276 #endif
277                 IsQPunc=IsQPunctual(L,U2,GeomAbs_IsoU,0.,Tol);
278                 UKnot=1;
279                 VKnot=1;
280                 S=L;
281               }
282               if(OsculSurf)
283               {
284                 myOsculSurf2->Append(L);
285                 myKdeg->Append(k);
286               }
287               else
288                 ClearOsculFlags(); //myAlong.SetValue(4,Standard_False);
289             }
290           }
291         }
292       }
293       else
294       {
295         ClearOsculFlags();
296       } 
297     }
298   }
299   else
300     ClearOsculFlags();
301 }
302
303 //=======================================================================
304 //function : BasisSurface
305 //purpose  : 
306 //=======================================================================
307
308 Handle(Geom_Surface) Geom_OsculatingSurface::BasisSurface() const
309 {
310   return myBasisSurf;
311 }
312
313 //=======================================================================
314 //function : Tolerance
315 //purpose  : 
316 //=======================================================================
317
318 Standard_Real Geom_OsculatingSurface::Tolerance() const
319 {
320   return myTol;
321 }
322
323 //=======================================================================
324 //function : UOscSurf
325 //purpose  : 
326 //=======================================================================
327
328 Standard_Boolean Geom_OsculatingSurface::UOscSurf
329   (const Standard_Real U,
330   const Standard_Real V,
331   Standard_Boolean& t,
332   Handle(Geom_BSplineSurface)& L) const
333 {
334   Standard_Boolean along = Standard_False;
335   if (myAlong(1) || myAlong(2)) 
336   {
337     Standard_Integer NU = 1, NV = 1;
338     Standard_Real u1,u2,v1,v2;
339     t = Standard_False;
340     myBasisSurf->Bounds(u1,u2,v1,v2);
341     Standard_Integer NbUK,NbVK;
342     Standard_Boolean isToSkipSecond = Standard_False;
343     if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) 
344     {
345       Handle(Geom_BSplineSurface) BSur = 
346         Handle(Geom_BSplineSurface)::DownCast (myBasisSurf);
347       NbUK = BSur->NbUKnots();
348       NbVK = BSur->NbVKnots();
349       TColStd_Array1OfReal UKnots(1,NbUK);
350       TColStd_Array1OfReal VKnots(1,NbVK);
351       BSur->UKnots(UKnots);
352       BSur->VKnots(VKnots);
353       BSplCLib::Hunt(UKnots,U,NU);
354       BSplCLib::Hunt(VKnots,V,NV);
355       if (NU < 1) NU=1;
356       if (NU >= NbUK) NU=NbUK-1;
357       if (NbVK==2 && NV==1)
358         // Need to find the closest end
359         if (VKnots(NbVK)-V > V-VKnots(1))
360           isToSkipSecond = Standard_True;
361     }
362     else {NU = 1; NV = 1 ; NbVK = 2 ;}
363
364     if (myAlong(1) && NV == 1) 
365     {
366       L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf1->Value(NU));
367       along = Standard_True;
368     }
369     if (myAlong(2) && (NV == NbVK-1) && !isToSkipSecond)
370     {
371       // t means that derivative vector of osculating surface is opposite
372       // to the original. This happens when (v-t)^k is negative, i.e.
373       // difference between degrees (k) is odd and t is the last parameter
374       if (myKdeg->Value(NU)%2) t = Standard_True;
375       L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf2->Value(NU));
376       along = Standard_True;
377     }
378   }
379   return along;
380 }
381
382 //=======================================================================
383 //function : VOscSurf
384 //purpose  : 
385 //=======================================================================
386
387 Standard_Boolean Geom_OsculatingSurface::VOscSurf
388   (const Standard_Real U,
389   const Standard_Real V,
390   Standard_Boolean& t,
391   Handle(Geom_BSplineSurface)& L) const
392 {
393   Standard_Boolean along = Standard_False;
394   if (myAlong(3) || myAlong(4)) 
395   {
396     Standard_Integer NU = 1, NV = 1;
397     Standard_Real u1,u2,v1,v2;
398     t = Standard_False;
399     myBasisSurf->Bounds(u1,u2,v1,v2);
400     Standard_Integer NbUK,NbVK;
401     Standard_Boolean isToSkipSecond = Standard_False;
402     if (myBasisSurf->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) 
403     {
404       Handle(Geom_BSplineSurface) BSur = 
405         Handle(Geom_BSplineSurface)::DownCast (myBasisSurf);
406       NbUK = BSur->NbUKnots();
407       NbVK = BSur->NbVKnots();
408       TColStd_Array1OfReal UKnots(1,NbUK);
409       TColStd_Array1OfReal VKnots(1,NbVK);
410       BSur->UKnots(UKnots);
411       BSur->VKnots(VKnots);
412       BSplCLib::Hunt(UKnots,U,NU);
413       BSplCLib::Hunt(VKnots,V,NV);
414       if (NV < 1) NV=1;
415       if (NV >= NbVK) NV=NbVK-1;
416       if (NbUK==2 && NU==1)
417         // Need to find the closest end
418         if (UKnots(NbUK)-U > U-UKnots(1))
419           isToSkipSecond = Standard_True;
420     }
421     else {NU = 1; NV = 1 ; NbUK = 2;}
422
423     if (myAlong(3) && NU == 1)  
424     {
425       L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf1->Value(NV));
426       along = Standard_True;
427     }
428     if (myAlong(4) && (NU == NbUK-1) && !isToSkipSecond)
429     {
430       if (myKdeg->Value(NV)%2) t = Standard_True;
431       L = *((Handle(Geom_BSplineSurface)*)& myOsculSurf2->Value(NV));
432       along = Standard_True;
433     }
434   }
435   return along;
436 }
437
438 //=======================================================================
439 //function : BuildOsculatingSurface
440 //purpose  : 
441 //=======================================================================
442
443 Standard_Boolean  Geom_OsculatingSurface::BuildOsculatingSurface
444   (const Standard_Real Param,
445   const Standard_Integer SUKnot,
446   const Standard_Integer SVKnot,
447   const Handle(Geom_BSplineSurface)& BS,
448   Handle(Geom_BSplineSurface)& BSpl) const
449 {
450   Standard_Boolean OsculSurf=Standard_True;
451 #ifdef OCCT_DEBUG
452   std::cout<<"t = "<<Param<<std::endl;
453   std::cout<<"======================================"<<std::endl<<std::endl;
454 #endif
455
456   // for cache
457   Standard_Integer MinDegree,
458     MaxDegree ;
459   Standard_Real udeg, vdeg;
460   udeg = BS->UDegree();
461   vdeg = BS->VDegree();
462   if( (IsAlongU() && vdeg <=1) || (IsAlongV() && udeg <=1))
463   {
464 #ifdef OCCT_DEBUG
465     std::cout<<" surface osculatrice nulle "<<std::endl;
466 #endif
467     //throw Standard_ConstructionError("Geom_OsculatingSurface");
468     OsculSurf=Standard_False;
469   }
470   else
471   {
472     MinDegree = (Standard_Integer ) Min(udeg,vdeg) ;
473     MaxDegree = (Standard_Integer ) Max(udeg,vdeg) ;
474
475     TColgp_Array2OfPnt cachepoles(1, MaxDegree + 1, 1, MinDegree + 1);
476     // end for cache
477
478     // for polynomial grid 
479     Standard_Integer MaxUDegree, MaxVDegree;
480     Standard_Integer UContinuity, VContinuity;
481
482     Handle(TColStd_HArray2OfInteger) NumCoeffPerSurface = 
483       new TColStd_HArray2OfInteger(1, 1, 1, 2);
484     Handle(TColStd_HArray1OfReal) PolynomialUIntervals = 
485       new TColStd_HArray1OfReal(1, 2);
486     Handle(TColStd_HArray1OfReal) PolynomialVIntervals = 
487       new TColStd_HArray1OfReal(1, 2);
488     Handle(TColStd_HArray1OfReal) TrueUIntervals = 
489       new TColStd_HArray1OfReal(1, 2);
490     Handle(TColStd_HArray1OfReal) TrueVIntervals = 
491       new TColStd_HArray1OfReal(1, 2);
492     MaxUDegree = (Standard_Integer ) udeg;
493     MaxVDegree = (Standard_Integer ) vdeg;
494
495     for (Standard_Integer i = 1; i <= 2; i++) 
496     {
497       PolynomialUIntervals->ChangeValue(i) = i-1;
498       PolynomialVIntervals->ChangeValue(i) = i-1;
499       TrueUIntervals->ChangeValue(i) = BS->UKnot(SUKnot+i-1);
500       TrueVIntervals->ChangeValue(i) = BS->VKnot(SVKnot+i-1);
501     }
502
503
504     Standard_Integer OscUNumCoeff=0, OscVNumCoeff=0;
505     if (IsAlongU()) 
506     {
507 #ifdef OCCT_DEBUG
508       std::cout<<">>>>>>>>>>> AlongU"<<std::endl;
509 #endif
510       OscUNumCoeff = (Standard_Integer ) udeg + 1;  
511       OscVNumCoeff = (Standard_Integer ) vdeg;  
512     }
513     if (IsAlongV()) 
514     {
515 #ifdef OCCT_DEBUG
516       std::cout<<">>>>>>>>>>> AlongV"<<std::endl;
517 #endif
518       OscUNumCoeff = (Standard_Integer ) udeg;  
519       OscVNumCoeff = (Standard_Integer ) vdeg + 1;  
520     }
521     NumCoeffPerSurface->ChangeValue(1,1) = OscUNumCoeff;  
522     NumCoeffPerSurface->ChangeValue(1,2) = OscVNumCoeff;  
523     Standard_Integer nbc = NumCoeffPerSurface->Value(1,1)*NumCoeffPerSurface->Value(1,2)*3;
524     //
525     if(nbc == 0)
526     {
527       return Standard_False;
528     }
529     //
530     Handle(TColStd_HArray1OfReal) Coefficients = new TColStd_HArray1OfReal(1, nbc);
531     //    end for polynomial grid
532
533     //    building the cache
534     Standard_Integer ULocalIndex, VLocalIndex;
535     Standard_Real ucacheparameter, vcacheparameter,uspanlength, vspanlength;
536     TColgp_Array2OfPnt NewPoles(1, BS->NbUPoles(), 1, BS->NbVPoles());
537
538     Standard_Integer aUfKnotsLength = BS->NbUPoles() + BS->UDegree() + 1;
539     Standard_Integer aVfKnotsLength = BS->NbVPoles() + BS->VDegree() + 1;
540
541     if(BS->IsUPeriodic())
542     {
543       TColStd_Array1OfInteger aMults(1, BS->NbUKnots());
544       BS->UMultiplicities(aMults);
545       aUfKnotsLength = BSplCLib::KnotSequenceLength(aMults, BS->UDegree(), Standard_True);
546     }
547
548     if(BS->IsVPeriodic())
549     {
550       TColStd_Array1OfInteger aMults(1, BS->NbVKnots());
551       BS->VMultiplicities(aMults);
552       aVfKnotsLength = BSplCLib::KnotSequenceLength(aMults, BS->VDegree(), Standard_True);
553     }
554
555     TColStd_Array1OfReal UFlatKnots(1, aUfKnotsLength);
556     TColStd_Array1OfReal VFlatKnots(1, aVfKnotsLength);
557     BS->Poles(NewPoles);
558     BS->UKnotSequence(UFlatKnots);
559     BS->VKnotSequence(VFlatKnots);
560
561     VLocalIndex = 0;
562     ULocalIndex = 0;
563     ucacheparameter = BS->UKnot(SUKnot);
564     vcacheparameter = BS->VKnot(SVKnot);
565     vspanlength = BS->VKnot(SVKnot + 1) - BS->VKnot(SVKnot);
566     uspanlength = BS->UKnot(SUKnot + 1) - BS->UKnot(SUKnot);
567
568     // On se ramene toujours a un parametrage tel que localement ce soit l'iso 
569     // u=0 ou v=0 qui soit degeneree
570
571     Standard_Boolean IsVNegative = Param > vcacheparameter + vspanlength/2;
572     Standard_Boolean IsUNegative = Param > ucacheparameter + uspanlength/2;
573
574     if (IsAlongU() && (Param > vcacheparameter + vspanlength/2))
575       vcacheparameter = vcacheparameter +  vspanlength;
576     if (IsAlongV() && (Param > ucacheparameter + uspanlength/2))
577       ucacheparameter = ucacheparameter +  uspanlength;
578
579     BSplSLib::BuildCache(ucacheparameter,   
580       vcacheparameter,   
581       uspanlength,         
582       vspanlength,         
583       BS->IsUPeriodic(),
584       BS->IsVPeriodic(),
585       BS->UDegree(),       
586       BS->VDegree(),       
587       ULocalIndex,         
588       VLocalIndex,         
589       UFlatKnots,
590       VFlatKnots,
591       NewPoles,
592       BSplSLib::NoWeights(),
593       cachepoles,
594       BSplSLib::NoWeights());
595     Standard_Integer m, n, index;
596     TColgp_Array2OfPnt OscCoeff(1,OscUNumCoeff , 1, OscVNumCoeff);
597
598     if (IsAlongU()) 
599     {
600       if (udeg > vdeg) 
601       {
602         for(n = 1; n <= udeg + 1; n++) 
603           for(m = 1; m <= vdeg; m++)
604             OscCoeff(n,m) = cachepoles(n,m+1) ;
605       }
606       else
607       {
608         for(n = 1; n <= udeg + 1; n++) 
609           for(m = 1; m <= vdeg; m++)
610             OscCoeff(n,m) = cachepoles(m+1,n) ;
611       }
612       if (IsVNegative) PLib::VTrimming(-1,0,OscCoeff,PLib::NoWeights2());
613
614       index=1;
615       for(n = 1; n <= udeg + 1; n++) 
616         for(m = 1; m <= vdeg; m++)
617         {
618           Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
619           Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
620           Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
621         }
622     }
623
624     if (IsAlongV()) 
625     {
626       if (udeg > vdeg) 
627       {
628         for(n = 1; n <= udeg; n++) 
629           for(m = 1; m <= vdeg + 1; m++)
630             OscCoeff(n,m) = cachepoles(n+1,m);
631       }
632       else
633       {
634         for(n = 1; n <= udeg; n++) 
635           for(m = 1; m <= vdeg + 1; m++)
636             OscCoeff(n,m) = cachepoles(m,n+1);
637       }
638       if (IsUNegative) PLib::UTrimming(-1,0,OscCoeff,PLib::NoWeights2());
639       index=1;
640       for(n = 1; n <= udeg; n++) 
641         for(m = 1; m <= vdeg + 1; m++)
642         {
643           Coefficients->ChangeValue(index++) = OscCoeff(n,m).X();
644           Coefficients->ChangeValue(index++) = OscCoeff(n,m).Y();
645           Coefficients->ChangeValue(index++) = OscCoeff(n,m).Z();
646         }
647     }
648
649     if (IsAlongU()) MaxVDegree--;
650     if (IsAlongV()) MaxUDegree--;
651     UContinuity = - 1;
652     VContinuity = - 1;
653
654     Convert_GridPolynomialToPoles Data(1,1,
655       UContinuity,
656       VContinuity,
657       MaxUDegree,
658       MaxVDegree,
659       NumCoeffPerSurface,
660       Coefficients,
661       PolynomialUIntervals,
662       PolynomialVIntervals,
663       TrueUIntervals,
664       TrueVIntervals);
665
666     //      Handle(Geom_BSplineSurface) BSpl = 
667     BSpl =new Geom_BSplineSurface(Data.Poles()->Array2(),
668       Data.UKnots()->Array1(),
669       Data.VKnots()->Array1(),
670       Data.UMultiplicities()->Array1(),
671       Data.VMultiplicities()->Array1(),
672       Data.UDegree(),
673       Data.VDegree(),
674       0, 0);
675 #ifdef OCCT_DEBUG
676     std::cout<<"^====================================^"<<std::endl<<std::endl;
677 #endif
678
679     //      L=BSpl;
680   }
681   return OsculSurf;
682 }
683
684 //=======================================================================
685 //function : IsQPunctual
686 //purpose  : 
687 //=======================================================================
688
689 Standard_Boolean Geom_OsculatingSurface::IsQPunctual
690   (const Handle(Geom_Surface)& S,
691   const Standard_Real         Param,
692   const GeomAbs_IsoType       IT,
693   const Standard_Real         TolMin,
694   const Standard_Real         TolMax) const
695 {
696   Standard_Real U1=0,U2=0,V1=0,V2=0,T;
697   Standard_Boolean Along = Standard_True;
698   S->Bounds(U1,U2,V1,V2);
699   gp_Vec D1U,D1V;
700   gp_Pnt P;
701   Standard_Real Step,D1NormMax;
702   if (IT == GeomAbs_IsoV) 
703   {
704     Step = (U2 - U1)/10;
705     D1NormMax=0.;
706     for (T=U1;T<=U2;T=T+Step) 
707     {
708       S->D1(T,Param,P,D1U,D1V);
709       D1NormMax=Max(D1NormMax,D1U.Magnitude());
710     }
711
712 #ifdef OCCT_DEBUG
713     std::cout << " D1NormMax = " << D1NormMax << std::endl;
714 #endif
715     if (D1NormMax >TolMax || D1NormMax < TolMin ) 
716       Along = Standard_False;
717   }
718   else 
719   {
720     Step = (V2 - V1)/10;
721     D1NormMax=0.;
722     for (T=V1;T<=V2;T=T+Step) 
723     {
724       S->D1(Param,T,P,D1U,D1V);
725       D1NormMax=Max(D1NormMax,D1V.Magnitude());
726     }
727 #ifdef OCCT_DEBUG
728     std::cout << " D1NormMax = " << D1NormMax << std::endl;
729 #endif
730     if (D1NormMax >TolMax || D1NormMax < TolMin ) 
731       Along = Standard_False;
732
733
734   }
735   return Along;
736 }
737
738 //=======================================================================
739 //function : HasOscSurf
740 //purpose  : 
741 //=======================================================================
742
743 Standard_Boolean Geom_OsculatingSurface::HasOscSurf() const
744 {
745   return (myAlong(1) || myAlong(2) || myAlong(3) || myAlong(4));
746 }
747
748 //=======================================================================
749 //function : IsAlongU
750 //purpose  : 
751 //=======================================================================
752
753 Standard_Boolean Geom_OsculatingSurface::IsAlongU() const
754 {
755   return (myAlong(1) || myAlong(2));
756 }
757 //=======================================================================
758 //function : IsAlongV
759 //purpose  : 
760 //=======================================================================
761
762 Standard_Boolean Geom_OsculatingSurface::IsAlongV() const
763 {
764   return (myAlong(3) || myAlong(4));
765 }
766
767
768 //=======================================================================
769 //function : IsGetSeqOfL1
770 //purpose  : 
771 //=======================================================================
772
773 const Geom_SequenceOfBSplineSurface& Geom_OsculatingSurface::GetSeqOfL1() const
774 {
775   return myOsculSurf1->Sequence();
776 }
777 //=======================================================================
778 //function : IsGetSeqOfL2
779 //purpose  : 
780 //=======================================================================
781
782 const Geom_SequenceOfBSplineSurface& Geom_OsculatingSurface::GetSeqOfL2() const
783 {
784   return myOsculSurf2->Sequence();
785 }
786 //=======================================================================
787 //function : ClearOsculFlags
788 //purpose  : 
789 //=======================================================================
790
791 void Geom_OsculatingSurface::ClearOsculFlags()
792 {
793   myAlong.SetValue(1,Standard_False);
794   myAlong.SetValue(2,Standard_False);
795   myAlong.SetValue(3,Standard_False);
796   myAlong.SetValue(4,Standard_False);
797
798 }
799
800 //=======================================================================
801 //function : DumpJson
802 //purpose  : 
803 //=======================================================================
804 void Geom_OsculatingSurface::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
805 {
806   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
807
808   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, myBasisSurf.get())
809   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myTol)
810
811   if (!myOsculSurf1.IsNull())
812     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myOsculSurf1->Size())
813   if (!myOsculSurf2.IsNull())
814     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myOsculSurf2->Size())
815   if (!myKdeg.IsNull())
816     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myKdeg->Size())
817
818   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myAlong.Size())
819 }