0032402: Coding Rules - eliminate msvc warning C4668 (symbol is not defined as a...
[occt.git] / src / GeomFill / GeomFill_CircularBlendFunc.cxx
1 // Created on: 1997-07-11
2 // Created by: Philippe MANGIN
3 // Copyright (c) 1997-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
18 #include <Adaptor3d_Curve.hxx>
19 #include <GCPnts_QuasiUniformDeflection.hxx>
20 #include <GeomFill.hxx>
21 #include <GeomFill_CircularBlendFunc.hxx>
22 #include <gp_Pnt.hxx>
23 #include <Precision.hxx>
24 #include <Standard_OutOfRange.hxx>
25 #include <Standard_Type.hxx>
26 #include <TColStd_Array1OfReal.hxx>
27 #include <TColStd_SequenceOfReal.hxx>
28
29 IMPLEMENT_STANDARD_RTTIEXT(GeomFill_CircularBlendFunc,Approx_SweepFunction)
30
31 #ifdef DRAW
32 #include <GeomAdaptor_Curve.hxx>
33 #include <Geom_BSplineCurve.hxx>
34 #include <DrawTrSurf.hxx>
35 static Standard_Integer NbSections = 0;
36 #endif
37
38 static const Standard_Real TolAng = 1.e-6;
39
40 static GeomAbs_Shape GeomFillNextShape(const GeomAbs_Shape S)
41 {
42   switch (S) {
43   case GeomAbs_C0 :
44     return  GeomAbs_C1;
45   case GeomAbs_C1 :
46     return  GeomAbs_C2;
47   case GeomAbs_C2 :
48     return  GeomAbs_C3;
49   case GeomAbs_C3 :
50     return  GeomAbs_CN;
51   default :
52     return  GeomAbs_CN;
53   }
54 }
55
56 static void GeomFillFusInt(const TColStd_Array1OfReal& I1,
57                     const TColStd_Array1OfReal& I2,
58                     TColStd_SequenceOfReal& Seq)
59 {
60   Standard_Integer ind1=1, ind2=1;
61   Standard_Real    Epspar = Precision::PConfusion()*0.99;
62   // en suposant que le positionement fonctionne a PConfusion()/2
63   Standard_Real    v1, v2;
64 // Initialisations : les IND1 et IND2 pointent sur le 1er element
65 // de chacune des 2 tables a traiter.
66
67
68 //--- On remplit TABSOR en parcourant TABLE1 et TABLE2 simultanement ---
69 //------------------ en eliminant les occurrences multiples ------------
70
71  while ((ind1<=I1.Upper()) && (ind2<=I2.Upper())) {
72       v1 = I1(ind1);
73       v2 = I2(ind2);
74       if (Abs(v1-v2)<= Epspar) {
75 // Ici les elements de I1 et I2 conviennent .
76          Seq.Append((v1+v2)/2);
77          ind1++;
78          ind2++;
79        }
80       else if (v1 < v2) {
81         // Ici l' element de I1 convient.
82          Seq.Append(v1);
83          ind1++;
84        }
85       else {
86 // Ici l' element de TABLE2 convient.
87          Seq.Append(v2);
88          ind2++;
89        }
90     }
91
92   if (ind1>I1.Upper()) { 
93 //----- Ici I1 est epuise, on complete avec la fin de TABLE2 -------
94
95     for (; ind2<=I2.Upper(); ind2++) {
96       Seq.Append(I2(ind2));
97     }
98   }
99
100   if (ind2>I2.Upper()) { 
101 //----- Ici I2 est epuise, on complete avec la fin de I1 -------
102
103     for (; ind1<=I1.Upper(); ind1++) {
104       Seq.Append(I1(ind1));
105     }
106   }
107 }
108
109
110 GeomFill_CircularBlendFunc::
111 GeomFill_CircularBlendFunc(const Handle(Adaptor3d_Curve)& Path,
112                            const Handle(Adaptor3d_Curve)& Curve1,
113                            const Handle(Adaptor3d_Curve)& Curve2,
114                            const Standard_Real Radius,
115                            const Standard_Boolean Polynomial) 
116                            : maxang(RealFirst()), 
117                              minang(RealLast()),
118                              distmin(RealLast())
119 {
120   // Recopie des arguments
121   myPath = myTPath = Path;
122   myCurve1 = myTCurve1 = Curve1;
123   myCurve2 = myTCurve2 = Curve2;
124   myRadius =  Radius;
125
126   // Estimations numeriques
127   Discret();
128
129   // Type de convertion ?
130   if (Polynomial) myTConv=Convert_Polynomial;
131   else if(maxang > 0.65*M_PI) 
132     myTConv=Convert_QuasiAngular; //car c'est Continue
133   else   myTConv = Convert_TgtThetaOver2; 
134                   //car c'est le plus performant 
135
136   // On en deduit la structure 
137   GeomFill::GetShape(maxang, 
138                      myNbPoles, myNbKnots, 
139                      myDegree, myTConv); 
140 }
141
142 void GeomFill_CircularBlendFunc::Discret()
143 {
144   Standard_Real TFirst =  myPath->FirstParameter();
145   Standard_Real TLast =  myPath->LastParameter(), T;
146   Standard_Integer ii;
147   Standard_Real L1, L2, L;
148   Handle(Adaptor3d_Curve) C;
149   gp_Pnt P1, P2, P3, Center;
150   gp_Vec DCenter;
151  
152   P1 = myCurve1->Value(TFirst);
153   P2 = myCurve1->Value((TFirst+TLast)/2.);
154   P3 = myCurve1->Value(TLast);
155   L1 = P1.Distance(P2) + P2.Distance(P3);
156
157   P1 = myCurve2->Value(TFirst);
158   P2 = myCurve2->Value((TFirst+TLast)/2.);
159   P3 = myCurve2->Value(TLast);
160   L2 = P1.Distance(P2) + P2.Distance(P3);
161
162   if (L1>L2) { 
163     L = L1;
164     C = myCurve1;
165   }
166   else {
167    L = L2;
168    C = myCurve2;    
169   }
170
171   Standard_Real Fleche = 1.e-2 * L;
172   Standard_Real Angle, Cosa, Percent;
173   GCPnts_QuasiUniformDeflection Samp;
174   Samp.Initialize (*C, Fleche);
175   myBary.SetCoord(0.,0.,0.);
176   gp_Vec ns1, ns2;
177
178   if (Samp.IsDone()) {
179     Percent = ((Standard_Real)1)/(2*Samp.NbPoints());
180 //    char name[100];
181     for (ii=1; ii<=Samp.NbPoints(); ii++) {
182       T = Samp.Parameter(ii); 
183       myCurve1->D0(T, P1);
184       myCurve2->D0(T, P2);
185 /*
186       sprintf(name,"PNT_%d",NbSections++);
187       DrawTrSurf::Set(name, P1);
188       sprintf(name,"PNT_%d",NbSections++);
189       DrawTrSurf::Set(name, P2);*/
190       myPath->D0(T, Center);      
191       ns1.SetXYZ( Center.XYZ() - P1.XYZ());
192       ns2.SetXYZ( Center.XYZ() - P2.XYZ());
193       ns1.Normalize();
194       ns2.Normalize();
195       Cosa = ns1.Dot(ns2);
196       if(Cosa > 1.) {Cosa = 1.;}
197       Angle = Abs(ACos(Cosa));
198       if (Angle>maxang) maxang = Angle;
199       if (Angle<minang) minang = Angle;
200       distmin = Min( distmin, P1.Distance(P2));
201       myBary.ChangeCoord() += (P1.XYZ()+P2.XYZ());
202     }
203   }
204   else {  
205     Standard_Real Delta = (TLast-TFirst)/20;
206     Percent = ((Standard_Real)1)/42;
207     for (ii=0, T=TFirst; ii<=20; ii++, T+=Delta) {
208       myCurve1->D0(T, P1);
209       myCurve2->D0(T, P2); 
210       myPath->D0(T, Center); 
211      
212       ns1.SetXYZ( Center.XYZ() - P1.XYZ());
213       ns2.SetXYZ( Center.XYZ() - P2.XYZ());
214       ns1.Normalize();
215       ns2.Normalize();
216       Cosa = ns1.Dot(ns2);
217       if(Cosa > 1.) Cosa = 1.;
218       Angle = Abs(ACos(Cosa));
219
220       if (Angle>maxang) maxang = Angle;
221       if (Angle<minang) minang = Angle;
222       distmin = Min( distmin, P1.Distance(P2));
223       myBary.ChangeCoord() += (P1.XYZ()+P2.XYZ());
224     }
225   } 
226   myBary.ChangeCoord() *= Percent;
227
228   // Faut il inverser la trajectoire ?
229   T = (TFirst + TLast)/2;
230   myCurve1->D0(T, P1);
231   myCurve2->D0(T, P2);
232   myPath->D1(T, Center, DCenter);
233  
234   ns1.SetXYZ( Center.XYZ() - P1.XYZ());
235   ns2.SetXYZ( Center.XYZ() - P2.XYZ());     
236
237   //myreverse = (DCenter.Dot(ns1.Crossed(ns2)) < 0);
238   myreverse = Standard_False;
239 }
240
241
242
243 Standard_Boolean GeomFill_CircularBlendFunc::D0(const Standard_Real Param,
244                                                 const Standard_Real,
245                                                 const Standard_Real,
246                                                 TColgp_Array1OfPnt& Poles,
247                                                 TColgp_Array1OfPnt2d&,
248                                                 TColStd_Array1OfReal& Weigths) 
249 {
250   gp_Pnt P1, P2, Center;
251   gp_Vec ns1, ns2, nplan;
252   gp_XYZ temp;
253
254 // Positionnement
255   myTPath->D0(Param, Center);
256   myTCurve1->D0(Param, P1);
257   myTCurve2->D0(Param, P2);
258   ns1.SetXYZ( Center.XYZ() - P1.XYZ());
259   ns2.SetXYZ( Center.XYZ() - P2.XYZ());
260   if (!ns1.IsParallel(ns2, TolAng))  nplan = ns1.Crossed(ns2);
261   else {
262     myTPath->D1(Param, Center, nplan);
263     if (myreverse) nplan.Reverse();
264   }
265
266 // Normalisation
267   ns1.Normalize();
268   ns2.Normalize();
269   nplan.Normalize(); 
270
271   temp.SetLinearForm(myRadius, ns1.XYZ(),
272                      myRadius, ns2.XYZ(),
273                      1, P1.XYZ(),
274                      P2.XYZ());
275   Center.ChangeCoord() = 0.5*temp;
276     
277   // Section
278   GeomFill::GetCircle(myTConv, 
279                       ns1, ns2, nplan,
280                       P1, P2, 
281                       myRadius, Center,
282                       Poles,  Weigths);  
283
284 #ifdef DRAW
285 //  Handle(Geom_BSplineCurve) BS = 
286 //    new Geom_BSplineCurve(Poles,Weights,Knots,Mults,Degree);
287 //  sprintf(name,"SECT_%d",NbSections++);
288 //  DrawTrSurf::Set(name,BS);
289 #endif
290   return Standard_True;
291 }
292
293
294 Standard_Boolean GeomFill_CircularBlendFunc::D1(const Standard_Real Param,
295 //                                              const Standard_Real First,
296                                                 const Standard_Real ,
297 //                                              const Standard_Real Last,
298                                                 const Standard_Real ,
299                                                 TColgp_Array1OfPnt& Poles,
300                                                 TColgp_Array1OfVec& DPoles,
301 //                                              TColgp_Array1OfPnt2d& Poles2d,
302                                                 TColgp_Array1OfPnt2d& ,
303 //                                              TColgp_Array1OfVec2d& DPoles2d,
304                                                 TColgp_Array1OfVec2d& ,
305                                                 TColStd_Array1OfReal& Weigths,
306                                                 TColStd_Array1OfReal& DWeigths) 
307 {
308   gp_Pnt P1, P2, Center;
309   Standard_Real invnorm1, invnorm2, invnormp;
310 //  gp_Vec DCenter, D2Center, nplan, dnplan, DP1, DP2;
311   gp_Vec DCenter, nplan, dnplan, DP1, DP2;
312 //  gp_Vec ns1, ns2, Dns1, Dns2, vtmp;
313   gp_Vec ns1, ns2, Dns1, Dns2;
314   gp_XYZ temp;
315
316 // Positionemment
317   myTPath  ->D1(Param, Center, DCenter);
318   myTCurve1->D1(Param, P1, DP1);
319   myTCurve2->D1(Param, P2, DP2);
320
321   ns1.SetXYZ( Center.XYZ() - P1.XYZ());
322   ns2.SetXYZ( Center.XYZ() - P2.XYZ());
323   Dns1 = DCenter - DP1;
324   Dns2 = DCenter - DP2;
325  
326   if (!ns1.IsParallel(ns2, TolAng)) {
327     nplan = ns1.Crossed(ns2);
328     dnplan =  Dns1.Crossed(ns2).Added( ns1.Crossed(Dns2));
329   }
330   else {
331     myTPath->D2(Param, Center, nplan, dnplan);
332     if (myreverse) {
333       nplan.Reverse();
334       dnplan.Reverse();
335     }
336   }
337
338 // Normalisation
339   invnorm1 = ((Standard_Real) 1) / ns1.Magnitude();
340   invnorm2 = ((Standard_Real) 1) / ns2.Magnitude(); 
341
342   ns1 *= invnorm1;
343   Dns1.SetLinearForm( -Dns1.Dot(ns1), ns1, Dns1);
344   Dns1 *= invnorm1; 
345       
346   ns2 *= invnorm2;
347   Dns2.SetLinearForm(-Dns2.Dot(ns2), ns2, Dns2);
348   Dns2 *= invnorm2;
349
350   temp.SetLinearForm(myRadius, ns1.XYZ(),
351                      myRadius, ns2.XYZ(),
352                      1, P1.XYZ(), P2.XYZ());       
353   Center.ChangeCoord() = 0.5*temp;
354   DCenter.SetLinearForm(myRadius, Dns1,
355                         myRadius, Dns2,
356                         1, DP1, DP2);
357   DCenter *= 0.5;
358     
359   invnormp = ((Standard_Real)1) / nplan.Magnitude();
360   nplan *= invnormp;
361   dnplan.SetLinearForm(-dnplan.Dot(nplan), nplan, dnplan);
362   dnplan *= invnormp;
363  
364   GeomFill::GetCircle(myTConv, 
365                       ns1, ns2, 
366                       Dns1, Dns2,
367                       nplan, dnplan,
368                       P1, P2,
369                       DP1, DP2,
370                       myRadius, 0,
371                       Center, DCenter,
372                       Poles,  DPoles,
373                       Weigths, DWeigths);
374   return Standard_True;
375 }
376
377 Standard_Boolean GeomFill_CircularBlendFunc::D2(const Standard_Real Param,
378 //                                              const Standard_Real First,
379                                                 const Standard_Real ,
380 //                                              const Standard_Real Last,
381                                                 const Standard_Real ,
382                                                 TColgp_Array1OfPnt& Poles,
383                                                 TColgp_Array1OfVec& DPoles,
384                                                 TColgp_Array1OfVec& D2Poles,
385 //                                              TColgp_Array1OfPnt2d& Poles2d,
386                                                 TColgp_Array1OfPnt2d& ,
387 //                                              TColgp_Array1OfVec2d& DPoles2d,
388                                                 TColgp_Array1OfVec2d& ,
389 //                                              TColgp_Array1OfVec2d& D2Poles2d,
390                                                 TColgp_Array1OfVec2d& ,
391                                                 TColStd_Array1OfReal& Weigths,
392                                                 TColStd_Array1OfReal& DWeigths,
393                                                 TColStd_Array1OfReal& D2Weigths) 
394 {
395   gp_Pnt P1, P2, Center;
396   Standard_Real invnorm1, invnorm2, invnormp, sc;
397   gp_Vec DCenter, D2Center, DP1, DP2, D2P1, D2P2;
398   gp_Vec nplan, dnplan, d2nplan;
399   gp_Vec ns1, ns2, Dns1, Dns2, D2ns1, D2ns2;
400   gp_XYZ temp;
401
402   // Positionement
403   myTPath  ->D2(Param, Center, DCenter, D2Center);
404   myTCurve1->D2(Param, P1, DP1, D2P1);
405   myTCurve2->D2(Param, P2, DP2, D2P2);
406
407   ns1.SetXYZ( Center.XYZ() - P1.XYZ());
408   Dns1 = DCenter - DP1;
409   D2ns1 =  D2Center - D2P1;  
410   ns2.SetXYZ( Center.XYZ() - P2.XYZ());
411   Dns2 = DCenter - DP2;
412   D2ns2 =  D2Center - D2P2;
413
414   if (!ns1.IsParallel(ns2, TolAng)) {
415     nplan = ns1.Crossed(ns2);
416     dnplan = Dns1.Crossed(ns2).Added( ns1.Crossed(Dns2));
417     d2nplan.SetLinearForm(1, D2ns1.Crossed(ns2),
418                           2, Dns1.Crossed(Dns2),
419                           ns1.Crossed(D2ns2));
420   }
421   else {
422     myTPath->D3(Param, Center, nplan, dnplan, d2nplan);
423     if (myreverse) {
424       nplan.Reverse();
425       dnplan.Reverse();
426       d2nplan.Reverse();
427     }
428   }
429
430   // Normalisation
431   invnorm1 = ((Standard_Real) 1) / ns1.Magnitude();
432   invnorm2 = ((Standard_Real) 1) / ns2.Magnitude(); 
433
434   ns1 *= invnorm1;
435   sc = Dns1.Dot(ns1);
436   D2ns1.SetLinearForm( 3*sc*sc*invnorm1 - D2ns1.Dot(ns1)
437                       - invnorm1*Dns1.SquareMagnitude(), ns1, 
438                       -2*sc*invnorm1 , Dns1,
439                       D2ns1);
440   Dns1.SetLinearForm( -Dns1.Dot(ns1), ns1, Dns1);
441   D2ns1 *= invnorm1;
442   Dns1 *= invnorm1;
443
444   
445      
446   ns2 *= invnorm2;
447   sc = Dns2.Dot(ns2);
448   D2ns2.SetLinearForm( 3*sc*sc*invnorm2 - D2ns2.Dot(ns2)
449                       - invnorm2*Dns2.SquareMagnitude(), ns2, 
450                       -2*sc*invnorm2 , Dns2,
451                       D2ns2);
452   Dns2.SetLinearForm(-sc, ns2, Dns2);
453   D2ns2 *= invnorm2;
454   Dns2 *= invnorm2;
455
456
457   temp.SetLinearForm(myRadius, ns1.XYZ(),
458                      myRadius, ns2.XYZ(),
459                      1, P1.XYZ(), P2.XYZ());       
460   Center.ChangeCoord() = 0.5*temp;
461   DCenter.SetLinearForm(myRadius, Dns1,
462                         myRadius, Dns2,
463                         1, DP1, DP2);
464   DCenter *= 0.5;
465   D2Center.SetLinearForm(myRadius, D2ns1,
466                          myRadius, D2ns2,
467                          1, D2P1, D2P2);
468   D2Center *= 0.5;
469  
470   invnormp = ((Standard_Real)1) / nplan.Magnitude();
471   nplan *= invnormp;   
472   sc = dnplan.Dot(nplan);
473   d2nplan.SetLinearForm( 3*sc*sc*invnormp - d2nplan.Dot(nplan)
474                       - invnormp*dnplan.SquareMagnitude(), nplan, 
475                       -2*sc*invnormp , dnplan,
476                       d2nplan); 
477   dnplan.SetLinearForm(-sc, nplan, dnplan);
478   dnplan *= invnormp;  
479   d2nplan *= invnormp;
480
481   GeomFill::GetCircle(myTConv, 
482                       ns1, ns2, 
483                       Dns1, Dns2,
484                       D2ns1, D2ns2,
485                       nplan, dnplan, d2nplan,
486                       P1, P2,
487                       DP1, DP2,
488                       D2P1, D2P2,
489                       myRadius, 0, 0,
490                       Center, DCenter, D2Center,
491                       Poles,  DPoles, D2Poles,
492                       Weigths, DWeigths, D2Weigths);
493   return Standard_True;
494 }
495
496  Standard_Integer GeomFill_CircularBlendFunc::Nb2dCurves() const
497 {
498   return 0;
499 }
500
501 void GeomFill_CircularBlendFunc::SectionShape(Standard_Integer& NbPoles,
502                                               Standard_Integer& NbKnots,
503                                               Standard_Integer& Degree) const
504 {
505   NbPoles = myNbPoles;
506   NbKnots = myNbKnots;
507   Degree  = myDegree; 
508 }
509
510  void GeomFill_CircularBlendFunc::Knots(TColStd_Array1OfReal& TKnots) const
511 {
512   GeomFill::Knots(myTConv, TKnots);
513 }
514
515 void GeomFill_CircularBlendFunc::Mults(TColStd_Array1OfInteger& TMults) const
516 {
517   GeomFill::Mults(myTConv, TMults);
518 }
519
520 Standard_Boolean GeomFill_CircularBlendFunc::IsRational() const
521 {
522   return (myTConv != Convert_Polynomial);
523 }
524
525 Standard_Integer GeomFill_CircularBlendFunc::
526 NbIntervals(const GeomAbs_Shape S) const
527 {
528  Standard_Integer NbI_Center, NbI_Cb1, NbI_Cb2, ii;
529  NbI_Center =  myPath->NbIntervals(GeomFillNextShape(S));
530  NbI_Cb1    =  myCurve1->NbIntervals(S);
531  NbI_Cb2    =  myCurve2->NbIntervals(S);
532
533  TColStd_Array1OfReal ICenter(1, NbI_Center+1);
534  TColStd_Array1OfReal ICb1(1, NbI_Cb1+1);
535  TColStd_Array1OfReal ICb2(1, NbI_Cb2+1);
536  TColStd_SequenceOfReal    Inter;
537
538  myPath->Intervals(ICenter, GeomFillNextShape(S));
539  myCurve1->Intervals(ICb1, S);
540  myCurve2->Intervals(ICb2, S);
541 /* std::cout << "Intervals : " << S << std::endl;
542  std::cout << "-- Center-> " << std::endl;
543  for (ii=1; ii<=ICenter.Length(); ii++) std::cout << " , "<< ICenter(ii);
544  std::cout << std::endl; std::cout << std::endl;
545  std::cout << "-- Cb1-> " << std::endl;
546  for (ii=1; ii<=ICb1.Length(); ii++) std::cout << " , "<< ICb1(ii);
547  std::cout << std::endl; std::cout << std::endl;
548  std::cout << "-- Cb2-> " << std::endl;
549  for (ii=1; ii<=ICb2.Length(); ii++) std::cout << " , "<< ICb1(ii);
550  std::cout << std::endl; std::cout << std::endl;*/
551
552  GeomFillFusInt(ICb1, ICb2, Inter);
553
554  TColStd_Array1OfReal ICbs (1, Inter.Length());
555  for (ii=1; ii<=ICbs.Length(); ii++) ICbs(ii) = Inter(ii);
556
557  Inter.Clear();
558  GeomFillFusInt(ICenter, ICbs, Inter);
559  
560  return Inter.Length()-1;  
561 }
562
563 void GeomFill_CircularBlendFunc::
564 Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
565 {
566  Standard_Integer NbI_Center, NbI_Cb1, NbI_Cb2, ii;
567  NbI_Center =  myPath->NbIntervals(GeomFillNextShape(S));
568  NbI_Cb1    =  myCurve1->NbIntervals(S);
569  NbI_Cb2    =  myCurve2->NbIntervals(S);
570
571  TColStd_Array1OfReal ICenter(1, NbI_Center+1);
572  TColStd_Array1OfReal ICb1(1, NbI_Cb1+1);
573  TColStd_Array1OfReal ICb2(1, NbI_Cb2+1);
574  TColStd_SequenceOfReal    Inter;
575
576  myPath->Intervals(ICenter, GeomFillNextShape(S));
577  myCurve1->Intervals(ICb1, S);
578  myCurve2->Intervals(ICb2, S);
579
580  GeomFillFusInt(ICb1, ICb2, Inter);
581
582  TColStd_Array1OfReal ICbs (1, Inter.Length());
583  for (ii=1; ii<=ICbs.Length(); ii++) ICbs(ii) = Inter(ii);
584
585  Inter.Clear();
586  GeomFillFusInt(ICenter, ICbs, Inter);
587
588  // Recopie du resultat
589  for (ii=1; ii<=Inter.Length(); ii++) T(ii) = Inter(ii);
590 }
591
592  void GeomFill_CircularBlendFunc::SetInterval(const Standard_Real First,
593                                               const Standard_Real Last) 
594 {
595   Standard_Real Eps = Precision::PConfusion();
596   myTPath = myPath->Trim(First, Last, Eps);
597   myTCurve1 = myCurve1->Trim(First, Last, Eps);
598   myTCurve2 = myCurve2->Trim(First, Last, Eps); 
599 }
600
601
602 void GeomFill_CircularBlendFunc::GetTolerance(const Standard_Real BoundTol,
603                                               const Standard_Real SurfTol,
604                                               const Standard_Real AngleTol,
605                                               TColStd_Array1OfReal& Tol3d) const
606 {
607  Standard_Integer low = Tol3d.Lower() , up=Tol3d.Upper();
608  Standard_Real Tol;
609
610  Tol= GeomFill::GetTolerance(myTConv, minang, 
611                              myRadius,  AngleTol, SurfTol);
612  Tol3d.Init(SurfTol);
613  Tol3d(low+1) = Tol3d(up-1) = Min(Tol, SurfTol);
614  Tol3d(low) = Tol3d(up) = Min(Tol, BoundTol);   
615 }
616
617
618  void GeomFill_CircularBlendFunc::SetTolerance(const Standard_Real, 
619                                                const Standard_Real) 
620 {
621  // y rien a faire !
622 }
623
624  gp_Pnt GeomFill_CircularBlendFunc::BarycentreOfSurf() const
625 {
626   return myBary;
627 }
628
629  Standard_Real GeomFill_CircularBlendFunc::MaximalSection() const
630 {
631   return maxang*myRadius;
632 }
633
634 void GeomFill_CircularBlendFunc::
635 GetMinimalWeight(TColStd_Array1OfReal& Weigths) const
636 {
637   GeomFill::GetMinimalWeights(myTConv, minang, maxang, Weigths); 
638 }
639